@venok/core 1.1.0 → 2.0.1-next.1

package/test/scanner.spec.js

@@ -1,620 +0,0 @@
-"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

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