test: add case for @midwayjs/express

midwayjs · czy88840616 · Sep 13, 2020 · Aug 31, 2020 · Aug 31, 2020 · Sep 1, 2020
commit 5bfa5b5e4a365e2d392611baddf81f2bd3d83fc7
diff --git a/packages/core/src/context/container.ts b/packages/core/src/context/container.ts
@@ -77,7 +77,7 @@ export class Container extends BaseApplicationContext implements IContainer {
     // inject properties
     const metaDatas = recursiveGetMetadata(TAGGED_PROP, target);
     for (const metaData of metaDatas) {
-      this.debugLogger(`inject properties => [${Object.keys(metaData)}]`);
+      this.debugLogger(`  inject properties => [${Object.keys(metaData)}]`);
       for (const metaKey in metaData) {
         for (const propertyMeta of metaData[ metaKey ]) {
           const refManaged = new ManagedReference();
@@ -109,35 +109,35 @@ export class Container extends BaseApplicationContext implements IContainer {
   private convertOptionsToDefinition(options: ObjectDefinitionOptions, definition: ObjectDefinition): ObjectDefinition {
     if (options) {
       if (options.isAsync) {
-        this.debugLogger(`   register isAsync = true`);
+        this.debugLogger(`  register isAsync = true`);
         definition.asynchronous = true;
       }
 
       if (options.initMethod) {
-        this.debugLogger(`   register initMethod = ${options.initMethod}`);
+        this.debugLogger(`  register initMethod = ${options.initMethod}`);
         definition.initMethod = options.initMethod;
       }
 
       if (options.destroyMethod) {
-        this.debugLogger(`   register destroyMethod = ${options.destroyMethod}`);
+        this.debugLogger(`  register destroyMethod = ${options.destroyMethod}`);
         definition.destroyMethod = options.destroyMethod;
       }
 
       if (options.scope) {
-        this.debugLogger(`   register scope = ${options.scope}`);
+        this.debugLogger(`  register scope = ${options.scope}`);
         definition.scope = options.scope;
       }
 
       if (options.constructorArgs) {
-        this.debugLogger(`   register constructorArgs = ${options.constructorArgs}`);
+        this.debugLogger(`  register constructorArgs = ${options.constructorArgs}`);
         definition.constructorArgs = options.constructorArgs;
       }
 
       if (options.isAutowire === false) {
-        this.debugLogger(`   register autowire = ${options.isAutowire}`);
+        this.debugLogger(`  register autowire = ${options.isAutowire}`);
         definition.autowire = false;
       } else if (options.isAutowire === true) {
-        this.debugLogger(`   register autowire = ${options.isAutowire}`);
+        this.debugLogger(`  register autowire = ${options.isAutowire}`);
         definition.autowire = true;
       }
     }

diff --git a/packages/core/src/context/requestContainer.ts b/packages/core/src/context/requestContainer.ts
@@ -12,8 +12,11 @@ export class MidwayRequestContainer extends MidwayContainer {
     this.applicationContext = applicationContext;
     // register ctx
     this.registerObject(REQUEST_CTX_KEY, ctx);
-    // register contextLogger
-    this.registerObject('logger', ctx.logger);
+
+    if (ctx.logger) {
+      // register contextLogger
+      this.registerObject('logger', ctx.logger);
+    }
 
     const resolverHandler = this.applicationContext.resolverHandler;
     this.beforeEachCreated(resolverHandler.beforeEachCreated.bind(resolverHandler));

diff --git a/packages/web-express/src/framework.ts b/packages/web-express/src/framework.ts
@@ -37,7 +37,7 @@ import {
   IMidwayExpressRequest
 } from './interface';
 import type { IRouter, IRouterHandler, RequestHandler } from 'express';
-import * as express from "express";
+import * as express from 'express';
 
 export class MidwayExpressFramework extends BaseFramework<IMidwayExpressConfigurationOptions> {
   protected app: IMidwayExpressApplication;
@@ -117,7 +117,7 @@ export class MidwayExpressFramework extends BaseFramework<IMidwayExpressConfigur
       const args = [req, res, next];
       if (Array.isArray(routeArgsInfo)) {
         await Promise.all(
-          routeArgsInfo.map(async ({index, type, propertyData}) => {
+          routeArgsInfo.map(async ({ index, type, propertyData }) => {
             args[index] = await extractExpressLikeValue(type, propertyData)(req, res, next);
           })
         );
@@ -130,16 +130,13 @@ export class MidwayExpressFramework extends BaseFramework<IMidwayExpressConfigur
         for (const routerRes of routerResponseData) {
           switch (routerRes.type) {
             case WEB_RESPONSE_HTTP_CODE:
-              res.status = routerRes.code;
+              res.status(routerRes.code);
               break;
             case WEB_RESPONSE_HEADER:
-              routerRes.setHeaders.forEach((key, value) => {
-                res.set(key, value);
-              });
+              res.set(routerRes.setHeaders);
               break;
             case WEB_RESPONSE_REDIRECT:
-              res.status = routerRes.code;
-              res.redirect(routerRes.url);
+              res.redirect(routerRes.code, routerRes.url);
               return;
           }
         }
@@ -218,12 +215,13 @@ export class MidwayExpressFramework extends BaseFramework<IMidwayExpressConfigur
         for (const webRouter of webRouterInfo) {
           // get middleware
           const middlewares2 = webRouter.middleware as unknown as MiddlewareParamArray;
-          const methodMiddlewares: MiddlewareParamArray = [];
+          // const methodMiddlewares: MiddlewareParamArray = [];
 
           await this.handlerWebMiddleware(
             middlewares2,
             (middlewareImpl: Middleware) => {
-              methodMiddlewares.push(middlewareImpl);
+              // methodMiddlewares.push(middlewareImpl);
+              newRouter.use(middlewareImpl);
             }
           );
 
@@ -242,19 +240,12 @@ export class MidwayExpressFramework extends BaseFramework<IMidwayExpressConfigur
               webRouter.method
             ) || [];
 
-          const routerArgs = [
-            webRouter.routerName,
-            webRouter.path,
-            ...methodMiddlewares,
-            this.generateController(
-              `${controllerId}.${webRouter.method}`,
-              routeArgsInfo,
-              routerResponseData
-            ),
-          ];
-
           // apply controller from request context
-          newRouter[webRouter.requestMethod].apply(newRouter, routerArgs);
+          newRouter[webRouter.requestMethod].call(newRouter, webRouter.path, this.generateController(
+            `${controllerId}.${webRouter.method}`,
+            routeArgsInfo,
+            routerResponseData
+          ));
         }
       }
 
@@ -274,10 +265,10 @@ export class MidwayExpressFramework extends BaseFramework<IMidwayExpressConfigur
   protected createRouter(controllerOption: ControllerOption): IRouter {
     const {
       prefix,
-      routerOptions: {sensitive},
+      routerOptions: { sensitive },
     } = controllerOption;
     if (prefix) {
-      return express.Router({caseSensitive: sensitive});
+      return express.Router({ caseSensitive: sensitive });
     }
     return null;
   }

diff --git a/packages/web-express/src/index.ts b/packages/web-express/src/index.ts
@@ -1,2 +1,2 @@
-export { MidwayExpressFramework } from './framework';
 export * from './interface';
+export { MidwayExpressFramework as Framework } from './framework';
diff --git a/packages/web-express/src/interface.ts b/packages/web-express/src/interface.ts
@@ -1,5 +1,4 @@
 import { IMidwayApplication, IMidwayContext } from '@midwayjs/core';
-// import { KoaMiddlewareParamArray } from '@midwayjs/decorator';
 import { Application, Request, Response, RequestHandler } from 'express';
 
 export type IMidwayExpressRequest = IMidwayContext & Request;

diff --git a/packages/web-express/test/fixtures/base-app/package.json b/packages/web-express/test/fixtures/base-app/package.json
@@ -0,0 +1,3 @@
+{
+  "name": "ali-demo"
+}
diff --git a/packages/web-express/test/fixtures/base-app/src/config/config.default.ts b/packages/web-express/test/fixtures/base-app/src/config/config.default.ts
@@ -0,0 +1,9 @@
+'use strict';
+
+export const keys = 'key';
+
+export const hello = {
+  a: 1,
+  b: 2,
+  d: [1, 2, 3],
+};
diff --git a/packages/web-express/test/fixtures/base-app/src/config/config.unittest.ts b/packages/web-express/test/fixtures/base-app/src/config/config.unittest.ts
@@ -0,0 +1,5 @@
+
+exports.hello = {
+  b: 4,
+  c: 3,
+};
diff --git a/packages/web-express/test/fixtures/base-app/src/configuration.ts b/packages/web-express/test/fixtures/base-app/src/configuration.ts
@@ -0,0 +1,20 @@
+import { Configuration, App } from '@midwayjs/decorator';
+import { IMidwayExpressApplication, IMidwayExpressRequest } from '../../../../src';
+
+@Configuration({
+  importConfigs: [
+    './config'
+  ]
+})
+export class ContainerConfiguration {
+
+  @App()
+  app: IMidwayExpressApplication;
+
+  async onReady() {
+    this.app.use((req: IMidwayExpressRequest, res, next) => {
+      console.log('invoke middleware in ready');
+      next();
+    });
+  }
+}
diff --git a/packages/web-express/test/fixtures/base-app/src/controller/api.ts b/packages/web-express/test/fixtures/base-app/src/controller/api.ts
@@ -0,0 +1,40 @@
+import {
+  Controller,
+  Post,
+  Get,
+  Provide,
+  Inject,
+  Query,
+  Body,
+  HttpCode,
+  Redirect,
+} from '@midwayjs/decorator';
+import { UserService } from '../service/user';
+import { IMidwayExpressRequest } from '../../../../../src';
+
+@Provide()
+@Controller('/')
+export class APIController {
+  @Inject()
+  req: IMidwayExpressRequest;
+
+  @Inject()
+  userService: UserService;
+
+  @Post()
+  async postData(@Body('bbbbb') bbbb) {
+    return 'data';
+  }
+
+  @Get('/', { middleware: [] })
+  @HttpCode(201)
+  async home(@Query('name') name: string) {
+    return 'hello world,' + name;
+  }
+
+  @Get('/login')
+  @Redirect('/')
+  async redirect() {
+  }
+
+}
diff --git a/packages/web-express/test/fixtures/base-app/src/service/user.ts b/packages/web-express/test/fixtures/base-app/src/service/user.ts
@@ -0,0 +1,10 @@
+import { Provide } from '@midwayjs/decorator';
+
+@Provide()
+export class UserService {
+  async hello(name) {
+    return {
+      name,
+    };
+  }
+}
diff --git a/packages/web-express/test/index.test.ts b/packages/web-express/test/index.test.ts
@@ -0,0 +1,29 @@
+import * as request from 'supertest';
+import { closeApp, creatApp } from './utils';
+import { IMidwayExpressApplication } from '../src';
+
+describe('/test/feature.test.ts', () => {
+
+  describe('test new features', () => {
+    let app: IMidwayExpressApplication;
+    beforeAll(async () => {
+      app = await creatApp('base-app');
+    });
+
+    afterAll(async () => {
+      await closeApp(app);
+    });
+
+    it('test get method with return value', async () => {
+      const result = await request(app).get('/').query({ name: 'harry' });
+      expect(result.status).toBe(201);
+      expect(result.text).toBe('hello world,harry');
+    });
+
+    it('test get method with redirect', async () => {
+      const result = await request(app).get('/login');
+      expect(result.status).toBe(302);
+    });
+  });
+
+});
diff --git a/packages/web-express/test/utils.ts b/packages/web-express/test/utils.ts
@@ -0,0 +1,11 @@
+import { IMidwayExpressConfigurationOptions, Framework, IMidwayExpressApplication } from '../src';
+import { join } from 'path';
+import { createApp, close } from '@midwayjs/mock';
+
+export async function creatApp(name: string, options: IMidwayExpressConfigurationOptions = {}): Promise<IMidwayExpressApplication> {
+  return createApp(join(__dirname, 'fixtures', name), options, Framework);
+}
+
+export async function closeApp(app) {
+  return close(app);
+}