@venok/core 1.1.0 → 2.0.0

package/test/interceptors/consumer.spec.js

@@ -1,136 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const async_hooks_1 = require("async_hooks");
-const chai_1 = require("chai");
-const rxjs_1 = require("rxjs");
-const sinon_1 = __importDefault(require("sinon"));
-const interceptors_1 = require("@venok/core/interceptors");
-describe("InterceptorsConsumer", () => {
-    let consumer;
-    let interceptors;
-    beforeEach(() => {
-        consumer = new interceptors_1.InterceptorsConsumer();
-        interceptors = [
-            {
-                intercept: sinon_1.default.stub().callsFake((ctx, handler) => handler.handle()),
-            },
-            {
-                intercept: sinon_1.default.stub().callsFake(async (ctx, handler) => handler.handle()),
-            },
-        ];
-    });
-    describe("intercept", () => {
-        describe("when interceptors array is empty", () => {
-            let next;
-            beforeEach(() => {
-                next = sinon_1.default.spy();
-            });
-            it("should call next()", async () => {
-                await consumer.intercept([], null, { constructor: null }, null, next);
-                (0, chai_1.expect)(next.calledOnce).to.be.true;
-            });
-        });
-        describe("when interceptors array is not empty", () => {
-            let next;
-            beforeEach(() => {
-                next = sinon_1.default.stub().returns(Promise.resolve(""));
-            });
-            it("does not call `intercept` (lazy evaluation)", async () => {
-                await consumer.intercept(interceptors, null, { constructor: null }, null, next);
-                (0, chai_1.expect)(interceptors[0].intercept.called).to.be.false;
-                (0, chai_1.expect)(interceptors[1].intercept.called).to.be.false;
-            });
-            it("should call every `intercept` method when subscribe", async () => {
-                const intercepted = await consumer.intercept(interceptors, null, { constructor: null }, null, next);
-                await transformToResult(intercepted);
-                (0, chai_1.expect)(interceptors[0].intercept.calledOnce).to.be.true;
-                (0, chai_1.expect)(interceptors[1].intercept.calledOnce).to.be.true;
-            });
-            it("should not call `next` (lazy evaluation)", async () => {
-                await consumer.intercept(interceptors, null, { constructor: null }, null, next);
-                (0, chai_1.expect)(next.called).to.be.false;
-            });
-            it("should call `next` when subscribe", async () => {
-                const intercepted = await consumer.intercept(interceptors, null, { constructor: null }, null, next);
-                await transformToResult(intercepted);
-                (0, chai_1.expect)(next.called).to.be.true;
-            });
-        });
-        describe("when AsyncLocalStorage is used", () => {
-            it("should allow an interceptor to set values in AsyncLocalStorage that are accesible from the controller", async () => {
-                const storage = new async_hooks_1.AsyncLocalStorage();
-                class StorageInterceptor {
-                    intercept(_context, next) {
-                        return storage.run({ value: "hello" }, () => next.handle());
-                    }
-                }
-                const next = () => {
-                    return Promise.resolve(storage.getStore().value);
-                };
-                const intercepted = await consumer.intercept([new StorageInterceptor()], null, { constructor: null }, null, next);
-                const result = await transformToResult(intercepted);
-                (0, chai_1.expect)(result).to.equal("hello");
-            });
-        });
-        describe("when retrying is enabled", () => {
-            it("should retry a specified amount of times", async () => {
-                let count = 0;
-                const next = () => {
-                    count++;
-                    if (count < 3) {
-                        return Promise.reject(new Error("count not reached"));
-                    }
-                    return Promise.resolve(count);
-                };
-                class RetryInterceptor {
-                    intercept(_context, next) {
-                        return next.handle().pipe((0, rxjs_1.retry)(4));
-                    }
-                }
-                const intercepted = await consumer.intercept([new RetryInterceptor()], null, { constructor: null }, null, next);
-                (0, chai_1.expect)(await transformToResult(intercepted)).to.equal(3);
-            });
-        });
-    });
-    describe("createContext", () => {
-        it("should return execution context object", () => {
-            const instance = { constructor: {} };
-            const callback = () => null;
-            const context = consumer.createContext([], instance, callback);
-            (0, chai_1.expect)(context.getClass()).to.be.eql(instance.constructor);
-            (0, chai_1.expect)(context.getHandler()).to.be.eql(callback);
-        });
-    });
-    describe("transformDeferred", () => {
-        describe("when next() result is plain value", () => {
-            it("should return Observable", async () => {
-                const val = 3;
-                const next = async () => val;
-                (0, chai_1.expect)(await (0, rxjs_1.lastValueFrom)(consumer.transformDeferred(next))).to.be.eql(val);
-            });
-        });
-        describe("when next() result is Promise", () => {
-            it("should return Observable", async () => {
-                const val = 3;
-                const next = async () => val;
-                (0, chai_1.expect)(await (0, rxjs_1.lastValueFrom)(consumer.transformDeferred(next))).to.be.eql(val);
-            });
-        });
-        describe("when next() result is Observable", () => {
-            it("should return Observable", async () => {
-                const val = 3;
-                const next = async () => (0, rxjs_1.of)(val);
-                (0, chai_1.expect)(await (0, rxjs_1.lastValueFrom)(consumer.transformDeferred(next))).to.be.eql(val);
-            });
-        });
-    });
-});
-async function transformToResult(resultOrDeferred) {
-    if (resultOrDeferred && typeof resultOrDeferred.subscribe === "function") {
-        return (0, rxjs_1.lastValueFrom)(resultOrDeferred);
-    }
-    return resultOrDeferred;
-}

package/test/interceptors/context-creator.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/test/interceptors/context-creator.spec.js

@@ -1,139 +0,0 @@
-"use strict";
-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 rxjs_1 = require("rxjs");
-const sinon_1 = __importDefault(require("sinon"));
-const interceptors_1 = require("@venok/core/interceptors");
-const config_1 = require("@venok/core/application/config");
-const wrapper_1 = require("@venok/core/injector/instance/wrapper");
-class Interceptor {
-}
-describe("InterceptorsContextCreator", () => {
-    let interceptorsContextCreator;
-    let interceptors;
-    let applicationConfig;
-    let container;
-    let getSpy;
-    class Interceptor1 {
-    }
-    class Interceptor2 {
-    }
-    beforeEach(() => {
-        interceptors = [
-            {
-                name: Interceptor1.name,
-                token: Interceptor1,
-                metatype: Interceptor1,
-                getInstanceByContextId: () => interceptors[0],
-                instance: {
-                    intercept: () => (0, rxjs_1.of)(true),
-                },
-            },
-            {
-                name: Interceptor2.name,
-                token: Interceptor2,
-                metatype: Interceptor2,
-                getInstanceByContextId: () => interceptors[1],
-                instance: {
-                    intercept: () => (0, rxjs_1.of)(true),
-                },
-            },
-            {},
-            undefined,
-        ];
-        getSpy = sinon_1.default.stub().returns({
-            injectables: new Map([
-                [Interceptor1, interceptors[0]],
-                [Interceptor2, interceptors[1]],
-            ]),
-        });
-        container = {
-            getModules: () => ({
-                get: getSpy,
-            }),
-        };
-        applicationConfig = new config_1.ApplicationConfig();
-        interceptorsContextCreator = new interceptors_1.InterceptorsContextCreator(container, applicationConfig);
-    });
-    describe("createConcreteContext", () => {
-        describe("when `moduleContext` is nil", () => {
-            it("should return empty array", () => {
-                const result = interceptorsContextCreator.createConcreteContext(interceptors);
-                (0, chai_1.expect)(result).to.be.empty;
-            });
-        });
-        describe("when `moduleContext` is defined", () => {
-            beforeEach(() => {
-                interceptorsContextCreator["moduleContext"] = "test";
-            });
-            it("should filter metatypes", () => {
-                const interceptorTypeRefs = [interceptors[0].metatype, interceptors[1].instance];
-                (0, chai_1.expect)(interceptorsContextCreator.createConcreteContext(interceptorTypeRefs)).to.have.length(2);
-            });
-        });
-    });
-    describe("getInterceptorInstance", () => {
-        describe("when param is an object", () => {
-            it("should return instance", () => {
-                const instance = { intercept: () => null };
-                (0, chai_1.expect)(interceptorsContextCreator.getInterceptorInstance(instance)).to.be.eql(instance);
-            });
-        });
-        describe("when param is a constructor", () => {
-            it("should pick instance from container", () => {
-                const wrapper = {
-                    instance: "test",
-                    getInstanceByContextId: () => wrapper,
-                };
-                sinon_1.default.stub(interceptorsContextCreator, "getInstanceByMetatype").callsFake(() => wrapper);
-                (0, chai_1.expect)(interceptorsContextCreator.getInterceptorInstance(Interceptor)).to.be.eql(wrapper.instance);
-            });
-            it("should return null", () => {
-                sinon_1.default.stub(interceptorsContextCreator, "getInstanceByMetatype").callsFake(() => null);
-                (0, chai_1.expect)(interceptorsContextCreator.getInterceptorInstance(Interceptor)).to.be.eql(null);
-            });
-        });
-    });
-    describe("getInstanceByMetatype", () => {
-        describe('when "moduleContext" is nil', () => {
-            it("should return undefined", () => {
-                interceptorsContextCreator.moduleContext = undefined;
-                (0, chai_1.expect)(interceptorsContextCreator.getInstanceByMetatype(null)).to.be.undefined;
-            });
-        });
-        describe('when "moduleContext" is not nil', () => {
-            beforeEach(() => {
-                interceptorsContextCreator.moduleContext = "test";
-            });
-            describe("and when module exists", () => {
-                it("should return undefined", () => {
-                    (0, chai_1.expect)(interceptorsContextCreator.getInstanceByMetatype(class {
-                    })).to.be.undefined;
-                });
-            });
-        });
-    });
-    describe("getGlobalMetadata", () => {
-        describe("when contextId is static and inquirerId is nil", () => {
-            it("should return global interceptors", () => {
-                const expectedResult = applicationConfig.getGlobalInterceptors();
-                (0, chai_1.expect)(interceptorsContextCreator.getGlobalMetadata()).to.be.equal(expectedResult);
-            });
-        });
-        describe("otherwise", () => {
-            it("should merge static global with request/transient scoped interceptors", () => {
-                const globalInterceptors = ["test"];
-                const instanceWrapper = new wrapper_1.InstanceWrapper();
-                const instance = "request-scoped";
-                const scopedInterceptorWrappers = [instanceWrapper];
-                sinon_1.default.stub(applicationConfig, "getGlobalInterceptors").callsFake(() => globalInterceptors);
-                sinon_1.default.stub(applicationConfig, "getGlobalRequestInterceptors").callsFake(() => scopedInterceptorWrappers);
-                sinon_1.default.stub(instanceWrapper, "getInstanceByContextId").callsFake(() => ({ instance }));
-                (0, chai_1.expect)(interceptorsContextCreator.getGlobalMetadata({ id: 3 })).to.contains(instance, ...globalInterceptors);
-            });
-        });
-    });
-});

package/test/metadata-scanner.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/test/metadata-scanner.spec.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const chai_1 = require("chai");
-const metadata_scanner_1 = require("@venok/core/metadata-scanner");
-describe("MetadataScanner", () => {
-    let scanner;
-    beforeEach(() => {
-        scanner = new metadata_scanner_1.MetadataScanner();
-    });
-    describe("scanFromPrototype", () => {
-        class Parent {
-            constructor() { }
-            testParent() { }
-            testParent2() { }
-            get propParent() {
-                return "";
-            }
-            set valParent(value) { }
-        }
-        class Test extends Parent {
-            constructor() {
-                super();
-            }
-            get prop() {
-                return "";
-            }
-            set val(value) { }
-            test() { }
-            test2() { }
-        }
-        it("should return only methods", () => {
-            const methods = scanner.getAllMethodNames(Test.prototype);
-            (0, chai_1.expect)(methods).to.eql(["test", "test2", "testParent", "testParent2"]);
-        });
-        it("should return the same instance for the same prototype", () => {
-            const methods1 = scanner.getAllMethodNames(Test.prototype);
-            const methods2 = scanner.getAllMethodNames(Test.prototype);
-            (0, chai_1.expect)(methods1 === methods2).to.eql(true);
-        });
-    });
-});

package/test/module/configurable-module.builder.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/test/module/configurable-module.builder.spec.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const chai_1 = require("chai");
-const module_1 = require("@venok/core/module");
-describe("ConfigurableModuleBuilder", () => {
-    describe("setExtras", () => {
-        it("should apply module definition transformer function and return typed builder", () => {
-            const { ConfigurableModuleClass } = new module_1.ConfigurableModuleBuilder()
-                .setExtras({ isGlobal: false }, (definition, extras) => ({
-                ...definition,
-                global: extras.isGlobal,
-            }))
-                .build();
-            (0, chai_1.expect)(ConfigurableModuleClass.register({
-                // No type error
-                isGlobal: true,
-            })).to.deep.include({
-                global: true,
-            });
-        });
-    });
-    describe("setClassMethodName", () => {
-        it("should set static class method name and return typed builder", () => {
-            const { ConfigurableModuleClass } = new module_1.ConfigurableModuleBuilder().setClassMethodName("forRoot").build();
-            (0, chai_1.expect)(ConfigurableModuleClass.forRoot).to.not.be.undefined;
-            (0, chai_1.expect)(ConfigurableModuleClass.forRootAsync).to.not.be.undefined;
-            (0, chai_1.expect)(ConfigurableModuleClass.register).to.be.undefined;
-        });
-    });
-    describe("setFactoryMethodName", () => {
-        it("should set configuration factory class method name and return typed builder", () => {
-            const { ConfigurableModuleClass } = new module_1.ConfigurableModuleBuilder().setFactoryMethodName("createOptions").build();
-            (0, chai_1.expect)(ConfigurableModuleClass.registerAsync({
-                useClass: class {
-                    // No type error
-                    createOptions() { }
-                },
-            })).to.not.be.undefined;
-        });
-    });
-    describe("build", () => {
-        it('should return a fully typed "ConfigurableModuleClass"', () => {
-            const { ConfigurableModuleClass, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE, MODULE_OPTIONS_TOKEN } = new module_1.ConfigurableModuleBuilder({
-                moduleName: "RandomTest",
-                alwaysTransient: true,
-            })
-                .setFactoryMethodName("createOptions")
-                .setClassMethodName("forFeature")
-                .setExtras({ isGlobal: false, extraProviders: [] }, (definition, extras) => ({
-                ...definition,
-                global: extras.isGlobal,
-                providers: definition.providers?.concat(extras.extraProviders),
-            }))
-                .build();
-            const provideInjectionTokensFrom = [
-                {
-                    provide: "a",
-                    useFactory: () => { },
-                    inject: ["b"],
-                },
-                {
-                    provide: "b",
-                    useFactory: () => { },
-                    inject: ["x"],
-                },
-                {
-                    provide: "c",
-                    useFactory: () => { },
-                    inject: ["y"],
-                },
-            ];
-            const definition = ConfigurableModuleClass.forFeatureAsync({
-                useFactory: () => { },
-                inject: ["a"],
-                provideInjectionTokensFrom,
-                isGlobal: true,
-                extraProviders: ["test"],
-            });
-            (0, chai_1.expect)(definition.global).to.equal(true);
-            (0, chai_1.expect)(definition.providers).to.have.length(5);
-            (0, chai_1.expect)(definition.providers).to.deep.contain("test");
-            (0, chai_1.expect)(definition.providers).to.include.members(provideInjectionTokensFrom.slice(0, 2));
-            (0, chai_1.expect)(definition.providers).not.to.include(provideInjectionTokensFrom[2]);
-            (0, chai_1.expect)(MODULE_OPTIONS_TOKEN).to.equal("RANDOM_TEST_MODULE_OPTIONS");
-            (0, chai_1.expect)(definition.providers[0].provide).to.equal("RANDOM_TEST_MODULE_OPTIONS");
-            try {
-                (0, chai_1.expect)(ASYNC_OPTIONS_TYPE.imports).to.equal(undefined);
-            }
-            catch (err) {
-                (0, chai_1.expect)(err).to.be.instanceOf(Error);
-                (0, chai_1.expect)(err.message).to.equal('"ASYNC_OPTIONS_TYPE" is not supposed to be used as a value.');
-            }
-            try {
-                (0, chai_1.expect)(OPTIONS_TYPE.isGlobal).to.equal(undefined);
-            }
-            catch (err) {
-                (0, chai_1.expect)(err).to.be.instanceOf(Error);
-                (0, chai_1.expect)(err.message).to.equal('"OPTIONS_TYPE" is not supposed to be used as a value.');
-            }
-        });
-    });
-});

package/test/module/helpers/get-injection-providers.helper.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/test/module/helpers/get-injection-providers.helper.spec.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const chai_1 = require("chai");
-const helpers_1 = require("@venok/core/module/helpers");
-describe("getInjectionProviders", () => {
-    it("should take only required providers", () => {
-        class C {
-        }
-        C.token = "a";
-        const p = [
-            {
-                provide: "a",
-                useValue: "a",
-            },
-            {
-                provide: "b",
-                useValue: "b",
-            },
-            C,
-            {
-                provide: "d",
-                useFactory: (c, b) => [c, b],
-                inject: [
-                    C,
-                    {
-                        token: "b",
-                        optional: true,
-                    },
-                    "x",
-                ],
-            },
-            {
-                provide: "e",
-                useFactory: (d, b) => [d, b],
-                inject: ["d", "b"],
-            },
-            {
-                provide: "f",
-                useValue: "f",
-            },
-        ];
-        // should not include 'a' and 'f'
-        const expected = p.slice(1, -1);
-        const result = (0, helpers_1.getInjectionProviders)(p, ["e"]);
-        (0, chai_1.expect)(result).to.have.length(expected.length);
-        (0, chai_1.expect)(result).to.have.members(expected);
-        (0, chai_1.expect)(result).not.to.have.members([p[0], p[5]]);
-    });
-});

package/test/pipes/consumer.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/test/pipes/consumer.spec.js

@@ -1,42 +0,0 @@
-"use strict";
-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 pipes_1 = require("@venok/core/pipes");
-const createPipe = (transform) => ({ transform });
-describe("PipesConsumer", () => {
-    let consumer;
-    beforeEach(() => {
-        consumer = new pipes_1.PipesConsumer();
-    });
-    describe("apply", () => {
-        let value, metatype, type, stringifiedType, transforms, data;
-        beforeEach(() => {
-            value = 0;
-            data = null;
-            (metatype = {}), (type = "query");
-            stringifiedType = "query";
-            transforms = [
-                createPipe(sinon_1.default.stub().callsFake((val) => val + 1)),
-                createPipe(sinon_1.default.stub().callsFake((val) => Promise.resolve(val + 1))),
-                createPipe(sinon_1.default.stub().callsFake((val) => val + 1)),
-            ];
-        });
-        it("should call all transform functions", (done) => {
-            consumer.apply(value, { metatype, type, data }, transforms).then(() => {
-                (0, chai_1.expect)(transforms.reduce((prev, next) => prev && next.transform.called, true)).to.be.true;
-                done();
-            });
-        });
-        it("should return expected result", (done) => {
-            const expectedResult = 3;
-            consumer.apply(value, { metatype, type, data }, transforms).then((result) => {
-                (0, chai_1.expect)(result).to.be.eql(expectedResult);
-                done();
-            });
-        });
-    });
-});

package/test/pipes/context-creator.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/test/pipes/context-creator.spec.js

@@ -1,108 +0,0 @@
-"use strict";
-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 pipes_1 = require("@venok/core/pipes");
-const container_1 = require("@venok/core/injector/container");
-const config_1 = require("@venok/core/application/config");
-const wrapper_1 = require("@venok/core/injector/instance/wrapper");
-class Pipe {
-}
-describe("PipesContextCreator", () => {
-    let creator;
-    let container;
-    let applicationConfig;
-    beforeEach(() => {
-        container = new container_1.VenokContainer();
-        applicationConfig = new config_1.ApplicationConfig();
-        creator = new pipes_1.PipesContextCreator(container, applicationConfig);
-    });
-    describe("createConcreteContext", () => {
-        describe("when metadata is empty or undefined", () => {
-            it("should return empty array", () => {
-                (0, chai_1.expect)(creator.createConcreteContext(undefined)).to.be.deep.equal([]);
-                (0, chai_1.expect)(creator.createConcreteContext([])).to.be.deep.equal([]);
-            });
-        });
-        describe("when metadata is not empty or undefined", () => {
-            const metadata = [null, {}, { transform: () => ({}) }];
-            it("should return expected array", () => {
-                const transforms = creator.createConcreteContext(metadata);
-                (0, chai_1.expect)(transforms).to.have.length(1);
-            });
-        });
-    });
-    describe("getPipeInstance", () => {
-        describe("when param is an object", () => {
-            it("should return instance", () => {
-                const instance = { transform: () => null };
-                (0, chai_1.expect)(creator.getPipeInstance(instance)).to.be.eql(instance);
-            });
-        });
-        describe("when param is a constructor", () => {
-            it("should pick instance from container", () => {
-                const wrapper = {
-                    instance: "test",
-                    getInstanceByContextId: () => wrapper,
-                };
-                sinon_1.default.stub(creator, "getInstanceByMetatype").callsFake(() => wrapper);
-                (0, chai_1.expect)(creator.getPipeInstance(Pipe)).to.be.eql(wrapper.instance);
-            });
-            it("should return null", () => {
-                sinon_1.default.stub(creator, "getInstanceByMetatype").callsFake(() => null);
-                (0, chai_1.expect)(creator.getPipeInstance(Pipe)).to.be.eql(null);
-            });
-        });
-    });
-    describe("getInstanceByMetatype", () => {
-        describe('when "moduleContext" is nil', () => {
-            it("should return undefined", () => {
-                creator.moduleContext = undefined;
-                (0, chai_1.expect)(creator.getInstanceByMetatype(null)).to.be.undefined;
-            });
-        });
-        describe('when "moduleContext" is not nil', () => {
-            beforeEach(() => {
-                creator.moduleContext = "test";
-            });
-            describe("and when module exists", () => {
-                it("should return undefined", () => {
-                    sinon_1.default.stub(container.getModules(), "get").callsFake(() => undefined);
-                    (0, chai_1.expect)(creator.getInstanceByMetatype(null)).to.be.undefined;
-                });
-            });
-            describe("and when module does not exist", () => {
-                it("should return instance", () => {
-                    const instance = { test: true };
-                    const module = { injectables: { get: () => instance } };
-                    sinon_1.default.stub(container.getModules(), "get").callsFake(() => module);
-                    (0, chai_1.expect)(creator.getInstanceByMetatype(class Test {
-                    })).to.be.eql(instance);
-                });
-            });
-        });
-    });
-    describe("getGlobalMetadata", () => {
-        describe("when contextId is static and inquirerId is nil", () => {
-            it("should return global pipes", () => {
-                const expectedResult = applicationConfig.getGlobalPipes();
-                (0, chai_1.expect)(creator.getGlobalMetadata()).to.be.equal(expectedResult);
-            });
-        });
-        describe("otherwise", () => {
-            it("should merge static global with request/transient scoped pipes", () => {
-                const globalPipes = ["test"];
-                const instanceWrapper = new wrapper_1.InstanceWrapper();
-                const instance = "request-scoped";
-                const scopedPipeWrappers = [instanceWrapper];
-                sinon_1.default.stub(applicationConfig, "getGlobalPipes").callsFake(() => globalPipes);
-                sinon_1.default.stub(applicationConfig, "getGlobalRequestPipes").callsFake(() => scopedPipeWrappers);
-                sinon_1.default.stub(instanceWrapper, "getInstanceByContextId").callsFake(() => ({ instance }));
-                (0, chai_1.expect)(creator.getGlobalMetadata({ id: 3 })).to.contains(instance, ...globalPipes);
-            });
-        });
-    });
-});

package/test/scanner.spec.d.ts

@@ -1 +0,0 @@
-export {};