@tsed/platform-test-sdk 8.11.1 → 8.12.0-rc.1

package/src/tests/testRouting.ts

@@ -1,71 +0,0 @@
-import {Controller} from "@tsed/di";
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {Get, Put} from "@tsed/schema";
-import SuperTest from "supertest";
-import {afterAll, afterEach, beforeAll, expect, it, vi} from "vitest";
-
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-
-const stub = vi.fn();
-
-@Controller("/routing")
-export class TestRoutingController {
-  @Get("/1")
-  scenario1() {
-    stub("scenario1");
-
-    return "test1";
-  }
-
-  @Put("") // empty string has an effect on the calls orders
-  scenario2() {
-    stub("scenario2");
-
-    return "shouldNotRun";
-  }
-
-  @Get("/3")
-  scenario3() {
-    stub("scenario3");
-
-    return "test3";
-  }
-}
-
-export function testRouting(options: PlatformTestingSdkOpts) {
-  let request: SuperTest.Agent;
-
-  beforeAll(
-    PlatformTest.bootstrap(options.server, {
-      ...options,
-      mount: {
-        "/rest": [TestRoutingController]
-      }
-    })
-  );
-  beforeAll(() => {
-    request = SuperTest(PlatformTest.callback());
-  });
-  afterAll(PlatformTest.reset);
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-
-  it("Scenario1: should call scenario1 only", async () => {
-    const {text} = await request.get("/rest/routing/1").expect(200);
-    expect(text).toEqual("test1");
-    expect(stub).toHaveBeenCalledWith("scenario1");
-  });
-
-  it("Scenario2: should call scenario2 only", async () => {
-    const {text} = await request.put("/rest/routing/").expect(200);
-    expect(text).toEqual("shouldNotRun");
-    expect(stub).toHaveBeenCalledWith("scenario2");
-  });
-
-  it("Scenario3: should call scenario3 only", async () => {
-    const {text} = await request.get("/rest/routing/3").expect(200);
-    expect(text).toEqual("test3");
-    expect(stub).toHaveBeenCalledWith("scenario3");
-  });
-}

package/src/tests/testScopeRequest.ts

@@ -1,116 +0,0 @@
-import {Controller, ProviderScope, Scope, Service} from "@tsed/di";
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {PathParams} 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";
-
-@Service()
-@Scope(ProviderScope.REQUEST)
-export class ScopeRequestService {
-  user: string;
-}
-
-@Controller("/scopes-request")
-@Scope(ProviderScope.REQUEST)
-export class ScopeRequestCtrl {
-  userId: string | null;
-
-  constructor(public scopeRequestService: ScopeRequestService) {}
-
-  $onDestroy() {
-    this.userId = null;
-  }
-
-  @Get("/:id")
-  testPerRequest(@PathParams("id") userId: string): Promise<any> {
-    this.scopeRequestService.user = userId;
-    this.userId = userId;
-
-    return new Promise((resolve, reject) => {
-      if (userId === "0") {
-        setTimeout(() => {
-          resolve({userId, idSrv: this.scopeRequestService.user, idCtrl: this.userId});
-        }, 500);
-      }
-
-      if (userId === "1") {
-        setTimeout(() => {
-          resolve({userId, idSrv: this.scopeRequestService.user, idCtrl: this.userId});
-        }, 300);
-      }
-
-      if (userId === "2") {
-        setTimeout(() => {
-          resolve({userId, idSrv: this.scopeRequestService.user, idCtrl: this.userId});
-        }, 150);
-      }
-    });
-  }
-}
-
-export function testScopeRequest(options: PlatformTestingSdkOpts) {
-  let request: SuperTest.Agent;
-
-  beforeAll(
-    PlatformTest.bootstrap(options.server, {
-      ...options,
-      mount: {
-        "/rest": [ScopeRequestCtrl]
-      }
-    })
-  );
-  beforeAll(() => {
-    request = SuperTest(PlatformTest.callback());
-  });
-  afterAll(PlatformTest.reset);
-
-  describe("GET /rest/scopes-request/:id", () => {
-    const send = (id: string) =>
-      new Promise((resolve, reject) => {
-        request
-          .get(`/rest/scopes-request/${id}`)
-          .expect(200)
-          .end((err: any, response: any) => {
-            if (err) {
-              reject(err);
-            } else {
-              resolve({id, ...JSON.parse(response.text)});
-            }
-          });
-      });
-
-    it("should respond with the right userId per request", () => {
-      const promises = [];
-
-      promises.push(send("0"));
-      promises.push(send("1"));
-      promises.push(send("2"));
-
-      return Promise.all(promises).then((responses) => {
-        expect(responses).toEqual([
-          {
-            id: "0",
-            idCtrl: "0",
-            idSrv: "0",
-            userId: "0"
-          },
-          {
-            id: "1",
-            idCtrl: "1",
-            idSrv: "1",
-            userId: "1"
-          },
-          {
-            id: "2",
-            idCtrl: "2",
-            idSrv: "2",
-            userId: "2"
-          }
-        ]);
-      });
-    });
-  });
-}

package/src/tests/testSession.ts

@@ -1,109 +0,0 @@
-import {promisify} from "node:util";
-
-import {Constant, Controller} from "@tsed/di";
-import {NotFound} from "@tsed/exceptions";
-import {Req} from "@tsed/platform-http";
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {BodyParams, Session} from "@tsed/platform-params";
-import {Allow, Email, Get, Ignore, MinLength, Post, Property, Required, Returns} from "@tsed/schema";
-import SuperTest from "supertest";
-import {afterAll, beforeAll, describe, expect, it} from "vitest";
-
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-
-export class UserCreation {
-  @Property()
-  name: string;
-
-  @Required()
-  @Email()
-  @Allow(null)
-  email: string;
-
-  @Required()
-  @MinLength(6)
-  @Allow(null)
-  password: string;
-}
-
-export class User extends UserCreation {
-  @Ignore()
-  declare password: string;
-}
-
-@Controller("/session")
-export class SessionCtrl {
-  @Constant("PLATFORM_NAME")
-  platformName: string;
-
-  @Post("/connect")
-  connect(@Session() session: any, @BodyParams() user: UserCreation) {
-    session.user = user;
-
-    return Promise.resolve(user);
-  }
-
-  @Get("/userinfo")
-  @Returns(200, User)
-  userInfo(@Session("user") user: User): Promise<User> {
-    if (!user) {
-      return Promise.reject(new NotFound("User not found"));
-    }
-
-    return Promise.resolve(user);
-  }
-
-  @Get("/logout")
-  @Returns(204)
-  logout(@Req() req: any) {
-    switch (this.platformName) {
-      case "koa":
-        return Promise.resolve((req.ctx.session = null));
-      case "express":
-        delete req.session.user;
-
-        return promisify(req.session.destroy.bind(req.session))();
-    }
-
-    return Promise.resolve();
-  }
-}
-
-export function testSession(options: PlatformTestingSdkOpts) {
-  let request: SuperTest.Agent;
-  beforeAll(
-    PlatformTest.bootstrap(options.server, {
-      ...options,
-      mount: {
-        "/rest": [SessionCtrl]
-      }
-    })
-  );
-  beforeAll(() => {
-    request = SuperTest.agent(PlatformTest.callback());
-  });
-  afterAll(PlatformTest.reset);
-
-  describe("Scenario1: POST /rest/session/connected", () => {
-    it("should keep connected user in session and destroy session", async () => {
-      await request.get("/rest/session/userinfo").expect(404);
-
-      await request.post("/rest/session/connect").send({
-        name: "name",
-        email: "test@test.fr",
-        password: "password1234"
-      });
-
-      // @ts-ignore
-      const response = await request.get("/rest/session/userinfo").expect(200);
-
-      expect(response.body).toEqual({
-        email: "test@test.fr",
-        name: "name"
-      });
-
-      await request.get("/rest/session/logout").expect(204);
-      await request.get("/rest/session/userinfo").expect(404);
-    });
-  });
-}

package/src/tests/testStatics.ts

@@ -1,64 +0,0 @@
-import {readFileSync} from "node:fs";
-
-import {getValue} from "@tsed/core";
-import {Configuration, Controller} from "@tsed/di";
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {PlatformRouter} from "@tsed/platform-router";
-import SuperTest from "supertest";
-import {afterEach, beforeEach, expect, it} from "vitest";
-
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-
-@Controller("/statics")
-class CustomStaticsCtrl {
-  constructor(router: PlatformRouter, @Configuration() config: Configuration) {
-    router.statics("/", {
-      root: String(getValue(config, "statics./"))
-    });
-  }
-}
-
-export function testStatics(options: PlatformTestingSdkOpts) {
-  let request: SuperTest.Agent;
-  beforeEach(
-    PlatformTest.bootstrap(options.server, {
-      ...options,
-      mount: {
-        "/rest": [CustomStaticsCtrl]
-      }
-    })
-  );
-  beforeEach(() => {
-    request = SuperTest(PlatformTest.callback());
-  });
-  afterEach(PlatformTest.reset);
-
-  it("should return index HTML (1)", async () => {
-    const response = await request.get("/").expect(200);
-
-    expect(response.text).toEqual(readFileSync(`${options.rootDir}/public/index.html`, {encoding: "utf8"}));
-  });
-
-  it("should return index HTML (2)", async () => {
-    const response = await request.get("/index.html").expect(200);
-
-    expect(response.text).toEqual(readFileSync(`${options.rootDir}/public/index.html`, {encoding: "utf8"}));
-  });
-
-  it("should return index HTML (3)", async () => {
-    const response = await request.get("/rest/statics/index.html").expect(200);
-
-    expect(response.text).toEqual(readFileSync(`${options.rootDir}/public/index.html`, {encoding: "utf8"}));
-  });
-
-  it("should return 404", async () => {
-    const response = await request.get("/index-te.html").expect(404);
-
-    expect(response.body).toEqual({
-      errors: [],
-      message: 'Resource "/index-te.html" not found',
-      name: "NOT_FOUND",
-      status: 404
-    });
-  });
-}

package/src/tests/testStream.ts

@@ -1,63 +0,0 @@
-import {createReadStream} from "node:fs";
-import {join} from "node:path";
-
-import {Controller} from "@tsed/di";
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {ContentType, Get} from "@tsed/schema";
-import SuperTest from "supertest";
-import {afterAll, beforeAll, describe, expect, it} from "vitest";
-
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-
-const rootDir = import.meta.dirname; // automatically replaced by import.meta.dirname on build
-
-@Controller("/stream")
-class TestStreamCtrl {
-  @Get("/scenario1")
-  @ContentType("application/json")
-  testScenario1() {
-    return createReadStream(join(rootDir, "../data/response.data.json"), "utf-8");
-  }
-
-  @Get("/scenario1b")
-  @ContentType("application/json")
-  testScenario2() {
-    return Promise.resolve(createReadStream(join(rootDir, "../data/response.data.json"), "utf-8"));
-  }
-}
-
-export function testStream(options: PlatformTestingSdkOpts) {
-  let request: SuperTest.Agent;
-
-  beforeAll(
-    PlatformTest.bootstrap(options.server, {
-      ...options,
-      mount: {
-        "/rest": [TestStreamCtrl]
-      }
-    })
-  );
-  beforeAll(() => {
-    request = SuperTest(PlatformTest.callback());
-  });
-  afterAll(PlatformTest.reset);
-
-  describe("Scenario1: when endpoint return a stream", () => {
-    describe("GET /rest/stream/scenario1", () => {
-      it("should return a body", async () => {
-        const response = await request.get("/rest/stream/scenario1");
-
-        expect(response.headers["content-type"]).toContain("application/json");
-        expect(response.body).toEqual({id: "1"});
-      });
-    });
-
-    describe("GET /rest/stream/scenario1b", () => {
-      it("should return a body", async () => {
-        const response = await request.get("/rest/stream/scenario1b");
-
-        expect(response.body).toEqual({id: "1"});
-      });
-    });
-  });
-}

package/src/tests/testView.ts

@@ -1,75 +0,0 @@
-import {EOL} from "node:os";
-
-import {Controller} from "@tsed/di";
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {Middleware, UseBefore} from "@tsed/platform-middlewares";
-import {Locals} from "@tsed/platform-params";
-import {View} from "@tsed/platform-views";
-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(@Locals() locals: any) {
-    locals.localID = "local-10909";
-  }
-}
-
-@Controller("/views")
-class ViewCtrl {
-  @Get("/scenario-1")
-  @UseBefore(LocalsMiddleware)
-  @View("view.ejs", {opts: "opts"})
-  testScenario1() {
-    return {
-      world: "world"
-    };
-  }
-
-  @Get("/scenario-2")
-  @View("view", {opts: "opts"}) // missing extension
-  testScenario2() {
-    return {
-      world: "world"
-    };
-  }
-}
-
-export function testView(options: PlatformTestingSdkOpts) {
-  let request: SuperTest.Agent;
-
-  beforeAll(
-    PlatformTest.bootstrap(options.server, {
-      ...options,
-      mount: {
-        "/rest": [ViewCtrl]
-      }
-    })
-  );
-  beforeAll(() => {
-    request = SuperTest(PlatformTest.callback());
-  });
-  afterAll(() => PlatformTest.reset());
-
-  describe("Scenario1: GET /rest/views/scenario-1", () => {
-    it("should render a view", async () => {
-      const response = await request.get("/rest/views/scenario-1").expect(200);
-
-      expect(response.headers["content-type"]).toContain("text/html");
-      expect(response.text).toEqual(`<p>Hello world with opts and ID local-10909</p>${EOL}`);
-    });
-  });
-
-  describe("Scenario2: GET /rest/views/scenario-2", () => {
-    it("should throw an error when extension is not defined", async () => {
-      const response = await request.get("/rest/views/scenario-2").expect(500);
-
-      expect(response.body.name).toEqual("TEMPLATE_RENDER_ERROR");
-      expect(response.body.message).toContain("Template rendering error: ViewCtrl.testScenario2()");
-      expect(response.body.status).toEqual(500);
-    });
-  });
-}