World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
// `fmtInterval` 实体侧栏里把一条事实的有效区间画成 "yyyy-mm-dd ~ now" /
// "ended, date unknown" / 单点的纯函数——2024 那条 PR(#669 之前)已经在
// 区分 "endedUnknown" 与 "ongoing";现在把 "event"(一个时刻)补上:
// 之前显示 "2024-03-15 ~ 2024-03-15"(写端把 from/to 折成同一个时刻后
// UI 还把它当区间画),现在按 from 单独返回。
import { describe, expect, it, vi } from "vitest";
// 与 classHierarchy.test.ts 同:Graph.tsx 顶层 import 了 sigma,sigma 启动时
// 试着拿 WebGL2RenderingContext,vitest 默认跑在 jsdom 上没这个全局,模块
// 求值期就抛。Polyfill 即可,不必真渲染
vi.hoisted(() => {
for (const name of ["WebGLRenderingContext", "WebGL2RenderingContext"]) {
Object.defineProperty(globalThis, name, {
configurable: true,
value: class WebGLRenderingContext {},
});
}
});
import {
fmtInterval,
proofIndentClass,
PROOF_INDENT_CAP,
walkProofSteps,
} from "./Graph";
import type { EntityFact, ProofStep } from "../api";
const base: EntityFact = {
id: "f",
said_as: null,
direction: "out",
predicate_key: null,
predicate_label: null,
inferred: false,
temporal: null,
other_id: null,
other_name: null,
object_value: null,
qualifiers: [],
statement_qualifiers: [],
valid_from: null,
valid_to: null,
holds_from: null,
holds_to: null,
valid_from_precision: null,
valid_to_precision: null,
confidence: 1,
evidence_count: 1,
stale: false,
corrected: false,
contested: null,
last_evidence_time: null,
};
const isoDay = "2024-03-15T00:00:00Z";
describe("fmtInterval", () => {
it("eternal 不画区间", () => {
expect(fmtInterval({ ...base, temporal: "eternal", valid_from: isoDay, valid_to: isoDay })).toBe(
"",
);
});
it("event 画一个时刻(from == to 的 day 精度)", () => {
expect(
fmtInterval({
...base,
temporal: "event",
valid_from: isoDay,
valid_from_precision: "day",
valid_to: isoDay,
valid_to_precision: "day",
}),
).toBe("2024-03-15");
});
it("event 单 hour 精度按 from 时刻返回", () => {
expect(
fmtInterval({
...base,
temporal: "event",
valid_from: "2024-03-15T10:30:00Z",
valid_from_precision: "minute",
valid_to: "2024-03-15T10:30:00Z",
valid_to_precision: "minute",
}),
).toBe("2024-03-15T10:30Z");
});
it("event 没有 from 时退到 to", () => {
expect(
fmtInterval({
...base,
temporal: "event",
valid_from: null,
valid_to: "2024-03-15T00:00:00Z",
valid_to_precision: "day",
}),
).toBe("2024-03-15");
});
it("event from/to 都没有时返回空串(抽取失败不画)", () => {
expect(fmtInterval({ ...base, temporal: "event" })).toBe("");
});
it("state 正常区间:from ~ ongoing(valid_to 为 null)", () => {
expect(
fmtInterval({
...base,
temporal: "state",
valid_from: "2020-01-01T00:00:00Z",
valid_from_precision: "day",
valid_to: null,
valid_to_precision: null,
}),
).toBe("2020-01-01 ~ now");
});
it("state 闭环:from ~ to", () => {
expect(
fmtInterval({
...base,
temporal: "state",
valid_from: "2020-01-01T00:00:00Z",
valid_from_precision: "day",
valid_to: "2024-01-01T00:00:00Z",
valid_to_precision: "day",
}),
).toBe("2020-01-01 ~ 2024-01-01");
});
it("state endedUnknown:from ~ ended, date unknown", () => {
expect(
fmtInterval({
...base,
temporal: "state",
valid_from: "2020-01-01T00:00:00Z",
valid_from_precision: "day",
valid_to: null,
valid_to_precision: "unknown",
}),
).toBe("2020-01-01 ~ ended, date unknown");
});
it("state 什么都没有时返回空串", () => {
expect(fmtInterval({ ...base, temporal: "state" })).toBe("");
});
});
// 递归证明树(0030)的形状:服务端 proof() 返回的 ProofStep 现在带
// premises: ProofStep[],前端把它压平成 WalkedRow[] 喂给渲染组件。
// 这里断言三件事:
// 1. 深度单调 + 跨过 has_premises 边界才 +1(叶子的 premises 为空就停)
// 2. 三层嵌套的 9-节点树产出 9 行,深度序列为 [0,1,2,3,2,3,1,2,3],
// 即 DFS 前序:父 → 第一个子 → 第一个孙 → … → 第一个叶 → 兄弟 →
// 3. 叶子行的 has_premises=false;不是叶子的行它必为 true
// A
// / \
// B C
// / \ \
// D E F
// | | |
// G H I ← 叶子(premises 为空,walker 不下钻)
function step(
id: string,
premises: ProofStep[] = [],
partial: Partial<ProofStep> = {},
): ProofStep {
return {
seq: 0,
fact_id: id,
subject_id: id,
subject: id,
predicate_id: null,
predicate: "→",
object_id: null,
object: id,
valid_from: null,
valid_to: null,
confidence: 1,
retracted: false,
evidence: [],
premises,
...partial,
};
}
describe("walkProofSteps", () => {
it("叶子(premises 为空)只有一个深度 0 的行", () => {
const tree = [step("leaf")];
const rows = walkProofSteps(tree);
expect(rows).toHaveLength(1);
expect(rows[0].depth).toBe(0);
expect(rows[0].has_premises).toBe(false);
expect(rows[0].fact_id).toBe("leaf");
});
it("三层嵌套的树产出 9 行,深度 0..3 单调", () => {
const tree = [
step("A", [
step("B", [step("D", [step("G")]), step("E", [step("H")])]),
step("C", [step("F", [step("I")])]),
]),
];
const rows = walkProofSteps(tree);
expect(rows.map((r) => r.fact_id)).toEqual([
"A", "B", "D", "G", "E", "H", "C", "F", "I",
]);
expect(rows.map((r) => r.depth)).toEqual([
0, 1, 2, 3, 2, 3, 1, 2, 3,
]);
// 深度从不超过 4(一个 `premises` 边只 +1);从不低于 0;
// 同一行 `premises` 内的 depth 差只可能是 +1(刚下钻)或非正(爬回祖先或平移到同层)
for (const r of rows) {
expect(r.depth).toBeGreaterThanOrEqual(0);
expect(r.depth).toBeLessThanOrEqual(3);
}
// 进入 premises 时 +1,退出时不强制 -1(可以一次回到祖先)
for (let i = 1; i < rows.length; i++) {
const diff = rows[i].depth - rows[i - 1].depth;
expect(diff).toBeLessThanOrEqual(1);
}
});
it("叶子行 has_premises=false;非叶子行必为 true", () => {
const tree = [
step("A", [step("B", [step("leaf")])]),
];
const rows = walkProofSteps(tree);
const byId = Object.fromEntries(rows.map((r) => [r.fact_id, r]));
expect(byId["A"].has_premises).toBe(true);
expect(byId["B"].has_premises).toBe(true);
expect(byId["leaf"].has_premises).toBe(false);
});
it("深度起点偏移:depth=2 时整棵树每个节点的深度都比直接调用多 2", () => {
const tree = [step("A", [step("B")])];
const at0 = walkProofSteps(tree, 0);
const at2 = walkProofSteps(tree, 2);
expect(at0.map((r) => r.depth)).toEqual([0, 1]);
expect(at2.map((r) => r.depth)).toEqual([2, 3]);
});
});
// 缩进封顶:`cn` 是纯拼接、仓库里没有 tailwind-merge,所以同时发出 `ml-4`
// 与 `ml-0` 时谁生效由样式表顺序决定——那样的封顶形同虚设。这里钉住的是
// 「深到一定层数就不再发缩进类」,而不是「再发一个类把它盖掉」
describe("proofIndentClass", () => {
it("封顶以内:带缩进、内边距与那条竖线", () => {
for (let depth = 0; depth < PROOF_INDENT_CAP; depth++) {
const cls = proofIndentClass(depth);
expect(cls).toContain("ml-4");
expect(cls).toContain("pl-3");
expect(cls).toContain("border-l");
}
});
it("到了封顶就不再发缩进类", () => {
for (const depth of [PROOF_INDENT_CAP, PROOF_INDENT_CAP + 1, 12]) {
const cls = proofIndentClass(depth);
expect(cls).not.toContain("ml-4");
expect(cls).not.toContain("pl-3");
expect(cls).not.toContain("border-l");
}
});
it("任何深度都不会同时发出互相冲突的两个类", () => {
for (let depth = 0; depth <= 12; depth++) {
const parts = proofIndentClass(depth).split(/\s+/).filter(Boolean);
for (const [a, b] of [
["ml-4", "ml-0"],
["pl-3", "pl-0"],
["border-l", "border-l-0"],
]) {
expect(parts.includes(a) && parts.includes(b)).toBe(false);
}
// 同一个属性组里也不该出现两个取值
const margins = parts.filter((c) => /^ml-/.test(c));
expect(margins.length).toBeLessThanOrEqual(1);
}
});
it("每一层都留着 mt-1,封顶只去掉横向的缩进", () => {
for (let depth = 0; depth <= 12; depth++) {
expect(proofIndentClass(depth)).toContain("mt-1");
}
});
});