@venok/core 1.0.1-canary.5 → 2.0.0

package/test/injector/container.spec.js

@@ -1,203 +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 __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

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

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

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

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