@tsed/platform-test-sdk 7.12.0

package/lib/esm/tests/testResponse.js

@@ -0,0 +1,615 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Context, Controller, Get, getContext, PathParams, PlatformResponse, PlatformTest, Post, Res } from "@tsed/common";
+import { CollectionOf, ContentType, Enum, ForwardGroups, Groups, Ignore, Name, Property, Required, Returns, Status } from "@tsed/schema";
+import axios from "axios";
+import { createReadStream } from "fs";
+import { join } from "path";
+import { of } from "rxjs";
+import { agent } from "superagent";
+import SuperTest from "supertest";
+class Base {
+    ignoreMeBase;
+    fooBase;
+}
+__decorate([
+    Ignore(),
+    __metadata("design:type", String)
+], Base.prototype, "ignoreMeBase", void 0);
+__decorate([
+    Property(),
+    __metadata("design:type", String)
+], Base.prototype, "fooBase", void 0);
+class MyModel extends Base {
+    foo;
+    ignoreMe;
+    ignoreMe2;
+}
+__decorate([
+    Property(),
+    __metadata("design:type", String)
+], MyModel.prototype, "foo", void 0);
+__decorate([
+    Ignore(),
+    __metadata("design:type", String)
+], MyModel.prototype, "ignoreMe", void 0);
+__decorate([
+    Ignore((value, ctx) => ctx.endpoint),
+    __metadata("design:type", String)
+], MyModel.prototype, "ignoreMe2", void 0);
+class EmptyModel {
+    raw;
+    affected;
+}
+export var EnumValue;
+(function (EnumValue) {
+    EnumValue["One"] = "one";
+    EnumValue["Two"] = "two";
+})(EnumValue || (EnumValue = {}));
+export class NestedEnum {
+    value;
+}
+__decorate([
+    Required(),
+    Enum(EnumValue),
+    __metadata("design:type", String)
+], NestedEnum.prototype, "value", void 0);
+export class TestNestedEnum {
+    nested;
+}
+__decorate([
+    Property(),
+    __metadata("design:type", NestedEnum)
+], TestNestedEnum.prototype, "nested", void 0);
+export class ModelGroup {
+    id;
+    groups;
+}
+__decorate([
+    Property(),
+    __metadata("design:type", String)
+], ModelGroup.prototype, "id", void 0);
+__decorate([
+    Groups("!creation"),
+    __metadata("design:type", String)
+], ModelGroup.prototype, "groups", void 0);
+class TeamModel {
+    name;
+}
+__decorate([
+    Required(),
+    Name("teamName"),
+    __metadata("design:type", String)
+], TeamModel.prototype, "name", void 0);
+class TeamsModel {
+    teams;
+}
+__decorate([
+    Required(),
+    CollectionOf(TeamModel),
+    ForwardGroups(),
+    __metadata("design:type", Array)
+], TeamsModel.prototype, "teams", void 0);
+class AllowedModel {
+    id;
+    description;
+    prop1; // not display by default
+    prop2; // not display by default
+    sensitiveProp; // not displayed because it's a sensitive props
+}
+__decorate([
+    Property(),
+    __metadata("design:type", String)
+], AllowedModel.prototype, "id", void 0);
+__decorate([
+    Property(),
+    __metadata("design:type", String)
+], AllowedModel.prototype, "description", void 0);
+__decorate([
+    Groups("summary"),
+    __metadata("design:type", String)
+], AllowedModel.prototype, "prop1", void 0);
+__decorate([
+    Groups("details"),
+    __metadata("design:type", String)
+], AllowedModel.prototype, "prop2", void 0);
+__decorate([
+    Groups("admin"),
+    __metadata("design:type", String)
+], AllowedModel.prototype, "sensitiveProp", void 0);
+let TestResponseParamsCtrl = class TestResponseParamsCtrl {
+    testScenario1Get(id) {
+        return `hello-${id}`;
+    }
+    testScenario3EmptyResponse(id, ctx) {
+        if (id) {
+            return;
+        }
+        ctx.response.status(201);
+        return {
+            id: 1
+        };
+    }
+    async testScenario5Promise() {
+        await new Promise((resolve) => {
+            resolve(undefined);
+        });
+        return {
+            id: 1
+        };
+    }
+    testScenario6Observable() {
+        return of({ id: 1 });
+    }
+    async testScenario6bObservable() {
+        return of({ id: 1 });
+    }
+    testScenario7Stream() {
+        return createReadStream(join(__dirname, "../data/response.data.json"));
+    }
+    async testScenario7bStream() {
+        return createReadStream(join(__dirname, "../data/response.data.json"));
+    }
+    testScenario9Get() {
+        return "value";
+    }
+    testScenario9WithDynamicParam(id) {
+        return "value" + id;
+    }
+    testScenario10() {
+        const model = new MyModel();
+        model.foo = "foo";
+        model.ignoreMe = "ignoreMe";
+        model.ignoreMe2 = "ignoreMe2";
+        model.fooBase = "fooBase";
+        model.ignoreMeBase = "ignoreMeBase";
+        return model;
+    }
+    testScenario11() {
+        const t = new EmptyModel();
+        t.raw = 1;
+        t.affected = 1;
+        return t;
+    }
+    testScenario12(res) {
+        res.attachment("filename");
+        return Buffer.from("Hello");
+    }
+    async testScenario13(res) {
+        const http = agent();
+        const image_res = await http.get("https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png");
+        res.setHeader("Content-Disposition", "inline;filename=googlelogo_color_272x92dp.png;");
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        res.setHeader("Content-Type", "image/png");
+        return image_res.body;
+    }
+    scenario14() {
+        return {
+            jsonexample: 1
+        };
+    }
+    testScenario15a() {
+        return axios.get(`https://tsed.io/api.json`, {
+            responseType: "json"
+        });
+    }
+    async testScenario15b() {
+        return axios.get(`https://api.tsed.io/rest/github/typed/test`, {
+            responseType: "json"
+        });
+    }
+    async testScenario16() {
+        const test = new TestNestedEnum();
+        const nested = new NestedEnum();
+        nested.value = EnumValue.One;
+        test.nested = nested;
+        return test;
+    }
+    async testScenario17() {
+        const model = new ModelGroup();
+        model.id = "id";
+        model.groups = "groups";
+        return model;
+    }
+    testScenario18() {
+        const data = new TeamsModel();
+        const team = {};
+        team.name = "name";
+        data.teams = [team];
+        return data;
+    }
+    async testScenario19() {
+        const model = new AllowedModel();
+        model.id = "id";
+        model.prop1 = "prop1";
+        model.description = "description";
+        model.prop2 = "prop2";
+        model.sensitiveProp = "sensitiveProp";
+        return model;
+    }
+    async testScenario20() {
+        const $ctx = getContext();
+        return { id: $ctx?.request.query.id };
+    }
+};
+__decorate([
+    Get("/scenario1/:id"),
+    __param(0, PathParams("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", void 0)
+], TestResponseParamsCtrl.prototype, "testScenario1Get", null);
+__decorate([
+    Post("/scenario3/:id?"),
+    Status(204),
+    __param(0, PathParams("id")),
+    __param(1, Context()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Object]),
+    __metadata("design:returntype", void 0)
+], TestResponseParamsCtrl.prototype, "testScenario3EmptyResponse", null);
+__decorate([
+    Get("/scenario5"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TestResponseParamsCtrl.prototype, "testScenario5Promise", null);
+__decorate([
+    Get("/scenario6"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestResponseParamsCtrl.prototype, "testScenario6Observable", null);
+__decorate([
+    Get("/scenario6b"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TestResponseParamsCtrl.prototype, "testScenario6bObservable", null);
+__decorate([
+    Get("/scenario7"),
+    ContentType("application/json"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestResponseParamsCtrl.prototype, "testScenario7Stream", null);
+__decorate([
+    Get("/scenario7b"),
+    ContentType("application/json"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TestResponseParamsCtrl.prototype, "testScenario7bStream", null);
+__decorate([
+    Get("/scenario9/static"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", String)
+], TestResponseParamsCtrl.prototype, "testScenario9Get", null);
+__decorate([
+    Get("/scenario9/:id"),
+    __param(0, PathParams("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", String)
+], TestResponseParamsCtrl.prototype, "testScenario9WithDynamicParam", null);
+__decorate([
+    Get("/scenario10"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestResponseParamsCtrl.prototype, "testScenario10", null);
+__decorate([
+    Get("/scenario11"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestResponseParamsCtrl.prototype, "testScenario11", null);
+__decorate([
+    Get("/scenario12"),
+    __param(0, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PlatformResponse]),
+    __metadata("design:returntype", void 0)
+], TestResponseParamsCtrl.prototype, "testScenario12", null);
+__decorate([
+    Get("/scenario13"),
+    __param(0, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PlatformResponse]),
+    __metadata("design:returntype", Promise)
+], TestResponseParamsCtrl.prototype, "testScenario13", null);
+__decorate([
+    Get("/scenario14"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestResponseParamsCtrl.prototype, "scenario14", null);
+__decorate([
+    Get("/scenario15a"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestResponseParamsCtrl.prototype, "testScenario15a", null);
+__decorate([
+    Get("/scenario15b"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TestResponseParamsCtrl.prototype, "testScenario15b", null);
+__decorate([
+    Get("/scenario16"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TestResponseParamsCtrl.prototype, "testScenario16", null);
+__decorate([
+    Get("/scenario17"),
+    Returns(201, ModelGroup).Groups("creation"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TestResponseParamsCtrl.prototype, "testScenario17", null);
+__decorate([
+    Get("/scenario18"),
+    Returns(200, TeamsModel),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestResponseParamsCtrl.prototype, "testScenario18", null);
+__decorate([
+    Get("/scenario19"),
+    Returns(200, AllowedModel).Groups("!admin").AllowedGroups("summary", "details"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TestResponseParamsCtrl.prototype, "testScenario19", null);
+__decorate([
+    Get("/scenario20"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TestResponseParamsCtrl.prototype, "testScenario20", null);
+TestResponseParamsCtrl = __decorate([
+    Controller("/response")
+], TestResponseParamsCtrl);
+export function testResponse(options) {
+    let request;
+    beforeAll(PlatformTest.bootstrap(options.server, {
+        ...options,
+        mount: {
+            "/rest": [TestResponseParamsCtrl]
+        }
+    }));
+    beforeAll(() => {
+        request = SuperTest(PlatformTest.callback());
+    });
+    afterAll(PlatformTest.reset);
+    describe("Scenario1: return the id (classic)", () => {
+        describe("GET /rest/response/scenario1/:id", () => {
+            it("should return the id + test", async () => {
+                const response = await request.get("/rest/response/scenario1/10").expect(200);
+                expect(response.text).toEqual("hello-10");
+            });
+        });
+    });
+    describe("Scenario3: when response is empty or created", () => {
+        describe("GET /rest/response/scenario3/:id?", () => {
+            it("should return nothing with a 204 status", async () => {
+                const response = await request.post("/rest/response/scenario3/10").expect(204);
+                expect(response.text).toEqual("");
+            });
+            it("should return a body", async () => {
+                const response = await request.post("/rest/response/scenario3").expect(201);
+                expect(response.body).toEqual({ id: 1 });
+            });
+        });
+    });
+    describe("Scenario5: when endpoint response from promise", () => {
+        describe("GET /rest/response/scenario5", () => {
+            it("should return a body", async () => {
+                const response = await request.get("/rest/response/scenario5");
+                expect(response.body).toEqual({ id: 1 });
+            });
+        });
+    });
+    describe("Scenario6: when endpoint return an observable", () => {
+        describe("GET /rest/response/scenario6", () => {
+            it("should return a body", async () => {
+                const response = await request.get("/rest/response/scenario6");
+                expect(response.body).toEqual({ id: 1 });
+            });
+        });
+        describe("GET /rest/response/scenario6b", () => {
+            it("should return a body", async () => {
+                const response = await request.get("/rest/response/scenario6b");
+                expect(response.body).toEqual({ id: 1 });
+            });
+        });
+    });
+    describe("Scenario7: when endpoint return a stream", () => {
+        describe("GET /rest/response/scenario7", () => {
+            it("should return a body", async () => {
+                const response = await request.get("/rest/response/scenario7");
+                expect(response.body).toEqual({ id: "1" });
+            });
+        });
+        describe("GET /rest/response/scenario7b", () => {
+            it("should return a body", async () => {
+                const response = await request.get("/rest/response/scenario7b");
+                expect(response.body).toEqual({ id: "1" });
+            });
+        });
+    });
+    describe("Scenario9: routes without parameters must be defined first", () => {
+        describe("GET /rest/response/scenario9/static", () => {
+            it("should return the test", async () => {
+                const response = await request.get("/rest/response/scenario9/static").expect(200);
+                expect(response.text).toEqual("value");
+            });
+        });
+        describe("GET /rest/response/scenario9/:dynamic", () => {
+            it("should return the test + id", async () => {
+                const response = await request.get("/rest/response/scenario9/10").expect(200);
+                expect(response.text).toEqual("value10");
+            });
+        });
+        describe("GET /rest/response/scenario9/:dynamic", () => {
+            it("should throw a badRequest when path params isn't set as number", async () => {
+                const response = await request.get("/rest/response/scenario9/kkk").expect(400);
+                expect(response.body).toEqual({
+                    errors: [
+                        {
+                            data: "kkk",
+                            dataPath: "",
+                            instancePath: "",
+                            keyword: "type",
+                            message: "must be number",
+                            params: {
+                                type: "number"
+                            },
+                            schemaPath: "#/type"
+                        }
+                    ],
+                    message: 'Bad request on parameter "request.path.id".\nValue must be number. Given value: "kkk"',
+                    name: "AJV_VALIDATION_ERROR",
+                    status: 400
+                });
+            });
+        });
+    });
+    describe("Scenario10: return a model with ignored props", () => {
+        it("should return a body", async () => {
+            const response = await request.get("/rest/response/scenario10");
+            expect(response.body).toEqual({
+                foo: "foo",
+                fooBase: "fooBase"
+            });
+        });
+    });
+    describe("Scenario11: return models without props", () => {
+        it("should return a body", async () => {
+            const response = await request.get("/rest/response/scenario11");
+            expect(response.body).toEqual({
+                affected: 1,
+                raw: 1
+            });
+        });
+    });
+    describe("Scenario12: Return buffer", () => {
+        it("should return a body", async () => {
+            const response = await request.get("/rest/response/scenario12");
+            expect(response.headers["content-disposition"]).toEqual('attachment; filename="filename"');
+            expect(response.headers["content-type"]).toContain("application/octet-stream");
+            expect(response.headers["content-length"]).toEqual("5");
+            expect(response.body.toString()).toEqual("Hello");
+        });
+    });
+    describe("Scenario13: Return buffer", () => {
+        it("should return image", async () => {
+            const response = await request.get("/rest/response/scenario13");
+            expect(response.headers["content-disposition"]).toEqual("inline;filename=googlelogo_color_272x92dp.png;");
+            expect(response.headers["content-type"]).toContain("image/png");
+            expect(response.headers["content-length"]).toEqual("5969");
+        });
+    });
+    describe("Scenario14: Return application/json when Accept is */*", () => {
+        it("should return a */* content-type", async () => {
+            const response = await request
+                .get("/rest/response/scenario14")
+                .set("Accept", "*/*")
+                .set("Content-Type", "application/json")
+                .expect(200);
+            expect(response.headers["content-type"]).toEqual("application/json; charset=utf-8");
+            expect(response.body).toEqual({
+                jsonexample: 1
+            });
+        });
+    });
+    describe("Scenario15: Use axios as proxy", () => {
+        it("should return the response (200)", async () => {
+            const response = await request.get("/rest/response/scenario15a").expect(200);
+            expect(response.headers["content-type"]).toEqual("application/json; charset=utf-8");
+        });
+        it("should return the response (401)", async () => {
+            const response = await request.get("/rest/response/scenario15b").expect(401);
+            expect(response.headers["content-type"]).toEqual("application/json; charset=utf-8");
+        });
+    });
+    describe("Scenario16: Return response with nested enum", () => {
+        it("should return the response (200)", async () => {
+            const response = await request.get("/rest/response/scenario16").expect(200);
+            expect(response.body).toEqual({ nested: { value: "one" } });
+        });
+    });
+    describe("Scenario17: Return response with groups on 201", () => {
+        it("should return the response (200)", async () => {
+            const response = await request.get("/rest/response/scenario17").expect(201);
+            expect(response.body).toEqual({ id: "id" });
+        });
+    });
+    describe("Scenario18: Return data with alias", () => {
+        it("should return the response (200)", async () => {
+            const response = await request.get("/rest/response/scenario18").expect(200);
+            expect(response.body).toEqual({
+                teams: [
+                    {
+                        teamName: "name"
+                    }
+                ]
+            });
+        });
+    });
+    describe("Scenario19: includes options", () => {
+        it("should return the response (200)", async () => {
+            const response = await request.get("/rest/response/scenario19").expect(200);
+            expect(response.body).toEqual({
+                description: "description",
+                id: "id",
+                prop1: "prop1",
+                prop2: "prop2"
+            });
+        });
+        it("should return the response (200 + [summary])", async () => {
+            const response = await request.get("/rest/response/scenario19?includes=summary").expect(200);
+            expect(response.body).toEqual({
+                description: "description",
+                id: "id",
+                prop1: "prop1"
+            });
+        });
+        it("should return the response (200 + [summary, details])", async () => {
+            const response = await request.get("/rest/response/scenario19?includes=summary&includes=details").expect(200);
+            expect(response.body).toEqual({
+                description: "description",
+                id: "id",
+                prop2: "prop2",
+                prop1: "prop1"
+            });
+        });
+        it("should return the response (200 + [summary, details, admin])", async () => {
+            const response = await request.get("/rest/response/scenario19?includes=summary&includes=details&includes=admin").expect(200);
+            expect(response.body).toEqual({
+                description: "description",
+                id: "id",
+                prop2: "prop2",
+                prop1: "prop1"
+            });
+        });
+        it("should return the response (200 + 'summary,details,admin')", async () => {
+            const response = await request.get("/rest/response/scenario19?includes=summary,details,admin").expect(200);
+            expect(response.body).toEqual({
+                description: "description",
+                id: "id",
+                prop2: "prop2",
+                prop1: "prop1"
+            });
+        });
+    });
+    describe("Scenario20: should return query data from Context", () => {
+        it("should return the response (200)", async () => {
+            const response = await request.get("/rest/response/scenario20?id=id").expect(200);
+            expect(response.body).toEqual({ id: "id" });
+        });
+    });
+}
+//# sourceMappingURL=testResponse.js.map