test(): increase test coverage (unit tests)

Author: kamilmysliwiec

packages/core/router/router-explorer.ts

@@ -21,6 +21,7 @@ import { STATIC_CONTEXT } from '../injector/constants';
 import { NestContainer } from '../injector/container';
 import { Injector } from '../injector/injector';
 import { ContextId, InstanceWrapper } from '../injector/instance-wrapper';
+import { Module } from '../injector/module';
 import { InterceptorsConsumer } from '../interceptors/interceptors-consumer';
 import { InterceptorsContextCreator } from '../interceptors/interceptors-context-creator';
 import { MetadataScanner } from '../metadata-scanner';
@@ -183,52 +184,15 @@ export class RouterExplorer {
 
     const isRequestScoped = !instanceWrapper.isDependencyTreeStatic();
     const module = this.container.getModuleByKey(moduleKey);
-    const collection = module.controllers;
 
     if (isRequestScoped) {
-      const handler = async <TRequest, TResponse>(
-        req: TRequest,
-        res: TResponse,
-        next: () => void,
-      ) => {
-        try {
-          const contextId = createContextId();
-          this.registerRequestProvider(req, contextId);
-
-          const contextInstance = await this.injector.loadPerContext(
-            instance,
-            module,
-            collection,
-            contextId,
-          );
-          this.createCallbackProxy(
-            contextInstance,
-            contextInstance[methodName],
-            methodName,
-            moduleKey,
-            requestMethod,
-            contextId,
-            instanceWrapper.id,
-          )(req, res, next);
-        } catch (err) {
-          let exceptionFilter = this.exceptionFiltersCache.get(
-            instance[methodName],
-          );
-          if (!exceptionFilter) {
-            exceptionFilter = this.exceptionsFilter.create(
-              instance,
-              instance[methodName],
-              moduleKey,
-            );
-            this.exceptionFiltersCache.set(
-              instance[methodName],
-              exceptionFilter,
-            );
-          }
-          const host = new ExecutionContextHost([req, res, next]);
-          exceptionFilter.next(err, host);
-        }
-      };
+      const handler = this.createRequestScopedHandler(
+        instanceWrapper,
+        requestMethod,
+        module,
+        moduleKey,
+        methodName,
+      );
 
       paths.forEach(path => {
         const fullPath = stripSlash(basePath) + path;
@@ -277,6 +241,57 @@ export class RouterExplorer {
     return this.routerProxy.createProxy(executionContext, exceptionFilter);
   }
 
+  public createRequestScopedHandler(
+    instanceWrapper: InstanceWrapper,
+    requestMethod: RequestMethod,
+    module: Module,
+    moduleKey: string,
+    methodName: string,
+  ) {
+    const { instance } = instanceWrapper;
+    const collection = module.controllers;
+    return async <TRequest, TResponse>(
+      req: TRequest,
+      res: TResponse,
+      next: () => void,
+    ) => {
+      try {
+        const contextId = createContextId();
+        this.registerRequestProvider(req, contextId);
+
+        const contextInstance = await this.injector.loadPerContext(
+          instance,
+          module,
+          collection,
+          contextId,
+        );
+        this.createCallbackProxy(
+          contextInstance,
+          contextInstance[methodName],
+          methodName,
+          moduleKey,
+          requestMethod,
+          contextId,
+          instanceWrapper.id,
+        )(req, res, next);
+      } catch (err) {
+        let exceptionFilter = this.exceptionFiltersCache.get(
+          instance[methodName],
+        );
+        if (!exceptionFilter) {
+          exceptionFilter = this.exceptionsFilter.create(
+            instance,
+            instance[methodName],
+            moduleKey,
+          );
+          this.exceptionFiltersCache.set(instance[methodName], exceptionFilter);
+        }
+        const host = new ExecutionContextHost([req, res, next]);
+        exceptionFilter.next(err, host);
+      }
+    };
+  }
+
   private registerRequestProvider<T = any>(request: T, contextId: ContextId) {
     const coreModuleRef = this.container.getInternalCoreModuleRef();
     const wrapper = coreModuleRef.getProviderByKey(REQUEST);

packages/core/test/router/router-explorer.spec.ts

@@ -7,8 +7,13 @@ import {
   Post,
 } from '../../../common/decorators/http/request-mapping.decorator';
 import { RequestMethod } from '../../../common/enums/request-method.enum';
+import { Injector } from '../../../core/injector/injector';
+import { ApplicationConfig } from '../../application-config';
+import { ExecutionContextHost } from '../../helpers/execution-context-host';
 import { NestContainer } from '../../injector/container';
+import { InstanceWrapper } from '../../injector/instance-wrapper';
 import { MetadataScanner } from '../../metadata-scanner';
+import { RouterExceptionFilters } from '../../router/router-exception-filters';
 import { RouterExplorer } from '../../router/router-explorer';
 
 describe('RouterExplorer', () => {
@@ -28,11 +33,24 @@ describe('RouterExplorer', () => {
   }
 
   let routerBuilder: RouterExplorer;
+  let injector: Injector;
+  let exceptionsFilter: RouterExceptionFilters;
 
   beforeEach(() => {
+    const container = new NestContainer();
+
+    injector = new Injector();
+    exceptionsFilter = new RouterExceptionFilters(
+      container,
+      new ApplicationConfig(),
+      null,
+    );
     routerBuilder = new RouterExplorer(
       new MetadataScanner(),
-      new NestContainer(),
+      container,
+      injector,
+      null,
+      exceptionsFilter,
     );
   });
 
@@ -115,4 +133,49 @@ describe('RouterExplorer', () => {
       expect(() => routerBuilder.validateRoutePath(undefined)).to.throw();
     });
   });
+
+  describe('createRequestScopedHandler', () => {
+    let nextSpy: sinon.SinonSpy;
+
+    beforeEach(() => {
+      sinon.stub(injector, 'loadPerContext').callsFake(() => {
+        throw new Error();
+      });
+      nextSpy = sinon.spy();
+      sinon.stub(exceptionsFilter, 'create').callsFake(
+        () =>
+          ({
+            next: nextSpy,
+          } as any),
+      );
+    });
+
+    describe('when "loadPerContext" throws', () => {
+      const moduleKey = 'moduleKey';
+      const methodKey = 'methodKey';
+      const module = {
+        controllers: new Map(),
+      } as any;
+      const wrapper = new InstanceWrapper({
+        instance: { [methodKey]: {} },
+      });
+
+      it('should delegete error to exception filters', async () => {
+        const handler = routerBuilder.createRequestScopedHandler(
+          wrapper,
+          RequestMethod.ALL,
+          module,
+          moduleKey,
+          methodKey,
+        );
+        await handler(null, null, null);
+
+        expect(nextSpy.called).to.be.true;
+        expect(nextSpy.getCall(0).args[0]).to.be.instanceOf(Error);
+        expect(nextSpy.getCall(0).args[1]).to.be.instanceOf(
+          ExecutionContextHost,
+        );
+      });
+    });
+  });
 });

packages/microservices/listeners-controller.ts

@@ -7,13 +7,18 @@ import {
   ContextId,
   InstanceWrapper,
 } from '@nestjs/core/injector/instance-wrapper';
+import { Module } from '@nestjs/core/injector/module';
 import { MetadataScanner } from '@nestjs/core/metadata-scanner';
 import { REQUEST } from '@nestjs/core/router/request/request-constants';
 import { IClientProxyFactory } from './client/client-proxy-factory';
 import { ClientsContainer } from './container';
 import { ExceptionFiltersContext } from './context/exception-filters-context';
 import { RpcContextCreator } from './context/rpc-context-creator';
-import { CustomTransportStrategy, RequestContext } from './interfaces';
+import {
+  CustomTransportStrategy,
+  PatternMetadata,
+  RequestContext,
+} from './interfaces';
 import { ListenerMetadataExplorer } from './listener-metadata-explorer';
 import { Server } from './server/server';
 
@@ -42,7 +47,6 @@ export class ListenersController {
     const isStatic = instanceWrapper.isDependencyTreeStatic();
     const patternHandlers = this.metadataExplorer.explore(instance);
     const module = this.container.getModuleByKey(moduleKey);
-    const collection = module.controllers;
 
     patternHandlers.forEach(
       ({ pattern, targetCallback, methodKey, isEventHandler }) => {
@@ -54,43 +58,13 @@ export class ListenersController {
           );
           return server.addHandler(pattern, proxy, isEventHandler);
         }
-        const asyncHandler = async (...args: unknown[]) => {
-          try {
-            const data = args[0];
-            const contextId = createContextId();
-            this.registerRequestProvider({ pattern, data }, contextId);
-
-            const contextInstance = await this.injector.loadPerContext(
-              instance,
-              module,
-              collection,
-              contextId,
-            );
-            const proxy = this.contextCreator.create(
-              contextInstance,
-              contextInstance[methodKey],
-              moduleKey,
-            );
-            return proxy(data);
-          } catch (err) {
-            let exceptionFilter = this.exceptionFiltersCache.get(
-              instance[methodKey],
-            );
-            if (!exceptionFilter) {
-              exceptionFilter = this.exceptionFiltersContext.create(
-                instance,
-                instance[methodKey],
-                moduleKey,
-              );
-              this.exceptionFiltersCache.set(
-                instance[methodKey],
-                exceptionFilter,
-              );
-            }
-            const host = new ExecutionContextHost(args);
-            exceptionFilter.handle(err, host);
-          }
-        };
+        const asyncHandler = this.createRequestScopedHandler(
+          instance,
+          pattern,
+          module,
+          moduleKey,
+          methodKey,
+        );
         server.addHandler(pattern, asyncHandler, isEventHandler);
       },
     );
@@ -116,6 +90,50 @@ export class ListenersController {
     Reflect.set(instance, property, client);
   }
 
+  public createRequestScopedHandler(
+    instance: Controller,
+    pattern: PatternMetadata,
+    module: Module,
+    moduleKey: string,
+    methodKey: string,
+  ) {
+    const collection = module.controllers;
+    return async (...args: unknown[]) => {
+      try {
+        const data = args[0];
+        const contextId = createContextId();
+        this.registerRequestProvider({ pattern, data }, contextId);
+
+        const contextInstance = await this.injector.loadPerContext(
+          instance,
+          module,
+          collection,
+          contextId,
+        );
+        const proxy = this.contextCreator.create(
+          contextInstance,
+          contextInstance[methodKey],
+          moduleKey,
+        );
+        return proxy(data);
+      } catch (err) {
+        let exceptionFilter = this.exceptionFiltersCache.get(
+          instance[methodKey],
+        );
+        if (!exceptionFilter) {
+          exceptionFilter = this.exceptionFiltersContext.create(
+            instance,
+            instance[methodKey],
+            moduleKey,
+          );
+          this.exceptionFiltersCache.set(instance[methodKey], exceptionFilter);
+        }
+        const host = new ExecutionContextHost(args);
+        exceptionFilter.handle(err, host);
+      }
+    };
+  }
+
   private registerRequestProvider(
     request: RequestContext,
     contextId: ContextId,