@venok/core 1.0.0

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

@@ -0,0 +1,108 @@
+"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 loader_1 = require("@venok/core/injector/instance/loader");
+const injectable_decorator_1 = require("@venok/core/decorators/injectable.decorator");
+const injector_1 = require("@venok/core/injector/injector");
+const graph_inspector_1 = require("@venok/core/inspector/graph-inspector");
+const container_1 = require("@venok/core/injector/container");
+const wrapper_1 = require("@venok/core/injector/instance/wrapper");
+describe("InstanceLoader", () => {
+    let TestProvider = class TestProvider {
+    };
+    TestProvider = __decorate([
+        (0, injectable_decorator_1.Injectable)()
+    ], TestProvider);
+    let loader;
+    let injector;
+    let container;
+    let graphInspector;
+    let inspectInstanceWrapperStub;
+    let mockContainer;
+    let moduleMock;
+    beforeEach(() => {
+        container = new container_1.VenokContainer();
+        graphInspector = new graph_inspector_1.GraphInspector(container);
+        inspectInstanceWrapperStub = sinon_1.default.stub(graphInspector, "inspectInstanceWrapper");
+        injector = new injector_1.Injector();
+        loader = new loader_1.InstanceLoader(container, injector, graphInspector);
+        mockContainer = sinon_1.default.mock(container);
+        moduleMock = {
+            imports: new Set(),
+            providers: new Map(),
+            controllers: new Map(),
+            injectables: new Map(),
+            exports: new Set(),
+            metatype: { name: "test" },
+        };
+        const modules = new Map();
+        modules.set("Test", moduleMock);
+        mockContainer.expects("getModules").returns(modules);
+    });
+    it('should call "loadPrototype" for every provider and controller in every module', async () => {
+        const providerWrapper = new wrapper_1.InstanceWrapper({
+            instance: null,
+            metatype: TestProvider,
+            token: "TestProvider",
+        });
+        moduleMock.providers.set("TestProvider", providerWrapper);
+        const loadProviderPrototypeStub = sinon_1.default.stub(injector, "loadPrototype");
+        sinon_1.default.stub(injector, "loadProvider");
+        await loader.createInstancesOfDependencies();
+        (0, chai_1.expect)(loadProviderPrototypeStub.calledWith(providerWrapper, moduleMock.providers)).to.be.true;
+    });
+    describe("for every provider in every module", () => {
+        const testProviderToken = "TestProvider";
+        let loadProviderStub;
+        beforeEach(async () => {
+            const testProviderWrapper = new wrapper_1.InstanceWrapper({
+                instance: null,
+                metatype: TestProvider,
+                name: testProviderToken,
+                token: testProviderToken,
+            });
+            moduleMock.providers.set(testProviderToken, testProviderWrapper);
+            loadProviderStub = sinon_1.default.stub(injector, "loadProvider");
+            await loader.createInstancesOfDependencies();
+        });
+        it('should call "loadProvider"', async () => {
+            (0, chai_1.expect)(loadProviderStub.calledWith(moduleMock.providers.get(testProviderToken), moduleMock)).to.be.true;
+        });
+        it('should call "inspectInstanceWrapper"', async () => {
+            (0, chai_1.expect)(inspectInstanceWrapperStub.calledWith(moduleMock.providers.get(testProviderToken), moduleMock)).to
+                .be.true;
+        });
+    });
+    describe("for every injectable in every module", () => {
+        let loadInjectableStub;
+        beforeEach(async () => {
+            const testInjectable = new wrapper_1.InstanceWrapper({
+                instance: null,
+                metatype: TestProvider,
+                name: "TestProvider",
+                token: "TestProvider",
+            });
+            moduleMock.injectables.set("TestProvider", testInjectable);
+            loadInjectableStub = sinon_1.default.stub(injector, "loadInjectable");
+            await loader.createInstancesOfDependencies();
+        });
+        it('should call "loadInjectable"', async () => {
+            (0, chai_1.expect)(loadInjectableStub.calledWith(moduleMock.injectables.get("TestProvider"), moduleMock)).to.be.true;
+        });
+        it('should call "inspectInstanceWrapper"', async () => {
+            (0, chai_1.expect)(inspectInstanceWrapperStub.calledWith(moduleMock.injectables.get("TestProvider"), moduleMock)).to.be
+                .true;
+        });
+    });
+});

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

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