invest-mind-store/apps/api/test/modules/broker/broker.service.integration.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { BrokerService } from '../../../src/modules/broker/broker.service';
import { Broker } from '../../../src/modules/broker/broker.entity';
import { BrokerModule } from '../../../src/modules/broker/broker.module';
import { CreateBrokerDto } from '../../../src/modules/broker/dto/create-broker.dto';
import { BatchCreateBrokerDto } from '../../../src/modules/broker/dto/batch-create-broker.dto';
import { getDatabaseConfig } from '../../../src/database/database.config';
import { brokersConfig } from '../../../src/modules/broker/config/brokers.config';

describe('BrokerService (集成测试)', () => {
    let service: BrokerService;
    let repository: Repository<Broker>;
    let module: TestingModule;

    beforeAll(async () => {
        jest.setTimeout(30000); // 设置超时为 30 秒
        // 创建测试模块，使用真实数据库连接
        module = await Test.createTestingModule({
            imports: [
                ConfigModule.forRoot({
                    isGlobal: true,
                    envFilePath: ['.env.development', '.env'],
                }),
                TypeOrmModule.forRootAsync({
                    imports: [ConfigModule],
                    useFactory: (configService: ConfigService) => {
                        const config = getDatabaseConfig(configService);
                        // 使用测试数据库（如果配置了），否则使用开发数据库
                        const testDatabase =
                            configService.get<string>('DB_DATABASE') ||
                            (config.database as string);
                        return {
                            ...config,
                            database: testDatabase,
                            synchronize: true, // 测试环境允许同步
                            dropSchema: false, // 不删除现有数据
                        } as typeof config;
                    },
                    inject: [ConfigService],
                }),
                BrokerModule,
            ],
        }).compile();

        service = module.get<BrokerService>(BrokerService);
        repository = module.get<Repository<Broker>>(getRepositoryToken(Broker));

        // 清理测试数据（可选）
        await repository.clear();
    });

    afterAll(async () => {
        // 测试结束后清理
        // await repository.clear();
        await module.close();
    });

    describe.skip('create - 集成测试', () => {
        it('应该成功在数据库中创建券商', async () => {
            const createBrokerDto: CreateBrokerDto = {
                brokerCode: 'HTZQ_TEST',
                brokerName: '华泰证券测试',
                region: 'CN',
                sortOrder: 1,
                isActive: true,
            };

            const result = await service.create(createBrokerDto);
            console.log(result);

            expect(result).toBeDefined();
            expect(result.brokerId).toBeDefined();
            expect(result.brokerCode).toBe(createBrokerDto.brokerCode);
            expect(result.brokerName).toBe(createBrokerDto.brokerName);

            // 验证数据确实保存到数据库
            const savedBroker = await repository.findOne({
                where: { brokerId: result.brokerId },
            });
            expect(savedBroker).toBeDefined();
            expect(savedBroker?.brokerCode).toBe(createBrokerDto.brokerCode);

            // 清理
            // await repository.remove(result);
        });

        it('应该使用数据库默认值', async () => {
            const createBrokerDto: CreateBrokerDto = {
                brokerCode: 'ZSZQ_TEST',
                brokerName: '招商证券测试',
                region: 'CN',
                // 不提供 sortOrder 和 isActive
            };

            const result = await service.create(createBrokerDto);

            expect(result.sortOrder).toBe(0); // 数据库默认值
            expect(result.isActive).toBe(true); // 数据库默认值

            // 清理
            // await repository.remove(result);
        });
    });

    describe.only('batchCreate - 集成测试', () => {
        it('应该成功从配置文件批量创建券商', async () => {
            // 从配置文件读取券商数据
            const batchCreateDto: BatchCreateBrokerDto = {
                brokers: brokersConfig,
            };

            const result = await service.batchCreate(batchCreateDto);

            // 验证创建成功
            expect(result).toBeDefined();
            expect(Array.isArray(result)).toBe(true);
            expect(result.length).toBeGreaterThan(0);

            // 验证数据确实保存到数据库
            const savedBrokers = await repository.find({
                where: brokersConfig.map((broker) => ({
                    brokerCode: broker.brokerCode,
                    region: broker.region,
                })),
            });

            expect(savedBrokers.length).toBe(brokersConfig.length);

            // 验证部分数据
            const cnBrokers = savedBrokers.filter((b) => b.region === 'CN');
            const hkBrokers = savedBrokers.filter((b) => b.region === 'HK');
            const usBrokers = savedBrokers.filter((b) => b.region === 'US');

            expect(cnBrokers.length).toBeGreaterThan(0);
            expect(hkBrokers.length).toBeGreaterThan(0);
            expect(usBrokers.length).toBeGreaterThan(0);

            // 验证 brokerImage 为 null 或 undefined
            savedBrokers.forEach((broker) => {
                expect(broker.brokerImage).toBeFalsy(); // null 或 undefined 都通过
            });

            // 注意：不删除数据，保留在数据库中
        });
    });
});