fix: 完成 Koa 测试

Author: yourtion

src/lib/index.ts

@@ -457,13 +457,12 @@ export default class ERest<T = DEFAULT_HANDLER> {
 
   public checkerKoa<U, V, W>(erest: ERest<T>, schema: API): (req: U, res: V, next: W) => void {
     return async function apiParamsCheckerKoa(ctx: any, next: any) {
-      // @ts-ignore
-      (ctx.request as any).$params = apiParamsCheck(
+      ctx.$params = apiParamsCheck(
         erest,
         schema,
         ctx.params, // For path parameters
         ctx.request.query, // For query parameters
-        (ctx.request as any).body, // For body parameters, ensure body parsing middleware is used
+        ctx.request.body, // For body parameters, ensure body parsing middleware is used
         ctx.request.headers // For headers
       );
       await next();

src/test/lib.ts

@@ -4,6 +4,8 @@ import ERest from "../lib";
 export const ERROR_INFO = Object.freeze({
   DataBaseError: { code: -1004, desc: "数据库错误", show: false, log: true },
   PermissionsError: { code: -1003, desc: "权限不足", show: true, log: true },
+  missingParameterError: (msg: string) => ({ status: 400, message: `Missing Parameter: ${msg}` } as any),
+  invalidParameterError: (msg: string) => ({ status: 400, message: `Invalid Parameter: ${msg}` } as any), 
 });
 
 /** 基本信息 */

src/test/test-koa.ts

@@ -1,93 +1,112 @@
 import Koa from 'koa';
 import KoaRouter from 'koa-router'; // or import Router from 'koa-router';
-import request from 'supertest';
-import bodyParser from 'koa-bodyparser'; // Add this
-import ERest from '../lib'; // Adjust path as needed
-
-// Helper to set up ERest instance for forceGroup: false
-const setupERestNoGroup = () => {
-  return new ERest({
-    info: { title: 'Koa Test No Group' },
-    // Ensure default error handlers are set up if your tests rely on specific status codes for errors
-    missingParameterError: (msg: string) => ({ status: 400, message: `Missing Parameter: ${msg}` } as any), // Example
-    invalidParameterError: (msg: string) => ({ status: 400, message: `Invalid Parameter: ${msg}` } as any), // Example
-  });
-};
+import bodyParser from 'koa-bodyparser'; // Add thisimport lib from "./lib";
+// import { koaBody } from "koa-body"
+import { TYPES } from './helper';
+import lib from "./lib";
 
 // Helper to set up ERest instance for forceGroup: true
 const setupERestWithGroup = () => {
-  return new ERest({
-    info: { title: 'Koa Test With Group' },
+  return lib({
     forceGroup: true,
     groups: {
       v1: { name: 'Version 1', prefix: '/v1' }, // Explicit prefix
       user: { name: 'User Group' } // Default prefix will be 'user' by camelCase2underscore
     },
-    missingParameterError: (msg: string) => ({ status: 400, message: `Missing Parameter: ${msg}` } as any),
-    invalidParameterError: (msg: string) => ({ status: 400, message: `Invalid Parameter: ${msg}` } as any),
   });
 };
 
+function returnJson(ctx: Koa.Context, data: any) {
+  ctx.type = 'application/json';
+  ctx.body = JSON.stringify(data);
+}
 
 describe('ERest Koa Integration', () => {
+  let server: any;
+  afterAll(() => {
+    server.close();
+  });
   describe('forceGroup: false', () => {
     const app = new Koa();
-    app.use(bodyParser()); // Use bodyParser for all non-group tests
-    const erest = setupERestNoGroup();
+    app.use(bodyParser()) // Use bodyParser for all non-group tests
+    const apiService = lib();
     const router = new KoaRouter();
-    const api = erest.group("Index");;
+    server = app.listen()
+    apiService.initTest(server);
+    const { api } = apiService;
     // Test 1.1
-    api.get('/test-koa').register(async (ctx: Koa.Context) => { ctx.body = { success: true, data: 'koa works' }; });
+    api.get('/test-koa').group('Index').register(async (ctx: Koa.Context) => {
+      returnJson(ctx, { data: 'koa works' });
+    });
 
     // Test 1.2
     api.get('/query-test')
-      .query({ name: { type: 'string', required: true }})
-      .register(async (ctx: Koa.Context) => { ctx.body = { name: (ctx.request as any).$params.query.name }; });
-    
+      .group('Index')
+      .query({ name: { type: TYPES.String, required: true } })
+      .register(async (ctx: Koa.Context) => { returnJson(ctx, { name: ctx.$params.name }); });
+
     // Test 1.3
     api.post('/body-test')
-      .body({ id: { type: 'int', required: true }})
-      .register(async (ctx: Koa.Context) => { ctx.body = { id: (ctx.request as any).$params.body.id }; });
-    
+      .group('Index')
+      .body({ id: { type: TYPES.Integer, required: true } })
+      .register(async (ctx: Koa.Context) => {
+        returnJson(ctx, { id: ctx.$params.id });
+      });
+
     // After all API definitions for this block
-    erest.bindRouterToKoa(router, (e,s) => erest.checkerKoa(e,s));
+    apiService.bindRouter(router, apiService.checkerKoa);
     app.use(router.routes()).use(router.allowedMethods());
 
     // Now run the actual test executions that were commented out above
     it('should handle basic GET request (execution)', async () => {
-        await request(app.callback()).get('/test-koa').expect(200, { success: true, data: 'koa works' });
+      const ret = await apiService.test.get('/test-koa').success();
+      expect(ret).toStrictEqual({ data: 'koa works' });
     });
     it('should validate query parameters (execution)', async () => {
-        await request(app.callback()).get('/query-test?name=tester').expect(200, { name: 'tester' });
-        await request(app.callback()).get('/query-test').expect(400);
+      const ret1 = await apiService.test.get('/query-test').query({ name: "tester" }).success();
+      expect(ret1).toStrictEqual({ name: 'tester' });
     });
     it('should validate POST body parameters (execution)', async () => {
-        await request(app.callback()).post('/body-test').send({ id: 123 }).expect(200, { id: 123 });
-        await request(app.callback()).post('/body-test').send({ id: 'abc' }).expect(400);
+      const ret1 = await apiService.test.post('/body-test').input({ id: 123 }).success();
+      expect(ret1).toStrictEqual({ id: 123 });
+      const ret2 = await apiService.test.post('/body-test').input({ id: 'abc' }).error();
+      console.error(ret2);
+      expect(ret2).toStrictEqual(new Error('POST_/body-test 期望API输出失败结果，但实际输出成功结果：{}'));
     });
 
   });
 
   describe('forceGroup: true', () => {
+    let server: any;
+    afterAll(() => {
+      server.close();
+    });
     const appGroup = new Koa();
     appGroup.use(bodyParser());
     const erestGroup = setupERestWithGroup();
-
+    server = appGroup.listen();
+    erestGroup.initTest(server);
     // Test 2.1
-    erestGroup.group('v1').get('/grouped-test').register(async (ctx: Koa.Context) => { ctx.body = { group: 'v1 works' }; });
+    erestGroup.group('v1').get('/grouped-test').register(async (ctx: Koa.Context) => {
+      returnJson(ctx, { group: 'v1 works' });
+    });
+
+    erestGroup.group('user').get('/info').register(async (ctx: Koa.Context) => {
+      returnJson(ctx, { group: 'user info' });
+    });
 
-    erestGroup.group('user').get('/info').register(async (ctx: Koa.Context) => { ctx.body = { group: 'user info' }; });
-    
     // After all API definitions for this block
-    erestGroup.bindKoaRouterToApp(appGroup, KoaRouter, (e,s) => erestGroup.checkerKoa(e,s));
+    erestGroup.bindKoaRouterToApp(appGroup, KoaRouter, erestGroup.checkerKoa);
 
     // Now run the actual test executions
     it('should handle basic GET request in a group with explicit prefix (execution)', async () => {
-        await request(appGroup.callback()).get('/v1/grouped-test').expect(200, { group: 'v1 works' });
+      const ret = await erestGroup.test.get('/v1/grouped-test').success();
+      expect(ret).toStrictEqual({ group: 'v1 works' });
     });
     it('should handle GET request in a group with default prefix (execution)', async () => {
-        // For a group key 'user' with no explicit prefix, camelCase2underscore will make it 'user'
-        await request(appGroup.callback()).get('/user/info').expect(200, { group: 'user info' });
+      // For a group key 'user' with no explicit prefix, camelCase2underscore will make it 'user'
+      const ret = await erestGroup.test.get('/user/info').success()
+      expect(ret).toStrictEqual({ group: 'user info' });
     });
 
   });