467 lines
17 KiB
TypeScript
467 lines
17 KiB
TypeScript
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
|
||
|
||
import type { CheckerContext, ResolveContext } from "../../../../../src/server/checker/runner/types";
|
||
import type { ResolvedHttpTarget } from "../../../../../src/server/checker/types";
|
||
|
||
import { HttpChecker } from "../../../../../src/server/checker/runner/http/runner";
|
||
|
||
const checker = new HttpChecker();
|
||
const SELF_SIGNED_CERT = `-----BEGIN CERTIFICATE-----
|
||
MIIDJTCCAg2gAwIBAgIUTwQU8FzvnvxNYR7mMO0DLcnq+wQwDQYJKoZIhvcNAQEL
|
||
BQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MB4XDTI2MDUxMjE1NDAyOFoXDTM2MDUw
|
||
OTE1NDAyOFowFDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEF
|
||
AAOCAQ8AMIIBCgKCAQEArC0G46EXF8qPsCS2mtNwHzGFQvFQNcU8k7cZkCTwt4Cp
|
||
DlLOA2DbzR02LiVk/TA+d9qMUABAiXMndwebKv8EYxoKjwTY0jbVLKfEIIFxQS3F
|
||
uvKDgkYJz8P675p8fhR0Xa21+13b0/T8fperYC7fBZZsAqyo8+aF9QOUjy+kWRjr
|
||
lTTL1ez5L1nX0QCczTRaUDe51NTmcUYHJoiLqdKI2ZjXds7wnsaAfAgh7H9qr4wl
|
||
sUhCHV/Pg1LzBtfyLKZcImUJWWkj/KlgFgZ6aRyJHoGFmlZtXyaKhf3rEa+ZvKOy
|
||
MhcRmWC694PF+QjhrWS7oODLuY3XC5WKnLKxlBgfAwIDAQABo28wbTAdBgNVHQ4E
|
||
FgQUrHJEbBSDHOx/HAQ5nQp35v0Ljw8wHwYDVR0jBBgwFoAUrHJEbBSDHOx/HAQ5
|
||
nQp35v0Ljw8wDwYDVR0TAQH/BAUwAwEB/zAaBgNVHREEEzARgglsb2NhbGhvc3SH
|
||
BH8AAAEwDQYJKoZIhvcNAQELBQADggEBAEJ0s/FJ6KZalSM0ntHxlMOB9taUa60I
|
||
A6zqrEMauU8BqZO3QLmX6a821geZntQtz77kGtW6rQWxELBNjN3rXTbUKfKXN/Au
|
||
ZLftNJLsQOjKF+1uFOF49D4/5Le9PGvwl79Qua/l6JO5HRJL9Dh545/zEr9W5Erb
|
||
l4JoKKfyCEYjrPg5tl7d2PrHUmzk+sGlxEqNeKIl272+3UMVCbkVHI/v6rtb4F7p
|
||
u77O0UYLNIRFZQOVqvE7A7rfYy93J8EEQcADKH/Nhx8clFxC5X187EakcVAfkeKX
|
||
SL7R1kmUiLPiHbVCqGyS2m3RH2XDM3MbA9WCCczbwXn5Lwp5HEz0wb0=
|
||
-----END CERTIFICATE-----`;
|
||
const SELF_SIGNED_KEY = `-----BEGIN PRIVATE KEY-----
|
||
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCsLQbjoRcXyo+w
|
||
JLaa03AfMYVC8VA1xTyTtxmQJPC3gKkOUs4DYNvNHTYuJWT9MD532oxQAECJcyd3
|
||
B5sq/wRjGgqPBNjSNtUsp8QggXFBLcW68oOCRgnPw/rvmnx+FHRdrbX7XdvT9Px+
|
||
l6tgLt8FlmwCrKjz5oX1A5SPL6RZGOuVNMvV7PkvWdfRAJzNNFpQN7nU1OZxRgcm
|
||
iIup0ojZmNd2zvCexoB8CCHsf2qvjCWxSEIdX8+DUvMG1/IsplwiZQlZaSP8qWAW
|
||
BnppHIkegYWaVm1fJoqF/esRr5m8o7IyFxGZYLr3g8X5COGtZLug4Mu5jdcLlYqc
|
||
srGUGB8DAgMBAAECggEAO91wDsedIu2QZlttjonD62SphCwpinio5md8oOznMbav
|
||
kUZjUTNlWX01sHfaFFqo7b10mgBscB4086MWZa3D1b1hPHcf+H+OQXeXrwGy4knK
|
||
/YSDC1HU6YOoBZV+gcwU5dmXc+4fmCQPguizcr75VpUFuyxTlnJp01ZKWjrjdwKs
|
||
IMU8a1CxHMT5clFf/3rU4U5o90cktsiRzjc83QFNpvRsF0rAn98Z70ocDWAATxUu
|
||
efLonMur5t2wlu2CLjZSXHvkkwwFQ2u7XUXuudDRAKeg77+RGuUGk8Z5269cHs22
|
||
Ff4cej7vOnoU0CuDaXL37vzUXkfImB6pSFTblfiHgQKBgQDX+s0MqtTZeho6F6Iy
|
||
qHFWqkEItfrTErMEVjgBrMl42+EfzsAKa+910NPdV3z5Z/u7fAp3ComtxJ1pjiNj
|
||
bVah4/xobsHIIS1/XfPuxOaqkdOhhgYvCe8IIC6Z4yCPdRD5pW6dN18fK338YF4s
|
||
lVll+E/DJx7R08tFwSLGYNt5QQKBgQDMFFn1vT4GMHeeF2/kVNYE2U1Lntsy/swT
|
||
VLCgaOJuUvbJiKMa+J1jdjAsudAmOJgjTkR4sco0Rpsen+x7StaGBzMbXKHONUf3
|
||
OLzQsP06JnA9oAftxsjg0IDH8JCAuQsQ2xKMN+f0d0+pggOzS/z7336a3bm1Zeee
|
||
wYqjtLOjQwKBgQCRoTzt06qd0aUpkpH9knKJu1cKppowBKXMwM4W4wkegzRzHBeF
|
||
b24RhPO2ha1xBlpI+sSbq/FVyANUD1FxU2Jc2rtxN21WonhpL1KxpvbaAGYwvYwh
|
||
35LbacfCX9GuqYL+sju5qoJrJApZSCl36mRTS3GM5y3y0dp4eFgYZ2rVgQKBgCLq
|
||
tH2cFFmgv0aYQfeyIDASMexnUJ/IAoioK9Q2Pc+ceEcBDs8VjHAxD4sHe7qeYkFg
|
||
KczwtmT9U5sIx8BMjKm/35ml3rVWXmrJFV0rexgQ7ZFNqS2gnkwAwJf06/RqNJ98
|
||
rA67nf8wzrt02Ec8EBvUIGhE2XpU5i0+dgcOatHbAoGBAJIutK961t5lJVF1g1M9
|
||
KC4rmCCMCTvJSbruQWDpoxYa7Cl6+TopU+xu4537FCzHUJ3EPg3KsYCeCM0LEtR4
|
||
GQjRzFM3qqWabzoAV3KLaONWbK1rI9mHZf8KyWYiJ9cRXwTJ4rGYNMM/6QIUGQSx
|
||
agwJojCQqS4f6AfCNdUOzaRp
|
||
-----END PRIVATE KEY-----`;
|
||
|
||
describe("HttpChecker", () => {
|
||
let server: ReturnType<typeof Bun.serve>;
|
||
let baseUrl: string;
|
||
|
||
beforeAll(() => {
|
||
server = Bun.serve({
|
||
fetch(req) {
|
||
const url = new URL(req.url);
|
||
switch (url.pathname) {
|
||
case "/echo":
|
||
return new Response(JSON.stringify({ body: req.body ? "present" : "empty", method: req.method }), {
|
||
headers: { "content-type": "application/json" },
|
||
});
|
||
case "/gbk": {
|
||
const gbkBytes = new Uint8Array([0xc4, 0xe3, 0xba, 0xc3]);
|
||
return new Response(gbkBytes, { headers: { "content-type": "text/plain; charset=gbk" } });
|
||
}
|
||
case "/json":
|
||
return new Response(JSON.stringify({ status: "ok" }), {
|
||
headers: { "content-type": "application/json" },
|
||
});
|
||
case "/large":
|
||
return new Response("x".repeat(2000));
|
||
case "/notfound":
|
||
return new Response("not found", { status: 404 });
|
||
case "/ok":
|
||
return new Response("hello world", {
|
||
headers: { "content-type": "text/plain", "x-custom": "test-value" },
|
||
});
|
||
case "/redirect":
|
||
return new Response(null, { headers: { location: `${baseUrl}/ok` }, status: 301 });
|
||
case "/redirect-chain-1":
|
||
return new Response(null, { headers: { location: `${baseUrl}/redirect-chain-2` }, status: 302 });
|
||
case "/redirect-chain-2":
|
||
return new Response(null, { headers: { location: `${baseUrl}/ok` }, status: 302 });
|
||
default:
|
||
return new Response("ok");
|
||
}
|
||
},
|
||
port: 0,
|
||
});
|
||
baseUrl = `http://localhost:${server.port}`;
|
||
});
|
||
|
||
afterAll(() => {
|
||
void server.stop();
|
||
});
|
||
|
||
function makeTarget(overrides: {
|
||
body?: string;
|
||
expect?: Record<string, unknown>;
|
||
headers?: Record<string, string>;
|
||
ignoreSSL?: boolean;
|
||
maxBodyBytes?: number;
|
||
maxRedirects?: number;
|
||
method?: string;
|
||
timeoutMs?: number;
|
||
url?: string;
|
||
}): ResolvedHttpTarget {
|
||
return {
|
||
expect: overrides.expect,
|
||
group: "default",
|
||
http: {
|
||
body: overrides.body,
|
||
headers: overrides.headers ?? {},
|
||
ignoreSSL: overrides.ignoreSSL ?? false,
|
||
maxBodyBytes: overrides.maxBodyBytes ?? 1024 * 1024,
|
||
maxRedirects: overrides.maxRedirects ?? 0,
|
||
method: overrides.method ?? "GET",
|
||
url: overrides.url ?? `${baseUrl}/ok`,
|
||
},
|
||
intervalMs: 60000,
|
||
name: "test-http",
|
||
timeoutMs: overrides.timeoutMs ?? 5000,
|
||
type: "http",
|
||
};
|
||
}
|
||
|
||
function makeCtx(timeoutMs = 5000): CheckerContext {
|
||
const controller = new AbortController();
|
||
setTimeout(() => controller.abort(), timeoutMs);
|
||
return { signal: controller.signal };
|
||
}
|
||
|
||
test("成功请求 200", async () => {
|
||
const result = await checker.execute(makeTarget({ url: `${baseUrl}/ok` }), makeCtx());
|
||
expect(result.matched).toBe(true);
|
||
expect(result.statusDetail).toBe("HTTP 200");
|
||
expect(result.durationMs).not.toBeNull();
|
||
expect(result.failure).toBeNull();
|
||
});
|
||
|
||
test("404 不匹配默认 status [200]", async () => {
|
||
const result = await checker.execute(makeTarget({ url: `${baseUrl}/notfound` }), makeCtx());
|
||
expect(result.matched).toBe(false);
|
||
expect(result.statusDetail).toBe("HTTP 404");
|
||
expect(result.failure!.phase).toBe("status");
|
||
});
|
||
|
||
test("404 匹配自定义 status [404]", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { status: [404] }, url: `${baseUrl}/notfound` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(true);
|
||
});
|
||
|
||
test("headers 检查通过", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { headers: { "x-custom": "test-value" } }, url: `${baseUrl}/ok` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(true);
|
||
});
|
||
|
||
test("headers 检查失败", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { headers: { "x-custom": "wrong-value" } }, url: `${baseUrl}/ok` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(false);
|
||
expect(result.failure!.phase).toBe("headers");
|
||
});
|
||
|
||
test("body contains 检查", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { body: [{ contains: "hello" }] }, url: `${baseUrl}/ok` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(true);
|
||
});
|
||
|
||
test("body contains 失败", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { body: [{ contains: "nonexistent" }] }, url: `${baseUrl}/ok` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(false);
|
||
expect(result.failure!.phase).toBe("body");
|
||
});
|
||
|
||
test("body json 检查", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { body: [{ json: { equals: "ok", path: "$.status" } }] }, url: `${baseUrl}/json` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(true);
|
||
});
|
||
|
||
test("响应体超过 maxBodyBytes", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { body: [{ contains: "x" }] }, maxBodyBytes: 100, url: `${baseUrl}/large` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(false);
|
||
expect(result.failure!.phase).toBe("body");
|
||
expect(result.failure!.message).toContain("超过限制");
|
||
});
|
||
|
||
test("请求超时", async () => {
|
||
const timeoutServer = Bun.serve({
|
||
async fetch() {
|
||
await new Promise((resolve) => setTimeout(resolve, 10000));
|
||
return new Response("late");
|
||
},
|
||
port: 0,
|
||
});
|
||
|
||
try {
|
||
const result = await checker.execute(
|
||
makeTarget({ timeoutMs: 100, url: `http://localhost:${timeoutServer.port}/` }),
|
||
makeCtx(100),
|
||
);
|
||
expect(result.matched).toBe(false);
|
||
expect(result.failure!.message).toContain("超时");
|
||
} finally {
|
||
void timeoutServer.stop();
|
||
}
|
||
});
|
||
|
||
test("快速失败：status 失败时不读取 body", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { body: [{ contains: "something" }], status: [200] }, url: `${baseUrl}/notfound` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(false);
|
||
expect(result.failure!.phase).toBe("status");
|
||
});
|
||
|
||
test("status 通过但 body 失败", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { body: [{ contains: "not-in-body" }], status: [200] }, url: `${baseUrl}/ok` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(false);
|
||
expect(result.failure!.phase).toBe("body");
|
||
});
|
||
|
||
test("无 expect 时默认检查 status 200", async () => {
|
||
const result = await checker.execute(makeTarget({ expect: undefined, url: `${baseUrl}/ok` }), makeCtx());
|
||
expect(result.matched).toBe(true);
|
||
});
|
||
|
||
test("POST 请求携带 body", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({
|
||
body: "test-body",
|
||
expect: { body: [{ json: { equals: "present", path: "$.body" } }], status: [200] },
|
||
headers: { "content-type": "text/plain" },
|
||
method: "POST",
|
||
url: `${baseUrl}/echo`,
|
||
}),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(true);
|
||
});
|
||
|
||
test("serialize 返回 URL 和 config JSON", () => {
|
||
const target = makeTarget({});
|
||
const s = checker.serialize(target);
|
||
expect(s.target).toBe(target.http.url);
|
||
const config = JSON.parse(s.config) as { ignoreSSL: boolean; maxRedirects: number; method: string; url: string };
|
||
expect(config.url).toBe(target.http.url);
|
||
expect(config.method).toBe("GET");
|
||
expect(config.ignoreSSL).toBe(false);
|
||
expect(config.maxRedirects).toBe(0);
|
||
});
|
||
|
||
test("maxRedirects=0 不跟随重定向", async () => {
|
||
const result = await checker.execute(makeTarget({ maxRedirects: 0, url: `${baseUrl}/redirect` }), makeCtx());
|
||
expect(result.matched).toBe(false);
|
||
expect(result.statusDetail).toBe("HTTP 301");
|
||
});
|
||
|
||
test("maxRedirects>0 跟随重定向", async () => {
|
||
const result = await checker.execute(makeTarget({ maxRedirects: 5, url: `${baseUrl}/redirect` }), makeCtx());
|
||
expect(result.matched).toBe(true);
|
||
expect(result.statusDetail).toBe("HTTP 200");
|
||
});
|
||
|
||
test("maxRedirects 精确限制跟随次数", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ maxRedirects: 1, url: `${baseUrl}/redirect-chain-1` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(false);
|
||
expect(result.statusDetail).toBe("HTTP 302");
|
||
});
|
||
|
||
test("maxRedirects 允许足够次数时到达最终目标", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ maxRedirects: 2, url: `${baseUrl}/redirect-chain-1` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(true);
|
||
expect(result.statusDetail).toBe("HTTP 200");
|
||
});
|
||
|
||
test("ignoreSSL 跳过自签名证书校验", async () => {
|
||
const httpsServer = Bun.serve({
|
||
fetch() {
|
||
return new Response("secure ok");
|
||
},
|
||
port: 0,
|
||
tls: { cert: SELF_SIGNED_CERT, key: SELF_SIGNED_KEY },
|
||
});
|
||
|
||
try {
|
||
const strictResult = await checker.execute(
|
||
makeTarget({ ignoreSSL: false, url: `https://localhost:${httpsServer.port}/` }),
|
||
makeCtx(),
|
||
);
|
||
expect(strictResult.matched).toBe(false);
|
||
expect(strictResult.statusDetail).toBeNull();
|
||
|
||
const ignoredResult = await checker.execute(
|
||
makeTarget({ ignoreSSL: true, url: `https://localhost:${httpsServer.port}/` }),
|
||
makeCtx(),
|
||
);
|
||
expect(ignoredResult.matched).toBe(true);
|
||
expect(ignoredResult.statusDetail).toBe("HTTP 200");
|
||
} finally {
|
||
void httpsServer.stop();
|
||
}
|
||
});
|
||
|
||
test("响应体编码自动检测 GBK", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { body: [{ contains: "你好" }] }, url: `${baseUrl}/gbk` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(true);
|
||
});
|
||
|
||
test("响应体编码回退 UTF-8", async () => {
|
||
const result = await checker.execute(
|
||
makeTarget({ expect: { body: [{ contains: "hello" }] }, url: `${baseUrl}/ok` }),
|
||
makeCtx(),
|
||
);
|
||
expect(result.matched).toBe(true);
|
||
});
|
||
});
|
||
|
||
describe("HttpChecker.resolve", () => {
|
||
function makeResolveContext(): ResolveContext {
|
||
return {
|
||
configDir: ".",
|
||
defaultIntervalMs: 30000,
|
||
defaults: {},
|
||
defaultTimeoutMs: 10000,
|
||
};
|
||
}
|
||
|
||
test("method 非法抛出错误", () => {
|
||
expect(() =>
|
||
checker.resolve(
|
||
{ http: { method: "INVALID", url: "https://example.com" }, name: "test", type: "http" },
|
||
makeResolveContext(),
|
||
),
|
||
).toThrow("不合法");
|
||
});
|
||
|
||
test("URL 不以 http(s):// 开头抛出错误", () => {
|
||
expect(() =>
|
||
checker.resolve({ http: { url: "ftp://example.com" }, name: "test", type: "http" }, makeResolveContext()),
|
||
).toThrow("格式不合法");
|
||
});
|
||
|
||
test("maxRedirects 为负数抛出错误", () => {
|
||
expect(() =>
|
||
checker.resolve(
|
||
{ http: { maxRedirects: -1, url: "https://example.com" }, name: "test", type: "http" },
|
||
makeResolveContext(),
|
||
),
|
||
).toThrow("非负整数");
|
||
});
|
||
|
||
test("maxRedirects 非整数抛出错误", () => {
|
||
const target = {
|
||
http: { maxRedirects: 1.5, url: "https://example.com" },
|
||
name: "test",
|
||
type: "http",
|
||
} as unknown as Parameters<HttpChecker["resolve"]>[0];
|
||
expect(() => checker.resolve(target, makeResolveContext())).toThrow("非负整数");
|
||
});
|
||
|
||
test("ignoreSSL 非布尔值抛出错误", () => {
|
||
const target = {
|
||
http: { ignoreSSL: "true", url: "https://example.com" },
|
||
name: "test",
|
||
type: "http",
|
||
} as unknown as Parameters<HttpChecker["resolve"]>[0];
|
||
expect(() => checker.resolve(target, makeResolveContext())).toThrow("ignoreSSL 必须为布尔值");
|
||
});
|
||
|
||
test("缺少 http 分组抛出清晰错误", () => {
|
||
const target = { name: "test", type: "http" } as unknown as Parameters<HttpChecker["resolve"]>[0];
|
||
expect(() => checker.resolve(target, makeResolveContext())).toThrow("缺少 http.url 字段");
|
||
});
|
||
|
||
test("expect.status 非法模式抛出错误", () => {
|
||
expect(() =>
|
||
checker.resolve(
|
||
{ expect: { status: ["abc"] }, http: { url: "https://example.com" }, name: "test", type: "http" },
|
||
makeResolveContext(),
|
||
),
|
||
).toThrow("不合法");
|
||
});
|
||
|
||
test("ignoreSSL 默认值为 false", () => {
|
||
const result = checker.resolve(
|
||
{ http: { url: "https://example.com" }, name: "test", type: "http" },
|
||
makeResolveContext(),
|
||
);
|
||
expect((result as ResolvedHttpTarget).http.ignoreSSL).toBe(false);
|
||
});
|
||
|
||
test("maxRedirects 默认值为 0", () => {
|
||
const result = checker.resolve(
|
||
{ http: { url: "https://example.com" }, name: "test", type: "http" },
|
||
makeResolveContext(),
|
||
);
|
||
expect((result as ResolvedHttpTarget).http.maxRedirects).toBe(0);
|
||
});
|
||
|
||
test("method 统一转大写", () => {
|
||
const result = checker.resolve(
|
||
{ http: { method: "get", url: "https://example.com" }, name: "test", type: "http" },
|
||
makeResolveContext(),
|
||
);
|
||
expect((result as ResolvedHttpTarget).http.method).toBe("GET");
|
||
});
|
||
|
||
test("合法 status 范围模式通过校验", () => {
|
||
const result = checker.resolve(
|
||
{ expect: { status: ["2xx", 301] }, http: { url: "https://example.com" }, name: "test", type: "http" },
|
||
makeResolveContext(),
|
||
);
|
||
expect((result as ResolvedHttpTarget).expect?.status).toEqual(["2xx", 301]);
|
||
});
|
||
|
||
test("显式 ignoreSSL 和 maxRedirects 正确解析", () => {
|
||
const result = checker.resolve(
|
||
{ http: { ignoreSSL: true, maxRedirects: 3, url: "https://example.com" }, name: "test", type: "http" },
|
||
makeResolveContext(),
|
||
);
|
||
expect((result as ResolvedHttpTarget).http.ignoreSSL).toBe(true);
|
||
expect((result as ResolvedHttpTarget).http.maxRedirects).toBe(3);
|
||
});
|
||
});
|