@tsed/platform-test-sdk/lib/esm/tests/testHeaderParams.js

Package to test platform adapter integration with Ts.ED

import { __decorate, __metadata, __param } from "tslib";
import { Controller } from "@tsed/di";
import { Req } from "@tsed/platform-http";
import { PlatformTest } from "@tsed/platform-http/testing";
import { Middleware, Use } from "@tsed/platform-middlewares";
import { Context, HeaderParams, Locals } from "@tsed/platform-params";
import { Enum, Get, Post, Required } from "@tsed/schema";
import SuperTest from "supertest";
import { afterAll, beforeAll, describe, expect, it } from "vitest";
let SetId = class SetId {
    use(request, locals, $ctx) {
        request["user"] = 1;
        locals.id = "local-10909";
        $ctx.set("uid", "ctx-10909");
    }
};
__decorate([
    __param(0, Req()),
    __param(1, Locals()),
    __param(2, Context()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object, Object, Object]),
    __metadata("design:returntype", void 0)
], SetId.prototype, "use", null);
SetId = __decorate([
    Middleware()
], SetId);
let HeaderParamsCtrl = class HeaderParamsCtrl {
    /**
     * Handle request with a raw middleware + handler
     * Get Authorization from header
     * @param request
     * @param auth
     */
    scenario1(request, auth) {
        return {
            user: request.user,
            token: auth
        };
    }
    scenario2(contentType) {
        return { contentType };
    }
    testScenario3(token) {
        return { token };
    }
};
__decorate([
    Get("/scenario-1"),
    Use(SetId),
    __param(0, Req()),
    __param(1, HeaderParams("authorization")),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object, String]),
    __metadata("design:returntype", Object)
], HeaderParamsCtrl.prototype, "scenario1", null);
__decorate([
    Post("/scenario-2"),
    __param(0, HeaderParams("Content-type")),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [String]),
    __metadata("design:returntype", void 0)
], HeaderParamsCtrl.prototype, "scenario2", null);
__decorate([
    Get("/scenario-3"),
    __param(0, HeaderParams({
        expression: "x-token",
        useValidation: true
    })),
    __param(0, Required()),
    __param(0, Enum("test", "gcp")),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [String]),
    __metadata("design:returntype", Object)
], HeaderParamsCtrl.prototype, "testScenario3", null);
HeaderParamsCtrl = __decorate([
    Controller("/header-params")
], HeaderParamsCtrl);
export { HeaderParamsCtrl };
export function testHeaderParams(options) {
    let request;
    beforeAll(PlatformTest.bootstrap(options.server, {
        ...options,
        mount: {
            "/rest": [HeaderParamsCtrl]
        }
    }));
    beforeAll(() => {
        request = SuperTest(PlatformTest.callback());
    });
    afterAll(PlatformTest.reset);
    describe("Scenario 1: GET /rest/header-params/scenario-1", () => {
        it("should return a response with the extracted authorization from the request headers", async () => {
            const { body } = await request
                .get("/rest/header-params/scenario-1")
                .set({
                Authorization: "tokenauth"
            })
                .expect(200);
            expect(body.user).toEqual(1);
            expect(body.token).toEqual("tokenauth");
        });
    });
    describe("Scenario 2: POST with contentType", () => {
        it("should return a response with the extracted contentType from the request headers", async () => {
            const response = await request
                .post("/rest/header-params/scenario-2")
                .send({})
                .set({
                "Content-Type": "application/json"
            })
                .expect(200);
            expect(response.body).toEqual({
                contentType: "application/json"
            });
        });
    });
    describe("Scenario3: GET /rest/headers/scenario-3", () => {
        it("should accept the header", async () => {
            const response = await request.get("/rest/header-params/scenario-3").set("x-token", "test").expect(200);
            expect(response.body).toEqual({
                token: "test"
            });
        });
        it("should not validate the header", async () => {
            const response = await request.get("/rest/header-params/scenario-3").expect(400);
            expect(response.body).toEqual({
                errors: [
                    {
                        requestPath: "header",
                        dataPath: ".x-token",
                        keyword: "required",
                        message: "It should have required parameter 'x-token'",
                        modelName: "header",
                        params: {
                            missingProperty: "x-token"
                        },
                        schemaPath: "#/required"
                    }
                ],
                message: "Bad request on parameter \"request.header.x-token\".\nIt should have required parameter 'x-token'",
                name: "REQUIRED_VALIDATION_ERROR",
                status: 400
            });
        });
        it("should not validate the header - enum", async () => {
            const response = await request.get("/rest/header-params/scenario-3").set("x-token", "invalid").expect(400);
            expect(response.body).toEqual({
                errors: [
                    {
                        data: "invalid",
                        requestPath: "header",
                        dataPath: ".x-token",
                        instancePath: "",
                        keyword: "enum",
                        message: "must be equal to one of the allowed values",
                        params: {
                            allowedValues: ["test", "gcp"]
                        },
                        schemaPath: "#/enum"
                    }
                ],
                message: 'Bad request on parameter "request.header.x-token".\nValue must be equal to one of the allowed values. Given value: "invalid"',
                name: "AJV_VALIDATION_ERROR",
                status: 400
            });
        });
    });
}