@venok/core 1.1.0 → 2.0.1-next.1

package/test/injector/injector.spec.js

@@ -1,678 +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 __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("reflect-metadata");
-const chai_1 = __importDefault(require("chai"));
-const chai_2 = require("chai");
-const chai_as_promised_1 = __importDefault(require("chai-as-promised"));
-const sinon_1 = __importDefault(require("sinon"));
-const wrapper_1 = require("@venok/core/injector/instance/wrapper");
-const injector_1 = require("@venok/core/injector/injector");
-const injectable_decorator_1 = require("@venok/core/decorators/injectable.decorator");
-const constants_1 = require("@venok/core/injector/constants");
-const container_1 = require("@venok/core/injector/container");
-const module_1 = require("@venok/core/injector/module/module");
-const optional_decorator_1 = require("@venok/core/decorators/optional.decorator");
-const constants_2 = require("@venok/core/constants");
-const inject_decorator_1 = require("@venok/core/decorators/inject.decorator");
-chai_1.default.use(chai_as_promised_1.default);
-describe("Injector", () => {
-    let injector;
-    beforeEach(() => {
-        injector = new injector_1.Injector();
-    });
-    describe("loadInstance", () => {
-        let DependencyOne = class DependencyOne {
-        };
-        DependencyOne = __decorate([
-            (0, injectable_decorator_1.Injectable)()
-        ], DependencyOne);
-        let DependencyTwo = class DependencyTwo {
-        };
-        DependencyTwo = __decorate([
-            (0, injectable_decorator_1.Injectable)()
-        ], DependencyTwo);
-        let MainTest = class MainTest {
-            constructor(one, two) {
-                this.one = one;
-                this.two = two;
-            }
-        };
-        __decorate([
-            (0, inject_decorator_1.Inject)(),
-            __metadata("design:type", DependencyOne)
-        ], MainTest.prototype, "property", void 0);
-        MainTest = __decorate([
-            (0, injectable_decorator_1.Injectable)(),
-            __metadata("design:paramtypes", [DependencyOne,
-                DependencyTwo])
-        ], MainTest);
-        let moduleDeps;
-        let mainTest, depOne, depTwo;
-        beforeEach(() => {
-            moduleDeps = new module_1.Module(DependencyTwo, new container_1.VenokContainer());
-            mainTest = new wrapper_1.InstanceWrapper({
-                name: "MainTest",
-                token: "MainTest",
-                metatype: MainTest,
-                instance: Object.create(MainTest.prototype),
-                isResolved: false,
-            });
-            depOne = new wrapper_1.InstanceWrapper({
-                name: DependencyOne,
-                token: DependencyOne,
-                metatype: DependencyOne,
-                instance: Object.create(DependencyOne.prototype),
-                isResolved: false,
-            });
-            depTwo = new wrapper_1.InstanceWrapper({
-                name: DependencyTwo,
-                token: DependencyTwo,
-                metatype: DependencyTwo,
-                instance: Object.create(DependencyOne.prototype),
-                isResolved: false,
-            });
-            moduleDeps.providers.set("MainTest", mainTest);
-            moduleDeps.providers.set(DependencyOne, depOne);
-            moduleDeps.providers.set(DependencyTwo, depTwo);
-            moduleDeps.providers.set("MainTestResolved", {
-                ...mainTest,
-                isResolved: true,
-            });
-        });
-        it("should create an instance of component with proper dependencies", async () => {
-            await injector.loadInstance(mainTest, moduleDeps.providers, moduleDeps);
-            const { instance } = moduleDeps.providers.get("MainTest");
-            (0, chai_2.expect)(instance.one).instanceof(DependencyOne);
-            (0, chai_2.expect)(instance.two).instanceof(DependencyTwo);
-            (0, chai_2.expect)(instance).instanceof(MainTest);
-        });
-        it('should set "isResolved" property to true after instance initialization', async () => {
-            await injector.loadInstance(mainTest, moduleDeps.providers, moduleDeps);
-            const { isResolved } = moduleDeps.providers.get("MainTest").getInstanceByContextId(constants_1.STATIC_CONTEXT);
-            (0, chai_2.expect)(isResolved).to.be.true;
-        });
-        it("should throw RuntimeException when type is not stored in collection", () => {
-            return (0, chai_2.expect)(injector.loadInstance({}, moduleDeps.providers, moduleDeps)).to.eventually.be.rejected;
-        });
-        it('should await done$ when "isPending"', () => {
-            const wrapper = new wrapper_1.InstanceWrapper({
-                name: "MainTest",
-                metatype: MainTest,
-                instance: Object.create(MainTest.prototype),
-                isResolved: false,
-            });
-            const host = wrapper.getInstanceByContextId(constants_1.STATIC_CONTEXT);
-            host.donePromise = Promise.resolve();
-            host.isPending = true;
-            (0, chai_2.expect)(injector.loadInstance(wrapper, moduleDeps.providers, moduleDeps)).to.eventually.not.throw();
-        });
-        it('should await done$ when "isPending" and rethrow an exception (if thrown)', () => {
-            const error = new Error("Test error");
-            const wrapper = new wrapper_1.InstanceWrapper({
-                name: "MainTest",
-                metatype: MainTest,
-                instance: Object.create(MainTest.prototype),
-                isResolved: false,
-            });
-            const host = wrapper.getInstanceByContextId(constants_1.STATIC_CONTEXT);
-            host.donePromise = Promise.resolve(error);
-            host.isPending = true;
-            (0, chai_2.expect)(injector.loadInstance(wrapper, moduleDeps.providers, moduleDeps)).to.eventually.throw(error);
-        });
-        it("should return undefined when metatype is resolved", async () => {
-            const result = await injector.loadInstance(new wrapper_1.InstanceWrapper({
-                name: "MainTestResolved",
-                metatype: MainTest,
-                instance: Object.create(MainTest.prototype),
-                isResolved: true,
-            }), moduleDeps.providers, moduleDeps);
-            (0, chai_2.expect)(result).to.be.undefined;
-        });
-    });
-    describe("loadPrototype", () => {
-        let Test = class Test {
-        };
-        Test = __decorate([
-            (0, injectable_decorator_1.Injectable)()
-        ], Test);
-        let moduleDeps;
-        let test;
-        beforeEach(() => {
-            moduleDeps = new module_1.Module(Test, new container_1.VenokContainer());
-            test = new wrapper_1.InstanceWrapper({
-                name: "Test",
-                token: "Test",
-                metatype: Test,
-                instance: null,
-                isResolved: false,
-            });
-            moduleDeps.providers.set("Test", test);
-        });
-        it("should create prototype of instance", () => {
-            injector.loadPrototype(test, moduleDeps.providers);
-            (0, chai_2.expect)(moduleDeps.providers.get("Test").instance).to.deep.equal(Object.create(Test.prototype));
-        });
-        it("should return undefined when collection is nil", () => {
-            const result = injector.loadPrototype(test, null);
-            (0, chai_2.expect)(result).to.be.undefined;
-        });
-        it("should return undefined when target isResolved", () => {
-            const collection = {
-                get: () => ({
-                    getInstanceByContextId: () => ({ isResolved: true }),
-                    createPrototype: () => { },
-                }),
-            };
-            const result = injector.loadPrototype(test, collection);
-            (0, chai_2.expect)(result).to.be.undefined;
-        });
-        it('should return undefined when "inject" is not nil', () => {
-            const collection = {
-                get: () => new wrapper_1.InstanceWrapper({ inject: [] }),
-            };
-            const result = injector.loadPrototype(test, collection);
-            (0, chai_2.expect)(result).to.be.undefined;
-        });
-    });
-    describe("resolveSingleParam", () => {
-        it('should throw "RuntimeException" when param is undefined', async () => {
-            return (0, chai_2.expect)(injector.resolveSingleParam(null, undefined, { index: 0, dependencies: [] }, null)).to
-                .eventually.be.rejected;
-        });
-    });
-    describe("loadInjectable", () => {
-        let loadInstance;
-        beforeEach(() => {
-            loadInstance = sinon_1.default.spy();
-            injector.loadInstance = loadInstance;
-        });
-        it('should call "loadInstance" with expected arguments', async () => {
-            const module = { injectables: [] };
-            const wrapper = { test: "test" };
-            await injector.loadInjectable(wrapper, module);
-            (0, chai_2.expect)(loadInstance.calledWith(wrapper, module.injectables, module)).to.be.true;
-        });
-    });
-    describe("lookupComponent", () => {
-        let lookupComponentInImports;
-        const metatype = { name: "test", metatype: { name: "test" } };
-        const wrapper = new wrapper_1.InstanceWrapper({
-            name: "Test",
-            metatype: metatype,
-            instance: null,
-            isResolved: false,
-        });
-        beforeEach(() => {
-            lookupComponentInImports = sinon_1.default.stub();
-            injector.lookupComponentInImports = lookupComponentInImports;
-        });
-        it("should return object from collection if exists", async () => {
-            const instance = { test: 3 };
-            const collection = {
-                has: () => true,
-                get: () => instance,
-            };
-            const result = await injector.lookupComponent(collection, null, { name: metatype.name, index: 0, dependencies: [] }, wrapper);
-            (0, chai_2.expect)(result).to.be.equal(instance);
-        });
-        it("should throw an exception if recursion happens", () => {
-            const name = "RecursionService";
-            const instance = { test: 3 };
-            const collection = {
-                has: () => true,
-                get: () => instance,
-            };
-            const result = injector.lookupComponent(collection, null, { name, index: 0, dependencies: [] }, Object.assign(wrapper, {
-                name,
-            }));
-            (0, chai_2.expect)(result).to.eventually.be.rejected;
-        });
-        it('should call "lookupComponentInImports" when object is not in collection', async () => {
-            lookupComponentInImports.returns({});
-            const collection = {
-                has: () => false,
-            };
-            await injector.lookupComponent(collection, null, { name: metatype.name, index: 0, dependencies: [] }, wrapper);
-            (0, chai_2.expect)(lookupComponentInImports.called).to.be.true;
-        });
-        it('should throw "UnknownDependenciesException" when instanceWrapper is null and "exports" collection does not contain token', () => {
-            lookupComponentInImports.returns(null);
-            const collection = {
-                has: () => false,
-            };
-            const module = { exports: collection };
-            (0, chai_2.expect)(injector.lookupComponent(collection, module, { name: metatype.name, index: 0, dependencies: [] }, wrapper)).to.eventually.be.rejected;
-        });
-        it('should not throw "UnknownDependenciesException" instanceWrapper is not null', () => {
-            lookupComponentInImports.returns({});
-            const collection = {
-                has: () => false,
-            };
-            const module = { exports: collection };
-            (0, chai_2.expect)(injector.lookupComponent(collection, module, { name: metatype.name, index: 0, dependencies: [] }, wrapper)).to.eventually.be.not.rejected;
-        });
-    });
-    describe("lookupComponentInImports", () => {
-        let loadProvider;
-        const metatype = { name: "test" };
-        const module = {
-            relatedModules: new Map(),
-        };
-        beforeEach(() => {
-            loadProvider = sinon_1.default.spy();
-            injector.loadProvider = loadProvider;
-        });
-        it("should return null when there is no related modules", async () => {
-            const result = await injector.lookupComponentInImports(module, "testToken", new wrapper_1.InstanceWrapper());
-            (0, chai_2.expect)(result).to.be.eq(null);
-        });
-        it("should return null when related modules do not have appropriate component", () => {
-            let moduleFixture = {
-                relatedModules: new Map([
-                    [
-                        "key",
-                        {
-                            providers: {
-                                has: () => false,
-                            },
-                            exports: {
-                                has: () => true,
-                            },
-                        },
-                    ],
-                ]),
-            };
-            (0, chai_2.expect)(injector.lookupComponentInImports(moduleFixture, metatype, null)).to.be.eventually.eq(null);
-            moduleFixture = {
-                relatedModules: new Map([
-                    [
-                        "key",
-                        {
-                            providers: {
-                                has: () => true,
-                            },
-                            exports: {
-                                has: () => false,
-                            },
-                        },
-                    ],
-                ]),
-            };
-            (0, chai_2.expect)(injector.lookupComponentInImports(moduleFixture, metatype, null)).to.eventually.be.eq(null);
-        });
-        it('should call "loadProvider" when component is not resolved', async () => {
-            const moduleFixture = {
-                imports: new Map([
-                    [
-                        "key",
-                        {
-                            providers: {
-                                has: () => true,
-                                get: () => new wrapper_1.InstanceWrapper({
-                                    isResolved: false,
-                                }),
-                            },
-                            exports: {
-                                has: () => true,
-                            },
-                            imports: new Map(),
-                        },
-                    ],
-                ]),
-            };
-            await injector.lookupComponentInImports(moduleFixture, metatype, new wrapper_1.InstanceWrapper());
-            (0, chai_2.expect)(loadProvider.called).to.be.true;
-        });
-        it('should not call "loadProvider" when component is resolved', async () => {
-            const moduleFixture = {
-                relatedModules: new Map([
-                    [
-                        "key",
-                        {
-                            providers: {
-                                has: () => true,
-                                get: () => ({
-                                    isResolved: true,
-                                }),
-                            },
-                            exports: {
-                                has: () => true,
-                            },
-                            relatedModules: new Map(),
-                        },
-                    ],
-                ]),
-            };
-            await injector.lookupComponentInImports(moduleFixture, metatype, null);
-            (0, chai_2.expect)(loadProvider.called).to.be.false;
-        });
-    });
-    describe("resolveParamToken", () => {
-        let forwardRef;
-        let wrapper;
-        let param;
-        describe('when "forwardRef" property is not nil', () => {
-            beforeEach(() => {
-                forwardRef = "test";
-                wrapper = {};
-                param = {
-                    forwardRef: () => forwardRef,
-                };
-            });
-            it("return forwardRef() result", () => {
-                (0, chai_2.expect)(injector.resolveParamToken(wrapper, param)).to.be.eql(forwardRef);
-            });
-            it('set wrapper "forwardRef" property to true', () => {
-                injector.resolveParamToken(wrapper, param);
-                (0, chai_2.expect)(wrapper.forwardRef).to.be.true;
-            });
-        });
-        describe('when "forwardRef" property is nil', () => {
-            beforeEach(() => {
-                forwardRef = "test";
-                wrapper = {};
-                param = {};
-            });
-            it('set wrapper "forwardRef" property to false', () => {
-                injector.resolveParamToken(wrapper, param);
-                (0, chai_2.expect)(wrapper.forwardRef).to.be.undefined;
-            });
-            it("return param", () => {
-                (0, chai_2.expect)(injector.resolveParamToken(wrapper, param)).to.be.eql(param);
-            });
-        });
-    });
-    describe("resolveComponentInstance", () => {
-        let module;
-        beforeEach(() => {
-            module = {
-                providers: [],
-            };
-        });
-        describe("when instanceWrapper is not resolved and does not have forward ref", () => {
-            it("should call loadProvider", async () => {
-                const wrapper = new wrapper_1.InstanceWrapper({ isResolved: false });
-                const loadStub = sinon_1.default.stub(injector, "loadProvider").callsFake(() => null);
-                sinon_1.default.stub(injector, "lookupComponent").returns(Promise.resolve(wrapper));
-                await injector.resolveComponentInstance(module, "", { index: 0, dependencies: [] }, wrapper);
-                (0, chai_2.expect)(loadStub.called).to.be.true;
-            });
-            it("should not call loadProvider (isResolved)", async () => {
-                const wrapper = new wrapper_1.InstanceWrapper({ isResolved: true });
-                const loadStub = sinon_1.default.stub(injector, "loadProvider").callsFake(() => null);
-                sinon_1.default.stub(injector, "lookupComponent").returns(Promise.resolve(wrapper));
-                await injector.resolveComponentInstance(module, "", { index: 0, dependencies: [] }, wrapper);
-                (0, chai_2.expect)(loadStub.called).to.be.false;
-            });
-            it("should not call loadProvider (forwardRef)", async () => {
-                const wrapper = new wrapper_1.InstanceWrapper({
-                    isResolved: false,
-                    forwardRef: true,
-                });
-                const loadStub = sinon_1.default.stub(injector, "loadProvider").callsFake(() => null);
-                sinon_1.default.stub(injector, "lookupComponent").returns(Promise.resolve(wrapper));
-                await injector.resolveComponentInstance(module, "", { index: 0, dependencies: [] }, wrapper);
-                (0, chai_2.expect)(loadStub.called).to.be.false;
-            });
-        });
-        describe("when instanceWrapper has async property", () => {
-            it("should await instance", async () => {
-                sinon_1.default.stub(injector, "loadProvider").callsFake(() => null);
-                const instance = Promise.resolve(true);
-                const wrapper = new wrapper_1.InstanceWrapper({
-                    isResolved: false,
-                    forwardRef: true,
-                    async: true,
-                    instance,
-                });
-                sinon_1.default.stub(injector, "lookupComponent").returns(Promise.resolve(wrapper));
-                const result = await injector.resolveComponentInstance(module, "", { index: 0, dependencies: [] }, wrapper);
-                (0, chai_2.expect)(result.instance).to.be.true;
-            });
-        });
-    });
-    describe("applyProperties", () => {
-        describe("when instance is not an object", () => {
-            it("should return undefined", () => {
-                (0, chai_2.expect)(injector.applyProperties("test", [])).to.be.undefined;
-            });
-        });
-        describe("when instance is an object", () => {
-            it("should apply each not nil property", () => {
-                const properties = [
-                    { key: "one", instance: {} },
-                    { key: "two", instance: null },
-                    { key: "three", instance: true },
-                ];
-                const obj = {};
-                injector.applyProperties(obj, properties);
-                (0, chai_2.expect)(obj.one).to.be.eql(properties[0].instance);
-                (0, chai_2.expect)(obj.two).to.be.undefined;
-                (0, chai_2.expect)(obj.three).to.be.eql(properties[2].instance);
-            });
-        });
-    });
-    describe("instantiateClass", () => {
-        class TestClass {
-        }
-        describe("when context is static", () => {
-            it("should instantiate class", async () => {
-                const wrapper = new wrapper_1.InstanceWrapper({ metatype: TestClass });
-                await injector.instantiateClass([], wrapper, wrapper, constants_1.STATIC_CONTEXT);
-                (0, chai_2.expect)(wrapper.instance).to.not.be.undefined;
-                (0, chai_2.expect)(wrapper.instance).to.be.instanceOf(TestClass);
-            });
-            it("should call factory", async () => {
-                const wrapper = new wrapper_1.InstanceWrapper({
-                    inject: [],
-                    metatype: (() => ({})),
-                });
-                await injector.instantiateClass([], wrapper, wrapper, constants_1.STATIC_CONTEXT);
-                (0, chai_2.expect)(wrapper.instance).to.not.be.undefined;
-            });
-        });
-        describe("when context is not static", () => {
-            it("should not instantiate class", async () => {
-                const ctx = { id: 3 };
-                const wrapper = new wrapper_1.InstanceWrapper({ metatype: TestClass });
-                await injector.instantiateClass([], wrapper, wrapper, ctx);
-                (0, chai_2.expect)(wrapper.instance).to.be.undefined;
-                (0, chai_2.expect)(wrapper.getInstanceByContextId(ctx).isResolved).to.be.true;
-            });
-            it("should not call factory", async () => {
-                const wrapper = new wrapper_1.InstanceWrapper({
-                    inject: [],
-                    metatype: sinon_1.default.spy(),
-                });
-                await injector.instantiateClass([], wrapper, wrapper, { id: 2 });
-                (0, chai_2.expect)(wrapper.instance).to.be.undefined;
-                (0, chai_2.expect)(wrapper.metatype.called).to.be.false;
-            });
-        });
-    });
-    describe("loadPerContext", () => {
-        class TestClass {
-        }
-        it("should load instance per context id", async () => {
-            const container = new container_1.VenokContainer();
-            const moduleCtor = class TestModule {
-            };
-            const ctx = constants_1.STATIC_CONTEXT;
-            const { moduleRef } = (await container.addModule(moduleCtor, []));
-            moduleRef.addProvider({
-                provide: TestClass,
-                useClass: TestClass,
-            });
-            const instance = await injector.loadPerContext(new TestClass(), moduleRef, moduleRef.providers, ctx);
-            (0, chai_2.expect)(instance).to.be.instanceOf(TestClass);
-        });
-    });
-    describe("loadEnhancersPerContext", () => {
-        it("should load enhancers per context id", async () => {
-            const wrapper = new wrapper_1.InstanceWrapper();
-            wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({
-                host: new module_1.Module(class {
-                }, new container_1.VenokContainer()),
-            }));
-            wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({
-                host: new module_1.Module(class {
-                }, new container_1.VenokContainer()),
-            }));
-            const loadInstanceStub = sinon_1.default.stub(injector, "loadInstance").callsFake(async () => ({}));
-            await injector.loadEnhancersPerContext(wrapper, constants_1.STATIC_CONTEXT);
-            (0, chai_2.expect)(loadInstanceStub.calledTwice).to.be.true;
-        });
-    });
-    describe("loadCtorMetadata", () => {
-        it("should resolve ctor metadata", async () => {
-            const wrapper = new wrapper_1.InstanceWrapper();
-            wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
-            wrapper.addCtorMetadata(1, new wrapper_1.InstanceWrapper());
-            const resolveComponentHostStub = sinon_1.default
-                .stub(injector, "resolveComponentHost")
-                .callsFake(async () => new wrapper_1.InstanceWrapper());
-            await injector.loadCtorMetadata(wrapper.getCtorMetadata(), constants_1.STATIC_CONTEXT);
-            (0, chai_2.expect)(resolveComponentHostStub.calledTwice).to.be.true;
-        });
-    });
-    describe("loadPropertiesMetadata", () => {
-        it("should resolve properties metadata", async () => {
-            const wrapper = new wrapper_1.InstanceWrapper();
-            wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
-            wrapper.addPropertiesMetadata("key2", new wrapper_1.InstanceWrapper());
-            const resolveComponentHostStub = sinon_1.default
-                .stub(injector, "resolveComponentHost")
-                .callsFake(async () => new wrapper_1.InstanceWrapper());
-            await injector.loadPropertiesMetadata(wrapper.getPropertiesMetadata(), constants_1.STATIC_CONTEXT);
-            (0, chai_2.expect)(resolveComponentHostStub.calledTwice).to.be.true;
-        });
-    });
-    describe("resolveConstructorParams", () => {
-        it('should call "loadCtorMetadata" if metadata is not undefined', async () => {
-            const wrapper = new wrapper_1.InstanceWrapper();
-            const metadata = [];
-            sinon_1.default.stub(wrapper, "getCtorMetadata").callsFake(() => metadata);
-            const loadCtorMetadataSpy = sinon_1.default.spy(injector, "loadCtorMetadata");
-            await injector.resolveConstructorParams(wrapper, null, [], () => {
-                (0, chai_2.expect)(loadCtorMetadataSpy.called).to.be.true;
-            }, { id: 2 });
-        });
-    });
-    describe("resolveProperties", () => {
-        it('should call "loadPropertiesMetadata" if metadata is not undefined', async () => {
-            const wrapper = new wrapper_1.InstanceWrapper();
-            const metadata = [];
-            sinon_1.default.stub(wrapper, "getPropertiesMetadata").callsFake(() => metadata);
-            const loadPropertiesMetadataSpy = sinon_1.default.spy(injector, "loadPropertiesMetadata");
-            await injector.resolveProperties(wrapper, null, null, { id: 2 });
-            (0, chai_2.expect)(loadPropertiesMetadataSpy.called).to.be.true;
-        });
-    });
-    describe("getClassDependencies", () => {
-        it("should return an array that consists of deps and optional dep ids", async () => {
-            class FixtureDep1 {
-            }
-            class FixtureDep2 {
-            }
-            let FixtureClass = class FixtureClass {
-                constructor(dep1, dep2) {
-                    this.dep1 = dep1;
-                    this.dep2 = dep2;
-                }
-            };
-            FixtureClass = __decorate([
-                (0, injectable_decorator_1.Injectable)(),
-                __param(1, (0, optional_decorator_1.Optional)()),
-                __metadata("design:paramtypes", [FixtureDep1,
-                    FixtureDep2])
-            ], FixtureClass);
-            const wrapper = new wrapper_1.InstanceWrapper({ metatype: FixtureClass });
-            const [dependencies, optionalDependenciesIds] = injector.getClassDependencies(wrapper);
-            (0, chai_2.expect)(dependencies).to.deep.eq([FixtureDep1, FixtureDep2]);
-            (0, chai_2.expect)(optionalDependenciesIds).to.deep.eq([1]);
-        });
-        it("should not mutate the constructor metadata", async () => {
-            class FixtureDep1 {
-            }
-            /** This needs to be something other than FixtureDep1 so the test can ensure that the metadata was not mutated */
-            const injectionToken = "test_token";
-            let FixtureClass = class FixtureClass {
-                constructor(dep1) {
-                    this.dep1 = dep1;
-                }
-            };
-            FixtureClass = __decorate([
-                (0, injectable_decorator_1.Injectable)(),
-                __param(0, (0, inject_decorator_1.Inject)(injectionToken)),
-                __metadata("design:paramtypes", [FixtureDep1])
-            ], FixtureClass);
-            const wrapper = new wrapper_1.InstanceWrapper({ metatype: FixtureClass });
-            const [dependencies] = injector.getClassDependencies(wrapper);
-            (0, chai_2.expect)(dependencies).to.deep.eq([injectionToken]);
-            const paramtypes = Reflect.getMetadata(constants_2.PARAMTYPES_METADATA, FixtureClass);
-            (0, chai_2.expect)(paramtypes).to.deep.eq([FixtureDep1]);
-        });
-    });
-    describe("getFactoryProviderDependencies", () => {
-        it("should return an array that consists of deps and optional dep ids", async () => {
-            class FixtureDep1 {
-            }
-            class FixtureDep2 {
-            }
-            const wrapper = new wrapper_1.InstanceWrapper({
-                inject: [
-                    FixtureDep1,
-                    { token: FixtureDep2, optional: true },
-                    { token: FixtureDep2, optional: false },
-                    {},
-                ],
-            });
-            const [dependencies, optionalDependenciesIds] = injector.getFactoryProviderDependencies(wrapper);
-            (0, chai_2.expect)(dependencies).to.deep.eq([FixtureDep1, FixtureDep2, FixtureDep2, {}]);
-            (0, chai_2.expect)(optionalDependenciesIds).to.deep.eq([1]);
-        });
-    });
-    describe("addDependencyMetadata", () => {
-        let exposedInjector;
-        let hostWrapper;
-        let instanceWrapper;
-        beforeEach(() => {
-            exposedInjector = injector;
-            hostWrapper = new wrapper_1.InstanceWrapper();
-            instanceWrapper = new wrapper_1.InstanceWrapper();
-        });
-        it("should add dependency metadata to PropertiesMetadata when key is symbol", async () => {
-            const addPropertiesMetadataSpy = sinon_1.default.spy(hostWrapper, "addPropertiesMetadata");
-            const key = Symbol.for("symbol");
-            exposedInjector.addDependencyMetadata(key, hostWrapper, instanceWrapper);
-            (0, chai_2.expect)(addPropertiesMetadataSpy.called).to.be.true;
-        });
-        it("should add dependency metadata to PropertiesMetadata when key is string", async () => {
-            const addPropertiesMetadataSpy = sinon_1.default.spy(hostWrapper, "addPropertiesMetadata");
-            const key = "string";
-            exposedInjector.addDependencyMetadata(key, hostWrapper, instanceWrapper);
-            (0, chai_2.expect)(addPropertiesMetadataSpy.called).to.be.true;
-        });
-        it("should add dependency metadata to CtorMetadata when key is number", async () => {
-            const addCtorMetadataSpy = sinon_1.default.spy(hostWrapper, "addCtorMetadata");
-            const key = 0;
-            exposedInjector.addDependencyMetadata(key, hostWrapper, instanceWrapper);
-            (0, chai_2.expect)(addCtorMetadataSpy.called).to.be.true;
-        });
-    });
-});

package/test/injector/instance/loader.spec.d.ts

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