@venok/http 1.0.1-canary.0

package/test/context/response.controller.spec.js

@@ -0,0 +1,328 @@
+"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 rxjs_1 = require("rxjs");
+const sinon_1 = __importDefault(require("sinon"));
+const stream_1 = require("../../../../../../../stream");
+const response_controller_1 = require("@venok/http/context/response.controller");
+const adapter_helper_1 = require("@venok/http/helpers/adapter.helper");
+const shared_helper_1 = require("../../../core/helpers/shared.helper");
+const enums_1 = require("@venok/http/enums");
+describe("RouterResponseController", () => {
+    let adapter;
+    let routerResponseController;
+    beforeEach(() => {
+        adapter = new adapter_helper_1.NoopHttpAdapter({});
+        routerResponseController = new response_controller_1.RouterResponseController(adapter);
+    });
+    describe("apply", () => {
+        let response;
+        beforeEach(() => {
+            response = { send: sinon_1.default.spy(), json: sinon_1.default.spy(), status: sinon_1.default.spy() };
+        });
+        describe("when result is", () => {
+            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));
+                });
+            });
+            describe("nil", () => {
+                it("should call send()", async () => {
+                    const value = null;
+                    await routerResponseController.apply(value, response, 200);
+                    (0, chai_1.expect)(response.send.called).to.be.true;
+                });
+            });
+            describe("string", () => {
+                it("should call send(value)", async () => {
+                    const value = "string";
+                    await routerResponseController.apply(value, response, 200);
+                    (0, chai_1.expect)(response.send.called).to.be.true;
+                    (0, chai_1.expect)(response.send.calledWith(String(value))).to.be.true;
+                });
+            });
+            describe("object", () => {
+                it("should call json(value)", async () => {
+                    const value = { test: "test" };
+                    await routerResponseController.apply(value, response, 200);
+                    (0, chai_1.expect)(response.json.called).to.be.true;
+                    (0, chai_1.expect)(response.json.calledWith(value)).to.be.true;
+                });
+            });
+        });
+    });
+    describe("transformToResult", () => {
+        describe("when resultOrDeferred", () => {
+            describe("is Promise", () => {
+                it("should return Promise that resolves to the value resolved by the input Promise", async () => {
+                    const value = 100;
+                    (0, chai_1.expect)(await routerResponseController.transformToResult(Promise.resolve(value))).to.be.eq(value);
+                });
+            });
+            describe("is Observable", () => {
+                it("should return toPromise", async () => {
+                    const lastValue = 100;
+                    (0, chai_1.expect)(await routerResponseController.transformToResult((0, rxjs_1.of)(1, 2, 3, lastValue))).to.be.eq(lastValue);
+                });
+            });
+            describe("is an object that has the method `subscribe`", () => {
+                it("should return a Promise that resolves to the input value", async () => {
+                    const value = { subscribe() { } };
+                    (0, chai_1.expect)(await routerResponseController.transformToResult(value)).to.equal(value);
+                });
+            });
+            describe("is an ordinary value", () => {
+                it("should return a Promise that resolves to the input value", async () => {
+                    const value = 100;
+                    (0, chai_1.expect)(await routerResponseController.transformToResult(value)).to.be.eq(value);
+                });
+            });
+        });
+    });
+    describe("getStatusByMethod", () => {
+        describe("when RequestMethod is POST", () => {
+            it("should return 201", () => {
+                (0, chai_1.expect)(routerResponseController.getStatusByMethod(enums_1.RequestMethod.POST)).to.be.eql(201);
+            });
+        });
+        describe("when RequestMethod is not POST", () => {
+            it("should return 200", () => {
+                (0, chai_1.expect)(routerResponseController.getStatusByMethod(enums_1.RequestMethod.GET)).to.be.eql(200);
+            });
+        });
+    });
+    describe("render", () => {
+        beforeEach(() => {
+            sinon_1.default.stub(adapter, "render").callsFake((response, view, options) => {
+                return response.render(view, options);
+            });
+        });
+        it('should call "res.render()" with expected args', async () => {
+            const template = "template";
+            const value = "test";
+            const result = Promise.resolve(value);
+            const response = { render: sinon_1.default.spy() };
+            await routerResponseController.render(result, response, template);
+            (0, chai_1.expect)(response.render.calledWith(template, value)).to.be.true;
+        });
+    });
+    describe("setHeaders", () => {
+        let setHeaderStub;
+        beforeEach(() => {
+            setHeaderStub = sinon_1.default.stub(adapter, "setHeader").callsFake(() => ({}));
+        });
+        it("should set all custom headers", () => {
+            const response = {};
+            const headers = [{ name: "test", value: "test_value" }];
+            routerResponseController.setHeaders(response, headers);
+            (0, chai_1.expect)(setHeaderStub.calledWith(response, headers[0].name, headers[0].value)).to.be.true;
+        });
+    });
+    describe("status", () => {
+        let statusStub;
+        beforeEach(() => {
+            statusStub = sinon_1.default.stub(adapter, "status").callsFake(() => ({}));
+        });
+        it("should set status", () => {
+            const response = {};
+            const statusCode = 400;
+            routerResponseController.setStatus(response, statusCode);
+            (0, chai_1.expect)(statusStub.calledWith(response, statusCode)).to.be.true;
+        });
+    });
+    describe("redirect should HttpServer.redirect", () => {
+        it("should transformToResult", async () => {
+            const transformToResultSpy = sinon_1.default
+                .stub(routerResponseController, "transformToResult")
+                .returns(Promise.resolve({ statusCode: 123, url: "redirect url" }));
+            const result = {};
+            await routerResponseController.redirect(result, null, null);
+            (0, chai_1.expect)(transformToResultSpy.firstCall.args[0]).to.be.equal(result);
+        });
+        it("should pass the response to redirect", async () => {
+            sinon_1.default
+                .stub(routerResponseController, "transformToResult")
+                .returns(Promise.resolve({ statusCode: 123, url: "redirect url" }));
+            const redirectSpy = sinon_1.default.spy(adapter, "redirect");
+            const response = {};
+            await routerResponseController.redirect(null, response, null);
+            (0, chai_1.expect)(redirectSpy.firstCall.args[0]).to.be.equal(response);
+        });
+        describe("status code", () => {
+            it("should come from the transformed result if present", async () => {
+                sinon_1.default
+                    .stub(routerResponseController, "transformToResult")
+                    .returns(Promise.resolve({ statusCode: 123, url: "redirect url" }));
+                const redirectSpy = sinon_1.default.spy(adapter, "redirect");
+                await routerResponseController.redirect(null, null, {
+                    statusCode: 999,
+                    url: "not form here",
+                });
+                (0, chai_1.expect)(redirectSpy.firstCall.args[1]).to.be.eql(123);
+            });
+            it("should come from the redirectResponse if not on the transformed result", async () => {
+                sinon_1.default.stub(routerResponseController, "transformToResult").returns(Promise.resolve({}));
+                const redirectSpy = sinon_1.default.spy(adapter, "redirect");
+                await routerResponseController.redirect(null, null, {
+                    statusCode: 123,
+                    url: "redirect url",
+                });
+                (0, chai_1.expect)(redirectSpy.firstCall.args[1]).to.be.eql(123);
+            });
+            it("should default to HttpStatus.FOUND", async () => {
+                sinon_1.default.stub(routerResponseController, "transformToResult").returns(Promise.resolve({}));
+                const redirectSpy = sinon_1.default.spy(adapter, "redirect");
+                await routerResponseController.redirect(null, null, {
+                    url: "redirect url",
+                });
+                (0, chai_1.expect)(redirectSpy.firstCall.args[1]).to.be.eql(enums_1.HttpStatus.FOUND);
+            });
+        });
+        describe("url", () => {
+            it("should come from the transformed result if present", async () => {
+                sinon_1.default
+                    .stub(routerResponseController, "transformToResult")
+                    .returns(Promise.resolve({ statusCode: 123, url: "redirect url" }));
+                const redirectSpy = sinon_1.default.spy(adapter, "redirect");
+                await routerResponseController.redirect(null, null, {
+                    url: "not from here",
+                });
+                (0, chai_1.expect)(redirectSpy.firstCall.args[2]).to.be.eql("redirect url");
+            });
+            it("should come from the redirectResponse if not on the transformed result", async () => {
+                sinon_1.default.stub(routerResponseController, "transformToResult").returns(Promise.resolve({}));
+                const redirectSpy = sinon_1.default.spy(adapter, "redirect");
+                await routerResponseController.redirect(null, null, {
+                    statusCode: 123,
+                    url: "redirect url",
+                });
+                (0, chai_1.expect)(redirectSpy.firstCall.args[2]).to.be.eql("redirect url");
+            });
+        });
+    });
+    describe("Server-Sent-Events", () => {
+        it("should accept only observables", async () => {
+            const result = Promise.resolve("test");
+            try {
+                await routerResponseController.sse(result, {}, {});
+            }
+            catch (e) {
+                (0, chai_1.expect)(e.message).to.eql("You must return an Observable stream to use Server-Sent Events (SSE).");
+            }
+        });
+        it("should write string", async () => {
+            class Sink extends stream_1.Writable {
+                constructor() {
+                    super(...arguments);
+                    this.chunks = [];
+                }
+                _write(chunk, encoding, callback) {
+                    this.chunks.push(chunk);
+                    callback();
+                }
+                get content() {
+                    return this.chunks.join("");
+                }
+            }
+            const written = (stream) => new Promise((resolve, reject) => stream.on("error", reject).on("finish", resolve));
+            const result = (0, rxjs_1.of)("test");
+            const response = new Sink();
+            const request = new stream_1.PassThrough();
+            routerResponseController.sse(result, response, request);
+            request.destroy();
+            await written(response);
+            (0, chai_1.expect)(response.content).to.eql(`
+id: 1
+data: test
+
+`);
+        });
+        it("should close on request close", (done) => {
+            const result = (0, rxjs_1.of)("test");
+            const response = new stream_1.Writable();
+            response.end = () => done();
+            response._write = () => { };
+            const request = new stream_1.Writable();
+            request._write = () => { };
+            routerResponseController.sse(result, response, request);
+            request.emit("close");
+        });
+        it("should close the request when observable completes", (done) => {
+            const result = (0, rxjs_1.of)("test");
+            const response = new stream_1.Writable();
+            response.end = done;
+            response._write = () => { };
+            const request = new stream_1.Writable();
+            request._write = () => { };
+            routerResponseController.sse(result, response, request);
+        });
+        it("should allow to intercept the response", (done) => {
+            const result = sinon_1.default.spy();
+            const response = new stream_1.Writable();
+            response.end();
+            response._write = () => { };
+            const request = new stream_1.Writable();
+            request._write = () => { };
+            try {
+                routerResponseController.sse(result, response, request);
+            }
+            catch {
+                // Whether an error is thrown or not
+                // is not relevant, so long as
+                // result is not called
+            }
+            sinon_1.default.assert.notCalled(result);
+            done();
+        });
+        describe("when there is an error", () => {
+            it("should close the request", (done) => {
+                const result = new rxjs_1.Subject();
+                const response = new stream_1.Writable();
+                response.end = done;
+                response._write = () => { };
+                const request = new stream_1.Writable();
+                request._write = () => { };
+                routerResponseController.sse(result, response, request);
+                result.error(new Error("Some error"));
+            });
+            it("should write the error message to the stream", async () => {
+                class Sink extends stream_1.Writable {
+                    constructor() {
+                        super(...arguments);
+                        this.chunks = [];
+                    }
+                    _write(chunk, encoding, callback) {
+                        this.chunks.push(chunk);
+                        callback();
+                    }
+                    get content() {
+                        return this.chunks.join("");
+                    }
+                }
+                const written = (stream) => new Promise((resolve, reject) => stream.on("error", reject).on("finish", resolve));
+                const result = new rxjs_1.Subject();
+                const response = new Sink();
+                const request = new stream_1.PassThrough();
+                routerResponseController.sse(result, response, request);
+                result.error(new Error("Some error"));
+                request.destroy();
+                await written(response);
+                (0, chai_1.expect)(response.content).to.eql(`
+event: error
+id: 1
+data: Some error
+
+`);
+            });
+        });
+    });
+});

package/test/decorators/controller.decorator.spec.d.ts

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

package/test/decorators/controller.decorator.spec.js

@@ -0,0 +1,113 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const decorators_1 = require("@venok/http/decorators");
+const constants_1 = require("@venok/http/constants");
+describe("@Controller", () => {
+    const reflectedPath = "test";
+    const reflectedHost = "api.example.com";
+    const reflectedHostArray = ["api1.example.com", "api2.example.com"];
+    const reflectedVersion = "1";
+    const reflectedVersionWithDuplicates = ["1", "2", "2", "1", "2", "1"];
+    const reflectedVersionWithoutDuplicates = ["1", "2"];
+    let EmptyDecorator = class EmptyDecorator {
+    };
+    EmptyDecorator = __decorate([
+        (0, decorators_1.Controller)()
+    ], EmptyDecorator);
+    let Test = class Test {
+    };
+    Test = __decorate([
+        (0, decorators_1.Controller)(reflectedPath)
+    ], Test);
+    let PathAndHostDecorator = class PathAndHostDecorator {
+    };
+    PathAndHostDecorator = __decorate([
+        (0, decorators_1.Controller)({ path: reflectedPath, host: reflectedHost })
+    ], PathAndHostDecorator);
+    let PathAndHostArrayDecorator = class PathAndHostArrayDecorator {
+    };
+    PathAndHostArrayDecorator = __decorate([
+        (0, decorators_1.Controller)({ path: reflectedPath, host: reflectedHostArray })
+    ], PathAndHostArrayDecorator);
+    let HostOnlyDecorator = class HostOnlyDecorator {
+    };
+    HostOnlyDecorator = __decorate([
+        (0, decorators_1.Controller)({ host: reflectedHost })
+    ], HostOnlyDecorator);
+    let PathAndHostAndVersionDecorator = class PathAndHostAndVersionDecorator {
+    };
+    PathAndHostAndVersionDecorator = __decorate([
+        (0, decorators_1.Controller)({
+            path: reflectedPath,
+            host: reflectedHost,
+            version: reflectedVersion,
+        })
+    ], PathAndHostAndVersionDecorator);
+    let VersionOnlyDecorator = class VersionOnlyDecorator {
+    };
+    VersionOnlyDecorator = __decorate([
+        (0, decorators_1.Controller)({ version: reflectedVersion })
+    ], VersionOnlyDecorator);
+    let VersionOnlyArrayDecorator = class VersionOnlyArrayDecorator {
+    };
+    VersionOnlyArrayDecorator = __decorate([
+        (0, decorators_1.Controller)({ version: reflectedVersionWithDuplicates })
+    ], VersionOnlyArrayDecorator);
+    it(`should enhance component with "${constants_1.CONTROLLER_WATERMARK}" metadata`, () => {
+        const controllerWatermark = Reflect.getMetadata(constants_1.CONTROLLER_WATERMARK, EmptyDecorator);
+        (0, chai_1.expect)(controllerWatermark).to.be.true;
+    });
+    it("should enhance controller with expected path metadata", () => {
+        const path = Reflect.getMetadata("path", Test);
+        (0, chai_1.expect)(path).to.be.eql(reflectedPath);
+        const path2 = Reflect.getMetadata("path", PathAndHostDecorator);
+        (0, chai_1.expect)(path2).to.be.eql(reflectedPath);
+        const path3 = Reflect.getMetadata("path", PathAndHostAndVersionDecorator);
+        (0, chai_1.expect)(path3).to.be.eql(reflectedPath);
+    });
+    it("should enhance controller with expected host metadata", () => {
+        const host = Reflect.getMetadata("host", PathAndHostDecorator);
+        (0, chai_1.expect)(host).to.be.eql(reflectedHost);
+        const host2 = Reflect.getMetadata("host", HostOnlyDecorator);
+        (0, chai_1.expect)(host2).to.be.eql(reflectedHost);
+        const host3 = Reflect.getMetadata("host", PathAndHostArrayDecorator);
+        (0, chai_1.expect)(host3).to.be.eql(reflectedHostArray);
+        const host4 = Reflect.getMetadata("host", PathAndHostAndVersionDecorator);
+        (0, chai_1.expect)(host4).to.be.eql(reflectedHost);
+    });
+    it("should enhance controller with expected version metadata", () => {
+        const version = Reflect.getMetadata(constants_1.VERSION_METADATA, PathAndHostAndVersionDecorator);
+        (0, chai_1.expect)(version).to.be.eql(reflectedVersion);
+        const version2 = Reflect.getMetadata(constants_1.VERSION_METADATA, VersionOnlyDecorator);
+        (0, chai_1.expect)(version2).to.be.eql(reflectedVersion);
+        const version3 = Reflect.getMetadata(constants_1.VERSION_METADATA, VersionOnlyArrayDecorator);
+        (0, chai_1.expect)(version3).to.be.eql(reflectedVersionWithoutDuplicates);
+    });
+    it("should set default path when no object passed as param", () => {
+        const path = Reflect.getMetadata("path", EmptyDecorator);
+        (0, chai_1.expect)(path).to.be.eql("/");
+        const path2 = Reflect.getMetadata("path", HostOnlyDecorator);
+        (0, chai_1.expect)(path2).to.be.eql("/");
+        const path3 = Reflect.getMetadata("path", VersionOnlyDecorator);
+        (0, chai_1.expect)(path3).to.be.eql("/");
+    });
+    it("should not set host when no host passed as param", () => {
+        const host = Reflect.getMetadata("host", Test);
+        (0, chai_1.expect)(host).to.be.undefined;
+        const host2 = Reflect.getMetadata("host", EmptyDecorator);
+        (0, chai_1.expect)(host2).to.be.undefined;
+    });
+    it("should not set version when no version passed as param", () => {
+        const version = Reflect.getMetadata(constants_1.VERSION_METADATA, Test);
+        (0, chai_1.expect)(version).to.be.undefined;
+        const version2 = Reflect.getMetadata(constants_1.VERSION_METADATA, EmptyDecorator);
+        (0, chai_1.expect)(version2).to.be.undefined;
+    });
+});

package/test/decorators/header.decorator.spec.d.ts

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

package/test/decorators/header.decorator.spec.js

@@ -0,0 +1,33 @@
+"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("@venok/http/decorators");
+const constants_1 = require("@venok/http/constants");
+describe("@Header", () => {
+    class Test {
+        static test() { }
+    }
+    __decorate([
+        (0, decorators_1.Header)("Content-Type", "Test"),
+        (0, decorators_1.Header)("Authorization", "JWT"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Test, "test", null);
+    it("should enhance method with expected template string", () => {
+        const metadata = Reflect.getMetadata(constants_1.HEADERS_METADATA, Test.test);
+        (0, chai_1.expect)(metadata).to.be.eql([
+            { name: "Authorization", value: "JWT" },
+            { name: "Content-Type", value: "Test" },
+        ]);
+    });
+});

package/test/decorators/http-code.decorator.spec.d.ts

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

package/test/decorators/http-code.decorator.spec.js

@@ -0,0 +1,30 @@
+"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("@venok/http/decorators");
+const constants_1 = require("@venok/http/constants");
+describe("@HttpCode", () => {
+    const httpCode = 200;
+    class Test {
+        static test() { }
+    }
+    __decorate([
+        (0, decorators_1.HttpCode)(httpCode),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Test, "test", null);
+    it("should enhance method with expected http status code", () => {
+        const metadata = Reflect.getMetadata(constants_1.HTTP_CODE_METADATA, Test.test);
+        (0, chai_1.expect)(metadata).to.be.eql(httpCode);
+    });
+});

package/test/decorators/redirect.decorator.spec.d.ts

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

package/test/decorators/redirect.decorator.spec.js

@@ -0,0 +1,36 @@
+"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 enums_1 = require("@venok/http/enums");
+const decorators_1 = require("@venok/http/decorators");
+const constants_1 = require("@venok/http/constants");
+describe("@Redirect", () => {
+    const url = "https://test.com";
+    const statusCode = enums_1.HttpStatus.FOUND;
+    class Test {
+        static test() { }
+    }
+    __decorate([
+        (0, decorators_1.Redirect)(url, statusCode),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Test, "test", null);
+    it("should enhance method with expected redirect url string", () => {
+        const metadata = Reflect.getMetadata(constants_1.REDIRECT_METADATA, Test.test);
+        (0, chai_1.expect)(metadata.url).to.be.eql(url);
+    });
+    it("should enhance method with expected response code", () => {
+        const metadata = Reflect.getMetadata(constants_1.REDIRECT_METADATA, Test.test);
+        (0, chai_1.expect)(metadata.statusCode).to.be.eql(statusCode);
+    });
+});

package/test/decorators/render.decorator.spec.d.ts

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

package/test/decorators/render.decorator.spec.js

@@ -0,0 +1,30 @@
+"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("@venok/http/decorators");
+const constants_1 = require("@venok/http/constants");
+describe("@Render", () => {
+    const template = "template";
+    class Test {
+        static test() { }
+    }
+    __decorate([
+        (0, decorators_1.Render)("template"),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Test, "test", null);
+    it("should enhance method with expected template string", () => {
+        const metadata = Reflect.getMetadata(constants_1.RENDER_METADATA, Test.test);
+        (0, chai_1.expect)(metadata).to.be.eql(template);
+    });
+});

package/test/decorators/request-mapping.decorator.spec.d.ts

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