@tsed/platform-test-sdk 7.12.0

package/src/index.ts

@@ -0,0 +1,39 @@
+/**
+ * @file Automatically generated by barrelsby.
+ */
+
+export * from "./components/PlatformTestSdk";
+export * from "./errors/CustomBadRequest";
+export * from "./errors/CustomInternalError";
+export * from "./interfaces/PlatformTestingSdkOpts";
+export * from "./modules/feature/FeatureModule";
+export * from "./modules/feature/controllers/FeatureController";
+export * from "./tests/exports";
+export * from "./tests/testAcceptMime";
+export * from "./tests/testAuth";
+export * from "./tests/testBodyParams";
+export * from "./tests/testCache";
+export * from "./tests/testChildrenControllers";
+export * from "./tests/testCookies";
+export * from "./tests/testCtrlInheritance";
+export * from "./tests/testCustom404";
+export * from "./tests/testErrors";
+export * from "./tests/testHandlers";
+export * from "./tests/testHeaderParams";
+export * from "./tests/testHeaders";
+export * from "./tests/testInheritanceController";
+export * from "./tests/testLocals";
+export * from "./tests/testLocation";
+export * from "./tests/testMiddlewares";
+export * from "./tests/testModule";
+export * from "./tests/testMulter";
+export * from "./tests/testPathParams";
+export * from "./tests/testQueryParams";
+export * from "./tests/testRedirect";
+export * from "./tests/testResponse";
+export * from "./tests/testResponseFilter";
+export * from "./tests/testRouting";
+export * from "./tests/testScopeRequest";
+export * from "./tests/testSession";
+export * from "./tests/testStatics";
+export * from "./tests/testView";

package/src/interfaces/PlatformTestingSdkOpts.ts

@@ -0,0 +1,10 @@
+import {PlatformAdapter} from "@tsed/common";
+import {Type} from "@tsed/core";
+
+export interface PlatformTestingSdkOpts {
+  rootDir: string;
+  platform: Type<PlatformAdapter<any>>;
+  server: Type<any>;
+
+  [key: string]: any;
+}

package/src/interfaces/index.ts

@@ -0,0 +1,5 @@
+/**
+ * @file Automatically generated by barrelsby.
+ */
+
+export * from "./PlatformTestingSdkOpts";

package/src/modules/feature/FeatureModule.ts

@@ -0,0 +1,9 @@
+import {Module} from "@tsed/di";
+import {FeatureController} from "./controllers/FeatureController";
+
+@Module({
+  mount: {
+    "/rest": [FeatureController]
+  }
+})
+export class FeatureModule {}

package/src/modules/feature/controllers/FeatureController.ts

@@ -0,0 +1,11 @@
+import {Controller, Get} from "@tsed/common";
+import {Hidden} from "@tsed/swagger";
+
+@Hidden()
+@Controller("/features")
+export class FeatureController {
+  @Get("/")
+  get() {
+    return "From feature";
+  }
+}

package/src/tests/exports.ts

@@ -0,0 +1,69 @@
+import {PlatformTestingSdkOpts} from "../interfaces";
+import {testAcceptMime} from "./testAcceptMime";
+import {testAuth} from "./testAuth";
+import {testBodyParams} from "./testBodyParams";
+import {testChildrenControllers} from "./testChildrenControllers";
+import {testCookies} from "./testCookies";
+import {testCtrlInheritance} from "./testCtrlInheritance";
+import {testCustom404} from "./testCustom404";
+import {testErrors} from "./testErrors";
+import {testHandlers} from "./testHandlers";
+import {testHeaderParams} from "./testHeaderParams";
+import {testHeaders} from "./testHeaders";
+import {testInheritanceController} from "./testInheritanceController";
+import {testLocals} from "./testLocals";
+import {testLocation} from "./testLocation";
+import {testMiddlewares} from "./testMiddlewares";
+import {testModule} from "./testModule";
+import {testMulter} from "./testMulter";
+import {testPathParams} from "./testPathParams";
+import {testQueryParams} from "./testQueryParams";
+import {testRedirect} from "./testRedirect";
+import {testResponse} from "./testResponse";
+import {testResponseFilter} from "./testResponseFilter";
+import {testRouting} from "./testRouting";
+import {testScopeRequest} from "./testScopeRequest";
+import {testSession} from "./testSession";
+import {testStatics} from "./testStatics";
+import {testView} from "./testView";
+import {testCache} from "./testCache";
+
+export const specsContainer = new Map<string, (options: PlatformTestingSdkOpts) => void>();
+
+// HANDLERS AND MIDDLEWARES
+specsContainer.set("handlers", testHandlers);
+specsContainer.set("auth", testAuth);
+specsContainer.set("middlewares", testMiddlewares);
+
+// RESPONSES
+specsContainer.set("headers", testHeaders);
+specsContainer.set("acceptMime", testAcceptMime);
+specsContainer.set("location", testLocation);
+specsContainer.set("redirect", testRedirect);
+specsContainer.set("view", testView);
+specsContainer.set("errors", testErrors);
+specsContainer.set("response", testResponse);
+specsContainer.set("responseFilter", testResponseFilter);
+specsContainer.set("custom404", testCustom404);
+specsContainer.set("statics", testStatics);
+specsContainer.set("cache", testCache);
+
+// INPUTS
+specsContainer.set("cookies", testCookies);
+specsContainer.set("session", testSession);
+specsContainer.set("headerParams", testHeaderParams);
+specsContainer.set("bodyParams", testBodyParams);
+specsContainer.set("pathParams", testPathParams);
+specsContainer.set("queryParams", testQueryParams);
+specsContainer.set("locals", testLocals);
+specsContainer.set("multer", testMulter);
+
+// ROUTING
+specsContainer.set("scopeRequest", testScopeRequest);
+specsContainer.set("routing", testRouting);
+specsContainer.set("inheritance", testCtrlInheritance);
+
+// CODE ORGANIZATION
+specsContainer.set("childrenControllers", testChildrenControllers);
+specsContainer.set("inheritanceController", testInheritanceController);
+specsContainer.set("module", testModule);

package/src/tests/testAcceptMime.ts

@@ -0,0 +1,95 @@
+import {AcceptMime, Controller, Get, HeaderParams, PlatformTest, Post} from "@tsed/common";
+import {ContentType} from "@tsed/schema";
+import SuperTest from "supertest";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+@Controller("/accept-mime")
+class TestAcceptMimeCtrl {
+  @Post("/scenario-1")
+  @AcceptMime("application/json")
+  scenario1(@HeaderParams("Accept") accept: string) {
+    return {
+      accept
+    };
+  }
+
+  @Get("/scenario-2")
+  @ContentType("text")
+  @AcceptMime("text")
+  public ping() {
+    return "pong";
+  }
+}
+
+export function testAcceptMime(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [TestAcceptMimeCtrl]
+      }
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+  describe("Scenario 1: POST /rest/accept-mime/scenario-1", () => {
+    it('should return a 200 response when Accept header match with @AcceptMime("application/json")', async () => {
+      const response = await request
+        .post("/rest/accept-mime/scenario-1")
+        .set({
+          Accept: "application/json"
+        })
+        .expect(200);
+
+      expect(response.body).toEqual({
+        accept: "application/json"
+      });
+    });
+    it('should return a 406 response when Accept header doesn\'t match with @AcceptMime("application/json")', async () => {
+      const response = await request
+        .post("/rest/accept-mime/scenario-1")
+        .set({
+          Accept: "application/xml"
+        })
+        .expect(406);
+
+      expect(response.body).toEqual({
+        name: "NOT_ACCEPTABLE",
+        message: "You must accept content-type application/json",
+        status: 406,
+        errors: []
+      });
+    });
+  });
+  describe("Scenario 2: GET /rest/accept-mime/scenario-2", () => {
+    it('should return a 200 response when Accept header match with @AcceptMime("text")', async () => {
+      const response = await request
+        .get("/rest/accept-mime/scenario-2")
+        .set({
+          Accept: "text/*, application/json"
+        })
+        .expect(200);
+
+      expect(response.text).toEqual("pong");
+    });
+    it('should return a 406 response when Accept header doesn\'t match with @AcceptMime("text")', async () => {
+      const response = await request
+        .get("/rest/accept-mime/scenario-2")
+        .set({
+          Accept: "application/xml"
+        })
+        .expect(406);
+
+      expect(response.body).toEqual({
+        name: "NOT_ACCEPTABLE",
+        message: "You must accept content-type text",
+        status: 406,
+        errors: []
+      });
+    });
+  });
+}

package/src/tests/testAuth.ts

@@ -0,0 +1,339 @@
+import {Context, Controller, Get, Inject, Injectable, Middleware, PlatformTest, Post, Req, UseAuth} from "@tsed/common";
+import {useDecorators} from "@tsed/core";
+import {BadRequest, Forbidden, Unauthorized} from "@tsed/exceptions";
+import {In, Returns, Security} from "@tsed/schema";
+import SuperTest from "supertest";
+import baseSpec from "../data/swagger.json";
+import {PlatformTestingSdkOpts} from "../interfaces";
+
+@Injectable()
+export class TokenService {
+  private _token: string = "EMPTY";
+
+  token(token?: string) {
+    if (token) {
+      this._token = token;
+    }
+
+    return this._token;
+  }
+
+  isValid(token: string | undefined) {
+    return String(token).match(/token/);
+  }
+}
+
+@Middleware()
+class OAuthMiddleware {
+  @Inject()
+  tokenService: TokenService;
+
+  public use(@Context() ctx: Context) {
+    const {endpoint, request} = ctx;
+
+    const options = endpoint.get(OAuthMiddleware) || {};
+
+    if (!request.get("authorization")) {
+      throw new Unauthorized("Unauthorized");
+    }
+
+    if (!this.tokenService.isValid(request.get("authorization"))) {
+      throw new BadRequest("Bad token format");
+    }
+
+    if (options && options.role === "admin" && request.get("authorization") !== "admin_token") {
+      throw new Forbidden("Forbidden");
+    }
+
+    ctx.getRequest().user = {
+      id: "id",
+      name: "name"
+    };
+  }
+}
+
+export function OAuth(options: any = {}): Function {
+  return useDecorators(
+    UseAuth(OAuthMiddleware, options),
+    Security("global_auth", ...(options.scopes || [])),
+    In("header").Type(String).Name("Authorization").Required(),
+    Returns(401).Description("Unauthorized"),
+    Returns(403).Description("Forbidden")
+  );
+}
+
+@Controller("/auth")
+class TestAuthCtrl {
+  @Inject()
+  tokenService: TokenService;
+
+  @Post("/authorize")
+  authorize() {
+    this.tokenService.token("access_token");
+
+    return {
+      access_token: this.tokenService.token()
+    };
+  }
+
+  @Get("/userinfo")
+  @OAuth()
+  token(@Req("user") user: any) {
+    return user;
+  }
+
+  @Get("/admin")
+  @OAuth({role: "admin", scopes: ["admin"]})
+  admin() {
+    return {
+      granted: true
+    };
+  }
+
+  @Post("/stepUp")
+  stepUp() {
+    this.tokenService.token("admin_token");
+
+    return {
+      access_token: this.tokenService.token()
+    };
+  }
+}
+
+export function testAuth(options: PlatformTestingSdkOpts) {
+  let request: SuperTest.SuperTest<SuperTest.Test>;
+
+  beforeAll(
+    PlatformTest.bootstrap(options.server, {
+      ...options,
+      mount: {
+        "/rest": [TestAuthCtrl]
+      },
+      swagger: [
+        {
+          path: "/doc",
+          spec: baseSpec as any
+        }
+      ]
+    })
+  );
+  beforeAll(() => {
+    request = SuperTest.agent(PlatformTest.callback());
+  });
+  afterAll(PlatformTest.reset);
+
+  describe("Scenario 1: Create token, test token and stepup token", () => {
+    it("should create a token, call /userinfo to get userinfo and try admin route", async () => {
+      await request.get("/rest/auth/userinfo").expect(401);
+      await request
+        .get("/rest/auth/userinfo")
+        .set({
+          Authorization: "wrong"
+        })
+        .expect(400);
+
+      const {body} = await request.post("/rest/auth/authorize").expect(200);
+
+      expect(body.access_token).toEqual("access_token");
+
+      const {body: userInfo} = await request
+        .get("/rest/auth/userinfo")
+        .set({
+          Authorization: body.access_token
+        })
+        .expect(200);
+
+      expect(userInfo).toEqual({
+        id: "id",
+        name: "name"
+      });
+
+      await request
+        .get("/rest/auth/admin")
+        .set({
+          Authorization: body.access_token
+        })
+        .expect(403);
+
+      const {
+        body: {access_token}
+      } = await request.post("/rest/auth/stepUp").expect(200);
+
+      expect(access_token).toEqual("admin_token");
+
+      const {body: result} = await request
+        .get("/rest/auth/admin")
+        .set({
+          Authorization: access_token
+        })
+        .expect(200);
+
+      expect(result).toEqual({
+        granted: true
+      });
+    });
+  });
+
+  describe("Scenario 2: GET /swagger.json", () => {
+    it("should generate the swagger.spec", async () => {
+      const {body: spec} = await request.get("/doc/swagger.json").expect(200);
+
+      expect(spec).toEqual({
+        openapi: "3.0.1",
+        info: {
+          version: "1.0.0",
+          title: "Swagger Title",
+          description: "Swagger description",
+          termsOfService: "http://swagger.io/terms/",
+          contact: {email: "apiteam@swagger.io"},
+          license: {name: "Apache 2.0", url: "http://www.apache.org/licenses/LICENSE-2.0.html"}
+        },
+        paths: {
+          "/rest/auth/authorize": {
+            post: {
+              operationId: "testAuthCtrlAuthorize",
+              responses: {"200": {description: "Success"}},
+              parameters: [],
+              tags: ["TestAuthCtrl"]
+            }
+          },
+          "/rest/auth/userinfo": {
+            get: {
+              operationId: "testAuthCtrlToken",
+              responses: {
+                "401": {
+                  content: {"application/json": {schema: {$ref: "#/components/schemas/Unauthorized"}}},
+                  description: "Unauthorized"
+                },
+                "403": {
+                  content: {"application/json": {schema: {$ref: "#/components/schemas/Forbidden"}}},
+                  description: "Forbidden"
+                }
+              },
+              security: [{global_auth: []}],
+              parameters: [
+                {
+                  name: "Authorization",
+                  required: true,
+                  in: "header",
+                  schema: {type: "string"}
+                }
+              ],
+              tags: ["TestAuthCtrl"]
+            }
+          },
+          "/rest/auth/admin": {
+            get: {
+              operationId: "testAuthCtrlAdmin",
+              responses: {
+                "401": {
+                  content: {"application/json": {schema: {$ref: "#/components/schemas/Unauthorized"}}},
+                  description: "Unauthorized"
+                },
+                "403": {
+                  content: {"application/json": {schema: {$ref: "#/components/schemas/Forbidden"}}},
+                  description: "Forbidden"
+                }
+              },
+              security: [{global_auth: ["admin"]}],
+              parameters: [
+                {
+                  name: "Authorization",
+                  required: true,
+                  in: "header",
+                  schema: {type: "string"}
+                }
+              ],
+              tags: ["TestAuthCtrl"]
+            }
+          },
+          "/rest/auth/stepUp": {
+            post: {
+              operationId: "testAuthCtrlStepUp",
+              responses: {"200": {description: "Success"}},
+              parameters: [],
+              tags: ["TestAuthCtrl"]
+            }
+          }
+        },
+        components: {
+          securitySchemes: {
+            global_auth: {
+              type: "oauth2",
+              flows: {
+                implicit: {
+                  authorizationUrl: "http://petstore.swagger.io/oauth/dialog",
+                  scopes: {admin: "Admin access"}
+                }
+              }
+            }
+          },
+          schemas: {
+            Unauthorized: {
+              type: "object",
+              properties: {
+                name: {
+                  type: "string",
+                  description: "The error name",
+                  minLength: 1,
+                  example: "UNAUTHORIZED",
+                  default: "UNAUTHORIZED"
+                },
+                message: {type: "string", description: "An error message", minLength: 1},
+                status: {
+                  type: "number",
+                  description: "The status code of the exception",
+                  example: 401,
+                  default: 401
+                },
+                errors: {
+                  type: "array",
+                  items: {$ref: "#/components/schemas/GenericError"},
+                  description: "A list of related errors"
+                },
+                stack: {type: "string", description: "The stack trace (only in development mode)"}
+              },
+              required: ["name", "message", "status"]
+            },
+            GenericError: {
+              type: "object",
+              properties: {
+                name: {type: "string", description: "The error name", minLength: 1},
+                message: {type: "string", description: "An error message", minLength: 1}
+              },
+              additionalProperties: true,
+              required: ["name", "message"]
+            },
+            Forbidden: {
+              type: "object",
+              properties: {
+                name: {
+                  type: "string",
+                  description: "The error name",
+                  minLength: 1,
+                  example: "FORBIDDEN",
+                  default: "FORBIDDEN"
+                },
+                message: {type: "string", description: "An error message", minLength: 1},
+                status: {
+                  type: "number",
+                  description: "The status code of the exception",
+                  example: 403,
+                  default: 403
+                },
+                errors: {
+                  type: "array",
+                  items: {$ref: "#/components/schemas/GenericError"},
+                  description: "A list of related errors"
+                },
+                stack: {type: "string", description: "The stack trace (only in development mode)"}
+              },
+              required: ["name", "message", "status"]
+            }
+          }
+        },
+        tags: [{name: "TestAuthCtrl"}]
+      });
+    });
+  });
+}