tests(@nestjs/core) increase injector test-cov

Author: kamilmysliwiec

package.json

@@ -15,16 +15,17 @@
     ],
     "exclude": [
       "node_modules/",
+      "src/**/*.spec.ts",
+      "src/core/adapters/*.ts",
+      "src/websockets/adapters/*.ts",
       "src/core/nest-application.ts",
       "src/core/nest-factory.ts",
       "src/core/nest-microservice.ts",
-      "src/**/*.spec.ts",
       "src/common/services/logger.service.ts",
       "src/core/errors/exceptions",
       "src/microservices/exceptions/",
       "src/microservices/microservices-module.ts",
-      "src/core/adapters/*.ts",
-      "src/websockets/adapters/*.ts"
+      "src/core/middlewares/middlewares-module.ts"
     ],
     "extension": [
       ".ts"

src/core/injector/injector.ts

@@ -83,7 +83,7 @@ export class Injector {
                 );
             } else {
                 const factoryResult = currentMetatype.metatype(...instances);
-                currentMetatype.instance = await this.resolveFactoryInstance(currentMetatype, factoryResult);
+                currentMetatype.instance = await this.resolveFactoryInstance(factoryResult);
             }
             currentMetatype.isResolved = true;
             done();
@@ -216,7 +216,7 @@ export class Injector {
         return component;
     }
 
-    public async resolveFactoryInstance(currentMetatype, factoryResult): Promise<any> {
+    public async resolveFactoryInstance(factoryResult): Promise<any> {
         if (!(factoryResult instanceof Promise)) {
             return factoryResult;
         }

src/core/test/injector/injector.spec.ts

@@ -81,6 +81,18 @@ describe('Injector', () => {
             ).to.eventually.be.rejected;
         });
 
+        it('should await done$ when "isPending"', async () => {
+            const value = 'test';
+            const result = await injector.loadInstance({
+                name: 'MainTest',
+                metatype: MainTest,
+                instance: Object.create(MainTest.prototype),
+                isResolved: false,
+                isPending: true,
+                done$: Promise.resolve(value) as any,
+            }, moduleDeps.components, moduleDeps);
+            expect(result).to.be.eql(value);
+        });
     });
 
     describe('loadPrototypeOfInstance', () => {
@@ -112,6 +124,7 @@ describe('Injector', () => {
             injector.loadPrototypeOfInstance(test, moduleDeps.components);
             expect(moduleDeps.components.get('Test')).to.deep.equal(expectedResult);
         });
+
     });
 
     describe('resolveSingleParam', () => {
@@ -155,6 +168,53 @@ describe('Injector', () => {
         });
     });
 
+    describe('loadInstanceOfRoute', () => {
+        let loadInstance: sinon.SinonSpy;
+
+        beforeEach(() => {
+            loadInstance = sinon.spy();
+            injector.loadInstance = loadInstance;
+        });
+
+        it('should call "loadInstance" with expected arguments', async () => {
+            const module = { routes: [] };
+            const wrapper = { test: 'test' };
+
+            await injector.loadInstanceOfRoute(wrapper as any, module as any);
+            expect(loadInstance.calledWith(wrapper, module.routes, module)).to.be.true;
+        });
+    });
+
+    describe('loadInstanceOfInjectable', () => {
+        let loadInstance: sinon.SinonSpy;
+
+        beforeEach(() => {
+            loadInstance = sinon.spy();
+            injector.loadInstance = loadInstance;
+        });
+
+        it('should call "loadInstance" with expected arguments', async () => {
+            const module = { injectables: [] };
+            const wrapper = { test: 'test' };
+
+            await injector.loadInstanceOfInjectable(wrapper as any, module as any);
+            expect(loadInstance.calledWith(wrapper, module.injectables, module)).to.be.true;
+        });
+    });
+
+    describe('resolveFactoryInstance', () => {
+        it('should resolve deffered value', async () => {
+            const wrapper = { test: 'test' };
+            const result = await injector.resolveFactoryInstance(Promise.resolve(wrapper));
+            expect(result).to.be.eql(wrapper);
+        });
+        it('should return exact same value', async () => {
+            const wrapper = { test: 'test' };
+            const result = await injector.resolveFactoryInstance(wrapper);
+            expect(result).to.be.eql(wrapper);
+        });
+    });
+
     describe('scanForComponent', () => {
         let scanForComponentInRelatedModules: sinon.SinonStub;
         const metatype = { name: 'test', metatype: { name: 'test' }};

src/microservices/microservices-module.ts

@@ -20,18 +20,19 @@ export class MicroservicesModule {
     private static listenersController: ListenersController;
 
     public static setup(container, config) {
+        const contextCreator = new RpcContextCreator(
+            new RpcProxy(),
+            new ExceptionFiltersContext(config),
+            new PipesContextCreator(config),
+            new PipesConsumer(),
+            new GuardsContextCreator(container, config),
+            new GuardsConsumer(),
+            new InterceptorsContextCreator(container, config),
+            new InterceptorsConsumer(),
+        );
         this.listenersController = new ListenersController(
             MicroservicesModule.clientsContainer,
-            new RpcContextCreator(
-                new RpcProxy(),
-                new ExceptionFiltersContext(config),
-                new PipesContextCreator(config),
-                new PipesConsumer(),
-                new GuardsContextCreator(container, config),
-                new GuardsConsumer(),
-                new InterceptorsContextCreator(container, config),
-                new InterceptorsConsumer(),
-            ),
+            contextCreator,
         );
     }