@venok/core 1.0.0

package/test/scanner.spec.js

@@ -0,0 +1,620 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const injectable_decorator_1 = require("@venok/core/decorators/injectable.decorator");
+const catch_decorator_1 = require("@venok/core/decorators/catch.decorator");
+const module_decorator_1 = require("@venok/core/decorators/module.decorator");
+const scanner_1 = require("@venok/core/scanner");
+const container_1 = require("@venok/core/injector/container");
+const graph_inspector_1 = require("@venok/core/inspector/graph-inspector");
+const metadata_scanner_1 = require("@venok/core/metadata-scanner");
+const config_1 = require("@venok/core/application/config");
+const undefined_module_exception_1 = require("@venok/core/errors/exceptions/undefined-module.exception");
+const invalid_module_exception_1 = require("@venok/core/errors/exceptions/invalid-module.exception");
+const constants_1 = require("@venok/core/constants");
+const wrapper_1 = require("@venok/core/injector/instance/wrapper");
+const interfaces_1 = require("@venok/core/interfaces");
+const invalid_class_module_exception_1 = require("@venok/core/errors/exceptions/invalid-class-module.exception");
+const use_guards_decorator_1 = require("@venok/core/decorators/use-guards.decorator");
+describe("DependenciesScanner", () => {
+    class Guard {
+    }
+    let TestComponent = class TestComponent {
+    };
+    TestComponent = __decorate([
+        (0, injectable_decorator_1.Injectable)()
+    ], TestComponent);
+    let TestExceptionFilterWithoutInjectable = class TestExceptionFilterWithoutInjectable {
+    };
+    TestExceptionFilterWithoutInjectable = __decorate([
+        (0, catch_decorator_1.Catch)()
+    ], TestExceptionFilterWithoutInjectable);
+    let BasicModule = class BasicModule {
+    };
+    BasicModule = __decorate([
+        (0, module_decorator_1.Module)({
+            providers: [TestComponent],
+            exports: [TestComponent],
+        })
+    ], BasicModule);
+    let TestModule = class TestModule {
+    };
+    TestModule = __decorate([
+        (0, module_decorator_1.Module)({
+            imports: [BasicModule],
+            providers: [TestComponent],
+        })
+    ], TestModule);
+    let UndefinedModule = class UndefinedModule {
+    };
+    UndefinedModule = __decorate([
+        (0, module_decorator_1.Module)({
+            imports: [undefined],
+        })
+    ], UndefinedModule);
+    let InvalidModule = class InvalidModule {
+    };
+    InvalidModule = __decorate([
+        (0, module_decorator_1.Module)({
+            imports: [null],
+        })
+    ], InvalidModule);
+    let scanner;
+    let mockContainer;
+    let container;
+    let graphInspector;
+    beforeEach(() => {
+        container = new container_1.VenokContainer();
+        mockContainer = sinon_1.default.mock(container);
+        graphInspector = new graph_inspector_1.GraphInspector(container);
+        scanner = new scanner_1.DependenciesScanner(container, new metadata_scanner_1.MetadataScanner(), graphInspector, new config_1.ApplicationConfig());
+        sinon_1.default.stub(scanner, "registerCoreModule").callsFake(async () => { });
+    });
+    afterEach(() => {
+        mockContainer.restore();
+    });
+    it('should "insertOrOverrideModule" call twice (2 modules) container method "addModule"', async () => {
+        const expectationCountAddModule = mockContainer.expects("addModule").twice();
+        const expectationCountReplaceModule = mockContainer.expects("replaceModule").never();
+        await scanner.scan(TestModule);
+        expectationCountAddModule.verify();
+        expectationCountReplaceModule.verify();
+    });
+    it('should "insertProvider" call twice (2 components) container method "addProvider"', async () => {
+        const expectation = mockContainer.expects("addProvider").twice();
+        const stub = sinon_1.default.stub(scanner, "insertExportedProvider");
+        await scanner.scan(TestModule);
+        expectation.verify();
+        stub.restore();
+    });
+    it('should "insertExportedProvider" call once (1 component) container method "addExportedProvider"', async () => {
+        const expectation = mockContainer.expects("addExportedProvider").once();
+        await scanner.scan(TestModule);
+        expectation.verify();
+    });
+    it('should "insertProvider" call once container method "addProvider"', async () => {
+        const expectation = mockContainer.expects("addProvider").once();
+        const stub = sinon_1.default.stub(scanner, "insertExportedProvider");
+        await scanner.scan(BasicModule);
+        expectation.verify();
+        stub.restore();
+    });
+    describe("when there is modules overrides", () => {
+        let OverwrittenTestComponent = class OverwrittenTestComponent {
+        };
+        OverwrittenTestComponent = __decorate([
+            (0, injectable_decorator_1.Injectable)()
+        ], OverwrittenTestComponent);
+        let OverwrittenInjectableOne = class OverwrittenInjectableOne {
+        };
+        OverwrittenInjectableOne = __decorate([
+            (0, injectable_decorator_1.Injectable)()
+        ], OverwrittenInjectableOne);
+        let OverwrittenInjectableTwo = class OverwrittenInjectableTwo {
+        };
+        OverwrittenInjectableTwo = __decorate([
+            (0, injectable_decorator_1.Injectable)()
+        ], OverwrittenInjectableTwo);
+        let OverwrittenModuleOne = class OverwrittenModuleOne {
+        };
+        OverwrittenModuleOne = __decorate([
+            (0, module_decorator_1.Module)({
+                providers: [OverwrittenTestComponent, OverwrittenInjectableOne],
+            })
+        ], OverwrittenModuleOne);
+        let OverwrittenModuleTwo = class OverwrittenModuleTwo {
+        };
+        OverwrittenModuleTwo = __decorate([
+            (0, module_decorator_1.Module)({
+                providers: [OverwrittenInjectableTwo],
+            })
+        ], OverwrittenModuleTwo);
+        let OverrideTestModule = class OverrideTestModule {
+        };
+        OverrideTestModule = __decorate([
+            (0, module_decorator_1.Module)({
+                imports: [OverwrittenModuleOne, OverwrittenModuleTwo],
+            })
+        ], OverrideTestModule);
+        let OverrideTestComponent = class OverrideTestComponent {
+        };
+        OverrideTestComponent = __decorate([
+            (0, injectable_decorator_1.Injectable)()
+        ], OverrideTestComponent);
+        let OverrideModuleOne = class OverrideModuleOne {
+        };
+        OverrideModuleOne = __decorate([
+            (0, module_decorator_1.Module)({
+                providers: [OverrideTestComponent, OverwrittenInjectableOne],
+            })
+        ], OverrideModuleOne);
+        let OverrideModuleTwo = class OverrideModuleTwo {
+        };
+        OverrideModuleTwo = __decorate([
+            (0, module_decorator_1.Module)({
+                providers: [OverwrittenInjectableTwo],
+            })
+        ], OverrideModuleTwo);
+        const modulesToOverride = [
+            { moduleToReplace: OverwrittenModuleOne, newModule: OverrideModuleOne },
+            { moduleToReplace: OverwrittenModuleTwo, newModule: OverrideModuleTwo },
+        ];
+        it('should "putModule" call twice (2 modules) container method "replaceModule"', async () => {
+            const expectationReplaceModuleFirst = mockContainer
+                .expects("replaceModule")
+                .once()
+                .withArgs(OverwrittenModuleOne, OverrideModuleOne, sinon_1.default.match.array);
+            const expectationReplaceModuleSecond = mockContainer
+                .expects("replaceModule")
+                .once()
+                .withArgs(OverwrittenModuleTwo, OverrideModuleTwo, sinon_1.default.match.array);
+            const expectationCountAddModule = mockContainer.expects("addModule").once();
+            await scanner.scan(OverrideTestModule, {
+                overrides: modulesToOverride,
+            });
+            expectationReplaceModuleFirst.verify();
+            expectationReplaceModuleSecond.verify();
+            expectationCountAddModule.verify();
+        });
+        it('should "putModule" call container method "replaceModule" with forwardRef() when forwardRef property exists', async () => {
+            const overwrittenForwardRefSpy = sinon_1.default.spy();
+            let OverwrittenForwardRef = class OverwrittenForwardRef {
+            };
+            OverwrittenForwardRef = __decorate([
+                (0, module_decorator_1.Module)({})
+            ], OverwrittenForwardRef);
+            let Overwritten = class Overwritten {
+                static forwardRef() {
+                    overwrittenForwardRefSpy();
+                    return OverwrittenForwardRef;
+                }
+            };
+            Overwritten = __decorate([
+                (0, module_decorator_1.Module)({})
+            ], Overwritten);
+            const overrideForwardRefSpy = sinon_1.default.spy();
+            let OverrideForwardRef = class OverrideForwardRef {
+            };
+            OverrideForwardRef = __decorate([
+                (0, module_decorator_1.Module)({})
+            ], OverrideForwardRef);
+            let Override = class Override {
+                static forwardRef() {
+                    overrideForwardRefSpy();
+                    return OverrideForwardRef;
+                }
+            };
+            Override = __decorate([
+                (0, module_decorator_1.Module)({})
+            ], Override);
+            let OverrideForwardRefTestModule = class OverrideForwardRefTestModule {
+            };
+            OverrideForwardRefTestModule = __decorate([
+                (0, module_decorator_1.Module)({
+                    imports: [Overwritten],
+                })
+            ], OverrideForwardRefTestModule);
+            await scanner.scan(OverrideForwardRefTestModule, {
+                overrides: [
+                    {
+                        moduleToReplace: Overwritten,
+                        newModule: Override,
+                    },
+                ],
+            });
+            (0, chai_1.expect)(overwrittenForwardRefSpy.called).to.be.true;
+            (0, chai_1.expect)(overrideForwardRefSpy.called).to.be.true;
+        });
+    });
+    describe("reflectDynamicMetadata", () => {
+        describe("when param has prototype", () => {
+            it('should call "reflectParamInjectables" and "reflectInjectables"', () => {
+                const reflectInjectables = sinon_1.default.stub(scanner, "reflectInjectables").callsFake(() => undefined);
+                const reflectParamInjectables = sinon_1.default.stub(scanner, "reflectParamInjectables").callsFake(() => undefined);
+                scanner.reflectDynamicMetadata({ prototype: true }, "");
+                (0, chai_1.expect)(reflectInjectables.called).to.be.true;
+                (0, chai_1.expect)(reflectParamInjectables.called).to.be.true;
+            });
+        });
+        describe("when param has not prototype", () => {
+            it('should not call ""reflectParamInjectables" and "reflectInjectables"', () => {
+                const reflectInjectables = sinon_1.default.stub(scanner, "reflectInjectables").callsFake(() => undefined);
+                const reflectParamInjectables = sinon_1.default
+                    .stub(scanner, "reflectParamInjectables")
+                    .callsFake(() => undefined);
+                scanner.reflectDynamicMetadata({}, "");
+                (0, chai_1.expect)(reflectInjectables.called).to.be.false;
+                (0, chai_1.expect)(reflectParamInjectables.called).to.be.false;
+            });
+        });
+    });
+    describe("insertInjectable", () => {
+        class InjectableCls {
+        }
+        class HostCls {
+        }
+        const instanceWrapper = { id: "random_id" };
+        const token = "token";
+        const methodKey = "methodKey";
+        let addInjectableStub;
+        let insertEnhancerMetadataCacheStub;
+        beforeEach(() => {
+            addInjectableStub = sinon_1.default.stub(scanner.container, "addInjectable").callsFake(() => instanceWrapper);
+            insertEnhancerMetadataCacheStub = sinon_1.default
+                .stub(graphInspector, "insertEnhancerMetadataCache")
+                .callsFake(() => undefined);
+        });
+        describe("when injectable is of type function", () => {
+            const subtype = "filter";
+            beforeEach(() => {
+                scanner.insertInjectable(InjectableCls, token, HostCls, subtype, methodKey);
+            });
+            it('should call "addInjectable"', () => {
+                (0, chai_1.expect)(addInjectableStub.calledWith(InjectableCls, token)).to.be.true;
+            });
+            it('should call "insertEnhancerMetadataCache"', () => {
+                (0, chai_1.expect)(insertEnhancerMetadataCacheStub.calledWith({
+                    moduleToken: token,
+                    classRef: HostCls,
+                    enhancerInstanceWrapper: instanceWrapper,
+                    targetNodeId: instanceWrapper.id,
+                    methodKey,
+                    subtype,
+                })).to.be.true;
+            });
+        });
+        describe("when injectable is not of type function", () => {
+            const injectableRef = new InjectableCls();
+            const subtype = "interceptor";
+            beforeEach(() => {
+                scanner.insertInjectable(injectableRef, token, HostCls, subtype, methodKey);
+            });
+            it('should not call "addInjectable"', () => {
+                (0, chai_1.expect)(addInjectableStub.notCalled).to.be.true;
+            });
+            it('should call "insertEnhancerMetadataCache"', () => {
+                (0, chai_1.expect)(insertEnhancerMetadataCacheStub.calledWith({
+                    moduleToken: token,
+                    classRef: HostCls,
+                    enhancerRef: injectableRef,
+                    methodKey,
+                    subtype,
+                })).to.be.true;
+            });
+        });
+    });
+    class CompMethod {
+        method() { }
+        method2() { }
+    }
+    __decorate([
+        (0, use_guards_decorator_1.UseGuards)(Guard),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], CompMethod.prototype, "method", null);
+    __decorate([
+        (0, use_guards_decorator_1.UseGuards)(Guard, Guard),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], CompMethod.prototype, "method2", null);
+    describe("reflectKeyMetadata", () => {
+        it("should return undefined", () => {
+            const result = scanner.reflectKeyMetadata(TestComponent, "key", "method");
+            (0, chai_1.expect)(result).to.be.undefined;
+        });
+        it("should return an array that consists of 1 element", () => {
+            const methodKey = "method";
+            const result = scanner.reflectKeyMetadata(CompMethod, constants_1.GUARDS_METADATA, methodKey);
+            (0, chai_1.expect)(result).to.be.deep.equal({ methodKey, metadata: [Guard] });
+        });
+        it("should return an array that consists of 2 elements", () => {
+            const methodKey = "method2";
+            const result = scanner.reflectKeyMetadata(CompMethod, constants_1.GUARDS_METADATA, methodKey);
+            (0, chai_1.expect)(result).to.be.deep.equal({ methodKey, metadata: [Guard, Guard] });
+        });
+    });
+    describe("insertModule", () => {
+        it("should call forwardRef() when forwardRef property exists", () => {
+            sinon_1.default.stub(container, "addModule").returns({});
+            const module = { forwardRef: sinon_1.default.spy() };
+            scanner.insertModule(module, []);
+            (0, chai_1.expect)(module.forwardRef.called).to.be.true;
+        });
+        it('should throw "InvalidClassModuleException" exception when supplying a class annotated with `@Injectable()` decorator', () => {
+            sinon_1.default.stub(container, "addModule").returns({});
+            (0, chai_1.expect)(scanner.insertModule(TestComponent, [])).to.be.rejectedWith(invalid_class_module_exception_1.InvalidClassModuleException);
+        });
+        it('should throw "InvalidClassModuleException" exception when supplying a class annotated with (only) `@Catch()` decorator', () => {
+            sinon_1.default.stub(container, "addModule").returns({});
+            (0, chai_1.expect)(scanner.insertModule(TestExceptionFilterWithoutInjectable, [])).to.be.rejectedWith(invalid_class_module_exception_1.InvalidClassModuleException);
+        });
+    });
+    describe("insertImport", () => {
+        it("should call forwardRef() when forwardRef property exists", async () => {
+            const module = { forwardRef: sinon_1.default.stub().returns({}) };
+            sinon_1.default.stub(container, "addImport").returns({});
+            await scanner.insertImport(module, [], "test");
+            (0, chai_1.expect)(module.forwardRef.called).to.be.true;
+        });
+        describe('when "related" is nil', () => {
+            it("should throw exception", async () => {
+                let error;
+                try {
+                    await scanner.insertImport(undefined, [], "test");
+                }
+                catch (e) {
+                    error = e;
+                }
+                (0, chai_1.expect)(error).to.not.be.undefined;
+            });
+        });
+    });
+    describe("insertProvider", () => {
+        const token = "token";
+        describe("when provider is not custom", () => {
+            it('should call container "addProvider" with expected args', () => {
+                const provider = {};
+                const expectation = mockContainer.expects("addProvider").withArgs(provider, token);
+                mockContainer.expects("addProvider").callsFake(() => false);
+                scanner.insertProvider(provider, token);
+                expectation.verify();
+            });
+        });
+        describe("when provider is custom", () => {
+            describe("and is global", () => {
+                const provider = {
+                    provide: constants_1.APP_INTERCEPTOR,
+                    useValue: true,
+                };
+                it('should call container "addProvider" with expected args', () => {
+                    const expectation = mockContainer.expects("addProvider").atLeast(1);
+                    mockContainer.expects("addProvider").callsFake(() => false);
+                    scanner.insertProvider(provider, token);
+                    expectation.verify();
+                });
+                it('should push new object to "applicationProvidersApplyMap" array', () => {
+                    mockContainer.expects("addProvider").callsFake(() => false);
+                    scanner.insertProvider(provider, token);
+                    const applyMap = scanner.applicationProvidersApplyMap;
+                    (0, chai_1.expect)(applyMap).to.have.length(1);
+                    (0, chai_1.expect)(applyMap[0].moduleKey).to.be.eql(token);
+                });
+            });
+            describe("and is global and request/transient scoped", () => {
+                const provider = {
+                    provide: constants_1.APP_INTERCEPTOR,
+                    useValue: true,
+                    scope: interfaces_1.Scope.REQUEST,
+                };
+                it('should call container "addInjectable" with expected args', () => {
+                    const expectation = mockContainer.expects("addInjectable").atLeast(1);
+                    mockContainer.expects("addInjectable").callsFake(() => false);
+                    scanner.insertProvider(provider, token);
+                    expectation.verify();
+                });
+            });
+            describe("and is not global", () => {
+                const component = {
+                    provide: "CUSTOM",
+                    useValue: true,
+                };
+                it('should call container "addProvider" with expected args', () => {
+                    const expectation = mockContainer.expects("addProvider").withArgs(component, token);
+                    mockContainer.expects("addProvider").callsFake(() => false);
+                    scanner.insertProvider(component, token);
+                    expectation.verify();
+                });
+                it('should not push new object to "applicationProvidersApplyMap" array', () => {
+                    (0, chai_1.expect)(scanner.applicationProvidersApplyMap).to.have.length(0);
+                    mockContainer.expects("addProvider").callsFake(() => false);
+                    scanner.insertProvider(component, token);
+                    (0, chai_1.expect)(scanner.applicationProvidersApplyMap).to.have.length(0);
+                });
+            });
+        });
+    });
+    describe("applyApplicationProviders", () => {
+        it("should apply each provider", () => {
+            const provider = {
+                moduleKey: "moduleToken",
+                providerKey: "providerToken",
+                type: constants_1.APP_GUARD,
+            };
+            scanner.applicationProvidersApplyMap = [provider];
+            const expectedInstance = {};
+            const instanceWrapper = {
+                instance: expectedInstance,
+            };
+            mockContainer.expects("getModules").callsFake(() => ({
+                get: () => ({
+                    providers: { get: () => instanceWrapper },
+                }),
+            }));
+            const applySpy = sinon_1.default.spy();
+            sinon_1.default.stub(scanner, "getApplyProvidersMap").callsFake(() => ({
+                [provider.type]: applySpy,
+            }));
+            const insertAttachedEnhancerStub = sinon_1.default.stub(graphInspector, "insertAttachedEnhancer");
+            scanner.applyApplicationProviders();
+            (0, chai_1.expect)(applySpy.called).to.be.true;
+            (0, chai_1.expect)(applySpy.calledWith(expectedInstance)).to.be.true;
+            (0, chai_1.expect)(insertAttachedEnhancerStub.calledWith(instanceWrapper)).to.be.true;
+        });
+        it("should apply each globally scoped provider", () => {
+            const provider = {
+                moduleKey: "moduleToken",
+                providerKey: "providerToken",
+                type: constants_1.APP_GUARD,
+                scope: interfaces_1.Scope.REQUEST,
+            };
+            scanner.applicationProvidersApplyMap = [provider];
+            const expectedInstanceWrapper = new wrapper_1.InstanceWrapper();
+            mockContainer.expects("getModules").callsFake(() => ({
+                get: () => ({
+                    injectables: { get: () => expectedInstanceWrapper },
+                }),
+            }));
+            const applySpy = sinon_1.default.spy();
+            sinon_1.default.stub(scanner, "getApplyRequestProvidersMap").callsFake(() => ({
+                [provider.type]: applySpy,
+            }));
+            const insertAttachedEnhancerStub = sinon_1.default.stub(graphInspector, "insertAttachedEnhancer");
+            scanner.applyApplicationProviders();
+            (0, chai_1.expect)(applySpy.called).to.be.true;
+            (0, chai_1.expect)(applySpy.calledWith(expectedInstanceWrapper)).to.be.true;
+            (0, chai_1.expect)(insertAttachedEnhancerStub.calledWith(expectedInstanceWrapper)).to.be.true;
+        });
+    });
+    describe("addScopedEnhancersMetadata", () => {
+        const provider = {
+            moduleKey: "moduleToken",
+            providerKey: "providerToken",
+            type: constants_1.APP_GUARD,
+            scope: interfaces_1.Scope.REQUEST,
+        };
+        it("should add enhancers metadata to every controller and every entry provider", () => {
+            scanner.applicationProvidersApplyMap = [provider];
+            const instance = new wrapper_1.InstanceWrapper({ name: "test" });
+            const controllers = new Map();
+            const providers = new Map();
+            const fakeController = new wrapper_1.InstanceWrapper();
+            const fakeProvider = new wrapper_1.InstanceWrapper();
+            const providerToken = "entryProvider";
+            controllers.set("test", fakeController);
+            providers.set(providerToken, fakeProvider);
+            mockContainer.expects("getModules").callsFake(() => ({
+                get: () => ({
+                    injectables: { get: () => instance },
+                    controllers,
+                    entryProviders: Array.from(providers.values()),
+                }),
+                values() {
+                    return [this.get()];
+                },
+            }));
+            const addEnhancerMetadataProviderSpy = sinon_1.default.spy(fakeProvider, "addEnhancerMetadata");
+            scanner.addScopedEnhancersMetadata();
+            (0, chai_1.expect)(addEnhancerMetadataProviderSpy.called).to.be.true;
+            (0, chai_1.expect)(addEnhancerMetadataProviderSpy.calledWith(instance)).to.be.true;
+        });
+    });
+    describe("getApplyProvidersMap", () => {
+        describe(`when token is ${constants_1.APP_INTERCEPTOR}`, () => {
+            it('call "addGlobalInterceptor"', () => {
+                const addSpy = sinon_1.default.spy(scanner.applicationConfig, "addGlobalInterceptor");
+                scanner.getApplyProvidersMap()[constants_1.APP_INTERCEPTOR](null);
+                (0, chai_1.expect)(addSpy.called).to.be.true;
+            });
+        });
+        describe(`when token is ${constants_1.APP_GUARD}`, () => {
+            it('call "addGlobalGuard"', () => {
+                const addSpy = sinon_1.default.spy(scanner.applicationConfig, "addGlobalGuard");
+                scanner.getApplyProvidersMap()[constants_1.APP_GUARD](null);
+                (0, chai_1.expect)(addSpy.called).to.be.true;
+            });
+        });
+        describe(`when token is ${constants_1.APP_PIPE}`, () => {
+            it('call "addGlobalPipe"', () => {
+                const addSpy = sinon_1.default.spy(scanner.applicationConfig, "addGlobalPipe");
+                scanner.getApplyProvidersMap()[constants_1.APP_PIPE](null);
+                (0, chai_1.expect)(addSpy.called).to.be.true;
+            });
+        });
+        describe(`when token is ${constants_1.APP_FILTER}`, () => {
+            it('call "addGlobalFilter"', () => {
+                const addSpy = sinon_1.default.spy(scanner.applicationConfig, "addGlobalFilter");
+                scanner.getApplyProvidersMap()[constants_1.APP_FILTER](null);
+                (0, chai_1.expect)(addSpy.called).to.be.true;
+            });
+        });
+    });
+    describe("getApplyRequestProvidersMap", () => {
+        describe(`when token is ${constants_1.APP_INTERCEPTOR}`, () => {
+            it('call "addGlobalRequestInterceptor"', () => {
+                const addSpy = sinon_1.default.spy(scanner.applicationConfig, "addGlobalRequestInterceptor");
+                scanner.getApplyRequestProvidersMap()[constants_1.APP_INTERCEPTOR](null);
+                (0, chai_1.expect)(addSpy.called).to.be.true;
+            });
+        });
+        describe(`when token is ${constants_1.APP_GUARD}`, () => {
+            it('call "addGlobalRequestGuard"', () => {
+                const addSpy = sinon_1.default.spy(scanner.applicationConfig, "addGlobalRequestGuard");
+                scanner.getApplyRequestProvidersMap()[constants_1.APP_GUARD](null);
+                (0, chai_1.expect)(addSpy.called).to.be.true;
+            });
+        });
+        describe(`when token is ${constants_1.APP_PIPE}`, () => {
+            it('call "addGlobalRequestPipe"', () => {
+                const addSpy = sinon_1.default.spy(scanner.applicationConfig, "addGlobalRequestPipe");
+                scanner.getApplyRequestProvidersMap()[constants_1.APP_PIPE](null);
+                (0, chai_1.expect)(addSpy.called).to.be.true;
+            });
+        });
+        describe(`when token is ${constants_1.APP_FILTER}`, () => {
+            it('call "addGlobalRequestFilter"', () => {
+                const addSpy = sinon_1.default.spy(scanner.applicationConfig, "addGlobalRequestFilter");
+                scanner.getApplyRequestProvidersMap()[constants_1.APP_FILTER](null);
+                (0, chai_1.expect)(addSpy.called).to.be.true;
+            });
+        });
+    });
+    describe("scanForModules", () => {
+        it("should throw an exception when the imports array includes undefined", () => {
+            try {
+                scanner.scanForModules({
+                    moduleDefinition: UndefinedModule,
+                    scope: [UndefinedModule],
+                });
+            }
+            catch (exception) {
+                (0, chai_1.expect)(exception instanceof undefined_module_exception_1.UndefinedModuleException).to.be.true;
+            }
+        });
+        it("should throw an exception when the imports array includes an invalid value", () => {
+            try {
+                scanner.scanForModules({
+                    moduleDefinition: InvalidModule,
+                    scope: [InvalidModule],
+                });
+            }
+            catch (exception) {
+                (0, chai_1.expect)(exception instanceof invalid_module_exception_1.InvalidModuleException).to.be.true;
+            }
+        });
+    });
+});

package/test/services/logger.service.spec.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";