create-dp-koa 1.0.0

package/template/test/controllers/controllers.test.ts

@@ -0,0 +1,173 @@
+import { TestDatabaseHelper, TestUtils } from '../utils/testHelpers';
+import { Provider } from 'dp-ioc2';
+import { YtUserController } from '../../src/controllers/home/ytUser.controller';
+import { YtShopController } from '../../src/controllers/home/ytShop.controller';
+import { CaptchaController } from '../../src/controllers/captcha.controller';
+
+describe('控制器测试', () => {
+    beforeAll(async () => {
+        await TestDatabaseHelper.initTestDatabase();
+    });
+
+    afterAll(async () => {
+        await TestDatabaseHelper.cleanupTestDatabase();
+    });
+
+    beforeEach(async () => {
+        await TestDatabaseHelper.resetTestData();
+    });
+
+    describe('用户控制器测试', () => {
+        let userController: YtUserController;
+
+        beforeEach(() => {
+            userController = Provider<any>(YtUserController);
+        });
+
+        test('应该能够获取用户信息', async () => {
+            const mockState = {
+                user: {
+                    userId: 1,
+                    type: 1
+                }
+            };
+
+            const result = await userController.getUserInfo(mockState);
+            expect(result.code).toBe(0);
+            expect(result.data).toBeDefined();
+            expect(result.data?.id).toBe(1);
+            expect(result.data?.nickName).toBe('测试用户1');
+            expect(result.data?.email).toBe('test1@example.com');
+        });
+
+        test('应该返回失败当用户不存在时', async () => {
+            const mockState = {
+                user: {
+                    userId: 999,
+                    type: 1
+                }
+            };
+
+            const result = await userController.getUserInfo(mockState);
+            expect(result.code).toBe(-1);
+            expect(result.data).toBeNull();
+            expect(result.message).toBe('用户不存在');
+        });
+
+        test('应该能够检查用户是否有店铺', async () => {
+            const mockState = {
+                user: {
+                    userId: 1,
+                    type: 1
+                }
+            };
+
+            const result = await userController.hasShop(mockState);
+            expect(result.code).toBe(0);
+            expect(result.data).toBeDefined();
+            expect(typeof result.data).toBe('number');
+        });
+    });
+
+    describe('店铺控制器测试', () => {
+        let shopController: YtShopController;
+
+        beforeEach(() => {
+            shopController = Provider<any>(YtShopController);
+        });
+
+        test('应该能够获取店铺信息', async () => {
+            const mockQuery = {
+                id: 1
+            };
+
+            const result = await shopController.getShopInfoById(mockQuery);
+            expect(result.code).toBe(0);
+            expect(result.data).toBeDefined();
+            expect(result.data?.id).toBe(1);
+            expect(result.data?.name).toBe('测试店铺1');
+            expect(result.data?.userId).toBeDefined();
+        });
+
+        test('应该返回失败当店铺不存在时', async () => {
+            const mockQuery = {
+                id: 999
+            };
+
+            const result = await shopController.getShopInfoById(mockQuery);
+            expect(result.code).toBe(-1);
+            expect(result.data).toBeNull();
+            expect(result.message).toBe('店铺不存在');
+        });
+
+        test('应该能够获取店铺商品列表', async () => {
+            const mockQuery = {
+                id: 1,
+                page: 1,
+                pageSize: 10
+            };
+
+            const result = await shopController.getShopGoodsList(mockQuery);
+            expect(result.code).toBe(0);
+            expect(result.data).toBeDefined();
+            expect(Array.isArray(result.data?.[0])).toBe(true);
+            expect(typeof result.data?.[1]).toBe('number');
+        });
+
+        test('应该能够获取店铺用户信息', async () => {
+            const mockQuery = {
+                shopId: 1
+            };
+
+            const result = await shopController.getShopUserInfo(mockQuery);
+            expect(result.code).toBe(0);
+            expect(result.data).toBeDefined();
+            expect(result.data?.id).toBeDefined();
+            expect(result.data?.nickName).toBeDefined();
+        });
+    });
+
+    describe('验证码控制器测试', () => {
+        let captchaController: CaptchaController;
+
+        beforeEach(() => {
+            captchaController = Provider<any>(CaptchaController);
+        });
+
+        test('应该能够生成验证码', async () => {
+            const result = await captchaController.getCaptcha();
+            expect(result).toBeDefined();
+            expect(result.image).toBeDefined();
+            expect(result.token).toBeDefined();
+            expect(result.contentType).toBe('image/svg+xml');
+        });
+
+        test('应该能够验证正确的验证码', async () => {
+            // 先生成验证码
+            const captchaResult = await captchaController.getCaptcha();
+            const { token } = captchaResult;
+
+            // 模拟用户输入（这里需要知道正确的验证码，实际测试中可能需要mock）
+            const mockBody = {
+                captcha: 'test', // 这里应该是正确的验证码
+                token: token
+            };
+
+            const result = await captchaController.verifyCaptcha(mockBody);
+            expect(result).toBeDefined();
+            expect(typeof result.success).toBe('boolean');
+        });
+
+        test('应该拒绝缺少token的验证请求', async () => {
+            const mockBody = {
+                captcha: 'test',
+                token: ''
+            };
+
+            const result = await captchaController.verifyCaptcha(mockBody);
+            expect(result.status).toBe(400);
+            expect(result.body?.success).toBe(false);
+            expect(result.body?.message).toBe('Missing captcha token');
+        });
+    });
+});

package/template/test/controllers/example/ExampleController.test.ts

@@ -0,0 +1,222 @@
+import { ExampleController, initializeCustomProcessors } from '../../../src/controllers/example/ExampleController';
+import { ProcessorManager } from '../../../src/framework/decorator/processor/ProcessorManager';
+import { AnnotationRegistry } from '../../../src/framework/decorator/processor/AnnotationDecorators';
+
+// 模拟依赖
+jest.mock('@src/framework/decorator/controller', () => ({
+    Get: jest.fn(),
+    Query: jest.fn(),
+    State: jest.fn()
+}));
+
+jest.mock('@src/framework/decorator/processor/AnnotationDecorators', () => ({
+    Logging: jest.fn(),
+    Permission: jest.fn(),
+    RateLimit: jest.fn(),
+    AnnotationRegistry: {
+        register: jest.fn(),
+        get: jest.fn(),
+        getAll: jest.fn()
+    }
+}));
+
+jest.mock('@src/framework/decorator/processor/ProcessorManager', () => ({
+    ProcessorManager: {
+        registerProcessor: jest.fn(),
+        initialize: jest.fn()
+    }
+}));
+
+jest.mock('@src/framework/utils/logger', () => ({
+    logger: {
+        info: jest.fn()
+    }
+}));
+
+describe('示例控制器测试', () => {
+    let exampleController: ExampleController;
+
+    beforeEach(() => {
+        exampleController = new ExampleController();
+        jest.clearAllMocks();
+    });
+
+    describe('ExampleController', () => {
+        test('应该能够创建控制器实例', () => {
+            expect(exampleController).toBeInstanceOf(ExampleController);
+        });
+
+        test('getSecureData方法应该返回正确的数据结构', async () => {
+            const mockQuery = { id: '123' };
+            const mockState = { user: { id: 1, name: 'test' } };
+
+            const result = await exampleController.getSecureData(mockQuery, mockState);
+
+            expect(result).toEqual({
+                code: 0,
+                data: {
+                    message: '这是受保护的数据',
+                    user: mockState.user,
+                    query: mockQuery
+                }
+            });
+        });
+
+        test('getMixedData方法应该返回正确的数据结构', async () => {
+            const mockQuery = { id: '456' };
+
+            const result = await exampleController.getMixedData(mockQuery);
+
+            expect(result).toEqual({
+                code: 0,
+                data: {
+                    message: '混合注解示例',
+                    query: mockQuery
+                }
+            });
+        });
+
+        test('getNewOnlyData方法应该返回正确的数据结构', async () => {
+            const result = await exampleController.getNewOnlyData();
+
+            expect(result).toEqual({
+                code: 0,
+                data: {
+                    message: '仅使用新注解系统'
+                }
+            });
+        });
+    });
+
+    describe('注解装饰器测试', () => {
+        test('getSecureData方法应该有正确的注解', () => {
+            const { Logging, Permission, RateLimit } = require('@src/framework/decorator/processor/AnnotationDecorators');
+
+            // 验证装饰器被调用
+            expect(Logging).toHaveBeenCalled();
+            expect(Permission).toHaveBeenCalledWith({ requiredPermission: 'read:data' });
+            expect(RateLimit).toHaveBeenCalledWith({ maxRequests: 10, windowMs: 60000 });
+        });
+
+        test('getMixedData方法应该有Logging注解', () => {
+            const { Logging } = require('@src/framework/decorator/processor/AnnotationDecorators');
+
+            expect(Logging).toHaveBeenCalled();
+        });
+
+        test('getNewOnlyData方法应该有Logging和RateLimit注解', () => {
+            const { Logging, RateLimit } = require('@src/framework/decorator/processor/AnnotationDecorators');
+
+            expect(Logging).toHaveBeenCalled();
+            expect(RateLimit).toHaveBeenCalledWith({ maxRequests: 5, windowMs: 30000 });
+        });
+    });
+
+    describe('initializeCustomProcessors', () => {
+        test('应该注册自定义处理器', () => {
+            const { ProcessorManager } = require('@src/framework/decorator/processor/ProcessorManager');
+
+            initializeCustomProcessors();
+
+            expect(ProcessorManager.registerProcessor).toHaveBeenCalledTimes(3);
+        });
+
+        test('应该记录注册日志', () => {
+            const { logger } = require('@src/framework/utils/logger');
+
+            initializeCustomProcessors();
+
+            expect(logger.info).toHaveBeenCalledWith('自定义注解处理器已注册');
+        });
+    });
+
+    describe('控制器方法集成测试', () => {
+        test('getSecureData方法应该处理权限检查', async () => {
+            const mockQuery = { id: '123' };
+            const mockState = { 
+                user: { 
+                    id: 1, 
+                    name: 'test',
+                    permissions: ['read:data'] 
+                } 
+            };
+
+            const result = await exampleController.getSecureData(mockQuery, mockState);
+
+            expect(result.code).toBe(0);
+            expect(result.data.user).toEqual(mockState.user);
+        });
+
+        test('getMixedData方法应该处理查询参数', async () => {
+            const mockQuery = { 
+                id: '456',
+                name: 'test',
+                category: 'example'
+            };
+
+            const result = await exampleController.getMixedData(mockQuery);
+
+            expect(result.code).toBe(0);
+            expect(result.data.query).toEqual(mockQuery);
+        });
+
+        test('getNewOnlyData方法应该返回静态数据', async () => {
+            const result = await exampleController.getNewOnlyData();
+
+            expect(result.code).toBe(0);
+            expect(result.data.message).toBe('仅使用新注解系统');
+        });
+    });
+
+    describe('错误处理测试', () => {
+        test('方法应该能够处理异常情况', async () => {
+            // 测试空参数
+            const result1 = await exampleController.getSecureData(null, null);
+            expect(result1.code).toBe(0);
+
+            // 测试undefined参数
+            const result2 = await exampleController.getMixedData(undefined);
+            expect(result2.code).toBe(0);
+
+            // 测试空对象参数
+            const result3 = await exampleController.getSecureData({}, {});
+            expect(result3.code).toBe(0);
+        });
+    });
+
+    describe('注解系统兼容性测试', () => {
+        test('应该能够与旧的注解系统兼容', () => {
+            const { Get, Query, State } = require('@src/framework/decorator/controller');
+
+            // 验证旧的装饰器被调用
+            expect(Get).toHaveBeenCalled();
+            expect(Query).toHaveBeenCalled();
+            expect(State).toHaveBeenCalled();
+        });
+
+        test('应该能够使用新的注解装饰器', () => {
+            const { Logging, Permission, RateLimit } = require('@src/framework/decorator/processor/AnnotationDecorators');
+
+            // 验证新的装饰器被调用
+            expect(Logging).toHaveBeenCalled();
+            expect(Permission).toHaveBeenCalled();
+            expect(RateLimit).toHaveBeenCalled();
+        });
+    });
+
+    describe('性能测试', () => {
+        test('方法调用应该有合理的性能', async () => {
+            const startTime = Date.now();
+            
+            for (let i = 0; i < 1000; i++) {
+                await exampleController.getNewOnlyData();
+            }
+            
+            const endTime = Date.now();
+            const duration = endTime - startTime;
+            
+            // 1000次调用应该在合理时间内完成（这里设置为1秒）
+            expect(duration).toBeLessThan(1000);
+        });
+    });
+});

package/template/test/controllers/example/NewAnnotationExampleController.test.ts

@@ -0,0 +1,200 @@
+import { NewAnnotationExampleController } from '../../../src/controllers/example/NewAnnotationExampleController';
+import { MigrationHelper } from '../../../src/framework/utils/MigrationHelper';
+import { ProcessorManager } from '../../../src/framework/decorator/processor/ProcessorManager';
+import { TestDatabaseHelper, TestUtils } from '../../utils/testHelpers';
+
+describe('新注解系统集成测试', () => {
+    let controller: NewAnnotationExampleController;
+
+    beforeAll(async () => {
+        // 初始化测试数据库
+        await TestDatabaseHelper.initTestDatabase();
+        
+        // 启用新注解系统
+        MigrationHelper.enableNewSystem();
+        
+        // 创建控制器实例
+        controller = new NewAnnotationExampleController();
+    });
+
+    afterAll(async () => {
+        // 清理测试数据库
+        await TestDatabaseHelper.closeTestDatabase();
+    });
+
+    beforeEach(async () => {
+        // 重置测试数据
+        await TestDatabaseHelper.resetTestData();
+    });
+
+    describe('系统状态检查', () => {
+        test('应该正确初始化新注解系统', () => {
+            const status = MigrationHelper.getSystemStatus();
+            expect(status.newSystemEnabled).toBe(true);
+            expect(status.newSystemInitialized).toBe(true);
+        });
+
+        test('应该能够检测控制器注解类型', () => {
+            const isNew = MigrationHelper.isUsingNewAnnotationSystem(controller);
+            const isLegacy = MigrationHelper.isUsingLegacyAnnotationSystem(controller);
+            
+            expect(isNew).toBe(true);
+            expect(isLegacy).toBe(true); // 因为使用了混合注解
+        });
+
+        test('应该能够检查控制器兼容性', () => {
+            const compatibility = MigrationHelper.checkControllerCompatibility(controller);
+            expect(compatibility.compatible).toBe(true);
+        });
+    });
+
+    describe('基础功能测试', () => {
+        test('应该能够执行基础示例方法', async () => {
+            const mockQuery = { id: '123', name: 'test' };
+            const mockContext = TestUtils.createMockContext({}, mockQuery);
+            
+            const result = await controller.basicExample(mockQuery);
+            
+            expect(result.code).toBe(0);
+            expect(result.data).toBe('基础示例执行成功');
+        });
+
+        test('应该能够处理权限检查', async () => {
+            const mockUser = {
+                id: 1,
+                name: 'test',
+                permissions: ['read:sensitive-data']
+            };
+            const mockState = { user: mockUser };
+            
+            const result = await controller.getProtectedData(mockUser);
+            
+            expect(result.code).toBe(0);
+            expect(result.data.message).toBe('这是受保护的数据');
+            expect(result.data.user).toEqual(mockUser);
+        });
+
+        test('应该能够处理限流', async () => {
+            const mockBody = { name: 'test', value: 'example' };
+            
+            // 第一次请求应该成功
+            const result1 = await controller.rateLimitedEndpoint(mockBody);
+            expect(result1.code).toBe(0);
+            
+            // 连续请求应该成功（在测试环境中限流可能不会生效）
+            const result2 = await controller.rateLimitedEndpoint(mockBody);
+            expect(result2.code).toBe(0);
+        });
+    });
+
+    describe('复合注解测试', () => {
+        test('应该能够处理复合注解', async () => {
+            const mockQuery = { id: '456', category: 'test' };
+            const mockUser = {
+                id: 1,
+                name: 'test',
+                permissions: ['read:complex-data']
+            };
+            
+            const result = await controller.complexExample(mockQuery, mockUser);
+            
+            expect(result.code).toBe(0);
+            expect(result.data.message).toBe('复杂示例执行成功');
+            expect(result.data.query).toEqual(mockQuery);
+            expect(result.data.user).toEqual(mockUser);
+        });
+
+        test('应该能够处理混合注解', async () => {
+            const mockBody = { name: 'mixed', value: 'example' };
+            
+            const result = await controller.mixedAnnotations(mockBody);
+            
+            expect(result.code).toBe(0);
+            expect(result.data.message).toBe('混合注解示例执行成功');
+            expect(result.data.note).toBe('这个端点同时使用了新旧注解系统');
+        });
+    });
+
+    describe('错误处理测试', () => {
+        test('应该能够处理权限不足错误', async () => {
+            await expect(controller.errorExample()).rejects.toThrow('模拟权限不足错误');
+        });
+    });
+
+    describe('异步处理测试', () => {
+        test('应该能够处理异步方法', async () => {
+            const startTime = Date.now();
+            const result = await controller.asyncExample();
+            const endTime = Date.now();
+            
+            expect(result.code).toBe(0);
+            expect(result.data.message).toBe('异步处理完成');
+            expect(endTime - startTime).toBeGreaterThanOrEqual(1000); // 至少1秒
+        });
+    });
+
+    describe('数据验证测试', () => {
+        test('应该能够处理数据验证', async () => {
+            const mockBody = { name: 'validation', value: 'test' };
+            
+            const result = await controller.validationExample(mockBody);
+            
+            expect(result.code).toBe(0);
+            expect(result.data.message).toBe('验证通过');
+            expect(result.data.receivedData).toEqual(mockBody);
+        });
+    });
+
+    describe('系统切换测试', () => {
+        test('应该能够切换注解系统', () => {
+            // 当前应该是新系统
+            expect(MigrationHelper.getCurrentSystem()).toBe('new');
+            
+            // 切换到旧系统
+            MigrationHelper.disableNewSystem();
+            expect(MigrationHelper.getCurrentSystem()).toBe('legacy');
+            
+            // 切换回新系统
+            MigrationHelper.enableNewSystem();
+            expect(MigrationHelper.getCurrentSystem()).toBe('new');
+        });
+
+        test('应该能够切换系统状态', () => {
+            const initialState = MigrationHelper.getCurrentSystem();
+            
+            // 切换系统
+            const newState = MigrationHelper.toggleSystem();
+            
+            if (initialState === 'new') {
+                expect(newState).toBe(false);
+                expect(MigrationHelper.getCurrentSystem()).toBe('legacy');
+            } else {
+                expect(newState).toBe(true);
+                expect(MigrationHelper.getCurrentSystem()).toBe('new');
+            }
+        });
+    });
+
+    describe('性能测试', () => {
+        test('应该能够处理大量请求', async () => {
+            const mockQuery = { id: 'perf', name: 'test' };
+            const startTime = Date.now();
+            
+            // 执行100次请求
+            const promises = Array(100).fill(null).map(() => 
+                controller.basicExample(mockQuery)
+            );
+            
+            const results = await Promise.all(promises);
+            const endTime = Date.now();
+            
+            // 验证所有请求都成功
+            results.forEach(result => {
+                expect(result.code).toBe(0);
+            });
+            
+            // 验证性能（100次请求应该在合理时间内完成）
+            expect(endTime - startTime).toBeLessThan(5000); // 5秒内完成
+        });
+    });
+});