@tsed/platform-test-sdk 7.12.0

package/src/tests/testLocals.ts

@@ -0,0 +1,46 @@
+import {Context, Controller, Get, Locals, Middleware, Next, PlatformContext, PlatformTest, Req, Request, Res, Use} from "@tsed/common";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+@Middleware()
+class LocalsMiddleware {
+  use(@Req() request: any, @Locals() locals: any, @Context() ctx: PlatformContext) {
+    locals.id = "local-10909";
+    ctx.set("uid", "ctx-10909");
+  }
+}
+
+@Controller("/locals")
+class LocalsCtrl {
+  @Get("/scenario-1")
+  @Use(LocalsMiddleware)
+  public testStackMiddlewares(@Locals("id") id: any, @Context("uid") uid: string): any {
+    return {
+      id: `${id}-${uid}`
+    };
+  }
+}
+
+export function testLocals(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [LocalsCtrl]
+      }
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+
+  describe("Scenario 1: GET /rest/locals/scenario-1", () => {
+    it("should call middleware and set a id in locals", async () => {
+      const {body}: any = await request.get("/rest/locals/scenario-1").expect(200);
+
+      expect(body.id).toEqual("local-10909-ctx-10909");
+    });
+  });
+}

package/src/tests/testLocation.ts

@@ -0,0 +1,37 @@
+import {Controller, Get, PlatformTest} from "@tsed/common";
+import SuperTest from "supertest";
+import {Location} from "@tsed/schema";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+@Controller("/location")
+class LocationCtrl {
+  @Get("/scenario-1")
+  @Location("/test")
+  testScenario1() {
+    return "Hello";
+  }
+}
+
+export function testLocation(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [LocationCtrl]
+      }
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+
+  it("Scenario1: GET /rest/location/scenario-1", async () => {
+    const response = await request.get("/rest/location/scenario-1").expect(200);
+
+    expect(response.text).toEqual("Hello");
+    expect(response.header.location).toEqual("/test");
+  });
+}

package/src/tests/testMiddlewares.ts

@@ -0,0 +1,159 @@
+import "@tsed/ajv";
+import {
+  Context,
+  Controller,
+  Err,
+  Get,
+  Middleware,
+  MiddlewareMethods,
+  PlatformTest,
+  QueryParams,
+  Use,
+  UseAfter,
+  UseBefore
+} from "@tsed/common";
+import {BadRequest, Exception, Unauthorized} from "@tsed/exceptions";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+@Middleware()
+class BeforeCustomMiddleware {
+  use(@Context() ctx: Context) {
+    ctx.set("stacks", ["UseBefore - Ctrl"]);
+  }
+}
+
+@Middleware()
+class BeforeEndpointCustomMiddleware {
+  use(@Context() ctx: Context) {
+    ctx.get("stacks").push("UseBefore - endpoint");
+  }
+}
+
+@Middleware()
+class AfterCustomMiddleware {
+  use(@Context() ctx: Context) {
+    ctx.get("stacks").push("UseAfter - Ctrl");
+  }
+}
+
+@Middleware()
+class UseCustomMiddleware {
+  use(@Context() ctx: Context) {
+    ctx.get("stacks").push("Use - Ctrl");
+  }
+}
+
+@Middleware()
+class AfterEndpointCustomMiddleware {
+  use(@Context() ctx: Context) {
+    ctx.get("stacks").push("UseAfter - endpoint");
+  }
+}
+
+@Middleware()
+class UseMiddleware {
+  use(@Context() ctx: Context) {
+    ctx.get("stacks").push("Use - Ctrl");
+  }
+}
+
+@Middleware()
+class UseEndpointMiddleware {
+  use(@Context() ctx: Context) {
+    ctx.get("stacks").push("Use - endpoint");
+  }
+}
+
+@Middleware()
+export class CatchErrorMiddleware implements MiddlewareMethods {
+  use(@Err() err: Exception) {
+    if ([401].includes(err.status)) {
+      throw new BadRequest("Bad format");
+    }
+
+    throw err;
+  }
+}
+
+@Controller("/middlewares")
+@UseBefore(BeforeCustomMiddleware)
+@UseAfter(AfterCustomMiddleware)
+@UseAfter(CatchErrorMiddleware)
+@Use(UseCustomMiddleware)
+class TestMiddlewaresCtrl {
+  @Get("/scenario-1")
+  @UseBefore(BeforeEndpointCustomMiddleware)
+  @UseAfter(AfterEndpointCustomMiddleware)
+  @Use(UseEndpointMiddleware)
+  scenario1(@Context() context: Context) {
+    context.get("stacks").push("endpoint");
+
+    return {stacks: context.get("stacks")};
+  }
+
+  @Get("/scenario-2")
+  scenario2(@QueryParams("test") test: string) {
+    if (test === "error") {
+      throw new Unauthorized("Unauthorized");
+    }
+
+    return {
+      hello: "world"
+    };
+  }
+}
+
+export function testMiddlewares(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+
+  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
+      });
+    });
+  });
+}

package/src/tests/testModule.ts

@@ -0,0 +1,46 @@
+import {Controller, Get, PlatformTest} from "@tsed/common";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+import {FeatureModule} from "../modules/feature/FeatureModule";
+
+@Controller("/root")
+class TestRootCtrl {
+  @Get("/")
+  testScenario1() {
+    return "From root";
+  }
+}
+
+export function testModule(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [TestRootCtrl]
+      },
+      imports: [FeatureModule]
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+
+  describe("Scenario1: GET /rest/root", () => {
+    it("should get content from root controller", async () => {
+      const response = await request.get("/rest/root").expect(200);
+
+      expect(response.text).toEqual("From root");
+    });
+  });
+
+  describe("Scenario2: GET /rest/features", () => {
+    it("should get content from a module with his controller", async () => {
+      const response = await request.get("/rest/features").expect(200);
+
+      expect(response.text).toEqual("From feature");
+    });
+  });
+}

package/src/tests/testMulter.ts

@@ -0,0 +1,140 @@
+import {BodyParams, Controller, MulterOptions, MultipartFile, PlatformMulterFile, PlatformTest, Post} from "@tsed/common";
+import {CollectionOf, Property, Required, Status} from "@tsed/schema";
+import {Request} from "express";
+import multer, {FileFilterCallback} from "multer";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+export class Task {
+  @Property()
+  id: string;
+
+  @Property()
+  title: string;
+}
+
+export class Event {
+  @Property()
+  @Required()
+  id: string;
+
+  @CollectionOf(Task)
+  tasks: Task[];
+}
+
+const fileFilterStub = jest.fn();
+const fileFilter = (req: Request, file: PlatformMulterFile, callback: FileFilterCallback) => {
+  fileFilterStub();
+  callback(null, true);
+};
+
+function getFileConfig(): any {
+  return {
+    storage: multer.diskStorage({
+      destination: (req: Express.Request, _fileItem, cb) => {
+        const path = `${__dirname}/../.tmp`;
+        cb(null, path);
+      }
+    }),
+    fileFilter
+  };
+}
+
+@Controller("/multer")
+export class TestMulterController {
+  @Post("/scenario-1")
+  @Status(201)
+  @MulterOptions({dest: `${__dirname}/../.tmp`})
+  uploadWithName(@Required() @MultipartFile("media") media: PlatformMulterFile) {
+    return media.originalname;
+  }
+
+  @Post("/scenario-2")
+  @Status(201)
+  @MulterOptions({dest: `${__dirname}/../.tmp`})
+  uploadWithPayload(@MultipartFile("media") media: PlatformMulterFile, @BodyParams("form_id") formId: string) {
+    return {
+      file: media.originalname,
+      formId
+    };
+  }
+
+  @Post("/scenario-3")
+  @Status(201)
+  @MulterOptions(getFileConfig())
+  uploadWithOptions(@MultipartFile("media") media: PlatformMulterFile) {
+    return {
+      file: media.originalname
+    };
+  }
+}
+
+export function testMulter(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [TestMulterController]
+      }
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+  beforeAll(() => jest.resetAllMocks());
+  describe("Scenario 1: POST /rest/multer/scenario-1", () => {
+    it("should upload file with multer", async () => {
+      const result = await request.post("/rest/multer/scenario-1").attach("media", `${__dirname}/../data/file.txt`).expect(201);
+
+      expect(result.text).toEqual("file.txt");
+    });
+
+    it("should throw an exception when there is no file", async () => {
+      const result = await request.post("/rest/multer/scenario-1").expect(400);
+
+      expect(result.body).toEqual({
+        name: "REQUIRED_VALIDATION_ERROR",
+        message: "Bad request on parameter \"request.files.media.0\".\nIt should have required parameter 'media.0'",
+        status: 400,
+        errors: [
+          {
+            dataPath: "",
+            keyword: "required",
+            message: "It should have required parameter 'media.0'",
+            modelName: "files",
+            params: {missingProperty: "media.0"},
+            schemaPath: "#/required"
+          }
+        ]
+      });
+    });
+  });
+  describe("Scenario 2: POST /rest/multer/scenario-2", () => {
+    it("should upload file with multer", async () => {
+      const result = await request
+        .post("/rest/multer/scenario-2")
+        .attach("media", `${__dirname}/../data/file.txt`)
+        .field({
+          form_id: "form_id"
+        })
+        .expect(201);
+
+      expect(result.body).toEqual({file: "file.txt", formId: "form_id"});
+    });
+  });
+  describe("Scenario 3: POST /rest/multer/scenario-3", () => {
+    it("should upload file with multer", async () => {
+      const result = await request.post("/rest/multer/scenario-3").attach("media", `${__dirname}/../data/file.txt`).field({}).expect(201);
+
+      expect(result.body).toEqual({
+        file: "file.txt"
+      });
+
+      // filterFilter is called
+      expect(fileFilterStub).toBeCalled();
+    });
+  });
+}

package/src/tests/testPathParams.ts

@@ -0,0 +1,122 @@
+import {Context, Controller, Get, PathParams, PlatformTest, Post} from "@tsed/common";
+import {Pattern} from "@tsed/schema";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+@Controller("/path-params")
+class TestPathParamsCtrl {
+  @Get("/scenario-1/:scope/:scopeId")
+  async testScenario1(@PathParams("scope") scope: string) {
+    // Here scope will be {0: 'a', 1: 'b', 2: 'c'} instead of 'abc' in version 5.47.0
+    expect(scope).toEqual("abc");
+
+    return scope;
+  }
+
+  @Get("/scenario-2/:scope/:scopeId")
+  async testScenario2(@PathParams("scope") scope: any) {
+    // This way it works in version 5.47.0
+    expect(scope).toEqual("abc");
+
+    return scope;
+  }
+
+  @Post("/scenario-3/:scope/:scopeId")
+  async testScenario3(@PathParams("scope") scope: string): Promise<any[]> {
+    expect(scope).toEqual("abc");
+
+    // Here the function will return  {0: 'a', 1: 'b', 2: 'c'} instead of ['a','b','c']  in version 5.44.13
+    return ["a", "b", "c"];
+  }
+
+  @Post("/scenario-4/:scope/:scopeId")
+  async testScenario4(@PathParams("scope") scope: string, @Context() ctx: Context) {
+    expect(scope).toEqual("abc");
+
+    // This way it works  in version 5.44.13
+    ctx.response.body(["a", "b", "c"]);
+  }
+
+  @Get("/scenario-5/:scopeId")
+  async testScenario5(@PathParams("scopeId") @Pattern(/^[0-9a-fA-F]{24}$/) scopeId: string, @Context() ctx: Context) {
+    return "test";
+  }
+
+  @Get("/scenario-6/:id")
+  async testScenario6(@PathParams("id") id: number) {
+    return {id};
+  }
+}
+
+export function testPathParams(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [TestPathParamsCtrl]
+      }
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+
+  it("Scenario 1: GET /rest/path-params/scenario-1/scope/scopeId", async () => {
+    const response = await request.get("/rest/path-params/scenario-1/abc/1").expect(200);
+
+    expect(response.text).toEqual("abc");
+  });
+
+  it("Scenario 2: GET /rest/path-params/scenario-2/scopeId", async () => {
+    const response = await request.get("/rest/path-params/scenario-2/abc/1").expect(200);
+
+    expect(response.text).toEqual("abc");
+  });
+
+  it("Scenario 3: POST /rest/path-params/scenario-3/scope/scopeId", async () => {
+    const response = await request.post("/rest/path-params/scenario-3/abc/1").expect(200);
+
+    expect(response.body).toEqual(["a", "b", "c"]);
+  });
+
+  it("Scenario 4: POST /rest/path-params/scenario-4/scope/scopeId", async () => {
+    const response = await request.post("/rest/path-params/scenario-4/abc/1").expect(200);
+
+    expect(response.body).toEqual(["a", "b", "c"]);
+  });
+
+  it("Scenario 5 a: GET /rest/path-params/scenario-5/scopeId", async () => {
+    const response = await request.get("/rest/path-params/scenario-5/1").expect(400);
+
+    expect(response.body).toEqual({
+      errors: [
+        {
+          data: "1",
+          dataPath: "",
+          instancePath: "",
+          keyword: "pattern",
+          message: 'must match pattern "^[0-9a-fA-F]{24}$"',
+          params: {
+            pattern: "^[0-9a-fA-F]{24}$"
+          },
+          schemaPath: "#/pattern"
+        }
+      ],
+      message: 'Bad request on parameter "request.path.scopeId".\nValue must match pattern "^[0-9a-fA-F]{24}$". Given value: "1"',
+      name: "AJV_VALIDATION_ERROR",
+      status: 400
+    });
+  });
+  it("Scenario 5b: GET /rest/path-params/scenario-5/scopeId", async () => {
+    await request.get("/rest/path-params/scenario-5/5ce4ee471495836c5e2e4cb0").expect(200);
+  });
+
+  it("Scenario 6: GET /rest/path-params/scenario-6/id", async () => {
+    const response = await request.get("/rest/path-params/scenario-6/1").expect(200);
+
+    expect(response.body).toEqual({id: 1});
+  });
+}