@tsed/platform-test-sdk 7.73.2 → 7.73.3

package/src/tests/testInheritanceController.ts

@@ -1,200 +0,0 @@
-import {BodyParams, Controller, Get, Middleware, PathParams, PlatformTest, Post, QueryParams, UseAuth} from "@tsed/common";
-import {NotFound} from "@tsed/exceptions";
-import {Description, MaxLength, MinLength, Property, Returns, Summary} from "@tsed/schema";
-import SuperTest from "supertest";
-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 = require("uuid").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

@@ -1,46 +0,0 @@
-import {Context, Controller, Get, Locals, Middleware, Next, PlatformContext, PlatformTest, Req, Request, Res, Use} from "@tsed/common";
-import SuperTest from "supertest";
-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

@@ -1,37 +0,0 @@
-import {Controller, Get, PlatformTest} from "@tsed/common";
-import SuperTest from "supertest";
-import {Location} from "@tsed/schema";
-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

@@ -1,159 +0,0 @@
-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/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

@@ -1,46 +0,0 @@
-import {Controller, Get, PlatformTest} from "@tsed/common";
-import SuperTest from "supertest";
-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

@@ -1,151 +0,0 @@
-import {BodyParams, Controller, MulterOptions, MultipartFile, PlatformMulterFile, PlatformTest} from "@tsed/common";
-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 {PlatformTestingSdkOpts} from "../interfaces/index.js";
-
-const rootDir = __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 = jest.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: __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(() => 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", `${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();
-    });
-  });
-}