@tsed/platform-test-sdk 7.79.4 → 7.80.0

package/src/tests/testErrors.ts

@@ -1,226 +0,0 @@
-import "@tsed/ajv";
-import {BodyParams, Controller, Err, Get, Middleware, PlatformTest, Post, UseAfter} from "@tsed/common";
-import {Env} from "@tsed/core";
-import {BadRequest, InternalServerError} from "@tsed/exceptions";
-import {Description, Name, Required, Returns, Summary} from "@tsed/schema";
-import SuperTest from "supertest";
-import {CustomBadRequest} from "../errors/CustomBadRequest.js";
-import {CustomInternalError} from "../errors/CustomInternalError.js";
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-
-class CustomModel {
-  @Required() name: string;
-}
-
-class CustomPropModel {
-  @Name("role_item")
-  @Required()
-  roleItem: string;
-}
-
-@Middleware()
-class ErrorMiddleware {
-  use(@Err() error: any) {
-    return {
-      message: "no error"
-    };
-  }
-}
-
-@Middleware()
-class FakeMiddleware {
-  use() {
-    return {
-      message: "should not be called by the platform when endpoint throw an error"
-    };
-  }
-}
-
-@Controller("/errors")
-export class ErrorsCtrl {
-  @Get("/scenario-1")
-  @Returns(500, InternalServerError).Description("Custom Bad Request")
-  public scenario1() {
-    throw new CustomBadRequest("Custom Bad Request");
-  }
-
-  @Get("/scenario-2")
-  @Returns(500).Description("Internal Server Error")
-  public scenario2() {
-    throw new Error("My error");
-  }
-
-  @Get("/scenario-3")
-  @Returns(400, CustomInternalError).Description("Bad request")
-  public scenario3() {
-    throw new CustomInternalError("My custom error");
-  }
-
-  @Post("/scenario-4")
-  @Returns(400)
-  public scenario4(@Required() @BodyParams("name") name: string) {
-    return name;
-  }
-
-  @Post("/scenario-5")
-  @Returns(400, BadRequest).Description("Bad request")
-  public scenario5(
-    @Required()
-    @BodyParams()
-    model: CustomModel
-  ) {
-    return model;
-  }
-
-  @Post("/scenario-6")
-  @Summary("Throw a Required prop if prop name is required")
-  @Description(`Return a required error`)
-  @Returns(400).Description("Bad request")
-  public scenario6(
-    @Required()
-    @BodyParams()
-    model: CustomPropModel
-  ) {
-    return model;
-  }
-
-  @Get("/scenario-7")
-  @Returns(400).Description("Bad request")
-  @UseAfter(FakeMiddleware)
-  @UseAfter(ErrorMiddleware)
-  public scenario7() {
-    throw new CustomInternalError("My custom error");
-  }
-}
-
-export function testErrors(options: PlatformTestingSdkOpts) {
-  let request: SuperTest.Agent;
-  beforeAll(
-    PlatformTest.bootstrap(options.server, {
-      ...options,
-      env: Env.TEST,
-      mount: {
-        "/rest": [ErrorsCtrl]
-      }
-    })
-  );
-  beforeAll(() => {
-    request = SuperTest(PlatformTest.callback());
-  });
-  afterAll(PlatformTest.reset);
-
-  it("Scenario 1: GET /rest/errors/scenario-1", async () => {
-    const response: any = await request.get("/rest/errors/scenario-1").expect(400);
-
-    expect(response.headers["x-header-error"]).toEqual("deny");
-    expect(response.body).toEqual({
-      name: "CUSTOM_BAD_REQUEST",
-      message: "Custom Bad Request",
-      status: 400,
-      errors: ["test"]
-    });
-  });
-
-  it("Scenario 2: GET /rest/errors/scenario-2", async () => {
-    const response: any = await request.get("/rest/errors/scenario-2").expect(500);
-
-    expect(response.body).toEqual({
-      errors: [],
-      message: "My error",
-      name: "Error",
-      status: 500
-    });
-  });
-
-  it("Scenario 3: GET /rest/errors/scenario-3", async () => {
-    const response: any = await request.get("/rest/errors/scenario-3").expect(500);
-
-    expect(response.headers["x-header-error"]).toEqual("deny");
-    expect(response.body).toEqual({
-      name: "CUSTOM_INTERNAL_SERVER_ERROR",
-      message: "My custom error",
-      status: 500,
-      errors: ["test"]
-    });
-  });
-
-  it("Scenario 4: POST /rest/errors/scenario-4", async () => {
-    const response: any = await request.post("/rest/errors/scenario-4").expect(400);
-
-    expect(response.body).toEqual({
-      errors: [
-        {
-          dataPath: ".name",
-          requestPath: "body",
-          keyword: "required",
-          message: "It should have required parameter 'name'",
-          modelName: "body",
-          params: {
-            missingProperty: "name"
-          },
-          schemaPath: "#/required"
-        }
-      ],
-      message: "Bad request on parameter \"request.body.name\".\nIt should have required parameter 'name'",
-      name: "REQUIRED_VALIDATION_ERROR",
-      status: 400
-    });
-  });
-
-  it("Scenario 5: POST /rest/errors/scenario-5", async () => {
-    const response: any = await request.post("/rest/errors/scenario-5").send({}).expect(400);
-
-    expect(response.body).toEqual({
-      errors: [
-        {
-          dataPath: ".name",
-          requestPath: "body",
-          instancePath: "",
-          keyword: "required",
-          message: "must have required property 'name'",
-          modelName: "CustomModel",
-          params: {
-            missingProperty: "name"
-          },
-          schemaPath: "#/required"
-        }
-      ],
-      message: 'Bad request on parameter "request.body".\nCustomModel must have required property \'name\'. Given value: "undefined"',
-      name: "AJV_VALIDATION_ERROR",
-      status: 400
-    });
-  });
-
-  it("Scenario 6: POST /rest/errors/scenario-6", async () => {
-    const response: any = await request.post(`/rest/errors/scenario-6`).send({}).expect(400);
-
-    expect(response.body).toEqual({
-      errors: [
-        {
-          dataPath: ".role_item",
-          requestPath: "body",
-          instancePath: "",
-          keyword: "required",
-          message: "must have required property 'role_item'",
-          modelName: "CustomPropModel",
-          params: {
-            missingProperty: "role_item"
-          },
-          schemaPath: "#/required"
-        }
-      ],
-      message:
-        'Bad request on parameter "request.body".\nCustomPropModel must have required property \'role_item\'. Given value: "undefined"',
-      name: "AJV_VALIDATION_ERROR",
-      status: 400
-    });
-  });
-
-  it("Scenario 7: GET /rest/errors/scenario-7", async () => {
-    const response: any = await request.get("/rest/errors/scenario-7").expect(200);
-
-    expect(response.body).toEqual({
-      message: "no error"
-    });
-  });
-}

package/src/tests/testHandlers.ts

@@ -1,90 +0,0 @@
-import {Context, Controller, Get, PathParams, PlatformTest} from "@tsed/common";
-import {Property, Required, Title} from "@tsed/schema";
-import SuperTest from "supertest";
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-
-export class MyModel {
-  @Title("ID")
-  @Property()
-  public id: string;
-
-  @Property()
-  @Required()
-  public name: string;
-}
-
-@Controller("/handlers")
-export class HandlersCtrl {
-  @Get("/scenario-1/:id") // Express style
-  public scenario1(@PathParams("id") id: string): MyModel {
-    const model = new MyModel();
-    model.id = id;
-    model.name = "test";
-
-    return model;
-  }
-
-  @Get("/scenario-2/:id") // Ts.ED style with response injection
-  public scenario2(
-    @Context() ctx: Context,
-    @PathParams("id")
-    @Required()
-    id: string
-  ): void {
-    const model = new MyModel();
-    model.id = "1";
-    model.name = "test";
-
-    try {
-      ctx.response.status(202).body(model);
-    } catch (er) {
-      console.log(er);
-    }
-  }
-
-  @Get("/scenario-3/:id") // Ts.ED style
-  public scenario3(@PathParams("id") id: string): Promise<any> {
-    const model = new MyModel();
-    model.id = id;
-    model.name = "test";
-
-    return Promise.resolve(model);
-  }
-}
-
-export function testHandlers(options: PlatformTestingSdkOpts) {
-  let request: SuperTest.Agent;
-  beforeAll(
-    PlatformTest.bootstrap(options.server, {
-      ...options,
-      logger: {},
-      mount: {
-        "/rest": [HandlersCtrl]
-      }
-    })
-  );
-  beforeAll(() => {
-    request = SuperTest(PlatformTest.callback());
-  });
-  afterAll(PlatformTest.reset);
-  it("Scenario 1: GET /rest/handlers/scenario-1/:id", async () => {
-    const {body}: any = await request.get("/rest/handlers/scenario-1/1").expect(200);
-
-    expect(body.id).toEqual("1");
-    expect(body.name).toEqual("test");
-  });
-
-  it("Scenario 2: GET /rest/handlers/scenario-2/:id", async () => {
-    const {body}: any = await request.get("/rest/handlers/scenario-2/1").expect(202);
-
-    expect(body.id).toEqual("1");
-    expect(body.name).toEqual("test");
-  });
-
-  it("Scenario 3: GET /rest/handlers/scenario-3/:id", async () => {
-    const {body}: any = await request.get("/rest/handlers/scenario-3/1").expect(200);
-
-    expect(body.id).toEqual("1");
-    expect(body.name).toEqual("test");
-  });
-}

package/src/tests/testHeaderParams.ts

@@ -1,152 +0,0 @@
-import {Context, Controller, Get, HeaderParams, Locals, Middleware, PlatformTest, Post, Req, Use} from "@tsed/common";
-import {Enum, Required} from "@tsed/schema";
-import SuperTest from "supertest";
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-
-@Middleware()
-class SetId {
-  use(@Req() request: any, @Locals() locals: any, @Context() $ctx: Context) {
-    request["user"] = 1;
-    locals.id = "local-10909";
-    $ctx.set("uid", "ctx-10909");
-  }
-}
-
-@Controller("/header-params")
-export class HeaderParamsCtrl {
-  /**
-   * Handle request with a raw middleware + handler
-   * Get Authorization from header
-   * @param request
-   * @param auth
-   */
-  @Get("/scenario-1")
-  @Use(SetId)
-  public scenario1(@Req() request: Req, @HeaderParams("authorization") auth: string): any {
-    return {
-      user: (request as any).user,
-      token: auth
-    };
-  }
-
-  @Post("/scenario-2")
-  scenario2(@HeaderParams("Content-type") contentType: string) {
-    return {contentType};
-  }
-
-  @Get("/scenario-3")
-  testScenario3(
-    @HeaderParams({
-      expression: "x-token",
-      useValidation: true
-    })
-    @Required()
-    @Enum("test", "gcp")
-    token: string
-  ): any {
-    return {token};
-  }
-}
-
-export function testHeaderParams(options: PlatformTestingSdkOpts) {
-  let request: SuperTest.Agent;
-  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}: any = 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
-      });
-    });
-  });
-}

package/src/tests/testHeaders.ts

@@ -1,91 +0,0 @@
-import {BodyParams, Controller, Get, PlatformResponse, PlatformTest, Res} from "@tsed/common";
-import {Returns} from "@tsed/schema";
-import SuperTest from "supertest";
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-
-@Controller("/headers")
-export class HeadersCtrl {
-  @Get("/scenario-1")
-  @Returns(200, String).Header("test", "x-token")
-  testScenario1(@BodyParams("test") value: string[]): any {
-    return "hello";
-  }
-
-  @Get("/scenario-2")
-  @Returns(200, String).Header("x-token-test", "test").Header("x-token-test-2", "test2").ContentType("application/xml")
-  testScenario2() {
-    return "<xml></xml>";
-  }
-
-  @Get("/scenario-3")
-  @Returns(200, String).Headers({
-    Location: {
-      description: "URL to the new xxx",
-      type: "string",
-      value: "/v1/location/header"
-    }
-  })
-  testScenario3(@Res() response: PlatformResponse) {
-    response.setHeader("Location", `/v1/location`);
-    return "Hello";
-  }
-}
-
-export function testHeaders(options: PlatformTestingSdkOpts) {
-  let request: SuperTest.Agent;
-
-  beforeAll(
-    PlatformTest.bootstrap(options.server, {
-      ...options,
-      logger: {
-        level: "off"
-      },
-      mount: {
-        "/rest": [HeadersCtrl]
-      }
-    })
-  );
-  beforeAll(() => {
-    request = SuperTest(PlatformTest.callback());
-  });
-  afterAll(PlatformTest.reset);
-
-  it("Scenario1: GET /rest/headers/scenario-1", async () => {
-    const response = await request.get("/rest/headers/scenario-1").expect(200);
-
-    expect(response.text).toEqual("hello");
-    expect(response.header["test"]).toEqual("x-token");
-  });
-
-  it("Scenario2: GET /rest/headers/scenario-2", (done: Function) => {
-    request
-      .get("/rest/headers/scenario-2")
-      .expect(200)
-      .end((err: any, response: any) => {
-        if (err) {
-          throw err;
-        }
-
-        expect(response.headers["x-token-test"]).toEqual("test");
-        expect(response.headers["x-token-test-2"]).toEqual("test2");
-        expect(response.headers["content-type"]).toContain("application/xml");
-
-        done();
-      });
-  });
-
-  it("Scenario3: GET /rest/headers/scenario-3", (done: Function) => {
-    request
-      .get("/rest/headers/scenario-3")
-      .expect(200)
-      .end((err: any, response: any) => {
-        if (err) {
-          throw err;
-        }
-
-        expect(response.headers["location"]).toEqual("/v1/location");
-
-        done();
-      });
-  });
-}