chore: 强化代码质量与风格检查体系

ESLint 升级到 recommended-type-checked + stylistic-type-checked，引入 perfectionist 导入排序和 import 插件导入验证。 Prettier 显式声明全部格式化参数，消除跨环境差异。 TypeScript 启用 noUnusedLocals 和 noPropertyAccessFromIndexSignature。完善 ignore 列表，排除 .agents/、bun.lock、data/ 等。引入 husky + lint-staged（pre-commit）+ commitlint（commit-msg）。更新 DEVELOPMENT.md 代码质量章节。修复所有新增规则检测到的类型和风格违规。
2026-05-12 18:44:59 +08:00
parent ce8baae3d1
commit a5cf6065c2
83 changed files with 2654 additions and 1824 deletions
--- a/tests/server/checker/runner/http/expect.test.ts
+++ b/tests/server/checker/runner/http/expect.test.ts
@@ -1,18 +1,21 @@
 import { describe, expect, test } from "bun:test";
+
 import { checkHttpExpect } from "../../../../../src/server/checker/runner/http/expect";

-function obs(overrides: { statusCode?: number; headers?: Record<string, string>; body?: string | null; durationMs?: number } = {}) {
+function obs(
+  overrides: { body?: null | string; durationMs?: number; headers?: Record<string, string>; statusCode?: number } = {},
+) {
  return {
-    statusCode: overrides.statusCode ?? 200,
-    headers: overrides.headers ?? {},
    body: overrides.body ?? "",
    durationMs: overrides.durationMs ?? 100,
+    headers: overrides.headers ?? {},
+    statusCode: overrides.statusCode ?? 200,
  };
 }

 describe("checkHttpExpect", () => {
  test("无 expect 配置时默认检查 status [200] 匹配成功", () => {
-    const r = checkHttpExpect(obs().statusCode, obs().headers, obs().body as string, obs().durationMs);
+    const r = checkHttpExpect(obs().statusCode, obs().headers, obs().body, obs().durationMs);
    expect(r.matched).toBe(true);
    expect(r.failure).toBeNull();
  });
@@ -65,7 +68,9 @@ describe("checkHttpExpect", () => {
  test("headers 操作符格式检查", () => {
    const h = { "content-type": "application/json" };
    expect(checkHttpExpect(200, h, "", 100, { headers: { "content-type": { contains: "json" } } }).matched).toBe(true);
-    expect(checkHttpExpect(200, h, "", 100, { headers: { "content-type": { match: "^application/" } } }).matched).toBe(true);
+    expect(checkHttpExpect(200, h, "", 100, { headers: { "content-type": { match: "^application/" } } }).matched).toBe(
+      true,
+    );
    expect(checkHttpExpect(200, h, "", 100, { headers: { "content-type": { contains: "xml" } } }).matched).toBe(false);
  });

@@ -81,9 +86,9 @@ describe("checkHttpExpect", () => {
  });

  test("body 规则数组按顺序检查", () => {
-    const body = JSON.stringify({ status: "ok", count: 5 });
+    const body = JSON.stringify({ count: 5, status: "ok" });
    const r = checkHttpExpect(200, {}, body, 100, {
-      body: [{ contains: "ok" }, { json: { path: "$.count", gte: 1 } }],
+      body: [{ contains: "ok" }, { json: { gte: 1, path: "$.count" } }],
    });
    expect(r.matched).toBe(true);
  });
@@ -104,26 +109,26 @@ describe("checkHttpExpect", () => {

  test("完整流水线 status->duration->headers->body 全部通过", () => {
    const r = checkHttpExpect(200, { "content-type": "application/json" }, JSON.stringify({ status: "healthy" }), 50, {
-      status: [200],
-      maxDurationMs: 100,
+      body: [{ json: { equals: "healthy", path: "$.status" } }],
      headers: { "content-type": { contains: "json" } },
-      body: [{ json: { path: "$.status", equals: "healthy" } }],
+      maxDurationMs: 100,
+      status: [200],
    });
    expect(r.matched).toBe(true);
    expect(r.failure).toBeNull();
  });

  test("完整流水线 status 通过但 duration 失败", () => {
-    const r = checkHttpExpect(200, {}, "", 500, { status: [200], maxDurationMs: 100 });
+    const r = checkHttpExpect(200, {}, "", 500, { maxDurationMs: 100, status: [200] });
    expect(r.matched).toBe(false);
    expect(r.failure!.phase).toBe("duration");
  });

  test("完整流水线 status 和 duration 通过但 headers 失败", () => {
    const r = checkHttpExpect(200, { "x-api": "v1" }, "", 50, {
-      status: [200],
-      maxDurationMs: 100,
      headers: { "x-api": "v2" },
+      maxDurationMs: 100,
+      status: [200],
    });
    expect(r.matched).toBe(false);
    expect(r.failure!.phase).toBe("headers");
@@ -131,10 +136,10 @@ describe("checkHttpExpect", () => {

  test("完整流水线 status/duration/headers 通过但 body 失败", () => {
    const r = checkHttpExpect(200, { "content-type": "text/plain" }, "error occurred", 50, {
-      status: [200],
-      maxDurationMs: 100,
-      headers: { "content-type": "text/plain" },
      body: [{ contains: "success" }],
+      headers: { "content-type": "text/plain" },
+      maxDurationMs: 100,
+      status: [200],
    });
    expect(r.matched).toBe(false);
    expect(r.failure!.phase).toBe("body");
--- a/tests/server/checker/runner/http/runner.test.ts
+++ b/tests/server/checker/runner/http/runner.test.ts
@@ -1,8 +1,10 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { HttpChecker } from "../../../../../src/server/checker/runner/http/runner";
+
 import type { CheckerContext } 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();

 describe("HttpChecker", () => {
@@ -11,61 +13,61 @@ describe("HttpChecker", () => {

  beforeAll(() => {
    server = Bun.serve({
-      port: 0,
      fetch(req) {
        const url = new URL(req.url);
        switch (url.pathname) {
-          case "/ok":
-            return new Response("hello world", {
-              headers: { "content-type": "text/plain", "x-custom": "test-value" },
+          case "/echo":
+            return new Response(JSON.stringify({ body: req.body ? "present" : "empty", method: req.method }), {
+              headers: { "content-type": "application/json" },
            });
          case "/json":
            return new Response(JSON.stringify({ status: "ok" }), {
              headers: { "content-type": "application/json" },
            });
-          case "/echo":
-            return new Response(JSON.stringify({ method: req.method, body: req.body ? "present" : "empty" }), {
-              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" },
+            });
          default:
            return new Response("ok");
        }
      },
+      port: 0,
    });
    baseUrl = `http://localhost:${server.port}`;
  });

  afterAll(() => {
-    server.stop();
+    void server.stop();
  });

  function makeTarget(overrides: {
-    url?: string;
-    method?: string;
    body?: string;
-    headers?: Record<string, string>;
    expect?: Record<string, unknown>;
+    headers?: Record<string, string>;
    maxBodyBytes?: number;
+    method?: string;
    timeoutMs?: number;
+    url?: string;
  }): ResolvedHttpTarget {
    return {
-      type: "http",
-      name: "test-http",
+      expect: overrides.expect,
      group: "default",
      http: {
-        url: overrides.url ?? `${baseUrl}/ok`,
-        method: overrides.method ?? "GET",
-        headers: overrides.headers ?? {},
        body: overrides.body,
+        headers: overrides.headers ?? {},
        maxBodyBytes: overrides.maxBodyBytes ?? 1024 * 1024,
+        method: overrides.method ?? "GET",
+        url: overrides.url ?? `${baseUrl}/ok`,
      },
      intervalMs: 60000,
+      name: "test-http",
      timeoutMs: overrides.timeoutMs ?? 5000,
-      expect: overrides.expect as ResolvedHttpTarget["expect"],
+      type: "http",
    };
  }

@@ -91,39 +93,60 @@ describe("HttpChecker", () => {
  });

  test("404 匹配自定义 status [404]", async () => {
-    const result = await checker.execute(makeTarget({ url: `${baseUrl}/notfound`, expect: { status: [404] } }), makeCtx());
+    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({ url: `${baseUrl}/ok`, expect: { headers: { "x-custom": "test-value" } } }), makeCtx());
+    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({ url: `${baseUrl}/ok`, expect: { headers: { "x-custom": "wrong-value" } } }), makeCtx());
+    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({ url: `${baseUrl}/ok`, expect: { body: [{ contains: "hello" }] } }), makeCtx());
+    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({ url: `${baseUrl}/ok`, expect: { body: [{ contains: "nonexistent" }] } }), makeCtx());
+    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({ url: `${baseUrl}/json`, expect: { body: [{ json: { path: "$.status", equals: "ok" } }] } }), makeCtx());
+    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({ url: `${baseUrl}/large`, maxBodyBytes: 100, expect: { body: [{ contains: "x" }] } }), makeCtx());
+    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("超过限制");
@@ -131,41 +154,59 @@ describe("HttpChecker", () => {

  test("请求超时", async () => {
    const timeoutServer = Bun.serve({
-      port: 0,
      async fetch() {
        await new Promise((resolve) => setTimeout(resolve, 10000));
        return new Response("late");
      },
+      port: 0,
    });

    try {
-      const result = await checker.execute(makeTarget({ url: `http://localhost:${timeoutServer.port}/`, timeoutMs: 100 }), makeCtx(100));
+      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 {
-      timeoutServer.stop();
+      void timeoutServer.stop();
    }
  });

  test("快速失败：status 失败时不读取 body", async () => {
-    const result = await checker.execute(makeTarget({ url: `${baseUrl}/notfound`, expect: { status: [200], body: [{ contains: "something" }] } }), makeCtx());
+    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({ url: `${baseUrl}/ok`, expect: { status: [200], body: [{ contains: "not-in-body" }] } }), makeCtx());
+    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({ url: `${baseUrl}/ok`, expect: undefined }), makeCtx());
+    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({ url: `${baseUrl}/echo`, method: "POST", body: "test-body", headers: { "content-type": "text/plain" }, expect: { status: [200], body: [{ json: { path: "$.body", equals: "present" } }] } }), makeCtx());
+    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);
  });

@@ -173,7 +214,7 @@ describe("HttpChecker", () => {
    const target = makeTarget({});
    const s = checker.serialize(target);
    expect(s.target).toBe(target.http.url);
-    const config = JSON.parse(s.config);
+    const config = JSON.parse(s.config) as { method: string; url: string };
    expect(config.url).toBe(target.http.url);
    expect(config.method).toBe("GET");
  });