create-dp-koa 1.0.0

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

@@ -0,0 +1,363 @@
+/**
+ * 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/framework/annotation/AnnotationDecorators.test.ts

@@ -0,0 +1,222 @@
+import { AnnotationRegistry, createAnnotationDecorator, createParameterDecorator } from '../../../src/framework/decorator/processor/AnnotationDecorators';
+
+describe('注解装饰器测试', () => {
+    beforeEach(() => {
+        // 清空所有注解数据
+        jest.clearAllMocks();
+    });
+
+    describe('AnnotationRegistry', () => {
+        test('应该能够注册注解数据', () => {
+            const target = {};
+            const methodName = 'testMethod';
+            const processorName = 'TestProcessor';
+            const data = { test: 'value' };
+
+            AnnotationRegistry.register(target, methodName, processorName, data);
+
+            expect(target.$_Annotations).toBeDefined();
+            expect(target.$_Annotations.has(methodName)).toBe(true);
+            expect(target.$_Annotations.get(methodName).get(processorName)).toEqual(data);
+        });
+
+        test('应该能够获取注解数据', () => {
+            const target = {};
+            const methodName = 'testMethod';
+            const processorName = 'TestProcessor';
+            const data = { test: 'value' };
+
+            AnnotationRegistry.register(target, methodName, processorName, data);
+
+            const retrievedData = AnnotationRegistry.get(target, methodName, processorName);
+            expect(retrievedData).toEqual(data);
+        });
+
+        test('获取不存在的注解数据应该返回null', () => {
+            const target = {};
+            const retrievedData = AnnotationRegistry.get(target, 'nonExistentMethod', 'NonExistentProcessor');
+            expect(retrievedData).toBeNull();
+        });
+
+        test('应该能够获取方法的所有注解', () => {
+            const target = {};
+            const methodName = 'testMethod';
+
+            AnnotationRegistry.register(target, methodName, 'Processor1', { data1: 'value1' });
+            AnnotationRegistry.register(target, methodName, 'Processor2', { data2: 'value2' });
+
+            const allAnnotations = AnnotationRegistry.getAll(target, methodName);
+            expect(allAnnotations.size).toBe(2);
+            expect(allAnnotations.get('Processor1')).toEqual({ data1: 'value1' });
+            expect(allAnnotations.get('Processor2')).toEqual({ data2: 'value2' });
+        });
+
+        test('获取不存在方法的注解应该返回空Map', () => {
+            const target = {};
+            const allAnnotations = AnnotationRegistry.getAll(target, 'nonExistentMethod');
+            expect(allAnnotations.size).toBe(0);
+        });
+
+        test('应该支持多次注册同一注解', () => {
+            const target = {};
+            const methodName = 'testMethod';
+            const processorName = 'TestProcessor';
+
+            AnnotationRegistry.register(target, methodName, processorName, { data1: 'value1' });
+            AnnotationRegistry.register(target, methodName, processorName, { data2: 'value2' });
+
+            const retrievedData = AnnotationRegistry.get(target, methodName, processorName);
+            expect(retrievedData).toEqual({ data2: 'value2' }); // 应该是最新的数据
+        });
+    });
+
+    describe('createAnnotationDecorator', () => {
+        test('应该创建注解装饰器', () => {
+            const TestAnnotation = createAnnotationDecorator('TestProcessor');
+            expect(typeof TestAnnotation).toBe('function');
+        });
+
+        test('创建的装饰器应该注册注解数据', () => {
+            const TestAnnotation = createAnnotationDecorator('TestProcessor');
+            const target = {};
+            const methodName = 'testMethod';
+            const descriptor = { value: jest.fn() };
+            const annotationData = { test: 'value' };
+
+            const result = TestAnnotation(annotationData)(target, methodName, descriptor);
+
+            expect(result).toBe(descriptor);
+            expect(AnnotationRegistry.get(target, methodName, 'TestProcessor')).toEqual(annotationData);
+        });
+
+        test('装饰器没有数据时应该注册undefined', () => {
+            const TestAnnotation = createAnnotationDecorator('TestProcessor');
+            const target = {};
+            const methodName = 'testMethod';
+            const descriptor = { value: jest.fn() };
+
+            TestAnnotation()(target, methodName, descriptor);
+
+            expect(AnnotationRegistry.get(target, methodName, 'TestProcessor')).toBeUndefined();
+        });
+
+        test('应该支持链式调用', () => {
+            const TestAnnotation = createAnnotationDecorator('TestProcessor');
+            const target = {};
+            const methodName = 'testMethod';
+            const descriptor = { value: jest.fn() };
+
+            const result = TestAnnotation({ data: 'value' })(target, methodName, descriptor);
+
+            expect(result).toBe(descriptor);
+            expect(AnnotationRegistry.get(target, methodName, 'TestProcessor')).toEqual({ data: 'value' });
+        });
+    });
+
+    describe('createParameterDecorator', () => {
+        test('应该创建参数装饰器', () => {
+            const TestParamAnnotation = createParameterDecorator('TestProcessor');
+            expect(typeof TestParamAnnotation).toBe('function');
+        });
+
+        test('创建的参数装饰器应该注册注解数据', () => {
+            const TestParamAnnotation = createParameterDecorator('TestProcessor');
+            const target = {};
+            const methodName = 'testMethod';
+            const parameterIndex = 0;
+            const annotationData = { test: 'value' };
+
+            TestParamAnnotation(annotationData)(target, methodName, parameterIndex);
+
+            const registeredData = AnnotationRegistry.get(target, methodName, 'TestProcessor');
+            expect(registeredData).toEqual({
+                ...annotationData,
+                parameterIndex: parameterIndex
+            });
+        });
+
+        test('参数装饰器应该记录参数索引', () => {
+            const TestParamAnnotation = createParameterDecorator('TestProcessor');
+            const target = {};
+            const methodName = 'testMethod';
+            const parameterIndex = 2;
+
+            TestParamAnnotation({ data: 'value' })(target, methodName, parameterIndex);
+
+            const registeredData = AnnotationRegistry.get(target, methodName, 'TestProcessor');
+            expect(registeredData.parameterIndex).toBe(parameterIndex);
+        });
+
+        test('应该支持多个参数装饰器', () => {
+            const TestParamAnnotation1 = createParameterDecorator('Processor1');
+            const TestParamAnnotation2 = createParameterDecorator('Processor2');
+            const target = {};
+            const methodName = 'testMethod';
+
+            TestParamAnnotation1({ data1: 'value1' })(target, methodName, 0);
+            TestParamAnnotation2({ data2: 'value2' })(target, methodName, 1);
+
+            expect(AnnotationRegistry.get(target, methodName, 'Processor1')).toEqual({
+                data1: 'value1',
+                parameterIndex: 0
+            });
+            expect(AnnotationRegistry.get(target, methodName, 'Processor2')).toEqual({
+                data2: 'value2',
+                parameterIndex: 1
+            });
+        });
+    });
+
+    describe('装饰器集成测试', () => {
+        test('应该支持多个注解装饰器', () => {
+            const LoggingAnnotation = createAnnotationDecorator('Logging');
+            const PermissionAnnotation = createAnnotationDecorator('Permission');
+            const target = {};
+            const methodName = 'testMethod';
+            const descriptor = { value: jest.fn() };
+
+            LoggingAnnotation({ level: 'info' })(target, methodName, descriptor);
+            PermissionAnnotation({ requiredPermission: 'read:data' })(target, methodName, descriptor);
+
+            expect(AnnotationRegistry.get(target, methodName, 'Logging')).toEqual({ level: 'info' });
+            expect(AnnotationRegistry.get(target, methodName, 'Permission')).toEqual({ requiredPermission: 'read:data' });
+        });
+
+        test('应该支持注解装饰器和参数装饰器混合使用', () => {
+            const LoggingAnnotation = createAnnotationDecorator('Logging');
+            const ValidatedParamAnnotation = createParameterDecorator('ParameterValidation');
+            const target = {};
+            const methodName = 'testMethod';
+            const descriptor = { value: jest.fn() };
+
+            LoggingAnnotation({ level: 'info' })(target, methodName, descriptor);
+            ValidatedParamAnnotation({ validate: 'TestClass' })(target, methodName, 0);
+
+            expect(AnnotationRegistry.get(target, methodName, 'Logging')).toEqual({ level: 'info' });
+            expect(AnnotationRegistry.get(target, methodName, 'ParameterValidation')).toEqual({
+                validate: 'TestClass',
+                parameterIndex: 0
+            });
+        });
+
+        test('应该支持同一方法的多个参数装饰器', () => {
+            const ValidatedParamAnnotation = createParameterDecorator('ParameterValidation');
+            const LoggedParamAnnotation = createParameterDecorator('Logging');
+            const target = {};
+            const methodName = 'testMethod';
+
+            ValidatedParamAnnotation({ validate: 'TestClass' })(target, methodName, 0);
+            LoggedParamAnnotation({ logLevel: 'debug' })(target, methodName, 1);
+
+            const allAnnotations = AnnotationRegistry.getAll(target, methodName);
+            expect(allAnnotations.size).toBe(2);
+            
+            // 由于参数装饰器会覆盖同一处理器的数据，这里只检查最后一个
+            const lastAnnotation = AnnotationRegistry.get(target, methodName, 'Logging');
+            expect(lastAnnotation).toEqual({
+                logLevel: 'debug',
+                parameterIndex: 1
+            });
+        });
+    });
+});