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

Package to test platform adapter integration with Ts.ED

import { __decorate, __metadata } from "tslib";
import { Controller } from "@tsed/di";
import { PlatformTest } from "@tsed/platform-http/testing";
import { ResponseFilter } from "@tsed/platform-response-filter";
import { Get, Property, Returns } from "@tsed/schema";
import SuperTest from "supertest";
import { afterAll, beforeAll, describe, expect, it } from "vitest";
class ResponseFilterModel {
}
__decorate([
    Property(),
    __metadata("design:type", String)
], ResponseFilterModel.prototype, "id", void 0);
let TestResponseFilterCtrl = class TestResponseFilterCtrl {
    testScenario1() {
        return { id: "id" };
    }
};
__decorate([
    Get("/scenario1/:id"),
    (Returns(200, ResponseFilterModel).Description("description")),
    (Returns(200, String).ContentType("text/xml")),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], TestResponseFilterCtrl.prototype, "testScenario1", null);
TestResponseFilterCtrl = __decorate([
    Controller("/response-filter")
], TestResponseFilterCtrl);
let XmlResponseFilter = class XmlResponseFilter {
    transform(data, ctx) {
        return "<xml>test</xml>";
    }
};
XmlResponseFilter = __decorate([
    ResponseFilter("text/xml")
], XmlResponseFilter);
let AnyResponseFilter = class AnyResponseFilter {
    transform(data, ctx) {
        return { data, errors: [] };
    }
};
AnyResponseFilter = __decorate([
    ResponseFilter("*/*")
], AnyResponseFilter);
export function testResponseFilter(options) {
    let request;
    beforeAll(PlatformTest.bootstrap(options.server, {
        ...options,
        mount: {
            "/rest": [TestResponseFilterCtrl]
        },
        responseFilters: [XmlResponseFilter, AnyResponseFilter]
    }));
    beforeAll(() => {
        request = SuperTest(PlatformTest.callback());
    });
    afterAll(PlatformTest.reset);
    describe("Scenario1: when have multiple contentType", () => {
        describe("GET /rest/response/scenario1/:id", () => {
            it("should return the xml format", async () => {
                const response = await request
                    .get("/rest/response-filter/scenario1/10")
                    .set({
                    Accept: "text/xml"
                })
                    .expect(200);
                expect(response.text).toEqual("<xml>test</xml>");
            });
            it("should return the xml format when Accept text/xml and application/json", async () => {
                const response = await request
                    .get("/rest/response-filter/scenario1/10")
                    .set({
                    Accept: "text/xml, application/json"
                })
                    .expect(200);
                expect(response.text).toEqual("<xml>test</xml>");
            });
            it("should return the json format", async () => {
                const response = await request
                    .get("/rest/response-filter/scenario1/10")
                    .set({
                    Accept: "application/json"
                })
                    .expect(200);
                expect(response.body).toEqual({
                    data: {
                        id: "id"
                    },
                    errors: []
                });
            });
            it("should return the json format by default", async () => {
                const response = await request.get("/rest/response-filter/scenario1/10").expect(200);
                expect(response.body).toEqual({
                    data: {
                        id: "id"
                    },
                    errors: []
                });
            });
        });
    });
}