@tsed/platform-test-sdk 7.12.0

package/src/tests/testRouting.ts

@@ -0,0 +1,65 @@
+import {Controller, Get, PlatformTest, Put} from "@tsed/common";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+const stub = jest.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.SuperTest<SuperTest.Test>;
+
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [TestRoutingController]
+      }
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+  afterEach(() => jest.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

@@ -0,0 +1,111 @@
+import {Controller, Get, PathParams, PlatformTest, ProviderScope, Scope, Service} from "@tsed/common";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+@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")
+  async 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.SuperTest<SuperTest.Test>;
+
+  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,104 @@
+import {BodyParams, Constant, Controller, Get, PlatformTest, Post, Req, Session} from "@tsed/common";
+import {NotFound} from "@tsed/exceptions";
+import {Indexed, Unique} from "@tsed/mongoose";
+import {Allow, Email, Ignore, MinLength, Property, Required, Returns} from "@tsed/schema";
+import SuperTest from "supertest";
+import {promisify} from "util";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+export class UserCreation {
+  @Property()
+  name: string;
+
+  @Indexed()
+  @Required()
+  @Email()
+  @Unique()
+  @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")
+  async connect(@Session() session: any, @BodyParams() user: UserCreation) {
+    session.user = user;
+
+    return user;
+  }
+
+  @Get("/userinfo")
+  @Returns(200, User)
+  async userInfo(@Session("user") user: User): Promise<User> {
+    if (!user) {
+      throw new NotFound("User not found");
+    }
+
+    return user;
+  }
+
+  @Get("/logout")
+  @Returns(204)
+  async logout(@Req() req: any) {
+    switch (this.platformName) {
+      case "koa":
+        return (req.ctx.session = null);
+      case "express":
+        delete req.session.user;
+
+        return promisify(req.session.destroy.bind(req.session))();
+    }
+  }
+}
+
+export function testSession(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+  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,61 @@
+import {Controller, PlatformTest} from "@tsed/common";
+import {getValue} from "@tsed/core";
+import {Configuration} from "@tsed/di";
+import {PlatformRouter} from "@tsed/platform-router";
+import {readFileSync} from "fs";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+@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.SuperTest<SuperTest.Test>;
+  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/testView.ts

@@ -0,0 +1,68 @@
+import {Controller, Get, Locals, Middleware, PlatformTest, UseBefore} from "@tsed/common";
+import {EOL} from "os";
+import SuperTest from "supertest";
+import {View} from "@tsed/platform-views";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+@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.SuperTest<SuperTest.Test>;
+
+  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);
+    });
+  });
+}

package/tsconfig.compile.esm.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.compile.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "module": "ES2020",
+    "rootDir": "src",
+    "outDir": "./lib/esm",
+    "declaration": true,
+    "declarationDir": "./lib/types"
+  },
+  "exclude": ["node_modules", "test", "lib", "benchmark", "coverage", "spec", "**/*.benchmark.ts", "**/*.spec.ts", "keys", "jest.config.js"]
+}