create-dp-koa 1.0.0

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

@@ -0,0 +1,246 @@
+import { AnnotationExecutor, AnnotationProcessorRegistry } from '../../../src/framework/decorator/processor/AnnotationProcessor';
+import { Context } from 'koa';
+
+// 模拟 Koa Context
+const createMockContext = (): Context => ({
+    status: 200,
+    body: null,
+    request: {
+        body: { test: 'body' },
+        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 TestProcessor implements AnnotationProcessor {
+    readonly name = 'TestProcessor';
+    readonly priority = 100;
+    
+    public processCallCount = 0;
+    public lastAnnotationData: any = null;
+    public shouldReturn = true;
+
+    async process(
+        ctx: Context,
+        controller: any,
+        methodName: string,
+        annotationData: any,
+        callParams: any[]
+    ): Promise<boolean> {
+        this.processCallCount++;
+        this.lastAnnotationData = annotationData;
+        return this.shouldReturn;
+    }
+}
+
+describe('注解执行器测试', () => {
+    let testProcessor: TestProcessor;
+    let mockContext: Context;
+
+    beforeEach(() => {
+        testProcessor = new TestProcessor();
+        mockContext = createMockContext();
+        AnnotationProcessorRegistry.clear();
+    });
+
+    describe('AnnotationExecutor.execute', () => {
+        test('应该能够执行所有相关处理器', async () => {
+            AnnotationProcessorRegistry.register(testProcessor);
+
+            const mockController = {
+                $_Annotations: new Map([
+                    ['testMethod', new Map([
+                        ['TestProcessor', { testData: 'value' }]
+                    ])]
+                ])
+            };
+
+            const result = await AnnotationExecutor.execute(
+                mockContext,
+                mockController,
+                'testMethod',
+                []
+            );
+
+            expect(result).toBe(true);
+            expect(testProcessor.processCallCount).toBe(1);
+            expect(testProcessor.lastAnnotationData).toEqual({ testData: 'value' });
+        });
+
+        test('应该跳过没有注解数据的方法', async () => {
+            AnnotationProcessorRegistry.register(testProcessor);
+
+            const mockController = {
+                $_Annotations: new Map([
+                    ['testMethod', new Map([
+                        ['TestProcessor', { testData: 'value' }]
+                    ])]
+                ])
+            };
+
+            const result = await AnnotationExecutor.execute(
+                mockContext,
+                mockController,
+                'otherMethod', // 没有注解数据的方法
+                []
+            );
+
+            expect(result).toBe(true);
+            expect(testProcessor.processCallCount).toBe(0);
+        });
+
+        test('处理器返回false应该中断执行', async () => {
+            testProcessor.shouldReturn = false;
+            AnnotationProcessorRegistry.register(testProcessor);
+
+            const mockController = {
+                $_Annotations: new Map([
+                    ['testMethod', new Map([
+                        ['TestProcessor', { testData: 'value' }]
+                    ])]
+                ])
+            };
+
+            const result = await AnnotationExecutor.execute(
+                mockContext,
+                mockController,
+                'testMethod',
+                []
+            );
+
+            expect(result).toBe(false);
+        });
+
+        test('应该支持多个处理器', async () => {
+            const processor1 = new TestProcessor();
+            processor1.name = 'Processor1';
+            processor1.priority = 50;
+
+            const processor2 = new TestProcessor();
+            processor2.name = 'Processor2';
+            processor2.priority = 100;
+
+            AnnotationProcessorRegistry.register(processor1);
+            AnnotationProcessorRegistry.register(processor2);
+
+            const mockController = {
+                $_Annotations: new Map([
+                    ['testMethod', new Map([
+                        ['Processor1', { data1: 'value1' }],
+                        ['Processor2', { data2: 'value2' }]
+                    ])]
+                ])
+            };
+
+            const result = await AnnotationExecutor.execute(
+                mockContext,
+                mockController,
+                'testMethod',
+                []
+            );
+
+            expect(result).toBe(true);
+            expect(processor1.processCallCount).toBe(1);
+            expect(processor2.processCallCount).toBe(1);
+            expect(processor1.lastAnnotationData).toEqual({ data1: 'value1' });
+            expect(processor2.lastAnnotationData).toEqual({ data2: 'value2' });
+        });
+
+        test('应该按优先级顺序执行处理器', async () => {
+            const executionOrder: string[] = [];
+
+            const processor1 = new TestProcessor();
+            processor1.name = 'Processor1';
+            processor1.priority = 100;
+            processor1.process = jest.fn().mockImplementation(async () => {
+                executionOrder.push('Processor1');
+                return true;
+            });
+
+            const processor2 = new TestProcessor();
+            processor2.name = 'Processor2';
+            processor2.priority = 50;
+            processor2.process = jest.fn().mockImplementation(async () => {
+                executionOrder.push('Processor2');
+                return true;
+            });
+
+            AnnotationProcessorRegistry.register(processor1);
+            AnnotationProcessorRegistry.register(processor2);
+
+            const mockController = {
+                $_Annotations: new Map([
+                    ['testMethod', new Map([
+                        ['Processor1', { data1: 'value1' }],
+                        ['Processor2', { data2: 'value2' }]
+                    ])]
+                ])
+            };
+
+            await AnnotationExecutor.execute(
+                mockContext,
+                mockController,
+                'testMethod',
+                []
+            );
+
+            expect(executionOrder).toEqual(['Processor2', 'Processor1']); // 优先级高的先执行
+        });
+
+        test('应该兼容旧的注解系统', async () => {
+            AnnotationProcessorRegistry.register(testProcessor);
+
+            const mockController = {
+                $_MethdosParamInfo: new Map([
+                    ['testMethod', [{ type: 'Body', validate: null }]]
+                ])
+            };
+
+            const result = await AnnotationExecutor.execute(
+                mockContext,
+                mockController,
+                'testMethod',
+                []
+            );
+
+            expect(result).toBe(true);
+            expect(testProcessor.processCallCount).toBe(1);
+        });
+
+        test('处理器抛出异常不应该中断执行', async () => {
+            const errorProcessor = new TestProcessor();
+            errorProcessor.name = 'ErrorProcessor';
+            errorProcessor.process = jest.fn().mockRejectedValue(new Error('Test error'));
+
+            const normalProcessor = new TestProcessor();
+            normalProcessor.name = 'NormalProcessor';
+
+            AnnotationProcessorRegistry.register(errorProcessor);
+            AnnotationProcessorRegistry.register(normalProcessor);
+
+            const mockController = {
+                $_Annotations: new Map([
+                    ['testMethod', new Map([
+                        ['ErrorProcessor', { data: 'value' }],
+                        ['NormalProcessor', { data: 'value' }]
+                    ])]
+                ])
+            };
+
+            const result = await AnnotationExecutor.execute(
+                mockContext,
+                mockController,
+                'testMethod',
+                []
+            );
+
+            expect(result).toBe(true);
+            expect(normalProcessor.processCallCount).toBe(1);
+        });
+    });
+});

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

@@ -0,0 +1,179 @@
+import { AnnotationProcessor, AnnotationProcessorRegistry } from '../../../src/framework/decorator/processor/AnnotationProcessor';
+import { Context } from 'koa';
+
+// 模拟 Koa Context
+const createMockContext = (): Context => ({
+    status: 200,
+    body: null,
+    request: {
+        body: {},
+        headers: {},
+        query: {}
+    },
+    params: {},
+    state: {},
+    set: jest.fn(),
+    throw: jest.fn()
+} as any);
+
+// 测试用的注解处理器
+class TestProcessor implements AnnotationProcessor {
+    readonly name = 'TestProcessor';
+    readonly priority = 100;
+    
+    public processCallCount = 0;
+    public lastAnnotationData: any = null;
+    public shouldReturn = true;
+
+    async process(
+        ctx: Context,
+        controller: any,
+        methodName: string,
+        annotationData: any,
+        callParams: any[]
+    ): Promise<boolean> {
+        this.processCallCount++;
+        this.lastAnnotationData = annotationData;
+        return this.shouldReturn;
+    }
+}
+
+// 可配置的测试处理器
+class ConfigurableTestProcessor implements AnnotationProcessor {
+    readonly name: string;
+    readonly priority: number;
+    
+    public processCallCount = 0;
+    public lastAnnotationData: any = null;
+    public shouldReturn = true;
+
+    constructor(name: string, priority: number) {
+        this.name = name;
+        this.priority = priority;
+    }
+
+    async process(
+        ctx: Context,
+        controller: any,
+        methodName: string,
+        annotationData: any,
+        callParams: any[]
+    ): Promise<boolean> {
+        this.processCallCount++;
+        this.lastAnnotationData = annotationData;
+        return this.shouldReturn;
+    }
+}
+
+describe('注解处理器系统测试', () => {
+    let testProcessor: TestProcessor;
+    let mockContext: Context;
+
+    beforeEach(() => {
+        testProcessor = new TestProcessor();
+        mockContext = createMockContext();
+        AnnotationProcessorRegistry.clear();
+    });
+
+    describe('AnnotationProcessorRegistry', () => {
+        test('应该能够注册处理器', () => {
+            AnnotationProcessorRegistry.register(testProcessor);
+            
+            const retrievedProcessor = AnnotationProcessorRegistry.getProcessor('TestProcessor');
+            expect(retrievedProcessor).toBe(testProcessor);
+        });
+
+        test('应该能够获取所有处理器', () => {
+            const processor1 = new ConfigurableTestProcessor('Processor1', 50);
+            const processor2 = new ConfigurableTestProcessor('Processor2', 100);
+
+            AnnotationProcessorRegistry.register(processor2);
+            AnnotationProcessorRegistry.register(processor1);
+
+            const allProcessors = AnnotationProcessorRegistry.getAllProcessors();
+            expect(allProcessors).toHaveLength(2);
+            expect(allProcessors[0]).toBe(processor1); // 优先级高的在前面
+            expect(allProcessors[1]).toBe(processor2);
+        });
+
+        test('应该能够移除处理器', () => {
+            AnnotationProcessorRegistry.register(testProcessor);
+            expect(AnnotationProcessorRegistry.getProcessor('TestProcessor')).toBe(testProcessor);
+
+            const removed = AnnotationProcessorRegistry.unregister('TestProcessor');
+            expect(removed).toBe(true);
+            expect(AnnotationProcessorRegistry.getProcessor('TestProcessor')).toBeUndefined();
+        });
+
+        test('应该能够清空所有处理器', () => {
+            AnnotationProcessorRegistry.register(testProcessor);
+            expect(AnnotationProcessorRegistry.getAllProcessors()).toHaveLength(1);
+
+            AnnotationProcessorRegistry.clear();
+            expect(AnnotationProcessorRegistry.getAllProcessors()).toHaveLength(0);
+        });
+
+        test('移除不存在的处理器应该返回false', () => {
+            const removed = AnnotationProcessorRegistry.unregister('NonExistentProcessor');
+            expect(removed).toBe(false);
+        });
+    });
+
+    describe('处理器优先级', () => {
+        test('应该按优先级排序处理器', () => {
+            const processor1 = new ConfigurableTestProcessor('Processor1', 200);
+            const processor2 = new ConfigurableTestProcessor('Processor2', 50);
+            const processor3 = new ConfigurableTestProcessor('Processor3', 100);
+
+            AnnotationProcessorRegistry.register(processor1);
+            AnnotationProcessorRegistry.register(processor2);
+            AnnotationProcessorRegistry.register(processor3);
+
+            const allProcessors = AnnotationProcessorRegistry.getAllProcessors();
+            expect(allProcessors[0]).toBe(processor2); // 优先级 50
+            expect(allProcessors[1]).toBe(processor3); // 优先级 100
+            expect(allProcessors[2]).toBe(processor1); // 优先级 200
+        });
+    });
+
+    describe('处理器执行', () => {
+        test('应该能够执行处理器', async () => {
+            AnnotationProcessorRegistry.register(testProcessor);
+
+            const mockController = {
+                $_Annotations: new Map([
+                    ['testMethod', new Map([
+                        ['TestProcessor', { testData: 'value' }]
+                    ])]
+                ])
+            };
+
+            const result = await AnnotationProcessorRegistry.getAllProcessors()[0].process(
+                mockContext,
+                mockController,
+                'testMethod',
+                { testData: 'value' },
+                []
+            );
+
+            expect(result).toBe(true);
+            expect(testProcessor.processCallCount).toBe(1);
+            expect(testProcessor.lastAnnotationData).toEqual({ testData: 'value' });
+        });
+
+        test('处理器返回false应该中断执行', async () => {
+            testProcessor.shouldReturn = false;
+            AnnotationProcessorRegistry.register(testProcessor);
+
+            const result = await testProcessor.process(
+                mockContext,
+                {},
+                'testMethod',
+                {},
+                []
+            );
+
+            expect(result).toBe(false);
+        });
+    });
+});