@venok/http 1.0.1-canary.0

package/test/exceptions/handler.spec.js

@@ -0,0 +1,145 @@
+"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 http_errors_1 = __importDefault(require("http-errors"));
+const sinon_1 = __importDefault(require("sinon"));
+const adapter_helper_1 = require("@venok/http/helpers/adapter.helper");
+const execution_host_1 = require("../../../core/context/execution-host");
+const invalid_exception_filter_exception_1 = require("../../../core/errors/exceptions/invalid-exception-filter.exception");
+const shared_helper_1 = require("../../../core/helpers/shared.helper");
+const errors_1 = require("../../errors");
+const filter_1 = require("../../filters/filter");
+const handler_1 = require("../../../core/exceptions/handler");
+describe("VenokExceptionsHandler", () => {
+    let adapter;
+    let handler;
+    let statusStub;
+    let jsonStub;
+    let response;
+    beforeEach(() => {
+        adapter = new adapter_helper_1.NoopHttpAdapter({});
+        handler = new handler_1.VenokExceptionsHandler(new filter_1.HttpExceptionFilter(adapter));
+        statusStub = sinon_1.default.stub();
+        jsonStub = sinon_1.default.stub();
+        response = {
+            status: statusStub,
+            json: jsonStub,
+        };
+        response.status.returns(response);
+        response.json.returns(response);
+    });
+    describe("next", () => {
+        beforeEach(() => {
+            sinon_1.default.stub(adapter, "reply").callsFake((responseRef, body, statusCode) => {
+                if (statusCode)
+                    responseRef.status(statusCode);
+                if ((0, shared_helper_1.isNull)(body))
+                    return responseRef.send();
+                return (0, shared_helper_1.isObject)(body) ? responseRef.json(body) : responseRef.send(String(body));
+            });
+        });
+        it("should send expected response status code and message when exception is unknown", () => {
+            handler.next(new Error(), new execution_host_1.ExecutionContextHost([0, response]));
+            (0, chai_1.expect)(statusStub.calledWith(500)).to.be.true;
+            (0, chai_1.expect)(jsonStub.calledWith({
+                statusCode: 500,
+                message: "Internal server error",
+            })).to.be.true;
+        });
+        describe('when exception is instantiated by "http-errors" library', () => {
+            it("should send expected response status code and message", () => {
+                const error = new http_errors_1.default.NotFound("User does not exist");
+                handler.next(error, new execution_host_1.ExecutionContextHost([0, response]));
+                (0, chai_1.expect)(statusStub.calledWith(404)).to.be.true;
+                (0, chai_1.expect)(jsonStub.calledWith({
+                    statusCode: 404,
+                    message: "User does not exist",
+                })).to.be.true;
+            });
+        });
+        describe("when exception is an instance of HttpException", () => {
+            it("should send expected response status code and json object", () => {
+                const status = 401;
+                const message = {
+                    custom: "Unauthorized",
+                };
+                handler.next(new errors_1.HttpException(message, status), new execution_host_1.ExecutionContextHost([0, response]));
+                (0, chai_1.expect)(statusStub.calledWith(status)).to.be.true;
+                (0, chai_1.expect)(jsonStub.calledWith(message)).to.be.true;
+            });
+            it("should send expected response status code and transform message to json", () => {
+                const status = 401;
+                const message = "Unauthorized";
+                handler.next(new errors_1.HttpException(message, status), new execution_host_1.ExecutionContextHost([0, response]));
+                (0, chai_1.expect)(statusStub.calledWith(status)).to.be.true;
+                (0, chai_1.expect)(jsonStub.calledWith({ message, statusCode: status })).to.be.true;
+            });
+        });
+        describe('when "invokeCustomFilters" returns true', () => {
+            beforeEach(() => {
+                sinon_1.default.stub(handler, "invokeCustomFilters").returns(true);
+            });
+            it("should do nothing", () => {
+                handler.next(new Error(), sinon_1.default.createStubInstance(execution_host_1.ExecutionContextHost));
+                (0, chai_1.expect)(statusStub.notCalled).to.be.true;
+                (0, chai_1.expect)(jsonStub.notCalled).to.be.true;
+            });
+        });
+    });
+    describe("setCustomFilters", () => {
+        const filters = ["test", "test2"];
+        it("should set custom filters", () => {
+            handler.setCustomFilters(filters);
+            (0, chai_1.expect)(handler.filters).to.be.eql(filters);
+        });
+        it("should throw exception when passed argument is not an array", () => {
+            (0, chai_1.expect)(() => handler.setCustomFilters(null)).to.throws(invalid_exception_filter_exception_1.InvalidExceptionFilterException);
+        });
+    });
+    describe("invokeCustomFilters", () => {
+        describe("when filters array is empty", () => {
+            it("should return false", () => {
+                (0, chai_1.expect)(handler.invokeCustomFilters(null, null)).to.be.false;
+            });
+        });
+        describe("when filters array is not empty", () => {
+            let filters, funcSpy;
+            class TestException {
+            }
+            beforeEach(() => {
+                funcSpy = sinon_1.default.spy();
+            });
+            describe("when filter exists in filters array", () => {
+                beforeEach(() => {
+                    filters = [{ exceptionMetatypes: [TestException], func: funcSpy }];
+                    handler.filters = filters;
+                });
+                it("should call funcSpy", () => {
+                    handler.invokeCustomFilters(new TestException(), null);
+                    (0, chai_1.expect)(funcSpy.notCalled).to.be.false;
+                });
+                it("should call funcSpy with exception and response passed as an arguments", () => {
+                    const exception = new TestException();
+                    const res = { foo: "bar" };
+                    handler.invokeCustomFilters(exception, res);
+                    (0, chai_1.expect)(funcSpy.calledWith(exception, res)).to.be.true;
+                });
+                it("should return true", () => {
+                    (0, chai_1.expect)(handler.invokeCustomFilters(new TestException(), null)).to.be.true;
+                });
+            });
+            describe("when filter does not exists in filters array", () => {
+                it("should not call funcSpy", () => {
+                    handler.invokeCustomFilters(new TestException(), null);
+                    (0, chai_1.expect)(funcSpy.notCalled).to.be.true;
+                });
+                it("should return false", () => {
+                    (0, chai_1.expect)(handler.invokeCustomFilters(new TestException(), null)).to.be.false;
+                });
+            });
+        });
+    });
+});

package/test/exceptions/proxy.spec.d.ts

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

package/test/exceptions/proxy.spec.js

@@ -0,0 +1,74 @@
+"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 adapter_helper_1 = require("@venok/http/helpers/adapter.helper");
+const execution_host_1 = require("../../../core/context/execution-host");
+const errors_1 = require("../../errors");
+const filter_1 = require("../../filters/filter");
+const context_1 = require("../../../core/context");
+const handler_1 = require("../../../core/exceptions/handler");
+describe("RouterProxy", () => {
+    let routerProxy;
+    let handler;
+    const httpException = new errors_1.HttpException("test", 500);
+    let nextStub;
+    beforeEach(() => {
+        handler = new handler_1.VenokExceptionsHandler(new filter_1.HttpExceptionFilter(new adapter_helper_1.NoopHttpAdapter({})));
+        nextStub = sinon_1.default.stub(handler, "next");
+        routerProxy = new context_1.VenokProxy();
+    });
+    describe("createProxy", () => {
+        it("should method return thunk", () => {
+            const proxy = routerProxy.createProxy(() => { }, handler);
+            (0, chai_1.expect)(typeof proxy === "function").to.be.true;
+        });
+        it("should method encapsulate callback passed as argument", () => {
+            const proxy = routerProxy.createProxy((req, res, next) => {
+                throw httpException;
+            }, handler);
+            proxy(null, null, null);
+            (0, chai_1.expect)(nextStub.calledOnce).to.be.true;
+            (0, chai_1.expect)(nextStub.calledWith(httpException, new execution_host_1.ExecutionContextHost([null, null, null]))).to.be.true;
+        });
+        it("should method encapsulate async callback passed as argument", (done) => {
+            const proxy = routerProxy.createProxy(async (req, res, next) => {
+                throw httpException;
+            }, handler);
+            proxy(null, null, null);
+            setTimeout(() => {
+                (0, chai_1.expect)(nextStub.calledOnce).to.be.true;
+                (0, chai_1.expect)(nextStub.calledWith(httpException, new execution_host_1.ExecutionContextHost([null, null, null]))).to.be.true;
+                done();
+            }, 0);
+        });
+    });
+    describe("createExceptionLayerProxy", () => {
+        it("should method return thunk", () => {
+            const proxy = routerProxy.createProxy(() => { }, handler);
+            (0, chai_1.expect)(typeof proxy === "function").to.be.true;
+        });
+        it("should method encapsulate callback passed as argument", () => {
+            const proxy = routerProxy.createExceptionLayerProxy((err, req, res, next) => {
+                throw httpException;
+            }, handler);
+            proxy(null, null, null, null);
+            (0, chai_1.expect)(nextStub.calledOnce).to.be.true;
+            (0, chai_1.expect)(nextStub.calledWith(httpException, new execution_host_1.ExecutionContextHost([null, null, null]))).to.be.true;
+        });
+        it("should method encapsulate async callback passed as argument", (done) => {
+            const proxy = routerProxy.createExceptionLayerProxy(async (err, req, res, next) => {
+                throw httpException;
+            }, handler);
+            proxy(null, null, null, null);
+            setTimeout(() => {
+                (0, chai_1.expect)(nextStub.calledOnce).to.be.true;
+                (0, chai_1.expect)(nextStub.calledWith(httpException, new execution_host_1.ExecutionContextHost([null, null, null]))).to.be.true;
+                done();
+            }, 0);
+        });
+    });
+});

package/test/explorers/path.explorer.spec.d.ts

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

package/test/explorers/path.explorer.spec.js

@@ -0,0 +1,190 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const decorators_1 = require("../../decorators");
+const path_explorer_1 = require("../../explorers/path.explorer");
+const core_1 = require("../../../core/index.ts");
+const enums_1 = require("../../enums");
+describe("PathExplorer", () => {
+    let TestRoute = class TestRoute {
+        getTest() { }
+        postTest() { }
+        anotherTest() { }
+        getTestUsingArray() { }
+    };
+    __decorate([
+        (0, decorators_1.Get)("test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRoute.prototype, "getTest", null);
+    __decorate([
+        (0, decorators_1.Post)("test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRoute.prototype, "postTest", null);
+    __decorate([
+        (0, decorators_1.All)("another-test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRoute.prototype, "anotherTest", null);
+    __decorate([
+        (0, decorators_1.Get)(["foo", "bar"]),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRoute.prototype, "getTestUsingArray", null);
+    TestRoute = __decorate([
+        (0, decorators_1.Controller)("global")
+    ], TestRoute);
+    let TestRouteAlias = class TestRouteAlias {
+        getTest() { }
+        postTest() { }
+        anotherTest() { }
+        getTestUsingArray() { }
+    };
+    __decorate([
+        (0, decorators_1.Get)("test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRouteAlias.prototype, "getTest", null);
+    __decorate([
+        (0, decorators_1.Post)("test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRouteAlias.prototype, "postTest", null);
+    __decorate([
+        (0, decorators_1.All)("another-test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRouteAlias.prototype, "anotherTest", null);
+    __decorate([
+        (0, decorators_1.Get)(["foo", "bar"]),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRouteAlias.prototype, "getTestUsingArray", null);
+    TestRouteAlias = __decorate([
+        (0, decorators_1.Controller)(["global", "global-alias"])
+    ], TestRouteAlias);
+    let pathsExplorer;
+    beforeEach(() => {
+        pathsExplorer = new path_explorer_1.PathsExplorer(new core_1.MetadataScanner());
+    });
+    describe("scanForPaths", () => {
+        it("should method return expected list of route paths", () => {
+            const paths = pathsExplorer.scanForPaths(new TestRoute());
+            (0, chai_1.expect)(paths).to.have.length(4);
+            (0, chai_1.expect)(paths[0].path).to.eql(["/test"]);
+            (0, chai_1.expect)(paths[1].path).to.eql(["/test"]);
+            (0, chai_1.expect)(paths[2].path).to.eql(["/another-test"]);
+            (0, chai_1.expect)(paths[3].path).to.eql(["/foo", "/bar"]);
+            (0, chai_1.expect)(paths[0].requestMethod).to.eql(enums_1.RequestMethod.GET);
+            (0, chai_1.expect)(paths[1].requestMethod).to.eql(enums_1.RequestMethod.POST);
+            (0, chai_1.expect)(paths[2].requestMethod).to.eql(enums_1.RequestMethod.ALL);
+            (0, chai_1.expect)(paths[3].requestMethod).to.eql(enums_1.RequestMethod.GET);
+        });
+        it("should method return expected list of route paths alias", () => {
+            const paths = pathsExplorer.scanForPaths(new TestRouteAlias());
+            (0, chai_1.expect)(paths).to.have.length(4);
+            (0, chai_1.expect)(paths[0].path).to.eql(["/test"]);
+            (0, chai_1.expect)(paths[1].path).to.eql(["/test"]);
+            (0, chai_1.expect)(paths[2].path).to.eql(["/another-test"]);
+            (0, chai_1.expect)(paths[3].path).to.eql(["/foo", "/bar"]);
+            (0, chai_1.expect)(paths[0].requestMethod).to.eql(enums_1.RequestMethod.GET);
+            (0, chai_1.expect)(paths[1].requestMethod).to.eql(enums_1.RequestMethod.POST);
+            (0, chai_1.expect)(paths[2].requestMethod).to.eql(enums_1.RequestMethod.ALL);
+            (0, chai_1.expect)(paths[3].requestMethod).to.eql(enums_1.RequestMethod.GET);
+        });
+    });
+    describe("exploreMethodMetadata", () => {
+        it("should method return expected object which represent single route", () => {
+            const instance = new TestRoute();
+            const instanceProto = Object.getPrototypeOf(instance);
+            const route = pathsExplorer.exploreMethodMetadata(instance, instanceProto, "getTest");
+            (0, chai_1.expect)(route.path).to.eql(["/test"]);
+            (0, chai_1.expect)(route.requestMethod).to.eql(enums_1.RequestMethod.GET);
+            (0, chai_1.expect)(route.targetCallback).to.eq(instance.getTest);
+        });
+        it("should method return expected object which represent single route with alias", () => {
+            const instance = new TestRouteAlias();
+            const instanceProto = Object.getPrototypeOf(instance);
+            const route = pathsExplorer.exploreMethodMetadata(instance, instanceProto, "getTest");
+            (0, chai_1.expect)(route.path).to.eql(["/test"]);
+            (0, chai_1.expect)(route.requestMethod).to.eql(enums_1.RequestMethod.GET);
+            (0, chai_1.expect)(route.targetCallback).to.eq(instance.getTest);
+        });
+        it("should method return expected object which represent multiple routes", () => {
+            const instance = new TestRoute();
+            const instanceProto = Object.getPrototypeOf(instance);
+            const route = pathsExplorer.exploreMethodMetadata(instance, instanceProto, "getTestUsingArray");
+            (0, chai_1.expect)(route.path).to.eql(["/foo", "/bar"]);
+            (0, chai_1.expect)(route.requestMethod).to.eql(enums_1.RequestMethod.GET);
+            (0, chai_1.expect)(route.targetCallback).to.eq(instance.getTestUsingArray);
+        });
+        it("should method return expected object which represent multiple routes with alias", () => {
+            const instance = new TestRouteAlias();
+            const instanceProto = Object.getPrototypeOf(instance);
+            const route = pathsExplorer.exploreMethodMetadata(instance, instanceProto, "getTestUsingArray");
+            (0, chai_1.expect)(route.path).to.eql(["/foo", "/bar"]);
+            (0, chai_1.expect)(route.requestMethod).to.eql(enums_1.RequestMethod.GET);
+            (0, chai_1.expect)(route.targetCallback).to.eq(instance.getTestUsingArray);
+        });
+        describe("when new implementation is injected into router", () => {
+            it("should method return changed impl of single route", () => {
+                const instance = new TestRoute();
+                const instanceProto = Object.getPrototypeOf(instance);
+                const newImpl = function () { };
+                instance.getTest = newImpl;
+                const route = pathsExplorer.exploreMethodMetadata(instance, instanceProto, "getTest");
+                (0, chai_1.expect)(route.targetCallback).to.eq(newImpl);
+                (0, chai_1.expect)(route.path).to.eql(["/test"]);
+                (0, chai_1.expect)(route.requestMethod).to.eql(enums_1.RequestMethod.GET);
+            });
+            it("should method return changed impl of single route which alias applied", () => {
+                const instance = new TestRouteAlias();
+                const instanceProto = Object.getPrototypeOf(instance);
+                const newImpl = function () { };
+                instance.getTest = newImpl;
+                const route = pathsExplorer.exploreMethodMetadata(instance, instanceProto, "getTest");
+                (0, chai_1.expect)(route.targetCallback).to.eq(newImpl);
+                (0, chai_1.expect)(route.path).to.eql(["/test"]);
+                (0, chai_1.expect)(route.requestMethod).to.eql(enums_1.RequestMethod.GET);
+            });
+            it("should method return changed impl of multiple routes", () => {
+                const instance = new TestRoute();
+                const instanceProto = Object.getPrototypeOf(instance);
+                const newImpl = function () { };
+                instance.getTestUsingArray = newImpl;
+                const route = pathsExplorer.exploreMethodMetadata(instance, instanceProto, "getTestUsingArray");
+                (0, chai_1.expect)(route.targetCallback).to.eq(newImpl);
+                (0, chai_1.expect)(route.path).to.eql(["/foo", "/bar"]);
+                (0, chai_1.expect)(route.requestMethod).to.eql(enums_1.RequestMethod.GET);
+            });
+            it("should method return changed impl of multiple routes which alias applied", () => {
+                const instance = new TestRouteAlias();
+                const instanceProto = Object.getPrototypeOf(instance);
+                const newImpl = function () { };
+                instance.getTestUsingArray = newImpl;
+                const route = pathsExplorer.exploreMethodMetadata(instance, instanceProto, "getTestUsingArray");
+                (0, chai_1.expect)(route.targetCallback).to.eq(newImpl);
+                (0, chai_1.expect)(route.path).to.eql(["/foo", "/bar"]);
+                (0, chai_1.expect)(route.requestMethod).to.eql(enums_1.RequestMethod.GET);
+            });
+        });
+    });
+});

package/test/explorers/router.explorer.spec.d.ts

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

package/test/explorers/router.explorer.spec.js

@@ -0,0 +1,206 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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 decorators_1 = require("../../decorators");
+const router_explorer_1 = require("../../explorers/router.explorer");
+const injector_1 = require("../../../core/injector/injector");
+const context_1 = require("../../filters/context");
+const core_1 = require("../../../core/index.ts");
+const factory_1 = require("../../factory");
+const graph_inspector_1 = require("../../../core/inspector/graph-inspector");
+const config_1 = require("../../application/config");
+const enums_1 = require("../../enums");
+const wrapper_1 = require("../../../core/injector/instance/wrapper");
+const execution_host_1 = require("../../../core/context/execution-host");
+const helpers_1 = require("../../helpers");
+describe("RouterExplorer", () => {
+    let TestRoute = class TestRoute {
+        getTest() { }
+        postTest() { }
+        anotherTest() { }
+        getTestUsingArray() { }
+    };
+    __decorate([
+        (0, decorators_1.Get)("test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRoute.prototype, "getTest", null);
+    __decorate([
+        (0, decorators_1.Post)("test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRoute.prototype, "postTest", null);
+    __decorate([
+        (0, decorators_1.All)("another-test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRoute.prototype, "anotherTest", null);
+    __decorate([
+        (0, decorators_1.Get)(["foo", "bar"]),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRoute.prototype, "getTestUsingArray", null);
+    TestRoute = __decorate([
+        (0, decorators_1.Controller)("global")
+    ], TestRoute);
+    let TestRouteAlias = class TestRouteAlias {
+        getTest() { }
+        postTest() { }
+        anotherTest() { }
+        getTestUsingArray() { }
+    };
+    __decorate([
+        (0, decorators_1.Get)("test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRouteAlias.prototype, "getTest", null);
+    __decorate([
+        (0, decorators_1.Post)("test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRouteAlias.prototype, "postTest", null);
+    __decorate([
+        (0, decorators_1.All)("another-test"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRouteAlias.prototype, "anotherTest", null);
+    __decorate([
+        (0, decorators_1.Get)(["foo", "bar"]),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], TestRouteAlias.prototype, "getTestUsingArray", null);
+    TestRouteAlias = __decorate([
+        (0, decorators_1.Controller)(["global", "global-alias"])
+    ], TestRouteAlias);
+    class ClassWithMissingControllerDecorator {
+    }
+    let routerBuilder;
+    let injector;
+    let exceptionsFilter;
+    let applicationConfig;
+    let httpConfig;
+    let routePathFactory;
+    let graphInspector;
+    beforeEach(() => {
+        const container = new core_1.VenokContainer();
+        httpConfig = new config_1.HttpConfig();
+        applicationConfig = new core_1.ApplicationConfig();
+        injector = new injector_1.Injector();
+        routePathFactory = new factory_1.RoutePathFactory(httpConfig);
+        graphInspector = new graph_inspector_1.GraphInspector(container);
+        exceptionsFilter = new context_1.RouterExceptionFiltersContext(container, applicationConfig, null);
+        routerBuilder = new router_explorer_1.RouterExplorer(new core_1.MetadataScanner(), container, injector, null, exceptionsFilter, applicationConfig, routePathFactory, graphInspector, httpConfig.getHttpAdapterRef());
+    });
+    describe("applyPathsToRouterProxy", () => {
+        it("should method return expected object which represent single route", () => {
+            const bindStub = sinon_1.default.stub(routerBuilder, "applyCallbackToRouter");
+            const paths = [
+                { path: [""], requestMethod: enums_1.RequestMethod.GET },
+                { path: ["test"], requestMethod: enums_1.RequestMethod.GET },
+                { path: ["foo", "bar"], requestMethod: enums_1.RequestMethod.GET },
+            ];
+            routerBuilder.applyPathsToRouterProxy(null, paths, null, "", {}, "");
+            (0, chai_1.expect)(bindStub.calledWith(null, paths[0], null)).to.be.true;
+            (0, chai_1.expect)(bindStub.callCount).to.be.eql(paths.length);
+        });
+        it("should method return expected object which represents a single versioned route", () => {
+            const bindStub = sinon_1.default.stub(routerBuilder, "applyCallbackToRouter");
+            const paths = [
+                { path: [""], requestMethod: enums_1.RequestMethod.GET },
+                { path: ["test"], requestMethod: enums_1.RequestMethod.GET },
+                { path: ["foo", "bar"], requestMethod: enums_1.RequestMethod.GET },
+            ];
+            const routePathMetadata = {
+                versioningOptions: { type: enums_1.VersioningType.URI },
+            };
+            routerBuilder.applyPathsToRouterProxy(null, paths, null, "", routePathMetadata, "1");
+            (0, chai_1.expect)(bindStub.calledWith(null, paths[0], null, "", routePathMetadata, "1")).to.be.true;
+            (0, chai_1.expect)(bindStub.callCount).to.be.eql(paths.length);
+        });
+    });
+    describe("extractRouterPath", () => {
+        it("should return expected path", () => {
+            (0, chai_1.expect)(routerBuilder.extractRouterPath(TestRoute)).to.be.eql(["/global"]);
+        });
+        it("should return expected path with alias", () => {
+            (0, chai_1.expect)(routerBuilder.extractRouterPath(TestRouteAlias)).to.be.eql(["/global", "/global-alias"]);
+        });
+        it("should return [] when missing the `@Controller()` decorator in the class, displaying class's name", () => {
+            (0, chai_1.expect)(routerBuilder.extractRouterPath(ClassWithMissingControllerDecorator)).to.be.eql([]);
+        });
+    });
+    describe("createRequestScopedHandler", () => {
+        let nextSpy;
+        beforeEach(() => {
+            sinon_1.default.stub(injector, "loadPerContext").callsFake(() => {
+                throw new Error();
+            });
+            nextSpy = sinon_1.default.spy();
+            sinon_1.default.stub(exceptionsFilter, "create").callsFake(() => ({
+                next: nextSpy,
+            }));
+        });
+        describe('when "loadPerContext" throws', () => {
+            const moduleKey = "moduleKey";
+            const methodKey = "methodKey";
+            const module = {
+                controllers: new Map(),
+            };
+            const wrapper = new wrapper_1.InstanceWrapper({
+                instance: { [methodKey]: {} },
+            });
+            it("should delegate error to exception filters", async () => {
+                const handler = routerBuilder.createRequestScopedHandler(wrapper, enums_1.RequestMethod.ALL, module, moduleKey, methodKey);
+                await handler(null, null, null);
+                (0, chai_1.expect)(nextSpy.called).to.be.true;
+                (0, chai_1.expect)(nextSpy.getCall(0).args[0]).to.be.instanceOf(Error);
+                (0, chai_1.expect)(nextSpy.getCall(0).args[1]).to.be.instanceOf(execution_host_1.ExecutionContextHost);
+            });
+        });
+    });
+    describe("applyVersionFilter", () => {
+        it("should call and return the `applyVersionFilter` from the underlying http server", () => {
+            const router = sinon_1.default.spy(new helpers_1.NoopHttpAdapter({}));
+            const routePathMetadata = {
+                methodVersion: sinon_1.default.fake(),
+                versioningOptions: sinon_1.default.fake(),
+            };
+            const handler = sinon_1.default.stub();
+            // We're using type assertion here because `applyVersionFilter` is private
+            const versionFilter = routerBuilder.applyVersionFilter(router, routePathMetadata, handler);
+            (0, chai_1.expect)(router.applyVersionFilter.calledOnceWithExactly(handler, routePathMetadata.methodVersion, routePathMetadata.versioningOptions)).to.be.true;
+            (0, chai_1.expect)(router.applyVersionFilter.returnValues[0]).to.be.equal(versionFilter);
+        });
+    });
+    describe("copyMetadataToCallback", () => {
+        it("should then copy the metadata from the original callback to the target callback", () => {
+            const originalCallback = () => { };
+            Reflect.defineMetadata("test_metadata_key", "test_metadata_value", originalCallback);
+            const targetCallback = () => { };
+            // We're using type assertion here because `copyMetadataToCallback` is private
+            routerBuilder.copyMetadataToCallback(originalCallback, targetCallback);
+            (0, chai_1.expect)(Reflect.getMetadata("test_metadata_key", targetCallback)).to.be.equal("test_metadata_value");
+        });
+    });
+});

package/test/factory/method.factory.spec.d.ts

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

package/test/factory/method.factory.spec.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const factory_1 = require("../../factory");
+const enums_1 = require("../../enums");
+describe("RouterMethodFactory", () => {
+    let factory;
+    const target = {
+        get: () => { },
+        post: () => { },
+        use: () => { },
+        delete: () => { },
+        put: () => { },
+        patch: () => { },
+        options: () => { },
+        head: () => { },
+        all: () => { },
+    };
+    beforeEach(() => {
+        factory = new factory_1.RouterMethodFactory();
+    });
+    it("should return proper method", () => {
+        (0, chai_1.expect)(factory.get(target, enums_1.RequestMethod.DELETE)).to.equal(target.delete);
+        (0, chai_1.expect)(factory.get(target, enums_1.RequestMethod.POST)).to.equal(target.post);
+        (0, chai_1.expect)(factory.get(target, enums_1.RequestMethod.ALL)).to.equal(target.all);
+        (0, chai_1.expect)(factory.get(target, enums_1.RequestMethod.PUT)).to.equal(target.put);
+        (0, chai_1.expect)(factory.get(target, enums_1.RequestMethod.GET)).to.equal(target.get);
+        (0, chai_1.expect)(factory.get(target, enums_1.RequestMethod.PATCH)).to.equal(target.patch);
+        (0, chai_1.expect)(factory.get(target, enums_1.RequestMethod.OPTIONS)).to.equal(target.options);
+        (0, chai_1.expect)(factory.get(target, enums_1.RequestMethod.HEAD)).to.equal(target.head);
+        (0, chai_1.expect)(factory.get(target, -1)).to.equal(target.use);
+    });
+});