DiAL/tests/server/checker/expect/body.test.ts

import { describe, expect, test } from "bun:test";
import {
  applyOperator,
  checkBodyExpect,
  checkExpectValue,
  evaluateJsonPath,
} from "../../../../src/server/checker/expect/body";

describe("evaluateJsonPath", () => {
  const obj = {
    status: "ok",
    code: 0,
    active: true,
    error: null,
    data: {
      count: 42,
      items: [{ name: "a" }, { name: "b" }],
      nested: { deep: "value" },
    },
    emptyObj: {},
    emptyArr: [],
  };

  test("简单字段访问", () => {
    expect(evaluateJsonPath(obj, "$.status")).toBe("ok");
    expect(evaluateJsonPath(obj, "$.code")).toBe(0);
    expect(evaluateJsonPath(obj, "$.active")).toBe(true);
    expect(evaluateJsonPath(obj, "$.error")).toBeNull();
  });

  test("嵌套对象访问", () => {
    expect(evaluateJsonPath(obj, "$.data.count")).toBe(42);
    expect(evaluateJsonPath(obj, "$.data.nested.deep")).toBe("value");
  });

  test("数组索引访问", () => {
    expect(evaluateJsonPath(obj, "$.data.items[0].name")).toBe("a");
    expect(evaluateJsonPath(obj, "$.data.items[1].name")).toBe("b");
  });

  test("路径不存在返回 undefined", () => {
    expect(evaluateJsonPath(obj, "$.notExist")).toBeUndefined();
    expect(evaluateJsonPath(obj, "$.data.notExist")).toBeUndefined();
    expect(evaluateJsonPath(obj, "$.data.items[99]")).toBeUndefined();
  });

  test("空对象和空数组", () => {
    expect(evaluateJsonPath(obj, "$.emptyObj")).toEqual({});
    expect(evaluateJsonPath(obj, "$.emptyArr")).toEqual([]);
  });

  test("非 $ 开头路径返回 undefined", () => {
    expect(evaluateJsonPath(obj, "status")).toBeUndefined();
    expect(evaluateJsonPath(obj, ".status")).toBeUndefined();
  });

  test("null 对象上访问", () => {
    expect(evaluateJsonPath(null, "$.any")).toBeUndefined();
  });
});

describe("applyOperator", () => {
  test("equals 操作符", () => {
    expect(applyOperator("ok", { equals: "ok" })).toBe(true);
    expect(applyOperator("ok", { equals: "error" })).toBe(false);
    expect(applyOperator(42, { equals: 42 })).toBe(true);
    expect(applyOperator(42, { equals: 41 })).toBe(false);
    expect(applyOperator(null, { equals: null })).toBe(true);
    expect(applyOperator(true, { equals: true })).toBe(true);
  });

  test("contains 操作符", () => {
    expect(applyOperator("hello world", { contains: "hello" })).toBe(true);
    expect(applyOperator("hello world", { contains: "missing" })).toBe(false);
    expect(applyOperator(12345, { contains: "23" })).toBe(true);
  });

  test("match 操作符", () => {
    expect(applyOperator("v2.1.0", { match: "\\d+\\.\\d+\\.\\d+" })).toBe(true);
    expect(applyOperator("v2.1", { match: "\\d+\\.\\d+\\.\\d+" })).toBe(false);
    expect(applyOperator("abc123", { match: "^\\w+\\d+$" })).toBe(true);
  });

  test("empty 操作符", () => {
    expect(applyOperator("", { empty: true })).toBe(true);
    expect(applyOperator(null, { empty: true })).toBe(true);
    expect(applyOperator(undefined, { empty: true })).toBe(true);
    expect(applyOperator([], { empty: true })).toBe(true);
    expect(applyOperator({}, { empty: true })).toBe(true);
    expect(applyOperator("ok", { empty: true })).toBe(false);
    expect(applyOperator([1, 2], { empty: false })).toBe(true);
    expect(applyOperator([], { empty: false })).toBe(false);
  });

  test("exists 操作符", () => {
    expect(applyOperator("ok", { exists: true })).toBe(true);
    expect(applyOperator(null, { exists: true })).toBe(true);
    expect(applyOperator(undefined, { exists: true })).toBe(false);
    expect(applyOperator(undefined, { exists: false })).toBe(true);
    expect(applyOperator("ok", { exists: false })).toBe(false);
  });

  test("gte 操作符", () => {
    expect(applyOperator(10, { gte: 5 })).toBe(true);
    expect(applyOperator(5, { gte: 5 })).toBe(true);
    expect(applyOperator(3, { gte: 5 })).toBe(false);
    expect(applyOperator("10", { gte: 5 })).toBe(true);
  });

  test("lte 操作符", () => {
    expect(applyOperator(3, { lte: 5 })).toBe(true);
    expect(applyOperator(5, { lte: 5 })).toBe(true);
    expect(applyOperator(10, { lte: 5 })).toBe(false);
  });

  test("gt 操作符", () => {
    expect(applyOperator(10, { gt: 5 })).toBe(true);
    expect(applyOperator(5, { gt: 5 })).toBe(false);
  });

  test("lt 操作符", () => {
    expect(applyOperator(3, { lt: 5 })).toBe(true);
    expect(applyOperator(5, { lt: 5 })).toBe(false);
  });

  test("多操作符 AND 组合", () => {
    expect(applyOperator(7, { gte: 5, lte: 10 })).toBe(true);
    expect(applyOperator(3, { gte: 5, lte: 10 })).toBe(false);
    expect(applyOperator(15, { gte: 5, lte: 10 })).toBe(false);
  });
});

describe("checkExpectValue", () => {
  test("原始值直接比较", () => {
    expect(checkExpectValue("ok", "ok")).toBe(true);
    expect(checkExpectValue("ok", "error")).toBe(false);
    expect(checkExpectValue(42, 42)).toBe(true);
    expect(checkExpectValue(null, null)).toBe(true);
  });

  test("对象作为操作符", () => {
    expect(checkExpectValue(42, { gte: 10 })).toBe(true);
    expect(checkExpectValue(42, { gte: 100 })).toBe(false);
    expect(checkExpectValue("hello", { contains: "ell" })).toBe(true);
  });
});

describe("checkBodyExpect (BodyRule[])", () => {
  test("无规则返回匹配成功", () => {
    const r = checkBodyExpect("anything");
    expect(r.matched).toBe(true);
    expect(r.failure).toBeNull();
  });

  test("空规则数组返回匹配成功", () => {
    const r = checkBodyExpect("anything", []);
    expect(r.matched).toBe(true);
    expect(r.failure).toBeNull();
  });

  test("contains 规则匹配成功", () => {
    const r = checkBodyExpect("hello world", [{ contains: "hello" }]);
    expect(r.matched).toBe(true);
    expect(r.failure).toBeNull();
  });

  test("contains 规则匹配失败", () => {
    const r = checkBodyExpect("hello world", [{ contains: "missing" }]);
    expect(r.matched).toBe(false);
    expect(r.failure).not.toBeNull();
    expect(r.failure!.kind).toBe("mismatch");
    expect(r.failure!.phase).toBe("body");
    expect(r.failure!.path).toBe("body[0]");
  });

  test("regex 规则匹配成功", () => {
    const r = checkBodyExpect("status: ok", [{ regex: "ok" }]);
    expect(r.matched).toBe(true);
  });

  test("regex 规则匹配失败", () => {
    const r = checkBodyExpect("status: error", [{ regex: "^ok$" }]);
    expect(r.matched).toBe(false);
    expect(r.failure!.path).toBe("body[0]");
  });

  test("json 等值匹配成功", () => {
    const body = JSON.stringify({ status: "ok", code: 0 });
    const r = checkBodyExpect(body, [{ json: { path: "$.status", equals: "ok" } }]);
    expect(r.matched).toBe(true);
  });

  test("json 等值匹配失败", () => {
    const body = JSON.stringify({ status: "ok" });
    const r = checkBodyExpect(body, [{ json: { path: "$.status", equals: "error" } }]);
    expect(r.matched).toBe(false);
    expect(r.failure!.kind).toBe("mismatch");
  });

  test("json 操作符匹配", () => {
    const body = JSON.stringify({ count: 42, version: "v2.1.0" });
    expect(checkBodyExpect(body, [{ json: { path: "$.count", gte: 10 } }]).matched).toBe(true);
    expect(checkBodyExpect(body, [{ json: { path: "$.version", match: "\\d+\\.\\d+\\.\\d+" } }]).matched).toBe(true);
    expect(checkBodyExpect(body, [{ json: { path: "$.count", gte: 100 } }]).matched).toBe(false);
  });

  test("json 路径不存在", () => {
    const body = JSON.stringify({ status: "ok" });
    const r = checkBodyExpect(body, [{ json: { path: "$.notExist", equals: "value" } }]);
    expect(r.matched).toBe(false);
  });

  test("json 解析失败", () => {
    const r = checkBodyExpect("not json", [{ json: { path: "$.status", equals: "ok" } }]);
    expect(r.matched).toBe(false);
    expect(r.failure!.kind).toBe("error");
  });

  test("css 文本内容匹配", () => {
    const html = "<div id='health'>OK</div><span class='ver'>1.0</span>";
    expect(checkBodyExpect(html, [{ css: { selector: "div#health", equals: "OK" } }]).matched).toBe(true);
    expect(checkBodyExpect(html, [{ css: { selector: "span.ver", equals: "1.0" } }]).matched).toBe(true);
    expect(checkBodyExpect(html, [{ css: { selector: "div#health", equals: "ERROR" } }]).matched).toBe(false);
  });

  test("css 选择器无匹配元素", () => {
    const html = "<div>OK</div>";
    const r = checkBodyExpect(html, [{ css: { selector: "span.missing", equals: "OK" } }]);
    expect(r.matched).toBe(false);
  });

  test("css attr 提取", () => {
    const html = '<meta name="version" content="2.0.1">';
    expect(
      checkBodyExpect(html, [{ css: { selector: 'meta[name="version"]', attr: "content", equals: "2.0.1" } }]).matched,
    ).toBe(true);
    expect(
      checkBodyExpect(html, [
        { css: { selector: 'meta[name="version"]', attr: "content", match: "\\d+\\.\\d+\\.\\d+" } },
      ]).matched,
    ).toBe(true);
  });

  test("css exists 检查", () => {
    const html = "<div id='test'>OK</div>";
    expect(checkBodyExpect(html, [{ css: { selector: "div#test", exists: true } }]).matched).toBe(true);
    expect(checkBodyExpect(html, [{ css: { selector: "span#missing", exists: false } }]).matched).toBe(true);
    expect(checkBodyExpect(html, [{ css: { selector: "div#test", exists: false } }]).matched).toBe(false);
  });

  test("xpath 节点文本匹配", () => {
    const xml = "<root><status>ok</status><code>200</code></root>";
    expect(checkBodyExpect(xml, [{ xpath: { path: "/root/status/text()", equals: "ok" } }]).matched).toBe(true);
    expect(checkBodyExpect(xml, [{ xpath: { path: "/root/status/text()", equals: "error" } }]).matched).toBe(false);
  });

  test("xpath 无匹配节点", () => {
    const xml = "<root><status>ok</status></root>";
    const r = checkBodyExpect(xml, [{ xpath: { path: "/root/missing/text()", equals: "ok" } }]);
    expect(r.matched).toBe(false);
  });

  test("规则数组按顺序检查，第一条失败立即返回", () => {
    const body = JSON.stringify({ status: "error" });
    const r = checkBodyExpect(body, [{ contains: "healthy" }, { json: { path: "$.status", equals: "error" } }]);
    expect(r.matched).toBe(false);
    expect(r.failure!.path).toBe("body[0]");
  });

  test("多条规则全部通过", () => {
    const body = JSON.stringify({ status: "healthy", count: 5 });
    const r = checkBodyExpect(body, [
      { contains: "healthy" },
      { json: { path: "$.status", equals: "healthy" } },
      { json: { path: "$.count", gte: 1 } },
    ]);
    expect(r.matched).toBe(true);
    expect(r.failure).toBeNull();
  });

  test("第二条规则失败返回正确索引", () => {
    const body = JSON.stringify({ status: "ok" });
    const r = checkBodyExpect(body, [{ contains: "ok" }, { json: { path: "$.status", equals: "error" } }]);
    expect(r.matched).toBe(false);
    expect(r.failure!.path).toContain("body[1]");
  });
});