build: update tests

Author: NoNameProvided

package-lock.json

@@ -52,8 +52,10 @@
   "devDependencies": {
     "@types/express": "^4.17.6",
     "@types/express-session": "^1.17.0",
+    "@types/form-data": "^2.5.0",
     "@types/jest": "^26.0.9",
     "@types/koa": "^2.11.3",
+    "@types/multer": "^1.4.3",
     "@types/node": "^14.0.11",
     "@typescript-eslint/eslint-plugin": "^3.8.0",
     "@typescript-eslint/parser": "^3.8.0",
@@ -66,7 +68,9 @@
     "eslint": "^7.6.0",
     "eslint-config-prettier": "^6.11.0",
     "eslint-plugin-jest": "^23.20.0",
+    "form-data": "^3.0.0",
     "handlebars": "^4.7.6",
+    "http-status-codes": "^1.4.0",
     "husky": "^4.2.5",
     "jest": "^26.2.2",
     "kcors": "^2.2.2",

package.json

@@ -0,0 +1,65 @@
+/**
+ * Container options.
+ */
+export interface UseContainerOptions {
+
+  /**
+   * If set to true, then default container will be used in the case if given container haven't returned anything.
+   */
+  fallback?: boolean;
+
+  /**
+   * If set to true, then default container will be used in the case if given container thrown an exception.
+   */
+  fallbackOnErrors?: boolean;
+
+}
+
+/**
+* Container to be used by this library for inversion control. If container was not implicitly set then by default
+* container simply creates a new instance of the given class.
+*/
+const defaultContainer: { get<T>(someClass: { new (...args: any[]): T }|Function): T } = new (class {
+  private instances: { type: Function, object: any }[] = [];
+  get<T>(someClass: { new (...args: any[]): T }): T {
+      let instance = this.instances.find(instance => instance.type === someClass);
+      if (!instance) {
+          instance = { type: someClass, object: new someClass() };
+          this.instances.push(instance);
+      }
+
+      return instance.object;
+  }
+})();
+
+let userContainer: { get<T>(someClass: { new (...args: any[]): T }|Function): T };
+let userContainerOptions: UseContainerOptions;
+
+/**
+* Sets container to be used by this library.
+*/
+export function useContainer(iocContainer: { get(someClass: any): any }, options?: UseContainerOptions): void {
+  userContainer = iocContainer;
+  userContainerOptions = options;
+}
+
+/**
+* Gets the IOC container used by this library.
+*/
+export function getFromContainer<T>(someClass: { new (...args: any[]): T }|Function): T {
+  if (userContainer) {
+      try {
+          const instance = userContainer.get(someClass);
+          if (instance)
+              return instance;
+
+          if (!userContainerOptions || !userContainerOptions.fallback)
+              return instance;
+
+      } catch (error) {
+          if (!userContainerOptions || !userContainerOptions.fallbackOnErrors)
+              throw error;
+      }
+  }
+  return defaultContainer.get<T>(someClass);
+}

src/util/container.ts

@@ -16,7 +16,7 @@ export class SessionMiddleware implements ExpressMiddlewareInterface {
     }
   }
 
-  private expSession = session({
+  private expSession = (session as any)({
     secret: '19majkel94_helps_pleerock',
     resave: false,
     saveUninitialized: true,

test/fakes/global-options/SessionMiddleware.ts

@@ -5,22 +5,25 @@ import { JsonController } from '../../src/decorator/JsonController';
 import { Post } from '../../src/decorator/Post';
 import { Body } from '../../src/decorator/Body';
 import { createExpressServer, createKoaServer, getMetadataArgsStorage } from '../../src/index';
-import { assertRequest } from './test-utils';
-const expect = require('chakram').expect;
+import { axios } from '../utilities/axios';
+import { AxiosError, AxiosResponse } from 'axios';
+
 
 describe('action options', () => {
   let initializedUser: any;
+  let expressApp: any;
   let User: any;
 
-  after(() => {
+  afterAll((done) => {
     defaultMetadataStorage.clear();
+    expressApp.close(done)
   });
 
   beforeEach(() => {
     initializedUser = undefined;
   });
 
-  before(() => {
+  beforeAll((done) => {
     // reset metadata args storage
     getMetadataArgsStorage().reset();
 
@@ -58,50 +61,37 @@ describe('action options', () => {
         return handler(user);
       }
     }
-  });
 
-  let expressApp: any, koaApp: any;
-  before(done => (expressApp = createExpressServer().listen(3001, done)));
-  after(done => expressApp.close(done));
-  before(done => (koaApp = createKoaServer().listen(3002, done)));
-  after(done => koaApp.close(done));
+    expressApp = createExpressServer().listen(3001, done)
+  });
 
   it('should use controller options when action transform options are not set', () => {
-    assertRequest([3001, 3002], 'post', 'default', { firstName: 'Umed', lastName: 'Khudoiberdiev' }, response => {
-      expect(initializedUser).to.be.instanceOf(User);
-      expect(initializedUser.lastName).to.be.undefined;
-      expect(response).to.have.status(200);
-      expect(response.body.lastName).to.equal('default');
+    expect.assertions(4);
+    return axios.post('/default', { firstName: 'Umed', lastName: 'Khudoiberdiev' }).then((response: AxiosResponse) => {
+      expect(initializedUser).toBeInstanceOf(User);
+      expect(initializedUser.lastName).toBeUndefined();
+      expect(response.status).toBe(200);
+      expect(response.data.lastName).toBe('default');
     });
   });
 
   it('should override controller options with action transformRequest option', () => {
-    assertRequest(
-      [3001, 3002],
-      'post',
-      'transformRequestOnly',
-      { firstName: 'Umed', lastName: 'Khudoiberdiev' },
-      response => {
-        expect(initializedUser).to.be.instanceOf(User);
-        expect(initializedUser.lastName).to.be.undefined;
-        expect(response).to.have.status(200);
-        expect(response.body.lastName).to.equal('default');
-      }
-    );
+    expect.assertions(4);
+    return axios.post('/transformRequestOnly', { firstName: 'Umed', lastName: 'Khudoiberdiev' }).then((response: AxiosResponse) => {
+      expect(initializedUser).toBeInstanceOf(User);
+      expect(initializedUser.lastName).toBeUndefined();
+      expect(response.status).toBe(200);
+      expect(response.data.lastName).toBe('default');
+    });
   });
 
   it('should override controller options with action transformResponse option', () => {
-    assertRequest(
-      [3001, 3002],
-      'post',
-      'transformResponseOnly',
-      { firstName: 'Umed', lastName: 'Khudoiberdiev' },
-      response => {
-        expect(initializedUser).not.to.be.instanceOf(User);
-        expect(initializedUser.lastName).to.exist;
-        expect(response).to.have.status(200);
-        expect(response.body.lastName).to.be.undefined;
-      }
-    );
+    expect.assertions(4);
+    return axios.post('/transformResponseOnly', { firstName: 'Umed', lastName: 'Khudoiberdiev' }).then((response: AxiosResponse) => {
+      expect(initializedUser).not.toBeInstanceOf(User);
+      expect(initializedUser.lastName).not.toBeUndefined();
+      expect(response.status).toBe(200);
+      expect(response.data.lastName).toBeUndefined();
+    });
   });
 });