@tsed/platform-test-sdk 8.0.1 → 8.0.3

package/src/tests/testInheritanceController.ts

@@ -0,0 +1,206 @@
+import {Controller} from "@tsed/di";
+import {NotFound} from "@tsed/exceptions";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {Middleware, UseAuth} from "@tsed/platform-middlewares";
+import {BodyParams, PathParams, QueryParams} from "@tsed/platform-params";
+import {Description, Get, MaxLength, MinLength, Post, Property, Returns, Summary} from "@tsed/schema";
+import SuperTest from "supertest";
+import {v4} from "uuid";
+import {afterAll, beforeAll, describe, expect, it} from "vitest";
+
+import {PlatformTestingSdkOpts} from "../interfaces/index.js";
+
+export class Resource {
+  @Property()
+  id: string;
+
+  @Property()
+  @MinLength(3)
+  @MaxLength(100)
+  name: string;
+}
+
+export class BaseController<T extends {id: string}> {
+  resources: T[];
+
+  @Get("/:id")
+  @Summary("Return an element by his resource")
+  get(
+    @Description("Id of the resource")
+    @PathParams("id")
+    id: string
+  ): Promise<any> {
+    const resource = this.resources.find((resource) => resource.id === id);
+
+    if (!resource) {
+      return Promise.reject(new NotFound("Not found"));
+    }
+
+    return Promise.resolve(resource);
+  }
+
+  @Get("/")
+  @Summary("Return all elements from a service")
+  list(): Promise<any[]> {
+    return Promise.resolve(this.resources);
+  }
+}
+
+@Controller("/resources")
+export class ResourcesCtrl extends BaseController<Resource> {
+  resources = [{id: "1", name: "John"}];
+
+  @Get("/:id")
+  @Summary("Return an element by his resource")
+  async get(
+    @Description("Id of the resource")
+    @PathParams("id")
+    id: string
+  ): Promise<any> {
+    const resource = await super.get(id);
+
+    resource.name = resource.name + " hello You!";
+
+    return resource;
+  }
+
+  @Post("/")
+  @(Returns(201).Type(Resource))
+  post(@BodyParams() resource: Resource) {
+    resource.id = v4();
+    this.resources.push(resource);
+
+    return resource;
+  }
+}
+
+@Middleware()
+class AuthMiddleware {
+  use() {
+    return true;
+  }
+}
+
+abstract class AttachmentController {
+  @Get("/:parentID/attachments")
+  getAll(@PathParams("parentID") parentID: string) {
+    return `All attachments of ${parentID}`;
+  }
+}
+
+@Controller("/findings")
+@UseAuth(AuthMiddleware)
+export class FindingsController extends AttachmentController {
+  @Get("/")
+  get() {
+    return "hello Finding";
+  }
+}
+
+export abstract class TestBaseController {
+  @Get("/")
+  scenario3(@QueryParams("search") search: string) {
+    return {
+      search
+    };
+  }
+
+  @Get("/override")
+  scenario5(@QueryParams("q") q: string) {
+    return {data: q};
+  }
+}
+
+@Controller("/test")
+export class TestChildController extends TestBaseController {
+  @Get("/:id")
+  scenario4(@PathParams("id") id: string): any {
+    return {id};
+  }
+
+  @Get("/override")
+  scenario5(@QueryParams("s") s: string) {
+    return {data: s};
+  }
+}
+
+export function testInheritanceController(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.Agent;
+
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [ResourcesCtrl, FindingsController, TestChildController]
+      }
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+
+  describe("Scenario 1:", () => {
+    it("should return list", async () => {
+      const {body} = await request.get("/rest/resources").expect(200);
+
+      expect(body).toEqual([{id: "1", name: "John"}]);
+    });
+
+    it("should return a resource", async () => {
+      const {body} = await request.get("/rest/resources/1").expect(200);
+
+      expect(body).toEqual({
+        id: "1",
+        name: "John hello You!"
+      });
+    });
+
+    it("should add a resource", async () => {
+      const {body} = await request
+        .post("/rest/resources")
+        .send({
+          name: "july"
+        })
+        .expect(201);
+
+      expect(body.name).toEqual("july");
+      expect(typeof body.id).toBe("string");
+
+      const {body: resource} = await request.get(`/rest/resources/${body.id}`).expect(200);
+
+      expect(resource.id).toEqual(body.id);
+    });
+  });
+
+  describe("scenario2: FindingsController", () => {
+    it("should call /rest/findings/:parentID/attachments", async () => {
+      const {text} = await request.get("/rest/findings/1/attachments").expect(200);
+
+      expect(text).toEqual("All attachments of 1");
+    });
+
+    it("should call /rest/findings", async () => {
+      const {text} = await request.get("/rest/findings").expect(200);
+
+      expect(text).toEqual("hello Finding");
+    });
+  });
+
+  it("Scenario3: should call inherited method", async () => {
+    const {body} = await request.get("/rest/test?search=test").expect(200);
+    expect(body).toEqual({
+      search: "test"
+    });
+  });
+
+  it("Scenario4: should the Child method", async () => {
+    const {body} = await request.get("/rest/test/1").expect(200);
+    expect(body).toEqual({id: "1"});
+  });
+
+  it("Scenario5: should call the Child method and not the base method", async () => {
+    const {body} = await request.get("/rest/test/1").expect(200);
+    expect(body).toEqual({id: "1"});
+  });
+}

package/src/tests/testLocals.ts

@@ -0,0 +1,53 @@
+import {Controller} from "@tsed/di";
+import {PlatformContext, Req} from "@tsed/platform-http";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {Middleware, Use} from "@tsed/platform-middlewares";
+import {Context, Locals} from "@tsed/platform-params";
+import {Get} from "@tsed/schema";
+import SuperTest from "supertest";
+import {afterAll, beforeAll, describe, expect, it} from "vitest";
+
+import {PlatformTestingSdkOpts} from "../interfaces/index.js";
+
+@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.Agent;
+  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,40 @@
+import {Controller} from "@tsed/di";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {Get, Location} from "@tsed/schema";
+import SuperTest from "supertest";
+import {afterAll, beforeAll, expect, it} from "vitest";
+
+import {PlatformTestingSdkOpts} from "../interfaces/index.js";
+
+@Controller("/location")
+class LocationCtrl {
+  @Get("/scenario-1")
+  @Location("/test")
+  testScenario1() {
+    return "Hello";
+  }
+}
+
+export function testLocation(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.Agent;
+
+  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,155 @@
+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, MiddlewareMethods, 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";
+
+import {PlatformTestingSdkOpts} from "../interfaces/index.js";
+
+@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.Agent;
+
+  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,50 @@
+import {Controller} from "@tsed/di";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {Get} from "@tsed/schema";
+import SuperTest from "supertest";
+import {afterAll, beforeAll, describe, expect, it} from "vitest";
+
+import {PlatformTestingSdkOpts} from "../interfaces/index.js";
+import {FeatureModule} from "../modules/feature/FeatureModule.js";
+
+@Controller("/root")
+class TestRootCtrl {
+  @Get("/")
+  testScenario1() {
+    return "From root";
+  }
+}
+
+export function testModule(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.Agent;
+
+  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,158 @@
+import {Controller} from "@tsed/di";
+import {MulterOptions, MultipartFile, PlatformMulterFile} from "@tsed/platform-http";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {BodyParams} from "@tsed/platform-params";
+import {CollectionOf, Post, Property, Required, Status} from "@tsed/schema";
+import multer, {FileFilterCallback} from "multer";
+import {dirname, join} from "path";
+import readPkgUp from "read-pkg-up";
+import SuperTest from "supertest";
+import {afterAll, beforeAll, describe, expect, it, vi} from "vitest";
+
+import {PlatformTestingSdkOpts} from "../interfaces/index.js";
+
+const rootDir = import.meta.dirname; // automatically replaced by import.meta.dirname on build
+
+export class Task {
+  @Property()
+  id: string;
+
+  @Property()
+  title: string;
+}
+
+export class Event {
+  @Property()
+  @Required()
+  id: string;
+
+  @CollectionOf(Task)
+  tasks: Task[];
+}
+
+const fileFilterStub = vi.fn();
+const fileFilter = (req: any, file: PlatformMulterFile, callback: FileFilterCallback) => {
+  fileFilterStub();
+  callback(null, true);
+};
+
+function getFileConfig(): any {
+  return {
+    storage: multer.diskStorage({
+      destination: (req: any, _fileItem, cb) => {
+        const path = `${rootDir}/../.tmp`;
+        cb(null, path);
+      }
+    }),
+    fileFilter
+  };
+}
+
+@Controller("/multer")
+export class TestMulterController {
+  @Post("/scenario-1")
+  @Status(201)
+  @MulterOptions({dest: `${rootDir}/../.tmp`})
+  uploadWithName(@Required() @MultipartFile("media") media: PlatformMulterFile) {
+    return media.originalname;
+  }
+
+  @Post("/scenario-2")
+  @Status(201)
+  @MulterOptions({dest: `${rootDir}/../.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.Agent;
+
+  const buffer = Buffer.from("test content");
+
+  const pkg = readPkgUp.sync({
+    cwd: import.meta.dirname
+  });
+  const rootDir = join(dirname(pkg?.path || ""), "src");
+
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [TestMulterController]
+      }
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+  beforeAll(() => {
+    vi.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", `${rootDir}/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: ".media.0",
+            requestPath: "files",
+            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", `${rootDir}/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", `${rootDir}/data/file.txt`).field({}).expect(201);
+
+      expect(result.body).toEqual({
+        file: "file.txt"
+      });
+
+      // filterFilter is called
+      expect(fileFilterStub).toBeCalled();
+    });
+  });
+}