feat(testing): add auto-mocking capabilities

In the current `Test` module there isn't an easy way to say "If this
dependency doesn't exist use this mock function instead." With this new
`useMocker` fluent function it becomes possible to tell the `TestingInjector`
to replace the undefined dependency with the automocking function. In doing so
classes that have a large number of dependencies no longer must be mocked one-by-one
. This is especially great when it comes to packages like `@golevelup/ts-jest`
which can create mocked dependencies of interfaces and classes with a single function.
I'm sure I've probably missed an edge case in here, so please let me know if you have
any major concerns.

Author: jmcdo29

integration/auto-mock/src/bar.service.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@nestjs/common';
+import { FooService } from './foo.service';
+
+@Injectable()
+export class BarService {
+
+  constructor(private readonly foo: FooService) {}
+
+  bar() {
+    this.foo.foo();
+  }
+}

integration/auto-mock/src/foo.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class FooService {
+  foo() {
+    console.log('foo called');
+  }
+}

integration/auto-mock/test/bar.service.spec.ts

@@ -0,0 +1,26 @@
+import { Test } from '@nestjs/testing';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { BarService } from '../src/bar.service';
+
+describe('Auto-Mocking Bar Deps', () => {
+  let service: BarService;
+  let stub = sinon.stub();
+  beforeEach(async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [BarService],
+    })
+      .useMocker(() => ({ foo: stub }))
+      .compile();
+    service = moduleRef.get(BarService);
+  });
+
+  it('should be defined', () => {
+    expect(service).not.to.be.undefined;
+  });
+  it('should call bar.bar', () => {
+    console.log(service);
+    service.bar();
+    expect(stub.called);
+  });
+});

integration/auto-mock/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": false,
+    "noImplicitAny": false,
+    "removeComments": true,
+    "noLib": false,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "es6",
+    "sourceMap": true,
+    "allowJs": true,
+    "outDir": "./dist"
+  },
+  "include": [
+    "src/**/*",
+    "e2e/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+  ]
+}

packages/testing/testing-injector.ts

@@ -0,0 +1,51 @@
+import {
+  Injector,
+  InjectorDependencyContext,
+} from '@nestjs/core/injector/injector';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { Module } from '@nestjs/core/injector/module';
+import { STATIC_CONTEXT } from '@nestjs/core/injector/constants';
+import { Scope } from '@nestjs/common';
+
+export class TestingInjector extends Injector {
+  private mocker?: <T extends any = {}>() => T;
+  setMocker(mocker: () => any): void {
+    this.mocker = mocker;
+  }
+
+  async resolveComponentInstance<T>(
+    moduleRef: Module,
+    name: any,
+    dependencyContext: InjectorDependencyContext,
+    wrapper: InstanceWrapper<T>,
+    contextId = STATIC_CONTEXT,
+    inquirer?: InstanceWrapper,
+    keyOrIndex?: string | number,
+  ): Promise<InstanceWrapper> {
+    try {
+      const retWrapper = await super.resolveComponentInstance(
+        moduleRef,
+        name,
+        dependencyContext,
+        wrapper,
+        contextId,
+        inquirer,
+        keyOrIndex,
+      );
+      return retWrapper;
+    } catch (err) {
+      if (this.mocker) {
+        const newWrapper = new InstanceWrapper({
+          name,
+          isAlias: false,
+          scope: wrapper.scope,
+          instance: this.mocker<T>(),
+          isResolved: true,
+        });
+        return newWrapper;
+      } else {
+        throw err;
+      }
+    }
+  }
+}

packages/testing/testing-instance-loader.ts

@@ -0,0 +1,11 @@
+import { InstanceLoader } from '@nestjs/core/injector/instance-loader';
+import { TestingInjector } from './testing-injector';
+
+export class TestingInstanceLoader extends InstanceLoader {
+  protected injector = new TestingInjector();
+
+  async createInstancesOfDependencies(mocker?: () => any): Promise<void> {
+    mocker && this.injector.setMocker(mocker);
+    await super.createInstancesOfDependencies();
+  }
+}

packages/testing/testing-module.builder.ts

@@ -2,21 +2,22 @@ import { Logger, LoggerService, Module } from '@nestjs/common';
 import { ModuleMetadata } from '@nestjs/common/interfaces';
 import { ApplicationConfig } from '@nestjs/core/application-config';
 import { NestContainer } from '@nestjs/core/injector/container';
-import { InstanceLoader } from '@nestjs/core/injector/instance-loader';
 import { MetadataScanner } from '@nestjs/core/metadata-scanner';
 import { DependenciesScanner } from '@nestjs/core/scanner';
 import { OverrideBy, OverrideByFactoryOptions } from './interfaces';
 import { TestingLogger } from './services/testing-logger.service';
+import { TestingInstanceLoader } from './testing-instance-loader';
 import { TestingModule } from './testing-module';
 
 export class TestingModuleBuilder {
   private readonly applicationConfig = new ApplicationConfig();
   private readonly container = new NestContainer(this.applicationConfig);
   private readonly overloadsMap = new Map();
   private readonly scanner: DependenciesScanner;
-  private readonly instanceLoader = new InstanceLoader(this.container);
+  private readonly instanceLoader = new TestingInstanceLoader(this.container);
   private readonly module: any;
   private testingLogger: LoggerService;
+  private mocker?: () => any;
 
   constructor(metadataScanner: MetadataScanner, metadata: ModuleMetadata) {
     this.scanner = new DependenciesScanner(
@@ -36,6 +37,11 @@ export class TestingModuleBuilder {
     return this.override(typeOrToken, false);
   }
 
+  public useMocker(mocker: () => any): TestingModuleBuilder {
+    this.mocker = mocker;
+    return this;
+  }
+
   public overrideFilter<T = any>(typeOrToken: T): OverrideBy {
     return this.override(typeOrToken, false);
   }
@@ -57,7 +63,7 @@ export class TestingModuleBuilder {
     await this.scanner.scan(this.module);
 
     this.applyOverloadsMap();
-    await this.instanceLoader.createInstancesOfDependencies();
+    await this.instanceLoader.createInstancesOfDependencies(this.mocker);
     this.scanner.applyApplicationProviders();
 
     const root = this.getRootModule();