create-dp-koa 1.0.0

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

@@ -0,0 +1,313 @@
+import { LoggingProcessor, PermissionProcessor, RateLimitProcessor } from '../../../src/framework/decorator/processor/processors/CustomProcessors';
+import { Context } from 'koa';
+
+// 模拟 Koa Context
+const createMockContext = (): Context => ({
+    status: 200,
+    body: null,
+    request: {
+        body: {},
+        headers: {},
+        query: {}
+    },
+    params: {},
+    state: {},
+    ip: '127.0.0.1',
+    set: jest.fn(),
+    throw: jest.fn()
+} as any);
+
+describe('自定义处理器测试', () => {
+    let mockContext: Context;
+
+    beforeEach(() => {
+        mockContext = createMockContext();
+        jest.clearAllMocks();
+        // 清空控制台输出
+        jest.spyOn(console, 'log').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe('LoggingProcessor', () => {
+        let processor: LoggingProcessor;
+
+        beforeEach(() => {
+            processor = new LoggingProcessor();
+        });
+
+        test('应该正确设置名称和优先级', () => {
+            expect(processor.name).toBe('Logging');
+            expect(processor.priority).toBe(10);
+        });
+
+        test('应该记录请求开始日志', async () => {
+            const mockController = {
+                constructor: { name: 'TestController' }
+            };
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                null,
+                [{ id: 1 }]
+            );
+
+            expect(result).toBe(true);
+            expect(console.log).toHaveBeenCalledWith(
+                '[Logging] 开始处理请求: TestController.testMethod'
+            );
+            expect(console.log).toHaveBeenCalledWith(
+                '[Logging] 请求参数:',
+                [{ id: 1 }]
+            );
+            expect(mockContext.state.loggingStartTime).toBeDefined();
+        });
+
+        test('logResponse静态方法应该记录响应日志', () => {
+            mockContext.state.loggingStartTime = Date.now() - 100; // 100ms前
+
+            LoggingProcessor.logResponse(
+                mockContext,
+                { constructor: { name: 'TestController' } },
+                'testMethod',
+                { data: 'test' }
+            );
+
+            expect(console.log).toHaveBeenCalledWith(
+                '[Logging] 完成处理请求: TestController.testMethod'
+            );
+            expect(console.log).toHaveBeenCalledWith(
+                '[Logging] 响应数据:',
+                { data: 'test' }
+            );
+            expect(console.log).toHaveBeenCalledWith(
+                expect.stringMatching(/\[Logging\] 处理耗时: \d+ms/)
+            );
+        });
+    });
+
+    describe('PermissionProcessor', () => {
+        let processor: PermissionProcessor;
+
+        beforeEach(() => {
+            processor = new PermissionProcessor();
+        });
+
+        test('应该正确设置名称和优先级', () => {
+            expect(processor.name).toBe('Permission');
+            expect(processor.priority).toBe(5);
+        });
+
+        test('没有用户信息时应该返回false', async () => {
+            mockContext.state = {};
+
+            const result = await processor.process(
+                mockContext,
+                {},
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(false);
+            expect(mockContext.status).toBe(401);
+            expect(mockContext.body).toEqual({ error: '未授权访问' });
+        });
+
+        test('有用户信息但没有权限要求时应该返回true', async () => {
+            mockContext.state = {
+                user: { id: 1, name: 'test' }
+            };
+
+            const result = await processor.process(
+                mockContext,
+                {},
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('用户有足够权限时应该返回true', async () => {
+            mockContext.state = {
+                user: {
+                    id: 1,
+                    name: 'test',
+                    permissions: ['read:data', 'write:data']
+                }
+            };
+
+            const result = await processor.process(
+                mockContext,
+                {},
+                'testMethod',
+                { requiredPermission: 'read:data' },
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('用户权限不足时应该返回false', async () => {
+            mockContext.state = {
+                user: {
+                    id: 1,
+                    name: 'test',
+                    permissions: ['read:data']
+                }
+            };
+
+            const result = await processor.process(
+                mockContext,
+                {},
+                'testMethod',
+                { requiredPermission: 'write:data' },
+                []
+            );
+
+            expect(result).toBe(false);
+            expect(mockContext.status).toBe(403);
+            expect(mockContext.body).toEqual({ error: '权限不足' });
+        });
+
+        test('用户没有权限数组时应该返回false', async () => {
+            mockContext.state = {
+                user: {
+                    id: 1,
+                    name: 'test'
+                }
+            };
+
+            const result = await processor.process(
+                mockContext,
+                {},
+                'testMethod',
+                { requiredPermission: 'read:data' },
+                []
+            );
+
+            expect(result).toBe(false);
+            expect(mockContext.status).toBe(403);
+            expect(mockContext.body).toEqual({ error: '权限不足' });
+        });
+    });
+
+    describe('RateLimitProcessor', () => {
+        let processor: RateLimitProcessor;
+
+        beforeEach(() => {
+            processor = new RateLimitProcessor();
+            // 清空静态属性
+            (RateLimitProcessor as any).requestCounts.clear();
+        });
+
+        test('应该正确设置名称和优先级', () => {
+            expect(processor.name).toBe('RateLimit');
+            expect(processor.priority).toBe(15);
+        });
+
+        test('没有注解数据时应该返回true', async () => {
+            const result = await processor.process(
+                mockContext,
+                {},
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('请求次数在限制内时应该返回true', async () => {
+            const result = await processor.process(
+                mockContext,
+                {},
+                'testMethod',
+                { maxRequests: 10, windowMs: 60000 },
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('请求次数超过限制时应该返回false', async () => {
+            const annotationData = { maxRequests: 2, windowMs: 60000 };
+
+            // 第一次请求
+            await processor.process(mockContext, {}, 'testMethod', annotationData, []);
+            
+            // 第二次请求
+            await processor.process(mockContext, {}, 'testMethod', annotationData, []);
+            
+            // 第三次请求应该被限制
+            const result = await processor.process(mockContext, {}, 'testMethod', annotationData, []);
+
+            expect(result).toBe(false);
+            expect(mockContext.status).toBe(429);
+            expect(mockContext.body).toEqual({ error: '请求过于频繁，请稍后再试' });
+        });
+
+        test('应该使用默认限制参数', async () => {
+            const result = await processor.process(
+                mockContext,
+                {},
+                'testMethod',
+                {},
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('不同客户端应该有独立的限制', async () => {
+            const context1 = createMockContext();
+            context1.ip = '192.168.1.1';
+            
+            const context2 = createMockContext();
+            context2.ip = '192.168.1.2';
+
+            const annotationData = { maxRequests: 1, windowMs: 60000 };
+
+            // 客户端1的请求
+            await processor.process(context1, {}, 'testMethod', annotationData, []);
+            
+            // 客户端2的请求应该不受影响
+            const result = await processor.process(context2, {}, 'testMethod', annotationData, []);
+
+            expect(result).toBe(true);
+        });
+
+        test('不同方法应该有独立的限制', async () => {
+            const annotationData = { maxRequests: 1, windowMs: 60000 };
+
+            // 方法1的请求
+            await processor.process(mockContext, { constructor: { name: 'Controller' } }, 'method1', annotationData, []);
+            
+            // 方法2的请求应该不受影响
+            const result = await processor.process(mockContext, { constructor: { name: 'Controller' } }, 'method2', annotationData, []);
+
+            expect(result).toBe(true);
+        });
+
+        test('时间窗口过期后应该重置计数器', async () => {
+            const annotationData = { maxRequests: 1, windowMs: 1 }; // 1ms窗口
+
+            // 第一次请求
+            await processor.process(mockContext, {}, 'testMethod', annotationData, []);
+            
+            // 等待窗口过期
+            await new Promise(resolve => setTimeout(resolve, 10));
+            
+            // 第二次请求应该成功
+            const result = await processor.process(mockContext, {}, 'testMethod', annotationData, []);
+
+            expect(result).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,371 @@
+import { ParameterValidationProcessor, ResponseValidationProcessor, CacheProcessor, ResponseCodeProcessor, ResponseHeaderProcessor } from '../../../src/framework/decorator/processor/processors/DefaultProcessors';
+import { Context } from 'koa';
+import { validate } from 'class-validator';
+
+// 模拟 class-validator
+jest.mock('class-validator', () => ({
+    validate: jest.fn()
+}));
+
+// 模拟 Koa Context
+const createMockContext = (): Context => ({
+    status: 200,
+    body: null,
+    request: {
+        body: { name: 'test', email: 'test@example.com' },
+        headers: { 'content-type': 'application/json' },
+        query: { id: '123' }
+    },
+    params: { userId: '456' },
+    state: { user: { id: 1, name: 'test' } },
+    set: jest.fn(),
+    throw: jest.fn()
+} as any);
+
+// 测试用的验证类
+class TestValidationClass {
+    name: string;
+    email: string;
+}
+
+describe('默认处理器测试', () => {
+    let mockContext: Context;
+
+    beforeEach(() => {
+        mockContext = createMockContext();
+        jest.clearAllMocks();
+    });
+
+    describe('ParameterValidationProcessor', () => {
+        let processor: ParameterValidationProcessor;
+
+        beforeEach(() => {
+            processor = new ParameterValidationProcessor();
+        });
+
+        test('应该正确设置名称和优先级', () => {
+            expect(processor.name).toBe('ParameterValidation');
+            expect(processor.priority).toBe(100);
+        });
+
+        test('没有参数信息时应该返回true', async () => {
+            const mockController = {};
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('没有验证类时应该返回true', async () => {
+            const mockController = {
+                $_MethdosParamInfo: new Map([
+                    ['testMethod', [{ type: 'Body', validate: null }]]
+                ])
+            };
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                [{ type: 'Body', validate: null }],
+                [{ name: 'test' }]
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('验证通过时应该返回true', async () => {
+            (validate as jest.Mock).mockResolvedValue([]);
+
+            const mockController = {
+                $_MethdosParamInfo: new Map([
+                    ['testMethod', [{ type: 'Body', validate: TestValidationClass }]]
+                ])
+            };
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                [{ type: 'Body', validate: TestValidationClass }],
+                [{ name: 'test', email: 'test@example.com' }]
+            );
+
+            expect(result).toBe(true);
+            expect(validate).toHaveBeenCalled();
+        });
+
+        test('验证失败时应该返回false并设置响应', async () => {
+            const validationErrors = [{ property: 'email', constraints: { isEmail: 'email格式不正确' } }];
+            (validate as jest.Mock).mockResolvedValue(validationErrors);
+
+            const mockController = {
+                $_MethdosParamInfo: new Map([
+                    ['testMethod', [{ type: 'Body', validate: TestValidationClass }]]
+                ])
+            };
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                [{ type: 'Body', validate: TestValidationClass }],
+                [{ name: 'test', email: 'invalid-email' }]
+            );
+
+            expect(result).toBe(false);
+            expect(mockContext.status).toBe(400);
+            expect(mockContext.body).toEqual(validationErrors);
+        });
+    });
+
+    describe('ResponseValidationProcessor', () => {
+        let processor: ResponseValidationProcessor;
+
+        beforeEach(() => {
+            processor = new ResponseValidationProcessor();
+        });
+
+        test('应该正确设置名称和优先级', () => {
+            expect(processor.name).toBe('ResponseValidation');
+            expect(processor.priority).toBe(200);
+        });
+
+        test('process方法应该返回true', async () => {
+            const result = await processor.process(
+                mockContext,
+                {},
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('validateResponse方法应该处理ResponseValidateIf注解', async () => {
+            (validate as jest.Mock).mockResolvedValue([]);
+
+            const mockController = {
+                $_ResponseValidateIf: new Map([
+                    ['testMethod', {
+                        fn: jest.fn().mockReturnValue({ name: 'test' }),
+                        clas: TestValidationClass
+                    }]
+                ])
+            };
+
+            const errors = await processor.validateResponse(
+                mockController,
+                'testMethod',
+                { name: 'test' }
+            );
+
+            expect(errors).toEqual([]);
+            expect(validate).toHaveBeenCalled();
+        });
+
+        test('validateResponse方法应该处理ResponseValidator注解', async () => {
+            (validate as jest.Mock).mockResolvedValue([]);
+
+            const mockController = {
+                $_ResponseValidator: new Map([
+                    ['testMethod', {
+                        clas: TestValidationClass,
+                        objectKey: 'data'
+                    }]
+                ])
+            };
+
+            const errors = await processor.validateResponse(
+                mockController,
+                'testMethod',
+                { data: { name: 'test' } }
+            );
+
+            expect(errors).toEqual([]);
+            expect(validate).toHaveBeenCalled();
+        });
+
+        test('没有验证注解时应该返回空数组', async () => {
+            const mockController = {};
+
+            const errors = await processor.validateResponse(
+                mockController,
+                'testMethod',
+                { name: 'test' }
+            );
+
+            expect(errors).toEqual([]);
+        });
+    });
+
+    describe('CacheProcessor', () => {
+        let processor: CacheProcessor;
+
+        beforeEach(() => {
+            processor = new CacheProcessor();
+        });
+
+        test('应该正确设置名称和优先级', () => {
+            expect(processor.name).toBe('Cache');
+            expect(processor.priority).toBe(50);
+        });
+
+        test('没有缓存注解时应该返回true', async () => {
+            const mockController = {};
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('缓存禁用时应该返回true', async () => {
+            const mockController = {
+                $_ControllerCache: new Map([
+                    ['testMethod', {
+                        cacheyFn: jest.fn(),
+                        options: { enable: false }
+                    }]
+                ])
+            };
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                { cacheyFn: jest.fn(), options: { enable: false } },
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+    });
+
+    describe('ResponseCodeProcessor', () => {
+        let processor: ResponseCodeProcessor;
+
+        beforeEach(() => {
+            processor = new ResponseCodeProcessor();
+        });
+
+        test('应该正确设置名称和优先级', () => {
+            expect(processor.name).toBe('ResponseCode');
+            expect(processor.priority).toBe(300);
+        });
+
+        test('没有响应码注解时应该返回true', async () => {
+            const mockController = {};
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('应该设置响应码', async () => {
+            const mockController = {
+                $_ResponseCode: new Map([
+                    ['testMethod', 201]
+                ])
+            };
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(true);
+            expect(mockContext.status).toBe(201);
+        });
+
+        test('没有指定响应码时应该使用默认值200', async () => {
+            const mockController = {
+                $_ResponseCode: new Map([
+                    ['testMethod', undefined]
+                ])
+            };
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(true);
+            expect(mockContext.status).toBe(200);
+        });
+    });
+
+    describe('ResponseHeaderProcessor', () => {
+        let processor: ResponseHeaderProcessor;
+
+        beforeEach(() => {
+            processor = new ResponseHeaderProcessor();
+        });
+
+        test('应该正确设置名称和优先级', () => {
+            expect(processor.name).toBe('ResponseHeader');
+            expect(processor.priority).toBe(400);
+        });
+
+        test('没有响应头注解时应该返回true', async () => {
+            const mockController = {};
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(true);
+        });
+
+        test('应该设置响应头', async () => {
+            const mockController = {
+                $_ResponseHeader: new Map([
+                    ['testMethod', new Map([
+                        ['Content-Type', 'application/json'],
+                        ['Cache-Control', 'no-cache']
+                    ])]
+                ])
+            };
+
+            const result = await processor.process(
+                mockContext,
+                mockController,
+                'testMethod',
+                null,
+                []
+            );
+
+            expect(result).toBe(true);
+            expect(mockContext.set).toHaveBeenCalledWith('Content-Type', 'application/json');
+            expect(mockContext.set).toHaveBeenCalledWith('Cache-Control', 'no-cache');
+        });
+    });
+});