@tsed/platform-test-sdk 7.12.0

package/src/tests/testCache.ts

@@ -0,0 +1,270 @@
+import {Controller, Get, Head, Inject, PathParams, PlatformTest, Post, QueryParams} from "@tsed/common";
+import {UseCache, PlatformCache} from "@tsed/platform-cache";
+import {Property} from "@tsed/schema";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+let increment = 0;
+
+export function testCache(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+
+  class MyModel {
+    @Property()
+    name: string;
+  }
+
+  class MyService {
+    @UseCache({
+      key: "key"
+    })
+    get(id: string) {
+      return {id: `one:${id}`};
+    }
+
+    @UseCache({
+      key(args: any[]) {
+        return `key:${args[0]}`;
+      }
+    })
+    get2(id: string) {
+      return {id: `one:${id}`};
+    }
+  }
+
+  @Controller("/caches")
+  class TestCacheController {
+    @Inject()
+    myService: MyService;
+
+    @Get("/scenario-1")
+    @UseCache()
+    scenario1() {
+      increment++;
+      return "hello world " + increment;
+    }
+
+    @Get("/scenario-2")
+    @UseCache({ttl: 400})
+    scenario2() {
+      return {info: "hello child"};
+    }
+
+    @Head("/scenario-3")
+    @UseCache()
+    scenario3() {
+      return undefined;
+    }
+
+    @Post("/scenario-4")
+    @UseCache()
+    scenario4() {
+      return {info: "hello child"};
+    }
+
+    @Get("/scenario-5/:id")
+    @UseCache({ttl: 400})
+    scenario5(@PathParams("id") id: string, @QueryParams() model: MyModel) {
+      return {info: "hello child", id, ...model};
+    }
+
+    @Get("/scenario-6/:id")
+    scenario6(@PathParams("id") id: string) {
+      return this.myService.get(id);
+    }
+
+    @Get("/scenario-7/:id")
+    scenario7(@PathParams("id") id: string) {
+      return this.myService.get2(id);
+    }
+  }
+
+  describe("withCache", () => {
+    beforeEach(
+      PlatformTest.bootstrap(options.server, {
+        ...options,
+        logger: {},
+        mount: {
+          "/rest": [TestCacheController]
+        },
+        cache: {
+          ttl: 300,
+          store: "memory"
+        }
+      })
+    );
+    beforeEach(() => {
+      request = SuperTest(PlatformTest.callback());
+    });
+    afterEach(PlatformTest.reset);
+
+    describe("scenario 1: GET /rest/caches/scenario-1", () => {
+      it("should return data with cached response", async () => {
+        const response = await request.get("/rest/caches/scenario-1").expect(200);
+        const response2 = await request.get("/rest/caches/scenario-1").expect(200);
+
+        expect(response.text).toContain("hello world");
+        expect(response.headers["cache-control"]).toMatch(/max-age=300/);
+        expect(response.headers["x-cached"]).toBeUndefined();
+
+        expect(response2.text).toContain("hello world");
+        expect(response2.headers["cache-control"]).toMatch(/max-age=300/);
+        expect(response2.headers["x-cached"]).toEqual("true");
+        expect(response2.headers["etag"]).toEqual(response.headers["etag"]);
+      });
+
+      it("should return 304 when content isn't modified", async () => {
+        const platformCache = PlatformTest.get<PlatformCache>(PlatformCache);
+
+        const response = await request.get("/rest/caches/scenario-1").expect(200);
+
+        await request.get("/rest/caches/scenario-1").set("if-none-match", response.headers["etag"]).expect(304);
+
+        await platformCache.reset();
+
+        await request.get("/rest/caches/scenario-1").set("if-none-match", response.headers["etag"]).expect(200);
+      });
+
+      it("should return fresh data if cache-control is set to no-cache", async () => {
+        await request.get("/rest/caches/scenario-1").expect(200);
+        const response2 = await request.get("/rest/caches/scenario-1").set("cache-control", "no-cache").expect(200);
+
+        expect(response2.text).toContain("hello world");
+        expect(response2.headers["cache-control"]).toMatch(/max-age=300/);
+        expect(response2.headers["x-cached"]).toBeUndefined();
+        expect(response2.headers["etag"]).toEqual(response2.headers["etag"]);
+      });
+    });
+    describe("scenario 2: GET /rest/caches/scenario-2", () => {
+      it("should return data with cached response", async () => {
+        const response = await request.get("/rest/caches/scenario-2").expect(200);
+        const response2 = await request.get("/rest/caches/scenario-2").expect(200);
+
+        expect(response.body).toEqual({info: "hello child"});
+        expect(response.headers["cache-control"]).toMatch(/max-age=400/);
+        expect(response.headers["x-cached"]).toBeUndefined();
+
+        expect(response2.body).toEqual({info: "hello child"});
+        expect(response2.headers["cache-control"]).toMatch(/max-age=400/);
+        expect(response2.headers["x-cached"]).toEqual("true");
+        expect(response2.headers["etag"]).toEqual(response.headers["etag"]);
+      });
+    });
+    describe("scenario 4: POST /rest/caches/scenario-4", () => {
+      it("should not cache POST method", async () => {
+        const response = await request.post("/rest/caches/scenario-4").expect(200);
+        const response2 = await request.post("/rest/caches/scenario-4").expect(200);
+
+        expect(response.body).toEqual({
+          info: "hello child"
+        });
+        expect(response.headers["cache-control"]).toBeUndefined();
+        expect(response.headers["x-cached"]).toBeUndefined();
+
+        expect(response2.body).toEqual({
+          info: "hello child"
+        });
+        expect(response.headers["cache-control"]).toBeUndefined();
+        expect(response2.headers["x-cached"]).toBeUndefined();
+        expect(response2.headers["etag"]).toEqual(response.headers["etag"]);
+      });
+    });
+    describe("scenario 5: GET /rest/caches/scenario-5", () => {
+      it("should return data with then cache response", async () => {
+        const response = await request.get("/rest/caches/scenario-5/1?name=1").expect(200);
+        const response2 = await request.get("/rest/caches/scenario-5/1?name=1").expect(200);
+        const response3 = await request.get("/rest/caches/scenario-5/2?name=2").expect(200);
+        const response4 = await request.get("/rest/caches/scenario-5/2?name=2").expect(200);
+        const response5 = await request.get("/rest/caches/scenario-5/2?name=3").expect(200);
+
+        expect(response.body).toEqual({
+          id: "1",
+          info: "hello child",
+          name: "1"
+        });
+        expect(response2.body).toEqual({
+          id: "1",
+          info: "hello child",
+          name: "1"
+        });
+        expect(response.headers["x-cached"]).toBeUndefined();
+        expect(response2.headers["x-cached"]).toEqual("true");
+        expect(response.body).toEqual(response2.body);
+
+        expect(response3.body).toEqual({
+          id: "2",
+          info: "hello child",
+          name: "2"
+        });
+        expect(response4.body).toEqual({
+          id: "2",
+          info: "hello child",
+          name: "2"
+        });
+        expect(response3.headers["x-cached"]).toBeUndefined();
+        expect(response4.headers["x-cached"]).toEqual("true");
+        expect(response3.body).toEqual(response4.body);
+
+        expect(response2.body).not.toEqual(response4);
+        expect(response5.body).not.toEqual(response4);
+      });
+    });
+    describe("scenario 6: GET /rest/caches/scenario-6", () => {
+      it("should return data from cached service", async () => {
+        const response = await request.get("/rest/caches/scenario-6/1").expect(200);
+        const response2 = await request.get("/rest/caches/scenario-6/2").expect(200);
+
+        expect(response.body).toEqual({id: "one:1"});
+        expect(response2.body).toEqual({id: "one:1"});
+        expect(response.headers["x-cached"]).toBeUndefined();
+        expect(response2.headers["x-cached"]).toBeUndefined();
+        expect(response.body).toEqual(response2.body);
+      });
+    });
+    describe("scenario 7: GET /rest/caches/scenario-7", () => {
+      it("should return data from cached service", async () => {
+        const response = await request.get("/rest/caches/scenario-7/1").expect(200);
+        const response2 = await request.get("/rest/caches/scenario-7/2").expect(200);
+        const response3 = await request.get("/rest/caches/scenario-7/2").expect(200);
+
+        expect(response.body).toEqual({id: "one:1"});
+        expect(response2.body).toEqual({
+          id: "one:2"
+        });
+        expect(response3.body).toEqual({
+          id: "one:2"
+        });
+        expect(response.body).not.toEqual(response2.body);
+      });
+    });
+  });
+  describe("withoutCache", () => {
+    beforeEach(
+      PlatformTest.bootstrap(options.server, {
+        ...options,
+        logger: {},
+        cache: false,
+        mount: {
+          "/rest": [TestCacheController]
+        }
+      })
+    );
+    beforeEach(() => {
+      request = SuperTest(PlatformTest.callback());
+    });
+    afterEach(PlatformTest.reset);
+
+    describe("scenario 1: GET /rest/caches/scenario-1", () => {
+      it("should return data with cached response", async () => {
+        const response = await request.get("/rest/caches/scenario-1").expect(200);
+        const response2 = await request.get("/rest/caches/scenario-1").expect(200);
+
+        expect(response.text).toContain("hello world");
+        expect(response.headers["x-cached"]).toBeUndefined();
+
+        expect(response2.text).toContain("hello world");
+        expect(response2.headers["x-cached"]).toBeUndefined();
+      });
+    });
+  });
+}

package/src/tests/testChildrenControllers.ts

@@ -0,0 +1,55 @@
+import {Controller, Get, PlatformTest} from "@tsed/common";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+export function testChildrenControllers(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+
+  @Controller("/children")
+  class TestChildController {
+    @Get("/scenario-2")
+    get() {
+      return "hello child";
+    }
+  }
+
+  @Controller({
+    path: "/controllers",
+    children: [TestChildController]
+  })
+  class TestController {
+    @Get("/scenario-1")
+    scenario1() {
+      return "hello world";
+    }
+  }
+
+  beforeEach(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [TestController]
+      }
+    })
+  );
+  beforeEach(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterEach(PlatformTest.reset);
+
+  describe("scenario 1: GET /rest/controllers/scenario-1", () => {
+    it("should return a response from method", async () => {
+      const response = await request.get("/rest/controllers/scenario-1").expect(200);
+
+      expect(response.text).toEqual("hello world");
+    });
+  });
+
+  describe("scenario 2: GET /rest/controllers/children/scenario-2", () => {
+    it("should return a response from method", async () => {
+      const response = await request.get("/rest/controllers/children/scenario-2").expect(200);
+
+      expect(response.text).toEqual("hello child");
+    });
+  });
+}

package/src/tests/testCookies.ts

@@ -0,0 +1,36 @@
+import {Controller, CookiesParams, Get, PlatformTest} from "@tsed/common";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+@Controller("/cookies")
+export class CookiesCtrl {
+  /**
+   * Handle request and get auth from cookies
+   * @param authorization
+   */
+  @Get("/scenario-1")
+  public scenario1(@CookiesParams("authorization") authorization: string) {
+    return {authorization};
+  }
+}
+
+export function testCookies(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [CookiesCtrl]
+      }
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+  it("Scenario 1: GET /rest/cookies/scenario-1", async () => {
+    const {body} = await request.get("/rest/cookies/scenario-1").set("Cookie", "authorization=eOIjdkk").expect(200);
+
+    expect(body.authorization).toEqual("eOIjdkk");
+  });
+}

package/src/tests/testCtrlInheritance.ts

@@ -0,0 +1,140 @@
+import {Controller, Get, PathParams, PlatformTest, QueryParams} from "@tsed/common";
+import {getSpec, SpecTypes} from "@tsed/schema";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+export abstract class TestBaseController {
+  @Get("/")
+  scenario1(@QueryParams("search") search: string) {
+    return {
+      search
+    };
+  }
+
+  @Get("/override")
+  scenario3(@QueryParams("q") q: string) {
+    return {data: q};
+  }
+}
+
+@Controller("/test")
+export class TestChildController extends TestBaseController {
+  @Get("/:id")
+  scenario2(@PathParams("id") id: string) {
+    return {id};
+  }
+
+  @Get("/override")
+  scenario3(@QueryParams("s") s: string) {
+    return {data: s};
+  }
+}
+
+export function testCtrlInheritance(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [TestChildController]
+      }
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+
+  it("Scenario1: should call inherited method", async () => {
+    const {body} = await request.get("/rest/test/?search=test").expect(200);
+    expect(body).toEqual({
+      search: "test"
+    });
+  });
+
+  it("Scenario2: should the Child method", async () => {
+    const {body} = await request.get("/rest/test/1").expect(200);
+    expect(body).toEqual({id: "1"});
+  });
+
+  it("Scenario2: 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"});
+  });
+
+  it("should generate swagger json", () => {
+    expect(getSpec(TestChildController, {specType: SpecTypes.OPENAPI})).toEqual({
+      paths: {
+        "/test": {
+          get: {
+            operationId: "testBaseControllerScenario1",
+            parameters: [
+              {
+                in: "query",
+                name: "search",
+                required: false,
+                schema: {
+                  type: "string"
+                }
+              }
+            ],
+            responses: {
+              "200": {
+                description: "Success"
+              }
+            },
+            tags: ["TestChildController"]
+          }
+        },
+        "/test/override": {
+          get: {
+            operationId: "testChildControllerScenario3",
+            parameters: [
+              {
+                in: "query",
+                name: "s",
+                required: false,
+                schema: {
+                  type: "string"
+                }
+              }
+            ],
+            responses: {
+              "200": {
+                description: "Success"
+              }
+            },
+            tags: ["TestChildController"]
+          }
+        },
+        "/test/{id}": {
+          get: {
+            operationId: "testChildControllerScenario2",
+            parameters: [
+              {
+                in: "path",
+                name: "id",
+                required: true,
+                schema: {
+                  type: "string"
+                }
+              }
+            ],
+            responses: {
+              "200": {
+                description: "Success"
+              }
+            },
+            tags: ["TestChildController"]
+          }
+        }
+      },
+      tags: [
+        {
+          name: "TestChildController"
+        }
+      ]
+    });
+  });
+}

package/src/tests/testCustom404.ts

@@ -0,0 +1,33 @@
+import {PlatformTest} from "@tsed/common";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+export function testCustom404(options: PlatformTestingSdkOpts) {
+  class CustomServer extends options.server {}
+
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+  beforeAll(
+    PlatformTest.bootstrap(CustomServer, {
+      ...options,
+      mount: {
+        "/rest": []
+      }
+    })
+  );
+
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+
+  it("Scenario 1: GET /", async () => {
+    const response: any = await request.get("/").expect(404);
+
+    expect(response.body).toEqual({
+      name: "NOT_FOUND",
+      message: 'Resource "/" not found',
+      status: 404,
+      errors: []
+    });
+  });
+}