@tsed/platform-test-sdk
Version:
Package to test platform adapter integration with Ts.ED
254 lines (253 loc) • 8.95 kB
JavaScript
import { __decorate, __metadata, __param } from "tslib";
import "@tsed/ajv";
import { Env } from "@tsed/core";
import { Controller } from "@tsed/di";
import { BadRequest, InternalServerError } from "@tsed/exceptions";
import { Err } from "@tsed/platform-http";
import { PlatformTest } from "@tsed/platform-http/testing";
import { Middleware, UseAfter } from "@tsed/platform-middlewares";
import { BodyParams } from "@tsed/platform-params";
import { Description, Get, Name, Post, Required, Returns, Summary } from "@tsed/schema";
import SuperTest from "supertest";
import { afterAll, beforeAll, expect, it } from "vitest";
import { CustomBadRequest } from "../errors/CustomBadRequest.js";
import { CustomInternalError } from "../errors/CustomInternalError.js";
class CustomModel {
}
__decorate([
Required(),
__metadata("design:type", String)
], CustomModel.prototype, "name", void 0);
class CustomPropModel {
}
__decorate([
Name("role_item"),
Required(),
__metadata("design:type", String)
], CustomPropModel.prototype, "roleItem", void 0);
let ErrorMiddleware = class ErrorMiddleware {
use(error) {
return {
message: "no error"
};
}
};
__decorate([
__param(0, Err()),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object]),
__metadata("design:returntype", void 0)
], ErrorMiddleware.prototype, "use", null);
ErrorMiddleware = __decorate([
Middleware()
], ErrorMiddleware);
let FakeMiddleware = class FakeMiddleware {
use() {
return {
message: "should not be called by the platform when endpoint throw an error"
};
}
};
FakeMiddleware = __decorate([
Middleware()
], FakeMiddleware);
let ErrorsCtrl = class ErrorsCtrl {
scenario1() {
throw new CustomBadRequest("Custom Bad Request");
}
scenario2() {
throw new Error("My error");
}
scenario3() {
throw new CustomInternalError("My custom error");
}
scenario4(name) {
return name;
}
scenario5(model) {
return model;
}
scenario6(model) {
return model;
}
scenario7() {
throw new CustomInternalError("My custom error");
}
};
__decorate([
Get("/scenario-1"),
(Returns(500, InternalServerError).Description("Custom Bad Request")),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], ErrorsCtrl.prototype, "scenario1", null);
__decorate([
Get("/scenario-2"),
(Returns(500).Description("Internal Server Error")),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], ErrorsCtrl.prototype, "scenario2", null);
__decorate([
Get("/scenario-3"),
(Returns(400, CustomInternalError).Description("Bad request")),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], ErrorsCtrl.prototype, "scenario3", null);
__decorate([
Post("/scenario-4"),
Returns(400),
__param(0, Required()),
__param(0, BodyParams("name")),
__metadata("design:type", Function),
__metadata("design:paramtypes", [String]),
__metadata("design:returntype", void 0)
], ErrorsCtrl.prototype, "scenario4", null);
__decorate([
Post("/scenario-5"),
(Returns(400, BadRequest).Description("Bad request")),
__param(0, Required()),
__param(0, BodyParams()),
__metadata("design:type", Function),
__metadata("design:paramtypes", [CustomModel]),
__metadata("design:returntype", void 0)
], ErrorsCtrl.prototype, "scenario5", null);
__decorate([
Post("/scenario-6"),
Summary("Throw a Required prop if prop name is required"),
Description(`Return a required error`),
(Returns(400).Description("Bad request")),
__param(0, Required()),
__param(0, BodyParams()),
__metadata("design:type", Function),
__metadata("design:paramtypes", [CustomPropModel]),
__metadata("design:returntype", void 0)
], ErrorsCtrl.prototype, "scenario6", null);
__decorate([
Get("/scenario-7"),
(Returns(400).Description("Bad request")),
UseAfter(FakeMiddleware),
UseAfter(ErrorMiddleware),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], ErrorsCtrl.prototype, "scenario7", null);
ErrorsCtrl = __decorate([
Controller("/errors")
], ErrorsCtrl);
export { ErrorsCtrl };
export function testErrors(options) {
let request;
beforeAll(PlatformTest.bootstrap(options.server, {
...options,
env: Env.TEST,
mount: {
"/rest": [ErrorsCtrl]
}
}));
beforeAll(() => {
request = SuperTest(PlatformTest.callback());
});
afterAll(PlatformTest.reset);
it("Scenario 1: GET /rest/errors/scenario-1", async () => {
const response = await request.get("/rest/errors/scenario-1").expect(400);
expect(response.headers["x-header-error"]).toEqual("deny");
expect(response.body).toEqual({
name: "CUSTOM_BAD_REQUEST",
message: "Custom Bad Request",
status: 400,
errors: ["test"]
});
});
it("Scenario 2: GET /rest/errors/scenario-2", async () => {
const response = await request.get("/rest/errors/scenario-2").expect(500);
expect(response.body).toEqual({
errors: [],
message: "My error",
name: "Error",
status: 500
});
});
it("Scenario 3: GET /rest/errors/scenario-3", async () => {
const response = await request.get("/rest/errors/scenario-3").expect(500);
expect(response.headers["x-header-error"]).toEqual("deny");
expect(response.body).toEqual({
name: "CUSTOM_INTERNAL_SERVER_ERROR",
message: "My custom error",
status: 500,
errors: ["test"]
});
});
it("Scenario 4: POST /rest/errors/scenario-4", async () => {
const response = await request.post("/rest/errors/scenario-4").expect(400);
expect(response.body).toEqual({
errors: [
{
dataPath: ".name",
requestPath: "body",
keyword: "required",
message: "It should have required parameter 'name'",
modelName: "body",
params: {
missingProperty: "name"
},
schemaPath: "#/required"
}
],
message: "Bad request on parameter \"request.body.name\".\nIt should have required parameter 'name'",
name: "REQUIRED_VALIDATION_ERROR",
status: 400
});
});
it("Scenario 5: POST /rest/errors/scenario-5", async () => {
const response = await request.post("/rest/errors/scenario-5").send({}).expect(400);
expect(response.body).toEqual({
errors: [
{
dataPath: ".name",
requestPath: "body",
instancePath: "",
keyword: "required",
message: "must have required property 'name'",
modelName: "CustomModel",
params: {
missingProperty: "name"
},
schemaPath: "#/required"
}
],
message: 'Bad request on parameter "request.body".\nCustomModel must have required property \'name\'. Given value: "undefined"',
name: "AJV_VALIDATION_ERROR",
status: 400
});
});
it("Scenario 6: POST /rest/errors/scenario-6", async () => {
const response = await request.post(`/rest/errors/scenario-6`).send({}).expect(400);
expect(response.body).toEqual({
errors: [
{
dataPath: ".role_item",
requestPath: "body",
instancePath: "",
keyword: "required",
message: "must have required property 'role_item'",
modelName: "CustomPropModel",
params: {
missingProperty: "role_item"
},
schemaPath: "#/required"
}
],
message: 'Bad request on parameter "request.body".\nCustomPropModel must have required property \'role_item\'. Given value: "undefined"',
name: "AJV_VALIDATION_ERROR",
status: 400
});
});
it("Scenario 7: GET /rest/errors/scenario-7", async () => {
const response = await request.get("/rest/errors/scenario-7").expect(200);
expect(response.body).toEqual({
message: "no error"
});
});
}