@nestjs/testing 12.1.3 → 12.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/testing",
-  "version": "12.1.3",
+  "version": "12.2.0",
   "description": "Nest - modern, fast, powerful node.js web framework (@testing)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -8,6 +8,7 @@
   "main": "./index.js",
   "exports": {
     ".": "./index.js",
+    "./package.json": "./package.json",
     "./*.js": "./*.js",
     "./*": "./*.js"
   },
@@ -41,5 +42,5 @@
       "optional": true
     }
   },
-  "gitHead": "4514623279f6087808e3c8f08fbf9f37d3c17482"
+  "gitHead": "af37111368de7fd2dfab0bdec2f530c7845510c2"
 }

package/testing-injector.d.ts

@@ -13,8 +13,10 @@ interface ResolutionContext {
 export declare class TestingInjector extends Injector {
     protected mocker?: MockFactory;
     protected container: NestContainer;
+    private readonly mockedInstances;
     setMocker(mocker: MockFactory): void;
     setContainer(container: NestContainer): void;
+    protected lookupSkippedProviderDependencies(wrapper: InstanceWrapper, moduleRef: Module): Promise<void>;
     resolveComponentWrapper<T>(moduleRef: Module, name: any, dependencyContext: InjectorDependencyContext, wrapper: InstanceWrapper<T>, resolutionContext?: ResolutionContext, keyOrIndex?: string | number): Promise<InstanceWrapper>;
     resolveComponentHost<T>(moduleRef: Module, instanceWrapper: InstanceWrapper<T>, resolutionContext?: ResolutionContext): Promise<InstanceWrapper>;
     private mockWrapper;

package/testing-injector.js

@@ -5,19 +5,31 @@ import { STATIC_CONTEXT, Injector, InstanceWrapper, } from '@nestjs/core/interna
 export class TestingInjector extends Injector {
     mocker;
     container;
+    mockedInstances = new Map();
     setMocker(mocker) {
         this.mocker = mocker;
+        this.mockedInstances.clear();
     }
     setContainer(container) {
         this.container = container;
     }
+    // Request-scoped and transient providers are not loaded at compile time,
+    // and the injector that resolves them later has no mocker. Their
+    // dependencies are still looked up here, through resolveComponentWrapper(),
+    // which mocks the missing ones without creating any instance.
+    async lookupSkippedProviderDependencies(wrapper, moduleRef) {
+        const lookup = super.lookupSkippedProviderDependencies(wrapper, moduleRef);
+        // With a mocker, a dependency that cannot be mocked fails later, at
+        // resolve time.
+        return this.mocker ? lookup.catch(() => undefined) : lookup;
+    }
     async resolveComponentWrapper(moduleRef, name, dependencyContext, wrapper, resolutionContext = { contextId: STATIC_CONTEXT }, keyOrIndex) {
         try {
             const existingProviderWrapper = await super.resolveComponentWrapper(moduleRef, name, dependencyContext, wrapper, resolutionContext, keyOrIndex);
             return existingProviderWrapper;
         }
         catch (err) {
-            return this.mockWrapper(err, moduleRef, name, wrapper);
+            return this.mockWrapper(err, moduleRef, name, name, wrapper);
         }
     }
     async resolveComponentHost(moduleRef, instanceWrapper, resolutionContext = { contextId: STATIC_CONTEXT }) {
@@ -26,21 +38,28 @@ export class TestingInjector extends Injector {
             return existingProviderWrapper;
         }
         catch (err) {
-            return this.mockWrapper(err, moduleRef, instanceWrapper.name, instanceWrapper);
+            return this.mockWrapper(err, moduleRef, instanceWrapper.name, instanceWrapper.token, instanceWrapper);
         }
     }
-    async mockWrapper(err, moduleRef, name, wrapper) {
+    async mockWrapper(err, moduleRef, name, token, wrapper) {
         if (!this.mocker) {
             throw err;
         }
-        const mockedInstance = this.mocker(name);
+        // Every provider that depends on the token must get the same mock,
+        // the one `get()` returns.
+        let mockedInstance = this.mockedInstances.get(token);
         if (!mockedInstance) {
-            throw err;
+            mockedInstance = this.mocker(name);
+            if (!mockedInstance) {
+                throw err;
+            }
+            this.mockedInstances.set(token, mockedInstance);
         }
+        // The mock is a single value, so it stays static whatever the scope of
+        // the provider it replaces or the provider that depends on it.
         const newWrapper = new InstanceWrapper({
             name,
             isAlias: false,
-            scope: wrapper.scope,
             instance: mockedInstance,
             isResolved: true,
             host: moduleRef,