@nestjs/testing 9.4.2 → 10.0.0

package/interfaces/mock-factory.d.ts

@@ -1,2 +1,2 @@
-import { InstanceToken } from '@nestjs/core/injector/module';
-export type MockFactory = (token?: InstanceToken) => any;
+import { InjectionToken } from '@nestjs/common';
+export type MockFactory = (token?: InjectionToken) => any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/testing",
-  "version": "9.4.2",
+  "version": "10.0.0",
   "description": "Nest - modern, fast, powerful node.js web framework (@testing)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -18,13 +18,13 @@
     "access": "public"
   },
   "dependencies": {
-    "tslib": "2.5.2"
+    "tslib": "2.5.3"
   },
   "peerDependencies": {
-    "@nestjs/common": "^9.0.0",
-    "@nestjs/core": "^9.0.0",
-    "@nestjs/microservices": "^9.0.0",
-    "@nestjs/platform-express": "^9.0.0"
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/microservices": "^10.0.0",
+    "@nestjs/platform-express": "^10.0.0"
   },
   "peerDependenciesMeta": {
     "@nestjs/microservices": {

package/test.js

@@ -8,5 +8,5 @@ class Test {
         return new testing_module_builder_1.TestingModuleBuilder(this.metadataScanner, metadata);
     }
 }
-Test.metadataScanner = new metadata_scanner_1.MetadataScanner();
 exports.Test = Test;
+Test.metadataScanner = new metadata_scanner_1.MetadataScanner();

package/testing-module.builder.d.ts

@@ -1,7 +1,9 @@
 import { LoggerService, ModuleMetadata } from '@nestjs/common';
 import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
 import { MetadataScanner } from '@nestjs/core/metadata-scanner';
+import { ModuleDefinition } from '../core/interfaces/module-definition.interface';
 import { MockFactory, OverrideBy } from './interfaces';
+import { OverrideModule } from './interfaces/override-module.interface';
 import { TestingModule } from './testing-module';
 /**
  * @publicApi
@@ -11,6 +13,7 @@ export declare class TestingModuleBuilder {
     private readonly applicationConfig;
     private readonly container;
     private readonly overloadsMap;
+    private readonly moduleOverloadsMap;
     private readonly module;
     private testingLogger;
     private mocker?;
@@ -22,10 +25,12 @@ export declare class TestingModuleBuilder {
     overrideGuard<T = any>(typeOrToken: T): OverrideBy;
     overrideInterceptor<T = any>(typeOrToken: T): OverrideBy;
     overrideProvider<T = any>(typeOrToken: T): OverrideBy;
+    overrideModule(moduleToOverride: ModuleDefinition): OverrideModule;
     compile(options?: Pick<NestApplicationContextOptions, 'snapshot' | 'preview'>): Promise<TestingModule>;
     private override;
     private createOverrideByBuilder;
     private applyOverloadsMap;
+    private getModuleOverloads;
     private getRootModule;
     private createInstancesOfDependencies;
     private createModule;

package/testing-module.builder.js

@@ -21,6 +21,7 @@ class TestingModuleBuilder {
         this.applicationConfig = new application_config_1.ApplicationConfig();
         this.container = new container_1.NestContainer(this.applicationConfig);
         this.overloadsMap = new Map();
+        this.moduleOverloadsMap = new Map();
         this.module = this.createModule(metadata);
     }
     setLogger(testingLogger) {
@@ -46,10 +47,18 @@ class TestingModuleBuilder {
     overrideProvider(typeOrToken) {
         return this.override(typeOrToken, true);
     }
+    overrideModule(moduleToOverride) {
+        return {
+            useModule: newModule => {
+                this.moduleOverloadsMap.set(moduleToOverride, newModule);
+                return this;
+            },
+        };
+    }
     async compile(options = {}) {
         this.applyLogger();
         let graphInspector;
-        if (options === null || options === void 0 ? void 0 : options.snapshot) {
+        if (options?.snapshot) {
             graphInspector = new graph_inspector_1.GraphInspector(this.container);
             uuid_factory_1.UuidFactory.mode = uuid_factory_1.UuidFactoryMode.Deterministic;
         }
@@ -58,7 +67,9 @@ class TestingModuleBuilder {
             uuid_factory_1.UuidFactory.mode = uuid_factory_1.UuidFactoryMode.Random;
         }
         const scanner = new scanner_1.DependenciesScanner(this.container, this.metadataScanner, graphInspector, this.applicationConfig);
-        await scanner.scan(this.module);
+        await scanner.scan(this.module, {
+            overrides: this.getModuleOverloads(),
+        });
         this.applyOverloadsMap();
         await this.createInstancesOfDependencies(graphInspector, options);
         scanner.applyApplicationProviders();
@@ -67,7 +78,10 @@ class TestingModuleBuilder {
     }
     override(typeOrToken, isProvider) {
         const addOverload = (options) => {
-            this.overloadsMap.set(typeOrToken, Object.assign(Object.assign({}, options), { isProvider }));
+            this.overloadsMap.set(typeOrToken, {
+                ...options,
+                isProvider,
+            });
             return this;
         };
         return this.createOverrideByBuilder(addOverload);
@@ -75,23 +89,30 @@ class TestingModuleBuilder {
     createOverrideByBuilder(add) {
         return {
             useValue: value => add({ useValue: value }),
-            useFactory: (options) => add(Object.assign(Object.assign({}, options), { useFactory: options.factory })),
+            useFactory: (options) => add({ ...options, useFactory: options.factory }),
             useClass: metatype => add({ useClass: metatype }),
         };
     }
     applyOverloadsMap() {
-        [...this.overloadsMap.entries()].forEach(([item, options]) => {
+        const overloads = [...this.overloadsMap.entries()];
+        overloads.forEach(([item, options]) => {
             this.container.replace(item, options);
         });
     }
+    getModuleOverloads() {
+        const overloads = [...this.moduleOverloadsMap.entries()];
+        return overloads.map(([moduleToReplace, newModule]) => ({
+            moduleToReplace,
+            newModule,
+        }));
+    }
     getRootModule() {
         const modules = this.container.getModules().values();
         return modules.next().value;
     }
     async createInstancesOfDependencies(graphInspector, options) {
-        var _a;
         const injector = new testing_injector_1.TestingInjector({
-            preview: (_a = options === null || options === void 0 ? void 0 : options.preview) !== null && _a !== void 0 ? _a : false,
+            preview: options?.preview ?? false,
         });
         const instanceLoader = new testing_instance_loader_1.TestingInstanceLoader(this.container, injector, graphInspector);
         await instanceLoader.createInstancesOfDependencies(this.container.getModules(), this.mocker);