@tsed/platform-test-sdk 8.0.1 → 8.0.3

package/src/tests/testScopeRequest.ts

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

@@ -0,0 +1,108 @@
+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 {promisify} from "util";
+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

@@ -0,0 +1,63 @@
+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 {readFileSync} from "fs";
+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

@@ -0,0 +1,62 @@
+import {Controller} from "@tsed/di";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import {ContentType, Get} from "@tsed/schema";
+import {createReadStream} from "fs";
+import {join} from "path";
+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

@@ -0,0 +1,74 @@
+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 {EOL} from "os";
+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"]).toEqual("text/html; charset=utf-8");
+      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);
+    });
+  });
+}