create-dp-koa 1.0.0 → 1.0.2

package/template/test/framework/TransactionManagerDemo.test.ts

@@ -1,363 +0,0 @@
-/**
- * TransactionManager Demo 单元测试
- * 测试各种事务管理器的使用场景
- */
-
-import { TestDatabaseHelper } from '../utils/testHelpers';
-import { transactionManager } from '../../src/framework/utils/TransactionManager';
-import { YtUserEntity } from '../../src/entity/ytUser.entity';
-import { getDataSource } from '../../src/framework/utils/db';
-
-describe('TransactionManager Demo 测试', () => {
-    let dataSource: any;
-
-    beforeAll(async () => {
-        await TestDatabaseHelper.initTestDatabase();
-        dataSource = getDataSource();
-    });
-
-    afterAll(async () => {
-        await TestDatabaseHelper.cleanupTestDatabase();
-    });
-
-    beforeEach(async () => {
-        await TestDatabaseHelper.resetTestData();
-    });
-
-    describe('示例 1: 基本事务', () => {
-        test('应该能够成功执行基本事务', async () => {
-            const result = await transactionManager.executeInTransaction(async (manager) => {
-                const user = new YtUserEntity();
-                user.email = 'test@example.com';
-                user.telnumber = '13800138000';
-                user.password = 'hashed';
-
-                return await manager.save(user);
-            });
-
-            expect(result).toBeDefined();
-            expect(result.email).toBe('test@example.com');
-            expect(result.telnumber).toBe('13800138000');
-
-            // 验证数据已保存到数据库
-            const savedUser = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'test@example.com' }
-            });
-            expect(savedUser).toBeDefined();
-        });
-
-        test('事务失败时应该自动回滚', async () => {
-            await expect(
-                transactionManager.executeInTransaction(async (manager) => {
-                    const user = new YtUserEntity();
-                    user.email = 'test-rollback@example.com';
-                    user.telnumber = '13800138001';
-                    user.password = 'hashed';
-                    await manager.save(user);
-
-                    // 故意抛出错误
-                    throw new Error('模拟错误');
-                })
-            ).rejects.toThrow('模拟错误');
-
-            // 验证数据已被回滚（未保存到数据库）
-            const savedUser = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'test-rollback@example.com' }
-            });
-            expect(savedUser).toBeNull();
-        });
-    });
-
-    describe('示例 2: 嵌套事务', () => {
-        test('应该能够处理嵌套事务', async () => {
-            const result = await transactionManager.executeInTransaction(async (manager) => {
-                // 外层事务：创建主用户
-                const mainUser = new YtUserEntity();
-                mainUser.email = 'main-user@example.com';
-                mainUser.telnumber = '13800138020';
-                mainUser.password = 'hashed';
-                const savedUser = await manager.save(mainUser);
-
-                // 嵌套事务：创建相关用户
-                await transactionManager.executeNestedTransaction(async (nestedManager) => {
-                    const relatedUser = new YtUserEntity();
-                    relatedUser.email = 'related-user@example.com';
-                    relatedUser.telnumber = '13800138021';
-                    relatedUser.password = 'hashed';
-                    await nestedManager.save(relatedUser);
-                });
-
-                return savedUser;
-            });
-
-            expect(result).toBeDefined();
-            expect(result.email).toBe('main-user@example.com');
-
-            // 验证所有数据都已保存
-            const mainUser = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'main-user@example.com' }
-            });
-            const relatedUser = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'related-user@example.com' }
-            });
-
-            expect(mainUser).toBeDefined();
-            expect(relatedUser).toBeDefined();
-        });
-
-        test('嵌套事务失败应该回滚外层事务', async () => {
-            await expect(
-                transactionManager.executeInTransaction(async (manager) => {
-                    // 外层事务
-                    const mainUser = new YtUserEntity();
-                    mainUser.email = 'main-fail@example.com';
-                    mainUser.telnumber = '13800138022';
-                    mainUser.password = 'hashed';
-                    await manager.save(mainUser);
-
-                    // 嵌套事务：故意失败
-                    await transactionManager.executeNestedTransaction(async (nestedManager) => {
-                        throw new Error('嵌套事务失败');
-                    });
-                })
-            ).rejects.toThrow('嵌套事务失败');
-
-            // 验证外层事务也被回滚
-            const savedUser = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'main-fail@example.com' }
-            });
-            expect(savedUser).toBeNull();
-        });
-    });
-
-    describe('示例 3: 批量操作事务', () => {
-        test('应该能够批量创建用户', async () => {
-            const operations = [
-                async (manager: any) => {
-                    const user = new YtUserEntity();
-                    user.email = 'batch-1@example.com';
-                    user.telnumber = '13800138010';
-                    user.password = 'hashed';
-                    return await manager.save(user);
-                },
-                async (manager: any) => {
-                    const user = new YtUserEntity();
-                    user.email = 'batch-2@example.com';
-                    user.telnumber = '13800138011';
-                    user.password = 'hashed';
-                    return await manager.save(user);
-                },
-                async (manager: any) => {
-                    const user = new YtUserEntity();
-                    user.email = 'batch-3@example.com';
-                    user.telnumber = '13800138012';
-                    user.password = 'hashed';
-                    return await manager.save(user);
-                }
-            ];
-
-            const results = await transactionManager.executeBatchTransaction(operations);
-
-            expect(results).toHaveLength(3);
-            expect(results[0].email).toBe('batch-1@example.com');
-            expect(results[1].email).toBe('batch-2@example.com');
-            expect(results[2].email).toBe('batch-3@example.com');
-
-            // 验证所有数据都已保存
-            const savedUsers = await dataSource.manager.find(YtUserEntity, {
-                where: [
-                    { email: 'batch-1@example.com' },
-                    { email: 'batch-2@example.com' },
-                    { email: 'batch-3@example.com' }
-                ] as any
-            });
-            expect(savedUsers).toHaveLength(3);
-        });
-
-        test('批量操作中任一失败应该全部回滚', async () => {
-            const operations = [
-                async (manager: any) => {
-                    const user = new YtUserEntity();
-                    user.email = 'batch-ok@example.com';
-                    user.telnumber = '13800138013';
-                    user.password = 'hashed';
-                    return await manager.save(user);
-                },
-                async (manager: any) => {
-                    // 故意抛出错误
-                    throw new Error('批量操作失败');
-                }
-            ];
-
-            await expect(
-                transactionManager.executeBatchTransaction(operations)
-            ).rejects.toThrow('批量操作失败');
-
-            // 验证没有数据被保存（全部回滚）
-            const savedUser = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'batch-ok@example.com' }
-            });
-            expect(savedUser).toBeNull();
-        });
-    });
-
-    describe('示例 4: 复杂业务场景', () => {
-        test('应该能够处理复杂的多步骤业务场景', async () => {
-            const result = await transactionManager.executeInTransaction(async (manager) => {
-                // 步骤 1: 创建主用户
-                const mainUser = new YtUserEntity();
-                mainUser.email = 'complex-1@example.com';
-                mainUser.telnumber = '13800138040';
-                mainUser.password = 'hashed';
-                const savedMainUser = await manager.save(mainUser);
-
-                // 步骤 2: 创建第二个用户
-                const secondUser = new YtUserEntity();
-                secondUser.email = 'complex-2@example.com';
-                secondUser.telnumber = '13800138041';
-                secondUser.password = 'hashed';
-                const savedSecondUser = await manager.save(secondUser);
-
-                // 步骤 3: 更新主用户
-                savedMainUser.email = 'complex-1-updated@example.com';
-                const updatedMainUser = await manager.save(savedMainUser);
-
-                return {
-                    mainUser: updatedMainUser,
-                    secondUser: savedSecondUser
-                };
-            });
-
-            expect(result).toBeDefined();
-            expect(result.mainUser.email).toBe('complex-1-updated@example.com');
-            expect(result.secondUser.email).toBe('complex-2@example.com');
-        });
-
-        test('复杂场景失败时应该回滚所有步骤', async () => {
-            await expect(
-                transactionManager.executeInTransaction(async (manager) => {
-                    // 步骤 1
-                    const user1 = new YtUserEntity();
-                    user1.email = 'fail-step1@example.com';
-                    user1.telnumber = '13800138050';
-                    user1.password = 'hashed';
-                    await manager.save(user1);
-
-                    // 步骤 2
-                    const user2 = new YtUserEntity();
-                    user2.email = 'fail-step2@example.com';
-                    user2.telnumber = '13800138051';
-                    user2.password = 'hashed';
-                    await manager.save(user2);
-
-                    // 步骤 3: 失败
-                    throw new Error('第三步失败');
-                })
-            ).rejects.toThrow('第三步失败');
-
-            // 验证所有步骤都被回滚
-            const user1 = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'fail-step1@example.com' }
-            });
-            const user2 = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'fail-step2@example.com' }
-            });
-
-            expect(user1).toBeNull();
-            expect(user2).toBeNull();
-        });
-    });
-
-    describe('示例 5: 条件事务', () => {
-        test('应该能够根据条件控制事务提交', async () => {
-            const result = await transactionManager.executeInTransaction(async (manager) => {
-                const user = new YtUserEntity();
-                user.email = 'conditional@example.com';
-                user.telnumber = '13800138060';
-                user.password = 'hashed';
-
-                return await manager.save(user);
-            });
-
-            expect(result).toBeDefined();
-
-            // 验证数据已保存
-            const savedUser = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'conditional@example.com' }
-            });
-            expect(savedUser).toBeDefined();
-        });
-
-        test('条件不满足时应该回滚事务', async () => {
-            await expect(
-                transactionManager.executeInTransaction(async (manager) => {
-                    const user = new YtUserEntity();
-                    user.email = 'conditional-fail@example.com';
-                    user.telnumber = '13800138061';
-                    user.password = 'hashed';
-                    await manager.save(user);
-
-                    // 模拟条件判断
-                    if (true) { // 条件不满足
-                        throw new Error('不符合提交条件');
-                    }
-
-                    return user;
-                })
-            ).rejects.toThrow('不符合提交条件');
-
-            // 验证数据已被回滚
-            const savedUser = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'conditional-fail@example.com' }
-            });
-            expect(savedUser).toBeNull();
-        });
-    });
-
-    describe('性能测试', () => {
-        test('批量操作性能', async () => {
-            const operationCount = 5; // 减少数量以加快测试
-            const operations = Array.from({ length: operationCount }, (_, i) => {
-                return async (manager: any) => {
-                    const user = new YtUserEntity();
-                    user.email = `perf-${i}@example.com`;
-                    user.telnumber = `13800138${String(i).padStart(3, '0')}`;
-                    user.password = 'hashed';
-                    return await manager.save(user);
-                };
-            });
-
-            const startTime = Date.now();
-            const results = await transactionManager.executeBatchTransaction(operations);
-            const endTime = Date.now();
-
-            expect(results).toHaveLength(operationCount);
-            expect(endTime - startTime).toBeLessThan(3000); // 应该在3秒内完成
-        });
-    });
-
-    describe('错误处理测试', () => {
-        test('应该能够正确处理回滚', async () => {
-            try {
-                await transactionManager.executeInTransaction(async (manager) => {
-                    const user = new YtUserEntity();
-                    user.email = 'rollback-test@example.com';
-                    user.telnumber = '13800138030';
-                    user.password = 'hashed';
-                    await manager.save(user);
-
-                    // 模拟业务规则错误
-                    throw new Error('业务规则：测试用户不允许');
-                });
-            } catch (error) {
-                expect(error).toBeDefined();
-            }
-
-            // 验证数据已被回滚
-            const savedUser = await dataSource.manager.findOne(YtUserEntity, {
-                where: { email: 'rollback-test@example.com' }
-            });
-            expect(savedUser).toBeNull();
-        });
-    });
-});

package/template/test/service/business.test.ts

@@ -1,87 +0,0 @@
-import { TestDatabaseHelper, TestUtils } from '../utils/testHelpers';
-import { YtUserService } from '../../src/service/ytUser.service';
-import { YtShopService } from '../../src/service/ytShop.service';
-import { YtGoodsService } from '../../src/service/ytGoods.service';
-import { Provider } from 'dp-ioc2';
-
-describe('业务服务测试', () => {
-    beforeAll(async () => {
-        await TestDatabaseHelper.initTestDatabase();
-    });
-
-    afterAll(async () => {
-        await TestDatabaseHelper.cleanupTestDatabase();
-    });
-
-    beforeEach(async () => {
-        await TestDatabaseHelper.resetTestData();
-    });
-
-    describe('店铺服务测试', () => {
-        let shopService: YtShopService;
-
-        beforeEach(() => {
-            shopService = Provider(YtShopService);
-        });
-
-        test('应该能够获取店铺商品列表', async () => {
-            const result = await shopService.getGoodsListByShopId(1, 1, 10);
-            expect(result.code).toBe('SUCCESS');
-            expect(result.data).toBeDefined();
-            expect(Array.isArray(result.data?.[0])).toBe(true);
-            expect(typeof result.data?.[1]).toBe('number');
-        });
-
-        test('应该能够获取店铺用户信息', async () => {
-            const result = await shopService.getShopUserInfo(1);
-            expect(result.code).toBe('SUCCESS');
-            expect(result.data).toBeDefined();
-            expect(result.data?.id).toBeDefined();
-            expect(result.data?.nickName).toBeDefined();
-        });
-
-        test('应该能够检查用户是否有店铺', async () => {
-            const result = await shopService.checkHasShop(1);
-            expect(result.code).toBe('SUCCESS');
-            expect(result.data).toBeDefined();
-            expect(typeof result.data).toBe('number');
-        });
-
-        test('应该返回null当用户没有店铺时', async () => {
-            const result = await shopService.checkHasShop(999);
-            expect(result.code).toBe('SUCCESS');
-            expect(result.data).toBeNull();
-        });
-    });
-
-    describe('商品服务测试', () => {
-        let goodsService: YtGoodsService;
-
-        beforeEach(() => {
-            goodsService = Provider(YtGoodsService);
-        });
-
-        test('应该能够解锁商品图片', async () => {
-            const result = await goodsService.unlockGoodsImage(1, 1, 'TEST_KEY_001');
-            expect(result.code).toBe('SUCCESS');
-            expect(result.data).toBe(true);
-        });
-
-        test('应该拒绝无效的解锁密钥', async () => {
-            const result = await goodsService.unlockGoodsImage(1, 1, 'INVALID_KEY');
-            expect(result.code).toBe('FAIL');
-            expect(result.data).toBe(false);
-            expect(result.message).toBe('无效的解锁key');
-        });
-
-        test('应该拒绝已使用的解锁密钥', async () => {
-            // 先使用一次密钥
-            await goodsService.unlockGoodsImage(3, 1, 'USED_KEY_001');
-            
-            // 再次使用应该失败
-            const result = await goodsService.unlockGoodsImage(3, 1, 'USED_KEY_001');
-            expect(result.code).toBe('FAIL');
-            expect(result.data).toBe(false);
-        });
-    });
-});

package/template/test/service/paramValidateTest.service.test.ts

@@ -1,184 +0,0 @@
-/**
- * 参数校验测试
- * 测试 dp-ioc2 的 @ParamValidate 装饰器功能
- */
-
-import { Provider } from 'dp-ioc2';
-import { ParamValidateTestService, CreateTestUserDto, UpdateTestUserDto } from '../../src/service/paramValidateTest.service';
-import { TestDatabaseHelper } from '../utils/testHelpers';
-import { IOCValidationError } from 'dp-ioc2';
-
-describe('ParamValidate 参数校验测试', () => {
-    let service: ParamValidateTestService;
-
-    beforeAll(async () => {
-        // 初始化测试数据库
-        await TestDatabaseHelper.initTestDatabase();
-        
-        // 使用 Provider 实例化 Service（dp-ioc2 要求）
-        service = Provider<ParamValidateTestService>(ParamValidateTestService);
-    });
-
-    afterAll(async () => {
-        await TestDatabaseHelper.cleanupTestDatabase();
-    });
-
-    describe('测试1：对象参数校验（class-validator）', () => {
-        test('应该能够成功创建用户（参数有效）', async () => {
-            const dto: CreateTestUserDto = {
-                name: '测试用户',
-                email: 'test@example.com',
-                age: 25
-            };
-
-            const result = await service.createUser(dto);
-
-            expect(result.code).toBe('SUCCESS');
-            expect(result.data).toBeDefined();
-            expect(result.data?.name).toBe('测试用户');
-            expect(result.data?.email).toBe('test@example.com');
-            expect(result.data?.age).toBe(25);
-        });
-
-        test('应该拒绝无效的用户名（长度不足）', async () => {
-            const dto: CreateTestUserDto = {
-                name: 'ab', // 长度不足3
-                email: 'test@example.com',
-                age: 25
-            };
-
-            // @ParamValidate 在方法调用前就抛出异常，需要在调用方捕获
-            await expect(service.createUser(dto)).rejects.toThrow(IOCValidationError);
-        });
-
-        test('应该拒绝无效的邮箱格式', async () => {
-            const dto: CreateTestUserDto = {
-                name: '测试用户',
-                email: 'invalid-email', // 无效邮箱
-                age: 25
-            };
-
-            await expect(service.createUser(dto)).rejects.toThrow(IOCValidationError);
-        });
-
-        test('应该拒绝年龄小于18', async () => {
-            const dto: CreateTestUserDto = {
-                name: '测试用户',
-                email: 'test@example.com',
-                age: 17 // 小于18
-            };
-
-            await expect(service.createUser(dto)).rejects.toThrow(IOCValidationError);
-        });
-
-        test('应该拒绝年龄大于100', async () => {
-            const dto: CreateTestUserDto = {
-                name: '测试用户',
-                email: 'test@example.com',
-                age: 101 // 大于100
-            };
-
-            await expect(service.createUser(dto)).rejects.toThrow(IOCValidationError);
-        });
-
-        test('应该支持普通对象自动转换为 DTO 实例', async () => {
-            // 传入普通对象，dp-ioc2 会自动转换为 DTO 实例
-            const plainObject = {
-                name: '测试用户',
-                email: 'test@example.com',
-                age: 25
-            };
-
-            const result = await service.createUser(plainObject as any);
-
-            expect(result.code).toBe('SUCCESS');
-            expect(result.data).toBeDefined();
-        });
-    });
-
-    describe('测试2：基本类型参数校验（Joi）', () => {
-        test('应该能够成功获取用户（有效ID）', async () => {
-            const result = await service.getUserById(123);
-
-            expect(result.code).toBe('SUCCESS');
-            expect(result.data).toBeDefined();
-            expect(result.data?.id).toBe(123);
-        });
-
-        test('应该拒绝负数ID', async () => {
-            await expect(service.getUserById(-1)).rejects.toThrow(IOCValidationError);
-        });
-
-        test('应该拒绝零值ID', async () => {
-            await expect(service.getUserById(0)).rejects.toThrow(IOCValidationError);
-        });
-
-        test('应该拒绝非整数ID', async () => {
-            // TypeScript 类型检查会阻止传入非数字，但运行时可能传入
-            await expect(service.getUserById(1.5 as any)).rejects.toThrow(IOCValidationError);
-        });
-    });
-
-    describe('测试3：混合参数校验', () => {
-        test('应该能够成功更新用户（所有参数有效）', async () => {
-            const dto: UpdateTestUserDto = {
-                name: '更新后的用户名',
-                email: 'updated@example.com'
-            };
-
-            const result = await service.updateUser(123, dto);
-
-            expect(result.code).toBe('SUCCESS');
-            expect(result.data).toBeDefined();
-            expect(result.data?.id).toBe(123);
-            expect(result.data?.name).toBe('更新后的用户名');
-            expect(result.data?.email).toBe('updated@example.com');
-        });
-
-        test('应该拒绝无效的用户ID（负数）', async () => {
-            const dto: UpdateTestUserDto = {
-                name: '更新后的用户名'
-            };
-
-            await expect(service.updateUser(-1, dto)).rejects.toThrow(IOCValidationError);
-        });
-
-        test('应该拒绝无效的邮箱格式', async () => {
-            const dto: UpdateTestUserDto = {
-                email: 'invalid-email'
-            };
-
-            await expect(service.updateUser(123, dto)).rejects.toThrow(IOCValidationError);
-        });
-    });
-
-    describe('测试4：无校验参数（对比测试）', () => {
-        test('无校验的方法应该接受任何参数', async () => {
-            // 这个方法没有 @ParamValidate，所以不会进行校验
-            const result = await service.getUserWithoutValidation(-1);
-
-            expect(result.code).toBe('SUCCESS');
-            // 即使传入负数，方法也会执行（因为没有校验）
-            expect(result.data?.id).toBe(-1);
-        });
-    });
-
-    describe('测试5：异常信息验证', () => {
-        test('应该包含详细的校验错误信息', async () => {
-            const invalidDto = {
-                name: 'ab', // 无效
-                email: 'invalid',
-                age: 10
-            };
-
-            try {
-                await service.createUser(invalidDto as any);
-                fail('应该抛出 IOCValidationError');
-            } catch (error) {
-                expect(error).toBeInstanceOf(IOCValidationError);
-                expect((error as IOCValidationError).message).toContain('Validation failed');
-            }
-        });
-    });
-});
-