mirror of
https://github.com/outline/outline.git
synced 2026-11-22 22:02:35 +03:00
raw-body throws a 500 'stream is not readable' when the request stream is already destroyed at parse time, which means the client went away. Map it to ClientClosedRequestError so it reports 499 and is not sent to the bug tracker.
163 lines
4.4 KiB
TypeScript
163 lines
4.4 KiB
TypeScript
import type Koa from "koa";
|
|
import { DatabaseError } from "sequelize";
|
|
import type { Mock } from "vitest";
|
|
import { requestErrorHandler } from "@server/logging/sentry";
|
|
import { InternalError, ValidationError, NotFoundError } from "./errors";
|
|
import onerror from "./onerror";
|
|
|
|
// Mock the requestErrorHandler from Sentry
|
|
vi.mock("@server/logging/sentry", () => ({
|
|
requestErrorHandler: vi.fn(),
|
|
}));
|
|
|
|
type MockCtx = {
|
|
headers: Record<string, string>;
|
|
headerSent: boolean;
|
|
writable: boolean;
|
|
accepts: Mock;
|
|
set: Mock;
|
|
res: { end: Mock; statusCode: number };
|
|
status: number | undefined;
|
|
type: string | undefined;
|
|
body: unknown;
|
|
};
|
|
|
|
type ReportableError = Error & {
|
|
status?: number;
|
|
isReportable?: boolean;
|
|
};
|
|
|
|
describe("onerror", () => {
|
|
let app: Koa;
|
|
let ctx: MockCtx;
|
|
|
|
beforeEach(() => {
|
|
// Create a mock Koa app
|
|
app = {
|
|
context: {},
|
|
} as unknown as Koa;
|
|
|
|
// Apply the onerror middleware
|
|
onerror(app);
|
|
|
|
// Create a mock context
|
|
ctx = {
|
|
headers: {},
|
|
headerSent: false,
|
|
writable: true,
|
|
accepts: vi.fn(() => "json"),
|
|
set: vi.fn(),
|
|
res: {
|
|
end: vi.fn(),
|
|
statusCode: 404,
|
|
},
|
|
status: undefined,
|
|
type: undefined,
|
|
body: undefined,
|
|
};
|
|
|
|
// Clear mock calls
|
|
(requestErrorHandler as Mock).mockClear();
|
|
});
|
|
|
|
it("should report InternalError to Sentry", () => {
|
|
const error = InternalError("Test internal error");
|
|
|
|
app.context.onerror.call(ctx, error);
|
|
|
|
expect(requestErrorHandler).toHaveBeenCalledWith(error, ctx);
|
|
expect(ctx.status).toBe(500);
|
|
});
|
|
|
|
it("should not report ValidationError to Sentry", () => {
|
|
const error = ValidationError("Test validation error");
|
|
|
|
app.context.onerror.call(ctx, error);
|
|
|
|
expect(requestErrorHandler).not.toHaveBeenCalled();
|
|
expect(ctx.status).toBe(400);
|
|
});
|
|
|
|
it("should not report NotFoundError to Sentry", () => {
|
|
const error = NotFoundError("Test not found error");
|
|
|
|
app.context.onerror.call(ctx, error);
|
|
|
|
expect(requestErrorHandler).not.toHaveBeenCalled();
|
|
expect(ctx.status).toBe(404);
|
|
});
|
|
|
|
it("should report unknown errors without isReportable property to Sentry", () => {
|
|
const error = new Error("Unknown error") as ReportableError;
|
|
error.status = 500;
|
|
|
|
app.context.onerror.call(ctx, error);
|
|
|
|
expect(requestErrorHandler).toHaveBeenCalledWith(error, ctx);
|
|
});
|
|
|
|
it("should report errors with invalid status codes to Sentry", () => {
|
|
const error = new Error("Invalid status error") as ReportableError;
|
|
error.status = 999;
|
|
|
|
app.context.onerror.call(ctx, error);
|
|
|
|
expect(requestErrorHandler).toHaveBeenCalledWith(error, ctx);
|
|
});
|
|
|
|
it("should not report errors explicitly marked with isReportable: false", () => {
|
|
const error = new Error("Custom error") as ReportableError;
|
|
error.status = 500;
|
|
error.isReportable = false;
|
|
|
|
app.context.onerror.call(ctx, error);
|
|
|
|
expect(requestErrorHandler).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("should convert a canceled query into a service unavailable error", () => {
|
|
const parent = new Error("canceling statement due to statement timeout");
|
|
Object.assign(parent, { code: "57014", sql: "SELECT 1" });
|
|
const error = new DatabaseError(parent as never);
|
|
|
|
app.context.onerror.call(ctx, error);
|
|
|
|
expect(requestErrorHandler).toHaveBeenCalled();
|
|
expect(ctx.status).toBe(503);
|
|
expect(ctx.body).toContain("request_timeout");
|
|
});
|
|
|
|
it("should convert an unreadable request stream into a client closed request", () => {
|
|
const error = new Error("stream is not readable") as ReportableError & {
|
|
type?: string;
|
|
};
|
|
error.status = 500;
|
|
error.type = "stream.not.readable";
|
|
|
|
app.context.onerror.call(ctx, error);
|
|
|
|
expect(requestErrorHandler).not.toHaveBeenCalled();
|
|
expect(ctx.status).toBe(499);
|
|
expect(ctx.body).toContain("client_closed_request");
|
|
});
|
|
|
|
it("should set the response status code when the response is not writable", () => {
|
|
ctx.writable = false;
|
|
|
|
app.context.onerror.call(ctx, InternalError("Test internal error"));
|
|
|
|
expect(ctx.res.statusCode).toBe(500);
|
|
expect(ctx.res.end).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("should report errors explicitly marked with isReportable: true", () => {
|
|
const error = new Error("Custom error") as ReportableError;
|
|
error.status = 400;
|
|
error.isReportable = true;
|
|
|
|
app.context.onerror.call(ctx, error);
|
|
|
|
expect(requestErrorHandler).toHaveBeenCalledWith(error, ctx);
|
|
});
|
|
});
|