create-dp-koa 1.0.0 → 1.0.2

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

@@ -1,173 +0,0 @@
-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/NewAnnotationExampleController.test.ts

@@ -1,200 +0,0 @@
-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秒内完成
-        });
-    });
-});