@venok/core 1.0.0

package/test/guards/context-creator.spec.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const guards_1 = require("@venok/core/guards");
+const config_1 = require("@venok/core/application/config");
+const wrapper_1 = require("@venok/core/injector/instance/wrapper");
+class Guard {
+}
+describe("GuardsContextCreator", () => {
+    let guardsContextCreator;
+    let applicationConfig;
+    let guards;
+    let container;
+    let getSpy;
+    class Guard1 {
+    }
+    class Guard2 {
+    }
+    beforeEach(() => {
+        guards = [
+            {
+                name: "Guard1",
+                token: Guard1,
+                metatype: Guard1,
+                instance: {
+                    canActivate: () => true,
+                },
+                getInstanceByContextId: () => guards[0],
+            },
+            {
+                name: "Guard2",
+                token: Guard2,
+                metatype: Guard2,
+                instance: {
+                    canActivate: () => true,
+                },
+                getInstanceByContextId: () => guards[1],
+            },
+            {},
+            undefined,
+        ];
+        getSpy = sinon_1.default.stub().returns({
+            injectables: new Map([
+                [Guard1, guards[0]],
+                [Guard2, guards[1]],
+            ]),
+        });
+        container = {
+            getModules: () => ({
+                get: getSpy,
+            }),
+        };
+        applicationConfig = new config_1.ApplicationConfig();
+        guardsContextCreator = new guards_1.GuardsContextCreator(container, applicationConfig);
+    });
+    describe("createConcreteContext", () => {
+        describe("when `moduleContext` is nil", () => {
+            it("should return empty array", () => {
+                const result = guardsContextCreator.createConcreteContext(guards);
+                (0, chai_1.expect)(result).to.be.empty;
+            });
+        });
+        describe("when `moduleContext` is defined", () => {
+            beforeEach(() => {
+                guardsContextCreator["moduleContext"] = "test";
+            });
+            it("should filter metatypes", () => {
+                const guardTypeRefs = [guards[0].metatype, guards[1].instance];
+                (0, chai_1.expect)(guardsContextCreator.createConcreteContext(guardTypeRefs)).to.have.length(2);
+            });
+        });
+    });
+    describe("getGuardInstance", () => {
+        describe("when param is an object", () => {
+            it("should return instance", () => {
+                const instance = { canActivate: () => null };
+                (0, chai_1.expect)(guardsContextCreator.getGuardInstance(instance)).to.be.eql(instance);
+            });
+        });
+        describe("when param is a constructor", () => {
+            it("should pick instance from container", () => {
+                const wrapper = {
+                    instance: "test",
+                    getInstanceByContextId: () => wrapper,
+                };
+                sinon_1.default.stub(guardsContextCreator, "getInstanceByMetatype").callsFake(() => wrapper);
+                (0, chai_1.expect)(guardsContextCreator.getGuardInstance(Guard)).to.be.eql(wrapper.instance);
+            });
+            it("should return null", () => {
+                sinon_1.default.stub(guardsContextCreator, "getInstanceByMetatype").callsFake(() => null);
+                (0, chai_1.expect)(guardsContextCreator.getGuardInstance(Guard)).to.be.eql(null);
+            });
+        });
+    });
+    describe("getInstanceByMetatype", () => {
+        describe('when "moduleContext" is nil', () => {
+            it("should return undefined", () => {
+                guardsContextCreator.moduleContext = undefined;
+                (0, chai_1.expect)(guardsContextCreator.getInstanceByMetatype(null)).to.be.undefined;
+            });
+        });
+        describe('when "moduleContext" is not nil', () => {
+            beforeEach(() => {
+                guardsContextCreator.moduleContext = "test";
+            });
+            describe("but module does not exist", () => {
+                it("should return undefined", () => {
+                    (0, chai_1.expect)(guardsContextCreator.getInstanceByMetatype(class RandomModule {
+                    })).to.be.undefined;
+                });
+            });
+        });
+    });
+    describe("getGlobalMetadata", () => {
+        describe("when contextId is static and inquirerId is nil", () => {
+            it("should return global guards", () => {
+                const expectedResult = applicationConfig.getGlobalGuards();
+                (0, chai_1.expect)(guardsContextCreator.getGlobalMetadata()).to.be.equal(expectedResult);
+            });
+        });
+        describe("otherwise", () => {
+            it("should merge static global with request/transient scoped guards", () => {
+                const globalGuards = ["test"];
+                const instanceWrapper = new wrapper_1.InstanceWrapper();
+                const instance = "request-scoped";
+                const scopedGuardWrappers = [instanceWrapper];
+                sinon_1.default.stub(applicationConfig, "getGlobalGuards").callsFake(() => globalGuards);
+                sinon_1.default.stub(applicationConfig, "getGlobalRequestGuards").callsFake(() => scopedGuardWrappers);
+                sinon_1.default.stub(instanceWrapper, "getInstanceByContextId").callsFake(() => ({ instance }));
+                (0, chai_1.expect)(guardsContextCreator.getGlobalMetadata({ id: 3 })).to.contains(instance, ...globalGuards);
+            });
+        });
+    });
+});

package/test/helpers/context-id-factory.spec.d.ts

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

package/test/helpers/context-id-factory.spec.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const context_id_factory_helper_1 = require("@venok/core/helpers/context-id-factory.helper");
+describe("createContextId", () => {
+    it('should return an object with random "id" property', () => {
+        (0, chai_1.expect)((0, context_id_factory_helper_1.createContextId)()).to.have.property("id");
+    });
+});

package/test/helpers/shared.spec.d.ts

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

package/test/helpers/shared.spec.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+function Foo(a) {
+    // @ts-ignore
+    this.a = 1;
+}
+describe("Shared utils", () => {
+    describe("isUndefined", () => {
+        it("should return true when obj is undefined", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isUndefined)(undefined)).to.be.true;
+        });
+        it("should return false when object is not undefined", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isUndefined)({})).to.be.false;
+        });
+    });
+    describe("isFunction", () => {
+        it("should return true when obj is function", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isFunction)(() => ({}))).to.be.true;
+        });
+        it("should return false when object is not function", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isFunction)(null)).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isFunction)(undefined)).to.be.false;
+        });
+    });
+    describe("isObject", () => {
+        it("should return true when obj is object", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isObject)({})).to.be.true;
+        });
+        it("should return false when object is not object", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isObject)(3)).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isObject)(null)).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isObject)(undefined)).to.be.false;
+        });
+    });
+    describe("isPlainObject", () => {
+        it("should return true when obj is plain object", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isPlainObject)({})).to.be.true;
+            (0, chai_1.expect)((0, shared_helper_1.isPlainObject)({ prop: true })).to.be.true;
+            (0, chai_1.expect)((0, shared_helper_1.isPlainObject)({
+                constructor: Foo,
+            })).to.be.true;
+            (0, chai_1.expect)((0, shared_helper_1.isPlainObject)(Object.create(null))).to.be.true;
+        });
+        it("should return false when object is not object", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isPlainObject)(3)).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isPlainObject)(null)).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isPlainObject)(undefined)).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isPlainObject)([1, 2, 3])).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isPlainObject)(new Date())).to.be.false;
+            // @ts-ignore
+            (0, chai_1.expect)((0, shared_helper_1.isPlainObject)(new Foo(1))).to.be.false;
+        });
+    });
+    describe("isString", () => {
+        it("should return true when val is a string", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isString)("true")).to.be.true;
+        });
+        it("should return false when val is not a string", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isString)(new String("fine"))).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isString)(false)).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isString)(null)).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isString)(undefined)).to.be.false;
+        });
+    });
+    describe("isSymbol", () => {
+        it("should return true when val is a Symbol", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isSymbol)(Symbol())).to.be.true;
+        });
+        it("should return false when val is not a symbol", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isSymbol)("Symbol()")).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isSymbol)(false)).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isSymbol)(null)).to.be.false;
+            (0, chai_1.expect)((0, shared_helper_1.isSymbol)(undefined)).to.be.false;
+        });
+    });
+    describe("isNumber", () => {
+        it("should return true when val is a number or NaN", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isNumber)(1)).to.be.true;
+            (0, chai_1.expect)((0, shared_helper_1.isNumber)(1.23)).to.be.true; // with decimals
+            (0, chai_1.expect)((0, shared_helper_1.isNumber)(123e-5)).to.be.true; // scientific (exponent) notation
+            (0, chai_1.expect)((0, shared_helper_1.isNumber)(0o1)).to.be.true; // octal notation
+            (0, chai_1.expect)((0, shared_helper_1.isNumber)(0b1)).to.be.true; // binary notation
+            (0, chai_1.expect)((0, shared_helper_1.isNumber)(0x1)).to.be.true; // hexadecimal notation
+            (0, chai_1.expect)((0, shared_helper_1.isNumber)(NaN)).to.be.true;
+        });
+        it("should return false when val is not a number", () => {
+            // expect(isNumber(1n)).to.be.false; // big int (available on ES2020)
+            (0, chai_1.expect)((0, shared_helper_1.isNumber)("1")).to.be.false; // string
+            (0, chai_1.expect)((0, shared_helper_1.isNumber)(undefined)).to.be.false; // nullish
+            (0, chai_1.expect)((0, shared_helper_1.isNumber)(null)).to.be.false; // nullish
+        });
+    });
+    describe("isConstructor", () => {
+        it("should return true when string is equal to constructor", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isConstructor)("constructor")).to.be.true;
+        });
+        it("should return false when string is not equal to constructor", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isConstructor)("nope")).to.be.false;
+        });
+    });
+    describe("isNull", () => {
+        it("should return true when obj is undefined or null", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isNull)(undefined)).to.be.true;
+            (0, chai_1.expect)((0, shared_helper_1.isNull)(null)).to.be.true;
+        });
+        it("should return false when object is not undefined and null", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isNull)("3")).to.be.false;
+        });
+    });
+    describe("isEmpty", () => {
+        it("should return true when array is empty or not exists", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isEmpty)([])).to.be.true;
+            (0, chai_1.expect)((0, shared_helper_1.isEmpty)(null)).to.be.true;
+            (0, chai_1.expect)((0, shared_helper_1.isEmpty)(undefined)).to.be.true;
+        });
+        it("should return false when array is not empty", () => {
+            (0, chai_1.expect)((0, shared_helper_1.isEmpty)([1, 2])).to.be.false;
+        });
+    });
+});

package/test/hooks/before-app-shutdown.hook.spec.d.ts

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

package/test/hooks/before-app-shutdown.hook.spec.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const module_1 = require("@venok/core/injector/module/module");
+const container_1 = require("@venok/core/injector/container");
+const hooks_1 = require("@venok/core/hooks");
+class SampleProvider {
+    beforeApplicationShutdown(signal) { }
+}
+class SampleModule {
+    beforeApplicationShutdown(signal) { }
+}
+class WithoutHookProvider {
+}
+describe("BeforeAppShutdown", () => {
+    let moduleRef;
+    let sampleProvider;
+    beforeEach(() => {
+        sampleProvider = new SampleProvider();
+        moduleRef = new module_1.Module(SampleModule, new container_1.VenokContainer());
+        const moduleWrapperRef = moduleRef.getProviderByKey(SampleModule);
+        moduleWrapperRef.instance = new SampleModule();
+        moduleRef.addProvider({
+            provide: SampleProvider,
+            useValue: sampleProvider,
+        });
+        moduleRef.addProvider({
+            provide: WithoutHookProvider,
+            useValue: new WithoutHookProvider(),
+        });
+    });
+    describe("callBeforeAppShutdownHook", () => {
+        it('should call "beforeApplicationShutdown" hook for the entire module', async () => {
+            const signal = "SIGTERM";
+            const hookSpy = sinon_1.default.spy(sampleProvider, "beforeApplicationShutdown");
+            await (0, hooks_1.callBeforeAppShutdownHook)(moduleRef, signal);
+            (0, chai_1.expect)(hookSpy.calledWith(signal)).to.be.true;
+        });
+    });
+});

package/test/hooks/on-app-bootstrap.hook.spec.d.ts

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

package/test/hooks/on-app-bootstrap.hook.spec.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const container_1 = require("@venok/core/injector/container");
+const module_1 = require("@venok/core/injector/module/module");
+const hooks_1 = require("@venok/core/hooks");
+class SampleProvider {
+    onApplicationBootstrap() { }
+}
+class SampleModule {
+    onApplicationBootstrap() { }
+}
+class WithoutHookProvider {
+}
+describe("OnApplicationBootstrap", () => {
+    let moduleRef;
+    let sampleProvider;
+    beforeEach(() => {
+        sampleProvider = new SampleProvider();
+        moduleRef = new module_1.Module(SampleModule, new container_1.VenokContainer());
+        const moduleWrapperRef = moduleRef.getProviderByKey(SampleModule);
+        moduleWrapperRef.instance = new SampleModule();
+        moduleRef.addProvider({
+            provide: SampleProvider,
+            useValue: sampleProvider,
+        });
+        moduleRef.addProvider({
+            provide: WithoutHookProvider,
+            useValue: new WithoutHookProvider(),
+        });
+    });
+    describe("callModuleBootstrapHook", () => {
+        it('should call "onApplicationBootstrap" hook for the entire module', async () => {
+            const hookSpy = sinon_1.default.spy(sampleProvider, "onApplicationBootstrap");
+            await (0, hooks_1.callModuleBootstrapHook)(moduleRef);
+            (0, chai_1.expect)(hookSpy.called).to.be.true;
+        });
+    });
+});

package/test/hooks/on-app-shutdown.hook.spec.d.ts

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

package/test/hooks/on-app-shutdown.hook.spec.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const container_1 = require("@venok/core/injector/container");
+const module_1 = require("@venok/core/injector/module/module");
+const hooks_1 = require("@venok/core/hooks");
+class SampleProvider {
+    onApplicationShutdown() { }
+}
+class SampleModule {
+    onApplicationShutdown() { }
+}
+class WithoutHookProvider {
+}
+describe("OnApplicationShutdown", () => {
+    let moduleRef;
+    let sampleProvider;
+    beforeEach(() => {
+        sampleProvider = new SampleProvider();
+        moduleRef = new module_1.Module(SampleModule, new container_1.VenokContainer());
+        const moduleWrapperRef = moduleRef.getProviderByKey(SampleModule);
+        moduleWrapperRef.instance = new SampleModule();
+        moduleRef.addProvider({
+            provide: SampleProvider,
+            useValue: sampleProvider,
+        });
+        moduleRef.addProvider({
+            provide: WithoutHookProvider,
+            useValue: new WithoutHookProvider(),
+        });
+    });
+    describe("callAppShutdownHook", () => {
+        it('should call "onApplicationShutdown" hook for the entire module', async () => {
+            const hookSpy = sinon_1.default.spy(sampleProvider, "onApplicationShutdown");
+            await (0, hooks_1.callAppShutdownHook)(moduleRef);
+            (0, chai_1.expect)(hookSpy.called).to.be.true;
+        });
+    });
+});

package/test/hooks/on-module-destroy.hook.spec.d.ts

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

package/test/hooks/on-module-destroy.hook.spec.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const container_1 = require("@venok/core/injector/container");
+const module_1 = require("@venok/core/injector/module/module");
+const hooks_1 = require("@venok/core/hooks");
+class SampleProvider {
+    onModuleDestroy() { }
+}
+class SampleModule {
+    onModuleDestroy() { }
+}
+class WithoutHookProvider {
+}
+describe("OnModuleDestroy", () => {
+    let moduleRef;
+    let sampleProvider;
+    beforeEach(() => {
+        sampleProvider = new SampleProvider();
+        moduleRef = new module_1.Module(SampleModule, new container_1.VenokContainer());
+        const moduleWrapperRef = moduleRef.getProviderByKey(SampleModule);
+        moduleWrapperRef.instance = new SampleModule();
+        moduleRef.addProvider({
+            provide: SampleProvider,
+            useValue: sampleProvider,
+        });
+        moduleRef.addProvider({
+            provide: WithoutHookProvider,
+            useValue: new WithoutHookProvider(),
+        });
+    });
+    describe("callModuleDestroyHook", () => {
+        it('should call "onModuleDestroy" hook for the entire module', async () => {
+            const hookSpy = sinon_1.default.spy(sampleProvider, "onModuleDestroy");
+            await (0, hooks_1.callModuleDestroyHook)(moduleRef);
+            (0, chai_1.expect)(hookSpy.called).to.be.true;
+        });
+    });
+});

package/test/hooks/on-module-init.hook.spec.d.ts

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

package/test/hooks/on-module-init.hook.spec.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const container_1 = require("@venok/core/injector/container");
+const module_1 = require("@venok/core/injector/module/module");
+const hooks_1 = require("@venok/core/hooks");
+class SampleProvider {
+    onModuleInit() { }
+}
+class SampleModule {
+    onModuleInit() { }
+}
+class WithoutHookProvider {
+}
+describe("OnModuleInit", () => {
+    let moduleRef;
+    let sampleProvider;
+    beforeEach(() => {
+        sampleProvider = new SampleProvider();
+        moduleRef = new module_1.Module(SampleModule, new container_1.VenokContainer());
+        const moduleWrapperRef = moduleRef.getProviderByKey(SampleModule);
+        moduleWrapperRef.instance = new SampleModule();
+        moduleRef.addProvider({
+            provide: SampleProvider,
+            useValue: sampleProvider,
+        });
+        moduleRef.addProvider({
+            provide: WithoutHookProvider,
+            useValue: new WithoutHookProvider(),
+        });
+    });
+    describe("callModuleInitHook", () => {
+        it('should call "onModuleInit" hook for the entire module', async () => {
+            const hookSpy = sinon_1.default.spy(sampleProvider, "onModuleInit");
+            await (0, hooks_1.callModuleInitHook)(moduleRef);
+            (0, chai_1.expect)(hookSpy.called).to.be.true;
+        });
+    });
+});

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

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

package/test/injector/compiler.spec.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const compiler_1 = require("@venok/core/injector/module/compiler");
+describe("ModuleCompiler", () => {
+    let compiler;
+    beforeEach(() => {
+        compiler = new compiler_1.ModuleCompiler();
+    });
+    describe("extractMetadata", () => {
+        describe("when module is a dynamic module", () => {
+            it('should return object with "type" and "dynamicMetadata" property', async () => {
+                const obj = { module: "test", providers: [] };
+                const { module, ...dynamicMetadata } = obj;
+                (0, chai_1.expect)(compiler.extractMetadata(obj)).to.be.deep.equal({
+                    type: module,
+                    dynamicMetadata,
+                });
+            });
+        });
+        describe("when module is a not dynamic module", () => {
+            it('should return object with "type" property', async () => {
+                const type = "test";
+                (0, chai_1.expect)(compiler.extractMetadata(type)).to.be.deep.equal({
+                    type,
+                });
+            });
+        });
+    });
+    describe("isDynamicModule", () => {
+        describe("when module is a dynamic module", () => {
+            it("should return true", () => {
+                (0, chai_1.expect)(compiler.isDynamicModule({ module: true })).to.be.true;
+            });
+        });
+        describe("when module is a dynamic module", () => {
+            it("should return false", () => {
+                (0, chai_1.expect)(compiler.isDynamicModule({ x: true })).to.be.false;
+            });
+        });
+    });
+});

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

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