create-dp-koa 1.0.0

package/template/test/framework/annotation/NewRouter.test.ts

@@ -0,0 +1,272 @@
+import { callControllerWithProcessors } from '../../../src/framework/utils/NewRouter';
+import { ProcessorManager } from '../../../src/framework/decorator/processor/ProcessorManager';
+import { LoggingProcessor, PermissionProcessor } from '../../../src/framework/decorator/processor/processors/CustomProcessors';
+import { Context } from 'koa';
+
+// 模拟 Koa Context
+const createMockContext = (): Context => ({
+    status: 200,
+    body: null,
+    request: {
+        body: { name: 'test' },
+        headers: { 'content-type': 'application/json' },
+        query: { id: '123' }
+    },
+    params: { userId: '456' },
+    state: { user: { id: 1, name: 'test', permissions: ['read:data'] } },
+    set: jest.fn(),
+    throw: jest.fn()
+} as any);
+
+// 模拟 class-validator
+jest.mock('class-validator', () => ({
+    validate: jest.fn().mockResolvedValue([])
+}));
+
+// 模拟缓存
+jest.mock('../../../src/framework/utils/cache', () => ({
+    createCache: jest.fn().mockReturnValue({
+        set: jest.fn(),
+        get: jest.fn()
+    }),
+    CacheType: {
+        CONTROLLER: 'controller'
+    }
+}));
+
+// 模拟日志
+jest.mock('../../../src/framework/utils/logger', () => ({
+    logger: {
+        error: jest.fn()
+    }
+}));
+
+describe('新路由系统集成测试', () => {
+    let mockContext: Context;
+
+    beforeEach(() => {
+        mockContext = createMockContext();
+        ProcessorManager.clear();
+        ProcessorManager.initialize();
+        jest.clearAllMocks();
+        jest.spyOn(console, 'log').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe('callControllerWithProcessors', () => {
+        test('应该能够调用控制器方法', async () => {
+            const mockController = {
+                testMethod: jest.fn().mockReturnValue({ data: 'test' }),
+                $_MethdosParamInfo: new Map([
+                    ['testMethod', [{ type: 'Body', validate: null }]]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(mockController.testMethod).toHaveBeenCalledWith({ name: 'test' });
+            expect(mockContext.body).toEqual({ data: 'test' });
+        });
+
+        test('应该能够处理异步控制器方法', async () => {
+            const mockController = {
+                testMethod: jest.fn().mockResolvedValue({ data: 'async test' }),
+                $_MethdosParamInfo: new Map([
+                    ['testMethod', [{ type: 'Body', validate: null }]]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(mockController.testMethod).toHaveBeenCalledWith({ name: 'test' });
+            expect(mockContext.body).toEqual({ data: 'async test' });
+        });
+
+        test('应该能够处理不同类型的参数', async () => {
+            const mockController = {
+                testMethod: jest.fn().mockReturnValue({ data: 'test' }),
+                $_MethdosParamInfo: new Map([
+                    ['testMethod', [
+                        { type: 'Body', validate: null },
+                        { type: 'Query', validate: null },
+                        { type: 'Params', validate: null },
+                        { type: 'Headers', validate: null },
+                        { type: 'State', validate: null }
+                    ]]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(mockController.testMethod).toHaveBeenCalledWith(
+                { name: 'test' }, // Body
+                { id: '123' },    // Query
+                { userId: '456' }, // Params
+                { 'content-type': 'application/json' }, // Headers
+                { user: { id: 1, name: 'test', permissions: ['read:data'] } } // State
+            );
+        });
+
+        test('应该能够处理响应验证', async () => {
+            const mockController = {
+                testMethod: jest.fn().mockReturnValue({ data: 'test' }),
+                $_ResponseValidator: new Map([
+                    ['testMethod', { clas: class {}, objectKey: '' }]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(mockContext.body).toEqual({ data: 'test' });
+        });
+
+        test('响应验证失败时应该设置错误响应', async () => {
+            const { validate } = require('class-validator');
+            validate.mockResolvedValue([{ property: 'data', constraints: { isNotEmpty: '数据不能为空' } }]);
+
+            const mockController = {
+                testMethod: jest.fn().mockReturnValue({ data: '' }),
+                $_ResponseValidator: new Map([
+                    ['testMethod', { clas: class {}, objectKey: '' }]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(mockContext.status).toBe(400);
+            expect(mockContext.body).toBe('接口testMethod返回数据参数校验异常');
+        });
+
+        test('应该能够处理缓存注解', async () => {
+            const mockController = {
+                testMethod: jest.fn().mockReturnValue({ data: 'test' }),
+                $_ControllerCache: new Map([
+                    ['testMethod', {
+                        cacheyFn: jest.fn().mockReturnValue('cache-key'),
+                        options: { enable: true, ttl: 30 }
+                    }]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(mockController.testMethod).toHaveBeenCalled();
+            expect(mockContext.body).toEqual({ data: 'test' });
+        });
+
+        test('应该能够处理响应码注解', async () => {
+            const mockController = {
+                testMethod: jest.fn().mockReturnValue({ data: 'test' }),
+                $_ResponseCode: new Map([
+                    ['testMethod', 201]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(mockContext.status).toBe(201);
+            expect(mockContext.body).toEqual({ data: 'test' });
+        });
+
+        test('应该能够处理响应头注解', async () => {
+            const mockController = {
+                testMethod: jest.fn().mockReturnValue({ data: 'test' }),
+                $_ResponseHeader: new Map([
+                    ['testMethod', new Map([
+                        ['Content-Type', 'application/json'],
+                        ['Cache-Control', 'no-cache']
+                    ])]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(mockContext.set).toHaveBeenCalledWith('Content-Type', 'application/json');
+            expect(mockContext.set).toHaveBeenCalledWith('Cache-Control', 'no-cache');
+        });
+
+        test('控制器方法抛出异常时应该重新抛出', async () => {
+            const mockController = {
+                testMethod: jest.fn().mockRejectedValue(new Error('Controller error'))
+            };
+
+            await expect(callControllerWithProcessors(mockContext, mockController, 'testMethod'))
+                .rejects.toThrow('Controller error');
+        });
+
+        test('应该能够处理自定义处理器', async () => {
+            ProcessorManager.registerProcessor(new LoggingProcessor());
+
+            const mockController = {
+                testMethod: jest.fn().mockReturnValue({ data: 'test' }),
+                $_Annotations: new Map([
+                    ['testMethod', new Map([
+                        ['Logging', { level: 'info' }]
+                    ])]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(console.log).toHaveBeenCalledWith(
+                '[Logging] 开始处理请求: undefined.testMethod'
+            );
+            expect(mockContext.body).toEqual({ data: 'test' });
+        });
+
+        test('权限处理器拒绝访问时应该中断执行', async () => {
+            ProcessorManager.registerProcessor(new PermissionProcessor());
+
+            const mockController = {
+                testMethod: jest.fn().mockReturnValue({ data: 'test' }),
+                $_Annotations: new Map([
+                    ['testMethod', new Map([
+                        ['Permission', { requiredPermission: 'write:data' }]
+                    ])]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(mockController.testMethod).not.toHaveBeenCalled();
+            expect(mockContext.status).toBe(403);
+            expect(mockContext.body).toEqual({ error: '权限不足' });
+        });
+
+        test('应该能够处理复杂的注解组合', async () => {
+            ProcessorManager.registerProcessor(new LoggingProcessor());
+            ProcessorManager.registerProcessor(new PermissionProcessor());
+
+            const mockController = {
+                testMethod: jest.fn().mockReturnValue({ data: 'test' }),
+                $_Annotations: new Map([
+                    ['testMethod', new Map([
+                        ['Logging', { level: 'info' }],
+                        ['Permission', { requiredPermission: 'read:data' }]
+                    ])]
+                ]),
+                $_ResponseCode: new Map([
+                    ['testMethod', 200]
+                ]),
+                $_ResponseHeader: new Map([
+                    ['testMethod', new Map([
+                        ['Content-Type', 'application/json']
+                    ])]
+                ])
+            };
+
+            await callControllerWithProcessors(mockContext, mockController, 'testMethod');
+
+            expect(console.log).toHaveBeenCalledWith(
+                '[Logging] 开始处理请求: undefined.testMethod'
+            );
+            expect(mockController.testMethod).toHaveBeenCalled();
+            expect(mockContext.status).toBe(200);
+            expect(mockContext.set).toHaveBeenCalledWith('Content-Type', 'application/json');
+            expect(mockContext.body).toEqual({ data: 'test' });
+        });
+    });
+});

package/template/test/framework/annotation/ProcessorManager.test.ts

@@ -0,0 +1,248 @@
+import { ProcessorManager } from '../../../src/framework/decorator/processor/ProcessorManager';
+import { AnnotationProcessor } from '../../../src/framework/decorator/processor/AnnotationProcessor';
+import { 
+    ParameterValidationProcessor,
+    ResponseValidationProcessor,
+    CacheProcessor,
+    ResponseCodeProcessor,
+    ResponseHeaderProcessor
+} from '../../../src/framework/decorator/processor/processors/DefaultProcessors';
+import { LoggingProcessor, PermissionProcessor, RateLimitProcessor } from '../../../src/framework/decorator/processor/processors/CustomProcessors';
+
+// 测试用的注解处理器
+class TestProcessor implements AnnotationProcessor {
+    readonly name = 'TestProcessor';
+    readonly priority = 100;
+
+    async process(): Promise<boolean> {
+        return true;
+    }
+}
+
+describe('处理器管理器测试', () => {
+    beforeEach(() => {
+        ProcessorManager.clear();
+    });
+
+    describe('ProcessorManager', () => {
+        test('initialize方法应该注册默认处理器', () => {
+            ProcessorManager.initialize();
+
+            const allProcessors = ProcessorManager.getAllProcessors();
+            expect(allProcessors.length).toBeGreaterThan(0);
+
+            // 检查是否包含默认处理器
+            const processorNames = allProcessors.map(p => p.name);
+            expect(processorNames).toContain('ParameterValidation');
+            expect(processorNames).toContain('ResponseValidation');
+            expect(processorNames).toContain('Cache');
+            expect(processorNames).toContain('ResponseCode');
+            expect(processorNames).toContain('ResponseHeader');
+        });
+
+        test('多次调用initialize不应该重复注册', () => {
+            ProcessorManager.initialize();
+            const firstCount = ProcessorManager.getAllProcessors().length;
+
+            ProcessorManager.initialize();
+            const secondCount = ProcessorManager.getAllProcessors().length;
+
+            expect(firstCount).toBe(secondCount);
+        });
+
+        test('应该能够注册自定义处理器', () => {
+            const testProcessor = new TestProcessor();
+            ProcessorManager.registerProcessor(testProcessor);
+
+            const retrievedProcessor = ProcessorManager.getProcessor('TestProcessor');
+            expect(retrievedProcessor).toBe(testProcessor);
+        });
+
+        test('应该能够获取所有处理器', () => {
+            const processor1 = new TestProcessor();
+            processor1.name = 'Processor1';
+            processor1.priority = 50;
+
+            const processor2 = new TestProcessor();
+            processor2.name = 'Processor2';
+            processor2.priority = 100;
+
+            ProcessorManager.registerProcessor(processor1);
+            ProcessorManager.registerProcessor(processor2);
+
+            const allProcessors = ProcessorManager.getAllProcessors();
+            expect(allProcessors).toHaveLength(2);
+            expect(allProcessors[0]).toBe(processor1); // 优先级高的在前面
+            expect(allProcessors[1]).toBe(processor2);
+        });
+
+        test('应该能够获取特定处理器', () => {
+            const testProcessor = new TestProcessor();
+            ProcessorManager.registerProcessor(testProcessor);
+
+            const retrievedProcessor = ProcessorManager.getProcessor('TestProcessor');
+            expect(retrievedProcessor).toBe(testProcessor);
+        });
+
+        test('获取不存在的处理器应该返回undefined', () => {
+            const retrievedProcessor = ProcessorManager.getProcessor('NonExistentProcessor');
+            expect(retrievedProcessor).toBeUndefined();
+        });
+
+        test('应该能够移除处理器', () => {
+            const testProcessor = new TestProcessor();
+            ProcessorManager.registerProcessor(testProcessor);
+
+            expect(ProcessorManager.getProcessor('TestProcessor')).toBe(testProcessor);
+
+            const removed = ProcessorManager.removeProcessor('TestProcessor');
+            expect(removed).toBe(true);
+            expect(ProcessorManager.getProcessor('TestProcessor')).toBeUndefined();
+        });
+
+        test('移除不存在的处理器应该返回false', () => {
+            const removed = ProcessorManager.removeProcessor('NonExistentProcessor');
+            expect(removed).toBe(false);
+        });
+
+        test('应该能够清空所有处理器', () => {
+            const testProcessor = new TestProcessor();
+            ProcessorManager.registerProcessor(testProcessor);
+
+            expect(ProcessorManager.getAllProcessors().length).toBeGreaterThan(0);
+
+            ProcessorManager.clear();
+            expect(ProcessorManager.getAllProcessors().length).toBe(0);
+        });
+
+        test('清空后应该能够重新初始化', () => {
+            ProcessorManager.initialize();
+            const initialCount = ProcessorManager.getAllProcessors().length;
+
+            ProcessorManager.clear();
+            expect(ProcessorManager.getAllProcessors().length).toBe(0);
+
+            ProcessorManager.initialize();
+            expect(ProcessorManager.getAllProcessors().length).toBe(initialCount);
+        });
+    });
+
+    describe('默认处理器注册', () => {
+        test('应该注册ParameterValidationProcessor', () => {
+            ProcessorManager.initialize();
+            const processor = ProcessorManager.getProcessor('ParameterValidation');
+            expect(processor).toBeInstanceOf(ParameterValidationProcessor);
+            expect(processor?.priority).toBe(100);
+        });
+
+        test('应该注册ResponseValidationProcessor', () => {
+            ProcessorManager.initialize();
+            const processor = ProcessorManager.getProcessor('ResponseValidation');
+            expect(processor).toBeInstanceOf(ResponseValidationProcessor);
+            expect(processor?.priority).toBe(200);
+        });
+
+        test('应该注册CacheProcessor', () => {
+            ProcessorManager.initialize();
+            const processor = ProcessorManager.getProcessor('Cache');
+            expect(processor).toBeInstanceOf(CacheProcessor);
+            expect(processor?.priority).toBe(50);
+        });
+
+        test('应该注册ResponseCodeProcessor', () => {
+            ProcessorManager.initialize();
+            const processor = ProcessorManager.getProcessor('ResponseCode');
+            expect(processor).toBeInstanceOf(ResponseCodeProcessor);
+            expect(processor?.priority).toBe(300);
+        });
+
+        test('应该注册ResponseHeaderProcessor', () => {
+            ProcessorManager.initialize();
+            const processor = ProcessorManager.getProcessor('ResponseHeader');
+            expect(processor).toBeInstanceOf(ResponseHeaderProcessor);
+            expect(processor?.priority).toBe(400);
+        });
+    });
+
+    describe('自定义处理器注册', () => {
+        test('应该能够注册LoggingProcessor', () => {
+            const loggingProcessor = new LoggingProcessor();
+            ProcessorManager.registerProcessor(loggingProcessor);
+
+            const retrievedProcessor = ProcessorManager.getProcessor('Logging');
+            expect(retrievedProcessor).toBe(loggingProcessor);
+            expect(retrievedProcessor?.priority).toBe(10);
+        });
+
+        test('应该能够注册PermissionProcessor', () => {
+            const permissionProcessor = new PermissionProcessor();
+            ProcessorManager.registerProcessor(permissionProcessor);
+
+            const retrievedProcessor = ProcessorManager.getProcessor('Permission');
+            expect(retrievedProcessor).toBe(permissionProcessor);
+            expect(retrievedProcessor?.priority).toBe(5);
+        });
+
+        test('应该能够注册RateLimitProcessor', () => {
+            const rateLimitProcessor = new RateLimitProcessor();
+            ProcessorManager.registerProcessor(rateLimitProcessor);
+
+            const retrievedProcessor = ProcessorManager.getProcessor('RateLimit');
+            expect(retrievedProcessor).toBe(rateLimitProcessor);
+            expect(retrievedProcessor?.priority).toBe(15);
+        });
+    });
+
+    describe('处理器优先级', () => {
+        test('应该按优先级排序所有处理器', () => {
+            const processor1 = new TestProcessor();
+            processor1.name = 'Processor1';
+            processor1.priority = 200;
+
+            const processor2 = new TestProcessor();
+            processor2.name = 'Processor2';
+            processor2.priority = 50;
+
+            const processor3 = new TestProcessor();
+            processor3.name = 'Processor3';
+            processor3.priority = 100;
+
+            ProcessorManager.registerProcessor(processor1);
+            ProcessorManager.registerProcessor(processor2);
+            ProcessorManager.registerProcessor(processor3);
+
+            const allProcessors = ProcessorManager.getAllProcessors();
+            expect(allProcessors[0]).toBe(processor2); // 优先级 50
+            expect(allProcessors[1]).toBe(processor3); // 优先级 100
+            expect(allProcessors[2]).toBe(processor1); // 优先级 200
+        });
+
+        test('默认处理器应该按正确优先级排序', () => {
+            ProcessorManager.initialize();
+            const allProcessors = ProcessorManager.getAllProcessors();
+
+            // 检查优先级顺序
+            const priorities = allProcessors.map(p => p.priority);
+            const sortedPriorities = [...priorities].sort((a, b) => a - b);
+            expect(priorities).toEqual(sortedPriorities);
+        });
+    });
+
+    describe('处理器覆盖', () => {
+        test('注册同名处理器应该覆盖原有处理器', () => {
+            const processor1 = new TestProcessor();
+            processor1.name = 'TestProcessor';
+            processor1.priority = 100;
+
+            const processor2 = new TestProcessor();
+            processor2.name = 'TestProcessor';
+            processor2.priority = 200;
+
+            ProcessorManager.registerProcessor(processor1);
+            expect(ProcessorManager.getProcessor('TestProcessor')).toBe(processor1);
+
+            ProcessorManager.registerProcessor(processor2);
+            expect(ProcessorManager.getProcessor('TestProcessor')).toBe(processor2);
+        });
+    });
+});

package/template/test/framework/annotation/setup.ts

@@ -0,0 +1,26 @@
+import { TestDatabaseHelper } from '../utils/testHelpers';
+
+// 设置测试环境
+beforeAll(async () => {
+    // 初始化测试数据库
+    await TestDatabaseHelper.initTestDatabase();
+});
+
+afterAll(async () => {
+    // 清理测试数据库
+    await TestDatabaseHelper.closeTestDatabase();
+});
+
+beforeEach(async () => {
+    // 重置测试数据
+    await TestDatabaseHelper.resetTestData();
+});
+
+// 全局测试超时设置
+jest.setTimeout(10000);
+
+// 清理所有定时器
+afterEach(() => {
+    jest.clearAllTimers();
+    jest.clearAllMocks();
+});

package/template/test/framework/cache.test.ts

@@ -0,0 +1,101 @@
+import { TestDatabaseHelper, TestUtils } from '../utils/testHelpers';
+import { createCache, CacheType, getCacheStats, clearAllCaches } from '../../src/framework/utils/cache';
+
+describe('缓存管理测试', () => {
+    beforeEach(() => {
+        clearAllCaches();
+    });
+
+    afterEach(() => {
+        clearAllCaches();
+    });
+
+    describe('缓存创建', () => {
+        test('应该能够创建用户缓存', () => {
+            const userCache = createCache('test-user-cache', CacheType.USER);
+            expect(userCache).toBeDefined();
+        });
+
+        test('应该能够创建控制器缓存', () => {
+            const controllerCache = createCache('test-controller-cache', CacheType.CONTROLLER);
+            expect(controllerCache).toBeDefined();
+        });
+
+        test('应该能够创建验证码缓存', () => {
+            const captchaCache = createCache('test-captcha-cache', CacheType.CAPTCHA);
+            expect(captchaCache).toBeDefined();
+        });
+    });
+
+    describe('缓存操作', () => {
+        test('应该能够设置和获取缓存值', () => {
+            const cache = createCache('test-cache', CacheType.TEMP);
+            const key = 'test-key';
+            const value = { name: 'test', value: 123 };
+
+            cache.set(key, value);
+            const retrieved = cache.get(key);
+
+            expect(retrieved).toEqual(value);
+        });
+
+        test('应该能够删除缓存值', () => {
+            const cache = createCache('test-cache', CacheType.TEMP);
+            const key = 'test-key';
+            const value = 'test-value';
+
+            cache.set(key, value);
+            expect(cache.get(key)).toBe(value);
+
+            cache.del(key);
+            expect(cache.get(key)).toBeUndefined();
+        });
+
+        test('应该能够清空所有缓存', () => {
+            const cache1 = createCache('test-cache-1', CacheType.TEMP);
+            const cache2 = createCache('test-cache-2', CacheType.TEMP);
+
+            cache1.set('key1', 'value1');
+            cache2.set('key2', 'value2');
+
+            expect(cache1.get('key1')).toBe('value1');
+            expect(cache2.get('key2')).toBe('value2');
+
+            clearAllCaches();
+
+            expect(cache1.get('key1')).toBeUndefined();
+            expect(cache2.get('key2')).toBeUndefined();
+        });
+    });
+
+    describe('缓存统计', () => {
+        test('应该能够获取缓存统计信息', () => {
+            const cache = createCache('test-cache-stats', CacheType.TEMP);
+            
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.get('key1'); // 命中
+            cache.get('key3'); // 未命中
+
+            const stats = getCacheStats();
+            expect(stats['test-cache-stats']).toBeDefined();
+            expect(stats['test-cache-stats'].hits).toBe(1);
+            expect(stats['test-cache-stats'].misses).toBe(1);
+            expect(stats['test-cache-stats'].keys).toBe(2);
+        });
+    });
+
+    describe('缓存过期', () => {
+        test('应该能够设置缓存过期时间', async () => {
+            const cache = createCache('test-cache', CacheType.TEMP);
+            const key = 'test-key';
+            const value = 'test-value';
+
+            cache.set(key, value, 1); // 1秒过期
+            expect(cache.get(key)).toBe(value);
+
+            await TestUtils.wait(1100); // 等待1.1秒
+            expect(cache.get(key)).toBeUndefined();
+        });
+    });
+});