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

Package to test platform adapter integration with Ts.ED

import { __decorate, __metadata, __param } from "tslib";
import "@tsed/ajv";
import { Controller } from "@tsed/di";
import { BadRequest, Exception, Unauthorized } from "@tsed/exceptions";
import { Err } from "@tsed/platform-http";
import { PlatformTest } from "@tsed/platform-http/testing";
import { Middleware, Use, UseAfter, UseBefore } from "@tsed/platform-middlewares";
import { Context, QueryParams } from "@tsed/platform-params";
import { Get } from "@tsed/schema";
import SuperTest from "supertest";
import { afterAll, beforeAll, describe, expect, it } from "vitest";
let BeforeCustomMiddleware = class BeforeCustomMiddleware {
    use(ctx) {
        ctx.set("stacks", ["UseBefore - Ctrl"]);
    }
};
__decorate([
    __param(0, Context()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", void 0)
], BeforeCustomMiddleware.prototype, "use", null);
BeforeCustomMiddleware = __decorate([
    Middleware()
], BeforeCustomMiddleware);
let BeforeEndpointCustomMiddleware = class BeforeEndpointCustomMiddleware {
    use(ctx) {
        ctx.get("stacks").push("UseBefore - endpoint");
    }
};
__decorate([
    __param(0, Context()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", void 0)
], BeforeEndpointCustomMiddleware.prototype, "use", null);
BeforeEndpointCustomMiddleware = __decorate([
    Middleware()
], BeforeEndpointCustomMiddleware);
let AfterCustomMiddleware = class AfterCustomMiddleware {
    use(ctx) {
        ctx.get("stacks").push("UseAfter - Ctrl");
    }
};
__decorate([
    __param(0, Context()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", void 0)
], AfterCustomMiddleware.prototype, "use", null);
AfterCustomMiddleware = __decorate([
    Middleware()
], AfterCustomMiddleware);
let UseCustomMiddleware = class UseCustomMiddleware {
    use(ctx) {
        ctx.get("stacks").push("Use - Ctrl");
    }
};
__decorate([
    __param(0, Context()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", void 0)
], UseCustomMiddleware.prototype, "use", null);
UseCustomMiddleware = __decorate([
    Middleware()
], UseCustomMiddleware);
let AfterEndpointCustomMiddleware = class AfterEndpointCustomMiddleware {
    use(ctx) {
        ctx.get("stacks").push("UseAfter - endpoint");
    }
};
__decorate([
    __param(0, Context()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", void 0)
], AfterEndpointCustomMiddleware.prototype, "use", null);
AfterEndpointCustomMiddleware = __decorate([
    Middleware()
], AfterEndpointCustomMiddleware);
let UseMiddleware = class UseMiddleware {
    use(ctx) {
        ctx.get("stacks").push("Use - Ctrl");
    }
};
__decorate([
    __param(0, Context()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", void 0)
], UseMiddleware.prototype, "use", null);
UseMiddleware = __decorate([
    Middleware()
], UseMiddleware);
let UseEndpointMiddleware = class UseEndpointMiddleware {
    use(ctx) {
        ctx.get("stacks").push("Use - endpoint");
    }
};
__decorate([
    __param(0, Context()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", void 0)
], UseEndpointMiddleware.prototype, "use", null);
UseEndpointMiddleware = __decorate([
    Middleware()
], UseEndpointMiddleware);
let CatchErrorMiddleware = class CatchErrorMiddleware {
    use(err) {
        if ([401].includes(err.status)) {
            throw new BadRequest("Bad format");
        }
        throw err;
    }
};
__decorate([
    __param(0, Err()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Exception]),
    __metadata("design:returntype", void 0)
], CatchErrorMiddleware.prototype, "use", null);
CatchErrorMiddleware = __decorate([
    Middleware()
], CatchErrorMiddleware);
export { CatchErrorMiddleware };
let TestMiddlewaresCtrl = class TestMiddlewaresCtrl {
    scenario1(context) {
        context.get("stacks").push("endpoint");
        return { stacks: context.get("stacks") };
    }
    scenario2(test) {
        if (test === "error") {
            throw new Unauthorized("Unauthorized");
        }
        return {
            hello: "world"
        };
    }
};
__decorate([
    Get("/scenario-1"),
    UseBefore(BeforeEndpointCustomMiddleware),
    UseAfter(AfterEndpointCustomMiddleware),
    Use(UseEndpointMiddleware),
    __param(0, Context()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", void 0)
], TestMiddlewaresCtrl.prototype, "scenario1", null);
__decorate([
    Get("/scenario-2"),
    __param(0, QueryParams("test")),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [String]),
    __metadata("design:returntype", void 0)
], TestMiddlewaresCtrl.prototype, "scenario2", null);
TestMiddlewaresCtrl = __decorate([
    Controller("/middlewares"),
    UseBefore(BeforeCustomMiddleware),
    UseAfter(AfterCustomMiddleware),
    UseAfter(CatchErrorMiddleware),
    Use(UseCustomMiddleware)
], TestMiddlewaresCtrl);
export function testMiddlewares(options) {
    let request;
    beforeAll(PlatformTest.bootstrap(options.server, {
        ...options,
        mount: {
            "/rest": [TestMiddlewaresCtrl]
        }
    }));
    beforeAll(() => {
        request = SuperTest(PlatformTest.callback());
    });
    afterAll(PlatformTest.reset);
    describe("Scenario 1: GET /rest/middlewares/scenario-1", () => {
        it("should call all middlewares", async () => {
            const response = await request.get("/rest/middlewares/scenario-1").expect(200);
            expect(response.body).toEqual({
                stacks: [
                    "UseBefore - Ctrl",
                    "UseBefore - endpoint",
                    "Use - Ctrl",
                    "Use - endpoint",
                    "endpoint",
                    "UseAfter - endpoint",
                    "UseAfter - Ctrl"
                ]
            });
        });
    });
    describe("Scenario 2: GET /rest/middlewares/scenario-2", () => {
        it("should call the endpoint without triggering middleware", async () => {
            const response = await request.get("/rest/middlewares/scenario-2").expect(200);
            expect(response.body).toEqual({
                hello: "world"
            });
        });
        it("should call the endpoint, throw an error and transform the error by calling the error middleware", async () => {
            const response = await request.get("/rest/middlewares/scenario-2?test=error").expect(400);
            expect(response.body).toEqual({
                errors: [],
                message: "Bad format",
                name: "BAD_REQUEST",
                status: 400
            });
        });
    });
}