mini-starter/packages/unified-advertisements-module/tests/utils/test-data-factory.ts

import { IntegrationTestDatabase } from '@d8d/shared-test-util';
import { UnifiedAdvertisement } from '../../src/entities/unified-advertisement.entity';
import { UnifiedAdvertisementType } from '../../src/entities/unified-advertisement-type.entity';
import type { EntityTarget, ObjectLiteral } from 'typeorm';

/**
 * 统一广告模块测试数据工厂
 */
export class UnifiedAdvertisementTestDataFactory {
  /**
   * 创建测试广告类型
   */
  static async createTestAdvertisementType(overrides: Partial<UnifiedAdvertisementType> = {}): Promise<UnifiedAdvertisementType> {
    const dataSource = await IntegrationTestDatabase.getDataSource();
    const repository = dataSource.getRepository(UnifiedAdvertisementType);

    const timestamp = Date.now();
    const defaultData: Partial<UnifiedAdvertisementType> = {
      name: `测试广告类型_${timestamp}`,
      code: `test_type_${timestamp}`,
      remark: '测试用广告类型',
      status: 1,
      createdAt: new Date(),
      updatedAt: new Date()
    };

    const typeData = { ...defaultData, ...overrides };
    const entity = repository.create(typeData);
    return await repository.save(entity);
  }

  /**
   * 创建测试广告
   */
  static async createTestAdvertisement(overrides: Partial<UnifiedAdvertisement> = {}): Promise<UnifiedAdvertisement> {
    const dataSource = await IntegrationTestDatabase.getDataSource();
    const repository = dataSource.getRepository(UnifiedAdvertisement);

    const timestamp = Date.now();

    // 如果没有提供typeId，先创建一个广告类型
    let typeId = overrides.typeId;
    if (!typeId) {
      const adType = await this.createTestAdvertisementType();
      typeId = adType.id;
    }

    const defaultData: Partial<UnifiedAdvertisement> = {
      title: `测试广告_${timestamp}`,
      typeId,
      code: `test_ad_${timestamp}`,
      url: 'https://example.com',
      imageFileId: null,
      sort: 0,
      status: 1,
      actionType: 1,
      createdAt: new Date(),
      updatedAt: new Date(),
      createdBy: 1,
      updatedBy: 1
    };

    const adData = { ...defaultData, ...overrides };
    const entity = repository.create(adData);
    return await repository.save(entity);
  }

  /**
   * 创建完整的测试数据集合
   */
  static async createTestDataSet(): Promise<{
    advertisementType: UnifiedAdvertisementType;
    advertisement: UnifiedAdvertisement;
  }> {
    const advertisementType = await this.createTestAdvertisementType();
    const advertisement = await this.createTestAdvertisement({ typeId: advertisementType.id });

    return {
      advertisementType,
      advertisement
    };
  }

  /**
   * 通用实体创建方法
   */
  static async createEntity<T extends ObjectLiteral>(
    entity: EntityTarget<T>,
    data: Partial<T>
  ): Promise<T> {
    const dataSource = await IntegrationTestDatabase.getDataSource();
    const repository = dataSource.getRepository(entity);
    const entityInstance = repository.create(data as T);
    return await repository.save(entityInstance);
  }

  /**
   * 批量创建实体
   */
  static async createEntities<T extends ObjectLiteral>(
    entity: EntityTarget<T>,
    dataArray: Partial<T>[]
  ): Promise<T[]> {
    const dataSource = await IntegrationTestDatabase.getDataSource();
    const repository = dataSource.getRepository(entity);
    const entities = dataArray.map(data => repository.create(data as T));
    return await repository.save(entities);
  }

  /**
   * 清理测试数据
   */
  static async cleanupTestData(): Promise<void> {
    const dataSource = await IntegrationTestDatabase.getDataSource();

    await dataSource.getRepository(UnifiedAdvertisement).clear();
    await dataSource.getRepository(UnifiedAdvertisementType).clear();
  }
}