@venok/core 1.0.0

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

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

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

@@ -0,0 +1,27 @@
+"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 creator_1 = require("@venok/core/context/external/creator");
+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([
+            creator_1.ExternalContextCreator,
+            container_1.ModulesContainer,
+            // HttpAdapterHost,
+            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

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

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

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

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

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

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

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

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

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

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