@venok/core 1.0.0

package/test/injector/container.spec.js

@@ -0,0 +1,203 @@
+"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 __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 container_1 = require("@venok/core/injector/container");
+const module_decorator_1 = require("@venok/core/decorators/module.decorator");
+const global_decorator_1 = require("@venok/core/decorators/global.decorator");
+const exceptions_1 = require("@venok/core/errors/exceptions");
+describe("VenokContainer", () => {
+    let container;
+    let TestModule = class TestModule {
+    };
+    TestModule = __decorate([
+        (0, module_decorator_1.Module)({})
+    ], TestModule);
+    let GlobalTestModule = class GlobalTestModule {
+    };
+    GlobalTestModule = __decorate([
+        (0, global_decorator_1.Global)(),
+        (0, module_decorator_1.Module)({})
+    ], GlobalTestModule);
+    beforeEach(() => {
+        container = new container_1.VenokContainer();
+    });
+    it('should "addProvider" throw "UnknownModuleException" when module is not stored in collection', () => {
+        (0, chai_1.expect)(() => container.addProvider({}, "TestModule")).throw(exceptions_1.UnknownModuleException);
+    });
+    it('should "addProvider" throw "CircularDependencyException" when provider is nil', () => {
+        (0, chai_1.expect)(() => container.addProvider(null, "TestModule")).throw(exceptions_1.CircularDependencyException);
+    });
+    it('should "addExportedProvider" throw "UnknownModuleException" when module is not stored in collection', () => {
+        (0, chai_1.expect)(() => container.addExportedProvider(null, "TestModule")).throw(exceptions_1.UnknownModuleException);
+    });
+    it('should "addInjectable" throw "UnknownModuleException" when module is not stored in collection', () => {
+        (0, chai_1.expect)(() => container.addInjectable(null, "TestModule", null)).throw(exceptions_1.UnknownModuleException);
+    });
+    describe("clear", () => {
+        it("should call `clear` on modules collection", () => {
+            const clearSpy = sinon_1.default.spy(container.modules, "clear");
+            container.clear();
+            (0, chai_1.expect)(clearSpy.called).to.be.true;
+        });
+    });
+    describe("addModule", () => {
+        it("should not add module if already exists in collection", async () => {
+            const modules = new Map();
+            const setSpy = sinon_1.default.spy(modules, "set");
+            container.modules = modules;
+            await container.addModule(TestModule, []);
+            await container.addModule(TestModule, []);
+            (0, chai_1.expect)(setSpy.calledOnce).to.be.true;
+        });
+        it("should throw an exception when metatype is not defined", () => {
+            (0, chai_1.expect)(container.addModule(undefined, [])).to.eventually.throws();
+        });
+        it("should add global module when module is global", async () => {
+            const addGlobalModuleSpy = sinon_1.default.spy(container, "addGlobalModule");
+            await container.addModule(GlobalTestModule, []);
+            (0, chai_1.expect)(addGlobalModuleSpy.calledOnce).to.be.true;
+        });
+    });
+    describe("replaceModule", () => {
+        it("should replace module if already exists in collection", async () => {
+            let ReplaceTestModule = class ReplaceTestModule {
+            };
+            ReplaceTestModule = __decorate([
+                (0, module_decorator_1.Module)({})
+            ], ReplaceTestModule);
+            const modules = new Map();
+            const setSpy = sinon_1.default.spy(modules, "set");
+            container.modules = modules;
+            await container.addModule(TestModule, []);
+            await container.replaceModule(TestModule, ReplaceTestModule, []);
+            (0, chai_1.expect)(setSpy.calledTwice).to.be.true;
+        });
+        it("should throw an exception when metatype is not defined", () => {
+            (0, chai_1.expect)(container.addModule(undefined, [])).to.eventually.throws();
+        });
+        it("should add global module when module is global", async () => {
+            const addGlobalModuleSpy = sinon_1.default.spy(container, "addGlobalModule");
+            await container.addModule(GlobalTestModule, []);
+            (0, chai_1.expect)(addGlobalModuleSpy.calledOnce).to.be.true;
+        });
+    });
+    describe("isGlobalModule", () => {
+        describe("when module is not globally scoped", () => {
+            it("should return false", () => {
+                (0, chai_1.expect)(container.isGlobalModule(TestModule)).to.be.false;
+            });
+        });
+        describe("when module is globally scoped", () => {
+            it("should return true", () => {
+                (0, chai_1.expect)(container.isGlobalModule(GlobalTestModule)).to.be.true;
+            });
+        });
+        describe("when dynamic module is globally scoped", () => {
+            it("should return true", () => {
+                (0, chai_1.expect)(container.isGlobalModule(TestModule, { global: true })).to.be.true;
+            });
+        });
+    });
+    describe("bindGlobalsToImports", () => {
+        it('should call "bindGlobalModuleToModule" for every global module', () => {
+            const global1 = { test: 1 };
+            const global2 = { test: 2 };
+            container.addGlobalModule(global1);
+            container.addGlobalModule(global2);
+            const bindGlobalModuleToModuleSpy = sinon_1.default.spy(container, "bindGlobalModuleToModule");
+            container.bindGlobalsToImports({
+                addImport: sinon_1.default.spy(),
+            });
+            (0, chai_1.expect)(bindGlobalModuleToModuleSpy.calledTwice).to.be.true;
+        });
+    });
+    describe("bindGlobalModuleToModule", () => {
+        describe('when "module" is not "globalModule"', () => {
+            it('should call "addImport"', () => {
+                const module = { addImport: sinon_1.default.spy() };
+                container.bindGlobalModuleToModule(module, null);
+                (0, chai_1.expect)(module.addImport.calledOnce).to.be.true;
+            });
+        });
+        describe('when "module" is "globalModule"', () => {
+            it('should not call "addImport"', () => {
+                const module = { addImport: sinon_1.default.spy() };
+                container.bindGlobalModuleToModule(module, module);
+                (0, chai_1.expect)(module.addImport.calledOnce).to.be.false;
+            });
+        });
+    });
+    describe("addDynamicMetadata", () => {
+        let token;
+        let collection;
+        beforeEach(() => {
+            token = "token";
+            collection = new Map();
+            container.dynamicModulesMetadata = collection;
+        });
+        describe("when dynamic metadata exists", () => {
+            it("should add to the dynamic metadata collection", () => {
+                const addSpy = sinon_1.default.spy(collection, "set");
+                const dynamicMetadata = { module: null };
+                container.addDynamicMetadata(token, dynamicMetadata, []);
+                (0, chai_1.expect)(addSpy.calledWith(token, dynamicMetadata)).to.be.true;
+            });
+        });
+        describe("when dynamic metadata does not exists", () => {
+            it("should not add to the dynamic metadata collection", () => {
+                const addSpy = sinon_1.default.spy(collection, "set");
+                container.addDynamicMetadata(token, null, []);
+                (0, chai_1.expect)(addSpy.called).to.be.false;
+            });
+        });
+    });
+    class Test {
+    }
+    describe("addDynamicModules", () => {
+        describe("when array is empty/undefined", () => {
+            it('should not call "addModule"', () => {
+                const addModuleSpy = sinon_1.default.spy(container, "addModule");
+                container.addDynamicModules(undefined, []);
+                (0, chai_1.expect)(addModuleSpy.called).to.be.false;
+            });
+        });
+        describe("when array is not empty/undefined", () => {
+            it('should call "addModule"', () => {
+                const addModuleSpy = sinon_1.default.spy(container, "addModule");
+                container.addDynamicModules([Test], []);
+                (0, chai_1.expect)(addModuleSpy.called).to.be.true;
+            });
+        });
+    });
+    describe("get applicationConfig", () => {
+        it("should return ApplicationConfig instance", () => {
+            (0, chai_1.expect)(container.applicationConfig).to.be.eql(container._applicationConfig);
+        });
+    });
+    describe("getModuleByKey", () => {
+        it("should return module by passed key", () => {
+            const key = "test";
+            const value = {};
+            container.getModules().set(key, value);
+            (0, chai_1.expect)(container.getModuleByKey(key)).to.be.eql(value);
+        });
+    });
+    describe("registerCoreModuleRef", () => {
+        it("should register core module ref", () => {
+            const ref = {};
+            container.registerCoreModuleRef(ref);
+            (0, chai_1.expect)(container.internalCoreModule).to.be.eql(ref);
+        });
+    });
+});

package/test/injector/helpers/classifier.spec.d.ts

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

package/test/injector/helpers/classifier.spec.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const classifier_helper_1 = require("@venok/core/injector/helpers/classifier.helper");
+const chai_1 = require("chai");
+describe("provider classifier", () => {
+    describe("isClassProvider", () => {
+        it("should return true if useClass is present", () => {
+            const classProvider = {
+                useClass: class TestClass {
+                },
+                provide: "token",
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isClassProvider)(classProvider)).to.be.true;
+        });
+        it("should return false if useClass is undefined", () => {
+            const classProvider = {
+                useClass: undefined,
+                provide: "token",
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isClassProvider)(classProvider)).to.be.false;
+        });
+        it("should return false if useClass is not present", () => {
+            const classProvider = {
+                provide: "token",
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isClassProvider)(classProvider)).to.be.false;
+        });
+        it("should return false if provider is undefined", () => {
+            const classProvider = undefined;
+            (0, chai_1.expect)((0, classifier_helper_1.isClassProvider)(classProvider)).to.be.false;
+        });
+    });
+    describe("isValueProvider", () => {
+        it("should return true if useValue is not undefined", () => {
+            const valueProvider = {
+                useValue: "value",
+                provide: "token",
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isValueProvider)(valueProvider)).to.be.true;
+        });
+        it('should return true if useValue is "false"', () => {
+            const valueProvider = {
+                useValue: false,
+                provide: "token",
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isValueProvider)(valueProvider)).to.be.true;
+        });
+        it('should return true if useValue is "null"', () => {
+            const valueProvider = {
+                useValue: null,
+                provide: "token",
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isValueProvider)(valueProvider)).to.be.true;
+        });
+        it("should return true if useValue is an empty string", () => {
+            const valueProvider = {
+                useValue: null,
+                provide: "",
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isValueProvider)(valueProvider)).to.be.true;
+        });
+        it("should return false if useValue is undefined", () => {
+            const valueProvider = {
+                useValue: undefined,
+                provide: "token",
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isValueProvider)(valueProvider)).to.be.false;
+        });
+        it("should return false if useValue is not present", () => {
+            const valueProvider = {
+                provide: "token",
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isValueProvider)(valueProvider)).to.be.false;
+        });
+        it("should return false if provider is undefined", () => {
+            const valueProvider = undefined;
+            (0, chai_1.expect)((0, classifier_helper_1.isValueProvider)(valueProvider)).to.be.false;
+        });
+    });
+    describe("isFactoryProvider", () => {
+        it("should return true if useFactory is present", () => {
+            const factoryProvider = {
+                provide: "token",
+                useFactory: () => { },
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isFactoryProvider)(factoryProvider)).to.be.true;
+        });
+        it("should return false if useFactory is not present", () => {
+            const factoryProvider = {
+                provide: "token",
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isFactoryProvider)(factoryProvider)).to.be.false;
+        });
+        it("should return false if useFactory is undefined", () => {
+            const factoryProvider = {
+                provide: "token",
+                useFactory: undefined,
+            };
+            (0, chai_1.expect)((0, classifier_helper_1.isFactoryProvider)(factoryProvider)).to.be.false;
+        });
+    });
+});

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

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