@tsed/platform-test-sdk 7.79.4 → 7.80.1

package/src/components/PlatformTestSdk.ts

@@ -1,29 +0,0 @@
-import {PlatformTest} from "@tsed/common";
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-import {specsContainer} from "../tests/exports.js";
-
-export class PlatformTestSdk {
-  protected constructor(private options: PlatformTestingSdkOpts) {}
-
-  static create(options: PlatformTestingSdkOpts) {
-    return new PlatformTestSdk(options);
-  }
-
-  test(name: string, options: any = {}) {
-    specsContainer.get(name)!({
-      ...this.options,
-      ...options
-    });
-  }
-
-  bootstrap(options: any = {}) {
-    return PlatformTest.bootstrap(this.options.server, {
-      ...this.options,
-      ...options
-    });
-  }
-
-  reset() {
-    return PlatformTest.reset;
-  }
-}

package/src/data/file.txt

@@ -1 +0,0 @@
-test content

package/src/data/response.data.json

@@ -1,3 +0,0 @@
-{
-  "id": "1"
-}

package/src/data/swagger.json

@@ -1,32 +0,0 @@
-{
-  "openapi": "3.0.1",
-  "info": {
-    "version": "1.0.0",
-    "description": "Swagger description",
-    "title": "Swagger Title",
-    "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"
-    }
-  },
-  "components": {
-    "securitySchemes": {
-      "global_auth": {
-        "type": "oauth2",
-        "flows": {
-          "implicit": {
-            "authorizationUrl": "http://petstore.swagger.io/oauth/dialog",
-            "scopes": {
-              "admin": "Admin access"
-            }
-          }
-        }
-      }
-    }
-  },
-  "paths": {}
-}

package/src/errors/CustomBadRequest.ts

@@ -1,16 +0,0 @@
-import {ResponseErrorObject} from "@tsed/common";
-import {BadRequest} from "@tsed/exceptions";
-
-export class CustomBadRequest extends BadRequest implements ResponseErrorObject {
-  name = "CUSTOM_BAD_REQUEST";
-  errors: any[];
-  headers = {};
-
-  constructor(message: string) {
-    super(message);
-    this.errors = ["test"];
-    this.headers = {
-      "X-HEADER-ERROR": "deny"
-    };
-  }
-}

package/src/errors/CustomInternalError.ts

@@ -1,16 +0,0 @@
-import {ResponseErrorObject} from "@tsed/common";
-import {InternalServerError} from "@tsed/exceptions";
-
-export class CustomInternalError extends InternalServerError implements ResponseErrorObject {
-  name = "CUSTOM_INTERNAL_SERVER_ERROR";
-  errors: any[];
-  headers = {};
-
-  constructor(message: string) {
-    super(message);
-    this.errors = ["test"];
-    this.headers = {
-      "X-HEADER-ERROR": "deny"
-    };
-  }
-}

package/src/interfaces/PlatformTestingSdkOpts.ts

@@ -1,10 +0,0 @@
-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/modules/feature/FeatureModule.ts

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

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

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

@@ -1,71 +0,0 @@
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-import {testAcceptMime} from "./testAcceptMime.js";
-import {testAuth} from "./testAuth.js";
-import {testBodyParams} from "./testBodyParams.js";
-import {testChildrenControllers} from "./testChildrenControllers.js";
-import {testCookies} from "./testCookies.js";
-import {testCustom404} from "./testCustom404.js";
-import {testDeepQueryParams} from "./testDeepQueryParams.js";
-import {testErrors} from "./testErrors.js";
-import {testHandlers} from "./testHandlers.js";
-import {testHeaderParams} from "./testHeaderParams.js";
-import {testHeaders} from "./testHeaders.js";
-import {testInheritanceController} from "./testInheritanceController.js";
-import {testLocals} from "./testLocals.js";
-import {testLocation} from "./testLocation.js";
-import {testMiddlewares} from "./testMiddlewares.js";
-import {testModule} from "./testModule.js";
-import {testMulter} from "./testMulter.js";
-import {testPathParams} from "./testPathParams.js";
-import {testQueryParams} from "./testQueryParams.js";
-import {testRedirect} from "./testRedirect.js";
-import {testResponse} from "./testResponse.js";
-import {testResponseFilter} from "./testResponseFilter.js";
-import {testRouting} from "./testRouting.js";
-import {testScopeRequest} from "./testScopeRequest.js";
-import {testSession} from "./testSession.js";
-import {testStatics} from "./testStatics.js";
-import {testStream} from "./testStream.js";
-import {testView} from "./testView.js";
-import {testCache} from "./testCache.js";
-
-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("stream", testStream);
-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("deepQueryParams", testDeepQueryParams);
-specsContainer.set("locals", testLocals);
-specsContainer.set("multer", testMulter);
-
-// ROUTING
-specsContainer.set("scopeRequest", testScopeRequest);
-specsContainer.set("routing", testRouting);
-
-// CODE ORGANIZATION
-specsContainer.set("childrenControllers", testChildrenControllers);
-specsContainer.set("inheritanceController", testInheritanceController);
-specsContainer.set("module", testModule);

package/src/tests/testAcceptMime.ts

@@ -1,95 +0,0 @@
-import {AcceptMime, Controller, Get, HeaderParams, PlatformTest, Post} from "@tsed/common";
-import {ContentType} from "@tsed/schema";
-import SuperTest from "supertest";
-import {PlatformTestingSdkOpts} from "../interfaces/index.js";
-
-@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.Agent;
-
-  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

@@ -1,339 +0,0 @@
-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/index.js";
-
-@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.Agent;
-
-  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"}]
-      });
-    });
-  });
-}