@venok/core 1.0.0

package/test/injector/instance/wrapper.spec.js

@@ -0,0 +1,772 @@
+"use strict";
+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 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const wrapper_1 = require("@venok/core/injector/instance/wrapper");
+const interfaces_1 = require("@venok/core/interfaces");
+const constants_1 = require("@venok/core/injector/constants");
+class TestClass {
+}
+describe("InstanceWrapper", () => {
+    describe("initialize", () => {
+        const partial = {
+            name: "test",
+            metatype: TestClass,
+            scope: interfaces_1.Scope.DEFAULT,
+            instance: new TestClass(),
+        };
+        it("should assign partial", () => {
+            const instance = new wrapper_1.InstanceWrapper(partial);
+            (0, chai_1.expect)(instance.name).to.be.eql(partial.name);
+            (0, chai_1.expect)(instance.scope).to.be.eql(partial.scope);
+            (0, chai_1.expect)(instance.metatype).to.be.eql(partial.metatype);
+        });
+        it("should set instance by context id", () => {
+            const instance = new wrapper_1.InstanceWrapper(partial);
+            (0, chai_1.expect)(instance.getInstanceByContextId(constants_1.STATIC_CONTEXT).instance).to.be.eql(partial.instance);
+        });
+    });
+    describe("isDependencyTreeStatic", () => {
+        describe("when circular reference", () => {
+            it("should return true", () => {
+                const wrapper = new wrapper_1.InstanceWrapper();
+                const otherWrapper = new wrapper_1.InstanceWrapper();
+                wrapper.addCtorMetadata(0, otherWrapper);
+                otherWrapper.addCtorMetadata(0, wrapper);
+                (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.true;
+                (0, chai_1.expect)(otherWrapper.isDependencyTreeStatic()).to.be.true;
+            });
+        });
+        describe("when circular reference and one non static", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper();
+                const otherWrapper = new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST });
+                wrapper.addCtorMetadata(0, otherWrapper);
+                otherWrapper.addCtorMetadata(0, wrapper);
+                (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+                (0, chai_1.expect)(otherWrapper.isDependencyTreeStatic()).to.be.false;
+            });
+        });
+        describe("when circular reference and one durable", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper();
+                const otherWrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                    durable: true,
+                });
+                wrapper.addCtorMetadata(0, otherWrapper);
+                otherWrapper.addCtorMetadata(0, wrapper);
+                (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+                (0, chai_1.expect)(otherWrapper.isDependencyTreeStatic()).to.be.false;
+            });
+        });
+        describe("when request scoped", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                });
+                (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+            });
+        });
+        describe("when request scoped durable", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                    durable: true,
+                });
+                (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+            });
+        });
+        describe("when request scoped explicit non durable", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                    durable: false,
+                });
+                (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+            });
+        });
+        describe("when default", () => {
+            it("should return true", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({});
+                (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.true;
+            });
+        });
+        describe("when statically scoped", () => {
+            describe("dependencies, properties, enhancers", () => {
+                describe("dependencies non static, properties static, enhancers static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+                    });
+                });
+                describe("dependencies static, properties non static, enhancers static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+                    });
+                });
+                describe("dependencies static, properties static, enhancers non static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+                    });
+                });
+            });
+            describe("dependencies", () => {
+                describe("when each is static", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.true;
+                    });
+                });
+                describe("when one is not static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        wrapper.addCtorMetadata(1, new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                        }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+                    });
+                });
+            });
+            describe("properties", () => {
+                describe("when each is static", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
+                        wrapper.addPropertiesMetadata("key2", new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.true;
+                    });
+                });
+                describe("when one is not static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        wrapper.addPropertiesMetadata("key2", new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+                    });
+                });
+            });
+            describe("enhancers", () => {
+                describe("when each is static", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.true;
+                    });
+                });
+                describe("when one is not static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeStatic()).to.be.false;
+                    });
+                });
+            });
+        });
+    });
+    describe("isDependencyTreeDurable", () => {
+        describe("when circular reference and default scope", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper();
+                const otherWrapper = new wrapper_1.InstanceWrapper();
+                wrapper.addCtorMetadata(0, otherWrapper);
+                otherWrapper.addCtorMetadata(0, wrapper);
+                (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                (0, chai_1.expect)(otherWrapper.isDependencyTreeDurable()).to.be.false;
+            });
+        });
+        describe("when circular reference and one non durable", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper();
+                const otherWrapper = new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST });
+                wrapper.addCtorMetadata(0, otherWrapper);
+                otherWrapper.addCtorMetadata(0, wrapper);
+                (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                (0, chai_1.expect)(otherWrapper.isDependencyTreeDurable()).to.be.false;
+            });
+        });
+        describe("when circular reference and one durable", () => {
+            it("should return true", () => {
+                const wrapper = new wrapper_1.InstanceWrapper();
+                const otherWrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                    durable: true,
+                });
+                wrapper.addCtorMetadata(0, otherWrapper);
+                otherWrapper.addCtorMetadata(0, wrapper);
+                (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                (0, chai_1.expect)(otherWrapper.isDependencyTreeDurable()).to.be.true;
+            });
+        });
+        describe("when request scoped and durable", () => {
+            it("should return true", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                    durable: true,
+                });
+                (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+            });
+        });
+        describe("when request scoped and non durable", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                });
+                (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+            });
+        });
+        describe("when request scoped and explicit non durable", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                    durable: false,
+                });
+                (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+            });
+        });
+        describe("when default scope", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper();
+                (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+            });
+        });
+        describe("when statically scoped", () => {
+            describe("dependencies, properties, enhancers", () => {
+                describe("dependencies non durable, properties non durable, enhancers durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        wrapper.addCtorMetadata(1, new wrapper_1.InstanceWrapper());
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("dependencies non durable, properties durable, enhancers durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        wrapper.addCtorMetadata(1, new wrapper_1.InstanceWrapper());
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("dependencies non durable, properties durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        wrapper.addCtorMetadata(1, new wrapper_1.InstanceWrapper());
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
+                        wrapper.addPropertiesMetadata("key2", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST, durable: true }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("properties durable, enhancers non durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
+                        wrapper.addPropertiesMetadata("key2", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST, durable: true }));
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("dependencies durable, enhancers non durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST, durable: true }));
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+            });
+            describe("dependencies", () => {
+                describe("when wrapper is non durable and dependency is static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST });
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when wrapper is durable and dependency is static", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        });
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when wrapper is non durable and dependency is durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                        });
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST, durable: true }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when wrapper is durable and dependency is static", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        });
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when wrapper is durable and dependency is non durable", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        });
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when each is static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when one is not static and non-durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        wrapper.addCtorMetadata(1, new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                        }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when one is not static and durable", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        wrapper.addCtorMetadata(1, new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when one is not static, durable and non durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addCtorMetadata(0, new wrapper_1.InstanceWrapper());
+                        wrapper.addCtorMetadata(1, new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        }));
+                        wrapper.addCtorMetadata(2, new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                        }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+            });
+            describe("properties", () => {
+                describe("when wrapper is non durable and dependency is static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST });
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when wrapper is durable and dependency is static", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        });
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when wrapper is non durable and dependency is durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                        });
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST, durable: true }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when wrapper is durable and dependency is static", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        });
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when wrapper is durable and dependency is non durable", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        });
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when each is static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper());
+                        wrapper.addPropertiesMetadata("key2", new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when one is not static and non-durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        wrapper.addPropertiesMetadata("key2", new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when one is not static and durable", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST, durable: true }));
+                        wrapper.addPropertiesMetadata("key2", new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when one is not static, non durable and durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addPropertiesMetadata("key1", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST, durable: true }));
+                        wrapper.addPropertiesMetadata("key2", new wrapper_1.InstanceWrapper());
+                        wrapper.addPropertiesMetadata("key3", new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+            });
+            describe("enhancers", () => {
+                describe("when wrapper is non durable and dependency is static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST });
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when wrapper is durable and dependency is static", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        });
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when wrapper is non durable and dependency is durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                        });
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST, durable: true }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when wrapper is durable and dependency is static", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        });
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when wrapper is durable and dependency is non durable", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper({
+                            scope: interfaces_1.Scope.REQUEST,
+                            durable: true,
+                        });
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when each is static", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when one is not static and non-durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+                describe("when one is not static and durable", () => {
+                    it("should return true", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST, durable: true }));
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.true;
+                    });
+                });
+                describe("when one is not static, non durable and durable", () => {
+                    it("should return false", () => {
+                        const wrapper = new wrapper_1.InstanceWrapper();
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST, durable: true }));
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper());
+                        wrapper.addEnhancerMetadata(new wrapper_1.InstanceWrapper({ scope: interfaces_1.Scope.REQUEST }));
+                        (0, chai_1.expect)(wrapper.isDependencyTreeDurable()).to.be.false;
+                    });
+                });
+            });
+        });
+    });
+    describe("isNotMetatype", () => {
+        describe("when metatype is nil", () => {
+            it("should return true", () => {
+                const instance = new wrapper_1.InstanceWrapper({ metatype: null });
+                (0, chai_1.expect)(instance.isNotMetatype).to.be.true;
+            });
+        });
+        describe("when metatype is not nil", () => {
+            it("should return false", () => {
+                const instance = new wrapper_1.InstanceWrapper({ metatype: TestClass });
+                (0, chai_1.expect)(instance.isNotMetatype).to.be.false;
+            });
+        });
+    });
+    describe("addEnhancerMetadata", () => {
+        it("should add enhancers metadata", () => {
+            const instance = new wrapper_1.InstanceWrapper();
+            const enhancers = [new wrapper_1.InstanceWrapper()];
+            instance.addEnhancerMetadata(enhancers[0]);
+            (0, chai_1.expect)(instance.getEnhancersMetadata()).to.be.eql(enhancers);
+        });
+    });
+    describe("when set instance has been called", () => {
+        it("should set static context value", () => {
+            const instance = { test: true };
+            const wrapper = new wrapper_1.InstanceWrapper();
+            wrapper.instance = instance;
+            (0, chai_1.expect)(wrapper.getInstanceByContextId(constants_1.STATIC_CONTEXT).instance).to.be.eql(instance);
+        });
+    });
+    describe("cloneStaticInstance", () => {
+        describe("when wrapper is static", () => {
+            it("should return static instance", () => {
+                const instance = { test: true };
+                const wrapper = new wrapper_1.InstanceWrapper({ instance });
+                (0, chai_1.expect)(wrapper.cloneStaticInstance({ id: 0 }).instance).to.be.eql(instance);
+            });
+        });
+        describe("when wrapper is not static", () => {
+            it("should clone instance by context id", () => {
+                const instance = { test: true };
+                const wrapper = new wrapper_1.InstanceWrapper({ instance, scope: interfaces_1.Scope.REQUEST });
+                (0, chai_1.expect)(wrapper.cloneStaticInstance({ id: 0 }).instance).to.be.undefined;
+            });
+        });
+    });
+    describe("getInstanceByContextId", () => {
+        describe("when transient and inquirer has been passed", () => {
+            it('should call "getInstanceByInquirerId"', () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.TRANSIENT,
+                });
+                const getInstanceByInquirerIdSpy = sinon_1.default.spy(wrapper, "getInstanceByInquirerId");
+                wrapper.getInstanceByContextId(constants_1.STATIC_CONTEXT, "inquirerId");
+                (0, chai_1.expect)(getInstanceByInquirerIdSpy.called).to.be.true;
+            });
+        });
+    });
+    describe("setInstanceByContextId", () => {
+        describe("when transient and inquirer has been passed", () => {
+            it('should call "setInstanceByInquirerId"', () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.TRANSIENT,
+                });
+                const setInstanceByInquirerIdSpy = sinon_1.default.spy(wrapper, "setInstanceByInquirerId");
+                wrapper.setInstanceByContextId(constants_1.STATIC_CONTEXT, { instance: {} }, "inquirerId");
+                (0, chai_1.expect)(setInstanceByInquirerIdSpy.called).to.be.true;
+            });
+        });
+    });
+    describe("isInRequestScope", () => {
+        describe("when tree and context are not static and is not transient", () => {
+            it("should return true", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                });
+                (0, chai_1.expect)(wrapper.isInRequestScope({ id: 3 })).to.be.true;
+            });
+        });
+        describe("otherwise", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.TRANSIENT,
+                });
+                (0, chai_1.expect)(wrapper.isInRequestScope({ id: 3 })).to.be.false;
+                const wrapper2 = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                });
+                (0, chai_1.expect)(wrapper2.isInRequestScope(constants_1.STATIC_CONTEXT)).to.be.false;
+            });
+        });
+    });
+    describe("isLazyTransient", () => {
+        describe("when inquirer is request scoped and context is not static and is transient", () => {
+            it("should return true", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.TRANSIENT,
+                });
+                (0, chai_1.expect)(wrapper.isLazyTransient({ id: 3 }, new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                }))).to.be.true;
+            });
+        });
+        describe("otherwise", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.TRANSIENT,
+                });
+                (0, chai_1.expect)(wrapper.isLazyTransient({ id: 3 }, new wrapper_1.InstanceWrapper())).to.be.false;
+                const wrapper2 = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                });
+                (0, chai_1.expect)(wrapper2.isLazyTransient(constants_1.STATIC_CONTEXT, new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.TRANSIENT,
+                }))).to.be.false;
+            });
+        });
+    });
+    describe("isStatic", () => {
+        describe("when inquirer is not request scoped and context and tree are static", () => {
+            it("should return true", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.DEFAULT,
+                });
+                (0, chai_1.expect)(wrapper.isStatic(constants_1.STATIC_CONTEXT, new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.DEFAULT,
+                }))).to.be.true;
+            });
+        });
+        describe("otherwise", () => {
+            it("should return false", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                });
+                (0, chai_1.expect)(wrapper.isStatic({ id: 3 }, new wrapper_1.InstanceWrapper())).to.be.false;
+                const wrapper2 = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.TRANSIENT,
+                });
+                (0, chai_1.expect)(wrapper2.isStatic(constants_1.STATIC_CONTEXT, new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.REQUEST,
+                }))).to.be.false;
+            });
+        });
+    });
+    describe("getStaticTransientInstances", () => {
+        describe("when instance is not transient", () => {
+            it("should return an empty array", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.DEFAULT,
+                });
+                (0, chai_1.expect)(wrapper.getStaticTransientInstances()).to.be.eql([]);
+            });
+        });
+        describe("when instance is transient", () => {
+            it("should return all static instances", () => {
+                const wrapper = new wrapper_1.InstanceWrapper({
+                    scope: interfaces_1.Scope.TRANSIENT,
+                });
+                const instanceHost = {
+                    instance: {},
+                };
+                wrapper.setInstanceByInquirerId(constants_1.STATIC_CONTEXT, "test", instanceHost);
+                (0, chai_1.expect)(wrapper.getStaticTransientInstances()).to.be.eql([instanceHost]);
+            });
+        });
+    });
+    describe("mergeWith", () => {
+        describe("when provider is a ValueProvider", () => {
+            it("should provide the given value in the STATIC_CONTEXT", () => {
+                const wrapper = new wrapper_1.InstanceWrapper();
+                wrapper.mergeWith({
+                    useValue: "value",
+                    provide: "token",
+                });
+                (0, chai_1.expect)(wrapper.getInstanceByContextId(constants_1.STATIC_CONTEXT).instance).to.be.equal("value");
+            });
+        });
+        describe("when provider is a ClassProvider", () => {
+            it("should alter the instance wrapper metatype with the given class", () => {
+                const wrapper = new wrapper_1.InstanceWrapper();
+                wrapper.mergeWith({
+                    useClass: TestClass,
+                    provide: "token",
+                });
+                (0, chai_1.expect)(wrapper.metatype).to.be.eql(TestClass);
+            });
+        });
+        describe("when provider is a FactoryProvider", () => {
+            describe("and it has injected dependencies", () => {
+                it("should alter the instance wrapper metatype and inject attributes with the given values", () => {
+                    const wrapper = new wrapper_1.InstanceWrapper();
+                    const factory = (_dependency1, _dependency2) => { };
+                    const injectedDependencies = ["dependency1", "dependency2"];
+                    wrapper.mergeWith({
+                        provide: "token",
+                        useFactory: factory,
+                        inject: injectedDependencies,
+                    });
+                    (0, chai_1.expect)(wrapper.metatype).to.be.eql(factory);
+                    (0, chai_1.expect)(wrapper.inject).to.be.eq(injectedDependencies);
+                });
+            });
+            describe("and it has no injected dependencies", () => {
+                it("should alter the instance wrapper metatype with the given values", () => {
+                    const wrapper = new wrapper_1.InstanceWrapper();
+                    const factory = (_dependency1, _dependency2) => { };
+                    wrapper.mergeWith({
+                        provide: "token",
+                        useFactory: factory,
+                    });
+                    (0, chai_1.expect)(wrapper.metatype).to.be.eql(factory);
+                    (0, chai_1.expect)(wrapper.inject).to.be.eql([]);
+                });
+            });
+        });
+    });
+});