@venok/core 1.0.1-canary.5 → 2.0.0

package/test/injector/internal-core-module/internal-core-module-factory.spec.d.ts

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

package/test/injector/internal-core-module/internal-core-module-factory.spec.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const chai_1 = require("chai");
-const container_1 = require("@venok/core/injector/module/container");
-const internal_core_module_factory_1 = require("@venok/core/injector/internal-core-module/internal-core-module-factory");
-const container_2 = require("@venok/core/injector/container");
-const internal_core_module_1 = require("@venok/core/injector/internal-core-module/internal-core-module");
-const loader_1 = require("@venok/core/injector/module/lazy/loader");
-const serialized_graph_1 = require("@venok/core/inspector/serialized-graph");
-const context_1 = require("@venok/core/context/context");
-describe("InternalCoreModuleFactory", () => {
-    it("should return the internal core module definition", () => {
-        const moduleDefinition = internal_core_module_factory_1.InternalCoreModuleFactory.create(new container_2.VenokContainer(), null, null, null, null);
-        (0, chai_1.expect)(moduleDefinition.module).to.equal(internal_core_module_1.InternalCoreModule);
-        const providedInjectables = moduleDefinition.providers.map((item) => item.provide);
-        (0, chai_1.expect)(providedInjectables).to.deep.equal([
-            container_2.VenokContainer,
-            context_1.VenokContextCreator,
-            container_1.ModulesContainer,
-            loader_1.LazyModuleLoader,
-            serialized_graph_1.SerializedGraph,
-        ]);
-        const lazyModuleLoaderProvider = moduleDefinition.providers.find((item) => item?.provide === loader_1.LazyModuleLoader);
-        (0, chai_1.expect)(lazyModuleLoaderProvider.useFactory()).to.be.instanceOf(loader_1.LazyModuleLoader);
-    });
-});

package/test/injector/module/lazy/loader.spec.d.ts

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

package/test/injector/module/lazy/loader.spec.js

@@ -1,71 +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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const chai_1 = require("chai");
-const loader_1 = require("@venok/core/injector/module/lazy/loader");
-const scanner_1 = require("@venok/core/scanner");
-const loader_2 = require("@venok/core/injector/instance/loader");
-const graph_inspector_1 = require("@venok/core/inspector/graph-inspector");
-const metadata_scanner_1 = require("@venok/core/metadata-scanner");
-const injector_1 = require("@venok/core/injector/injector");
-const container_1 = require("@venok/core/injector/container");
-const module_decorator_1 = require("@venok/core/decorators/module.decorator");
-describe("LazyModuleLoader", () => {
-    let lazyModuleLoader;
-    let dependenciesScanner;
-    let instanceLoader;
-    let modulesContainer;
-    class NoopLogger {
-        log() { }
-        error() { }
-        warn() { }
-    }
-    beforeEach(() => {
-        const venokContainer = new container_1.VenokContainer();
-        const graphInspector = new graph_inspector_1.GraphInspector(venokContainer);
-        dependenciesScanner = new scanner_1.DependenciesScanner(venokContainer, new metadata_scanner_1.MetadataScanner(), graphInspector);
-        const injector = new injector_1.Injector();
-        instanceLoader = new loader_2.InstanceLoader(venokContainer, injector, graphInspector, new NoopLogger());
-        modulesContainer = venokContainer.getModules();
-        lazyModuleLoader = new loader_1.LazyModuleLoader(dependenciesScanner, instanceLoader, venokContainer["moduleCompiler"], modulesContainer);
-    });
-    describe("load", () => {
-        const bProvider = { provide: "B", useValue: "B" };
-        let ModuleB = class ModuleB {
-        };
-        ModuleB = __decorate([
-            (0, module_decorator_1.Module)({ providers: [bProvider], exports: [bProvider] })
-        ], ModuleB);
-        let ModuleA = class ModuleA {
-        };
-        ModuleA = __decorate([
-            (0, module_decorator_1.Module)({ imports: [ModuleB] })
-        ], ModuleA);
-        // describe("when module was not loaded yet", () => {
-        //   it("should load it and return a module reference", async () => {
-        //     const moduleRef = await lazyModuleLoader.load(() => ModuleA);
-        //     console.log(moduleRef, ModuleRef);
-        //     expect(moduleRef).to.be.instanceOf(ModuleRef);
-        //     expect(moduleRef.get(bProvider.provide, { strict: false })).to.equal(bProvider.useValue);
-        //   });
-        // });
-        describe("when module was loaded already", () => {
-            let ModuleC = class ModuleC {
-            };
-            ModuleC = __decorate([
-                (0, module_decorator_1.Module)({})
-            ], ModuleC);
-            it("should return an existing module reference", async () => {
-                const moduleRef = await lazyModuleLoader.load(() => ModuleC);
-                const moduleRef2 = await lazyModuleLoader.load(() => ModuleC);
-                (0, chai_1.expect)(moduleRef).to.equal(moduleRef2);
-            });
-        });
-    });
-});

package/test/injector/module/module.spec.d.ts

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

package/test/injector/module/module.spec.js

@@ -1,410 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-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 __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const chai_1 = require("chai");
-const sinon = __importStar(require("sinon"));
-const module_decorator_1 = require("@venok/core/decorators/module.decorator");
-const module_1 = require("@venok/core/injector/module/module");
-const container_1 = require("@venok/core/injector/container");
-const injectable_decorator_1 = require("@venok/core/decorators/injectable.decorator");
-const interfaces_1 = require("@venok/core/interfaces");
-const wrapper_1 = require("@venok/core/injector/instance/wrapper");
-const exceptions_1 = require("@venok/core/errors/exceptions");
-describe("Module", () => {
-    let module;
-    let container;
-    let TestModule = class TestModule {
-    };
-    TestModule = __decorate([
-        (0, module_decorator_1.Module)({})
-    ], TestModule);
-    let TestProvider = class TestProvider {
-    };
-    TestProvider = __decorate([
-        (0, injectable_decorator_1.Injectable)()
-    ], TestProvider);
-    beforeEach(() => {
-        container = new container_1.VenokContainer();
-        module = new module_1.Module(TestModule, container);
-    });
-    it("should add injectable", () => {
-        const collection = new Map();
-        const setSpy = sinon.spy(collection, "set");
-        module._injectables = collection;
-        module.addInjectable(TestProvider, "interceptor", TestModule);
-        (0, chai_1.expect)(setSpy.calledWith(TestProvider, new wrapper_1.InstanceWrapper({
-            host: module,
-            name: "TestProvider",
-            token: TestProvider,
-            scope: undefined,
-            metatype: TestProvider,
-            instance: null,
-            durable: undefined,
-            isResolved: false,
-            subtype: "interceptor",
-        }))).to.be.true;
-    });
-    describe("when injectable is custom provided", () => {
-        it("should call `addCustomProvider`", () => {
-            const addCustomProviderSpy = sinon.spy(module, "addCustomProvider");
-            module.addInjectable({ provide: "test" }, "guard");
-            (0, chai_1.expect)(addCustomProviderSpy.called).to.be.true;
-        });
-    });
-    it("should add provider", () => {
-        const collection = new Map();
-        const setSpy = sinon.spy(collection, "set");
-        module._providers = collection;
-        module.addProvider(TestProvider);
-        (0, chai_1.expect)(setSpy.calledWith(TestProvider, new wrapper_1.InstanceWrapper({
-            host: module,
-            name: "TestProvider",
-            token: TestProvider,
-            scope: undefined,
-            metatype: TestProvider,
-            durable: undefined,
-            instance: null,
-            isResolved: false,
-        }))).to.be.true;
-    });
-    it('should call "addCustomProvider" when "provide" property exists', () => {
-        const addCustomProvider = sinon.spy();
-        module.addCustomProvider = addCustomProvider;
-        const provider = { provide: "test", useValue: "test" };
-        module.addProvider(provider);
-        (0, chai_1.expect)(addCustomProvider.called).to.be.true;
-    });
-    it('should call "addCustomClass" when "useClass" property exists', () => {
-        const addCustomClass = sinon.spy();
-        module.addCustomClass = addCustomClass;
-        const provider = { provide: "test", useClass: () => null };
-        module.addCustomProvider(provider, new Map());
-        (0, chai_1.expect)(addCustomClass.called).to.be.true;
-    });
-    it('should call "addCustomValue" when "useValue" property exists', () => {
-        const addCustomValue = sinon.spy();
-        module.addCustomValue = addCustomValue;
-        const provider = { provide: "test", useValue: () => null };
-        module.addCustomProvider(provider, new Map());
-        (0, chai_1.expect)(addCustomValue.called).to.be.true;
-    });
-    it('should call "addCustomValue" when "useValue" property exists but its value is `undefined`', () => {
-        const addCustomValue = sinon.spy();
-        module.addCustomValue = addCustomValue;
-        const provider = { provide: "test", useValue: undefined };
-        module.addCustomProvider(provider, new Map());
-        (0, chai_1.expect)(addCustomValue.called).to.be.true;
-    });
-    it('should call "addCustomFactory" when "useFactory" property exists', () => {
-        const addCustomFactory = sinon.spy();
-        module.addCustomFactory = addCustomFactory;
-        const provider = { provide: "test", useFactory: () => null };
-        module.addCustomProvider(provider, new Map());
-        (0, chai_1.expect)(addCustomFactory.called).to.be.true;
-    });
-    it('should call "addCustomUseExisting" when "useExisting" property exists', () => {
-        const addCustomUseExisting = sinon.spy();
-        module.addCustomUseExisting = addCustomUseExisting;
-        const provider = { provide: "test", useExisting: () => null };
-        module.addCustomUseExisting(provider, new Map());
-        (0, chai_1.expect)(addCustomUseExisting.called).to.be.true;
-    });
-    describe("addCustomClass", () => {
-        const type = { name: "TypeTest" };
-        const provider = { provide: type, useClass: type, durable: true };
-        let setSpy;
-        beforeEach(() => {
-            const collection = new Map();
-            setSpy = sinon.spy(collection, "set");
-            module._providers = collection;
-        });
-        it("should store provider", () => {
-            module.addCustomClass(provider, module._providers);
-            (0, chai_1.expect)(setSpy.calledWith(provider.provide, new wrapper_1.InstanceWrapper({
-                host: module,
-                token: type,
-                name: provider.provide.name,
-                scope: undefined,
-                metatype: type,
-                durable: true,
-                instance: null,
-                isResolved: false,
-                subtype: undefined,
-            }))).to.be.true;
-        });
-    });
-    describe("addCustomValue", () => {
-        let setSpy;
-        const value = () => ({});
-        const provider = { provide: value, useValue: value };
-        beforeEach(() => {
-            const collection = new Map();
-            setSpy = sinon.spy(collection, "set");
-            module._providers = collection;
-        });
-        it("should store provider", () => {
-            module.addCustomValue(provider, module._providers);
-            (0, chai_1.expect)(setSpy.calledWith(provider.provide, new wrapper_1.InstanceWrapper({
-                host: module,
-                token: provider.provide,
-                name: provider.provide.name,
-                scope: interfaces_1.Scope.DEFAULT,
-                metatype: null,
-                instance: value,
-                isResolved: true,
-                async: false,
-                subtype: undefined,
-            }))).to.be.true;
-        });
-    });
-    describe("addCustomFactory", () => {
-        const type = { name: "TypeTest" };
-        const inject = [1, 2, 3];
-        const provider = { provide: type, useFactory: type, inject, durable: true };
-        let setSpy;
-        beforeEach(() => {
-            const collection = new Map();
-            setSpy = sinon.spy(collection, "set");
-            module._providers = collection;
-        });
-        it("should store provider", () => {
-            module.addCustomFactory(provider, module._providers);
-            (0, chai_1.expect)(setSpy.calledWith(provider.provide, new wrapper_1.InstanceWrapper({
-                host: module,
-                token: provider.provide,
-                name: provider.provide.name,
-                scope: undefined,
-                metatype: type,
-                durable: true,
-                instance: null,
-                isResolved: false,
-                inject: inject,
-                subtype: undefined,
-            }))).to.be.true;
-        });
-    });
-    describe("addCustomUseExisting", () => {
-        const type = { name: "TypeTest" };
-        const provider = { provide: type, useExisting: type };
-        let setSpy;
-        beforeEach(() => {
-            const collection = new Map();
-            setSpy = sinon.spy(collection, "set");
-            module._providers = collection;
-        });
-        it("should store provider", () => {
-            module.addCustomUseExisting(provider, module._providers);
-            const factoryFn = module._providers.get(provider.provide).metatype;
-            const token = provider.provide;
-            (0, chai_1.expect)(setSpy.calledWith(token, new wrapper_1.InstanceWrapper({
-                host: module,
-                token,
-                name: provider.provide.name,
-                metatype: factoryFn,
-                instance: null,
-                inject: [provider.useExisting],
-                isResolved: false,
-                isAlias: true,
-                subtype: undefined,
-            }))).to.be.true;
-            (0, chai_1.expect)(factoryFn(provider.useExisting)).to.be.eql(type);
-        });
-    });
-    describe("when get instance", () => {
-        describe("when metatype does not exists in providers collection", () => {
-            beforeEach(() => {
-                sinon.stub(module._providers, "has").returns(false);
-            });
-            it("should throw RuntimeException", () => {
-                (0, chai_1.expect)(() => module.instance).to.throws(exceptions_1.RuntimeException);
-            });
-        });
-        describe("when metatype exists in providers collection", () => {
-            it("should return null", () => {
-                (0, chai_1.expect)(module.instance).to.be.eql(null);
-            });
-        });
-    });
-    describe("when exported provider is custom provided", () => {
-        beforeEach(() => {
-            sinon.stub(module, "validateExportedProvider").callsFake((o) => o);
-        });
-        it("should call `addCustomExportedProvider`", () => {
-            const addCustomExportedProviderSpy = sinon.spy(module, "addCustomExportedProvider");
-            module.addExportedProvider({ provide: "test" });
-            (0, chai_1.expect)(addCustomExportedProviderSpy.called).to.be.true;
-        });
-        it("should support symbols", () => {
-            const addCustomExportedProviderSpy = sinon.spy(module, "addCustomExportedProvider");
-            const symb = Symbol("test");
-            module.addExportedProvider({ provide: symb });
-            (0, chai_1.expect)(addCustomExportedProviderSpy.called).to.be.true;
-            (0, chai_1.expect)(module._exports.has(symb)).to.be.true;
-        });
-    });
-    describe("replace", () => {
-        describe("when provider", () => {
-            it("should call `mergeWith`", () => {
-                const wrapper = {
-                    mergeWith: sinon.spy(),
-                };
-                sinon.stub(module, "hasProvider").callsFake(() => true);
-                sinon.stub(module.providers, "get").callsFake(() => wrapper);
-                module.replace(null, { isProvider: true });
-                (0, chai_1.expect)(wrapper.mergeWith.called).to.be.true;
-            });
-        });
-        describe("when guard", () => {
-            it("should call `mergeWith`", () => {
-                const wrapper = {
-                    mergeWith: sinon.spy(),
-                    isProvider: true,
-                };
-                sinon.stub(module, "hasInjectable").callsFake(() => true);
-                sinon.stub(module.injectables, "get").callsFake(() => wrapper);
-                module.replace(null, {});
-                (0, chai_1.expect)(wrapper.mergeWith.called).to.be.true;
-            });
-        });
-    });
-    describe("imports", () => {
-        it("should return relatedModules", () => {
-            const test = ["test"];
-            module._imports = test;
-            (0, chai_1.expect)(module.imports).to.be.eql(test);
-        });
-    });
-    describe("injectables", () => {
-        it("should return injectables", () => {
-            const test = ["test"];
-            module._injectables = test;
-            (0, chai_1.expect)(module.injectables).to.be.eql(test);
-        });
-    });
-    describe("exports", () => {
-        it("should return exports", () => {
-            const test = ["test"];
-            module._exports = test;
-            (0, chai_1.expect)(module.exports).to.be.eql(test);
-        });
-    });
-    describe("providers", () => {
-        it("should return providers", () => {
-            const test = ["test"];
-            module._providers = test;
-            (0, chai_1.expect)(module.providers).to.be.eql(test);
-        });
-    });
-    describe("createModuleReferenceType", () => {
-        let moduleRef;
-        beforeEach(() => {
-            const Class = module.createModuleReferenceType();
-            moduleRef = new Class();
-        });
-        it('should return metatype with "get" method', () => {
-            (0, chai_1.expect)(!!moduleRef.get).to.be.true;
-        });
-        describe("get", () => {
-            it("should throw exception if not exists", () => {
-                (0, chai_1.expect)(() => moduleRef.get("fail")).to.throws(exceptions_1.UnknownElementException);
-            });
-        });
-    });
-    describe("validateExportedProvider", () => {
-        const token = "token";
-        describe("when unit exists in provider collection", () => {
-            it("should behave as identity", () => {
-                module._providers = new Map([[token, true]]);
-                (0, chai_1.expect)(module.validateExportedProvider(token)).to.be.eql(token);
-            });
-        });
-        describe("when unit exists in related modules collection", () => {
-            it("should behave as identity", () => {
-                class Random {
-                }
-                module._imports = new Set([new module_1.Module(Random, new container_1.VenokContainer())]);
-                (0, chai_1.expect)(module.validateExportedProvider(Random)).to.be.eql(Random);
-            });
-        });
-        describe("when unit does not exist in both provider and related modules collections", () => {
-            it("should throw UnknownExportException", () => {
-                (0, chai_1.expect)(() => module.validateExportedProvider(token)).to.throws(exceptions_1.UnknownExportException);
-            });
-        });
-    });
-    describe("hasProvider", () => {
-        describe("when module has provider", () => {
-            it("should return true", () => {
-                const token = "test";
-                module.providers.set(token, new wrapper_1.InstanceWrapper());
-                (0, chai_1.expect)(module.hasProvider(token)).to.be.true;
-            });
-        });
-        describe("otherwise", () => {
-            it("should return false", () => {
-                (0, chai_1.expect)(module.hasProvider("_")).to.be.false;
-            });
-        });
-    });
-    describe("hasInjectable", () => {
-        describe("when module has injectable", () => {
-            it("should return true", () => {
-                const token = "test";
-                module.injectables.set(token, new wrapper_1.InstanceWrapper());
-                (0, chai_1.expect)(module.hasInjectable(token)).to.be.true;
-            });
-        });
-        describe("otherwise", () => {
-            it("should return false", () => {
-                (0, chai_1.expect)(module.hasInjectable("_")).to.be.false;
-            });
-        });
-    });
-    describe('getter "id"', () => {
-        it("should return module id", () => {
-            (0, chai_1.expect)(module.id).to.be.equal(module["_id"]);
-        });
-    });
-    describe("getProviderByKey", () => {
-        describe("when does not exist", () => {
-            it("should return undefined", () => {
-                (0, chai_1.expect)(module.getProviderByKey("test")).to.be.undefined;
-            });
-        });
-        describe("otherwise", () => {
-            it("should return instance wrapper", () => {
-                module.addProvider(TestProvider);
-                (0, chai_1.expect)(module.getProviderByKey(TestProvider)).to.not.be.undefined;
-            });
-        });
-    });
-});

package/test/injector/module/token-factory.spec.d.ts

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

package/test/injector/module/token-factory.spec.js

@@ -1,84 +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 token_factory_1 = require("@venok/core/injector/module/token-factory");
-describe("ModuleTokenFactory", () => {
-    const moduleId = "constId";
-    let factory;
-    beforeEach(() => {
-        factory = new token_factory_1.TokenFactory();
-        sinon_1.default.stub(factory, "getModuleId").returns(moduleId);
-    });
-    describe("create", () => {
-        class Module {
-        }
-        it("should return expected token", () => {
-            const type = Module;
-            const token1 = factory.create(type, undefined);
-            const token2 = factory.create(type, undefined);
-            (0, chai_1.expect)(token1).to.be.deep.eq(token2);
-        });
-        it("should include dynamic metadata", () => {
-            const type = Module;
-            const token1 = factory.create(type, {
-                providers: [{}],
-            });
-            const token2 = factory.create(type, {
-                providers: [{}],
-            });
-            (0, chai_1.expect)(token1).to.be.deep.eq(token2);
-        });
-    });
-    describe("getModuleName", () => {
-        it("should map module metatype to name", () => {
-            const metatype = () => { };
-            (0, chai_1.expect)(factory.getModuleName(metatype)).to.be.eql(metatype.name);
-        });
-    });
-    describe("getStringifiedOpaqueToken", () => {
-        describe("when metadata exists", () => {
-            it("should return hash", () => {
-                const metadata = { providers: ["", {}] };
-                (0, chai_1.expect)(factory.getStringifiedOpaqueToken(metadata)).to.be.eql(JSON.stringify(metadata));
-            });
-            it("should return hash with class", () => {
-                class Provider {
-                }
-                const metadata = { providers: [Provider], exports: [Provider] };
-                (0, chai_1.expect)(factory.getStringifiedOpaqueToken(metadata)).to.be.eql('{"providers":["Provider"],"exports":["Provider"]}');
-            });
-            it("should return hash with value provider with non-class function", () => {
-                const provider = {
-                    provide: "ProvideValue",
-                    useValue: function Provider() { },
-                };
-                const metadata = { providers: [provider] };
-                (0, chai_1.expect)(factory.getStringifiedOpaqueToken(metadata)).to.be.eql(`{"providers":[{"provide":"ProvideValue","useValue":"${provider.useValue.toString()}"}]}`);
-            });
-            it("should serialize symbols in a dynamic metadata object", () => {
-                const metadata = {
-                    providers: [
-                        {
-                            provide: Symbol("a"),
-                            useValue: "a",
-                        },
-                        {
-                            provide: Symbol("b"),
-                            useValue: "b",
-                        },
-                    ],
-                };
-                (0, chai_1.expect)(factory.getStringifiedOpaqueToken(metadata)).to.be.eql('{"providers":[{"provide":"Symbol(a)","useValue":"a"},{"provide":"Symbol(b)","useValue":"b"}]}');
-            });
-        });
-        describe("when metadata does not exist", () => {
-            it("should return empty string", () => {
-                (0, chai_1.expect)(factory.getStringifiedOpaqueToken(undefined)).to.be.eql("");
-            });
-        });
-    });
-});

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

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