wehub-resource-sync
276 lines
8.1 KiB
TypeScript
276 lines
8.1 KiB
TypeScript
import { describe, it, expect, beforeEach, vi } from "vitest";
|
|
|
|
vi.mock("../src/logger.js", () => ({
|
|
logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
|
|
}));
|
|
|
|
import { registerCascadeFunction } from "../src/functions/cascade.js";
|
|
import type { Memory, GraphNode, GraphEdge } from "../src/types.js";
|
|
import { mockKV, mockSdk } from "./helpers/mocks.js";
|
|
|
|
describe("Cascade Update Function", () => {
|
|
let sdk: ReturnType<typeof mockSdk>;
|
|
let kv: ReturnType<typeof mockKV>;
|
|
|
|
beforeEach(() => {
|
|
sdk = mockSdk();
|
|
kv = mockKV();
|
|
vi.clearAllMocks();
|
|
registerCascadeFunction(sdk as never, kv as never);
|
|
});
|
|
|
|
it("returns error when supersededMemoryId is missing", async () => {
|
|
const result = (await sdk.trigger("mem::cascade-update", {})) as {
|
|
success: boolean;
|
|
error: string;
|
|
};
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toBe("supersededMemoryId is required");
|
|
});
|
|
|
|
it("returns error for non-existent memory", async () => {
|
|
const result = (await sdk.trigger("mem::cascade-update", {
|
|
supersededMemoryId: "mem_missing",
|
|
})) as { success: boolean; error: string };
|
|
expect(result.success).toBe(false);
|
|
expect(result.error).toBe("superseded memory not found");
|
|
});
|
|
|
|
it("flags graph nodes referencing superseded observation IDs", async () => {
|
|
const memory: Memory = {
|
|
id: "mem_old",
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
updatedAt: "2026-03-01T00:00:00Z",
|
|
type: "fact",
|
|
title: "Old fact",
|
|
content: "Old content",
|
|
concepts: ["react"],
|
|
files: [],
|
|
sessionIds: [],
|
|
strength: 5,
|
|
version: 1,
|
|
isLatest: false,
|
|
sourceObservationIds: ["obs_a", "obs_b"],
|
|
};
|
|
await kv.set("mem:memories", "mem_old", memory);
|
|
|
|
const node: GraphNode = {
|
|
id: "node_1",
|
|
type: "concept",
|
|
name: "react",
|
|
properties: {},
|
|
sourceObservationIds: ["obs_a"],
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
};
|
|
await kv.set("mem:graph:nodes", "node_1", node);
|
|
|
|
const unrelatedNode: GraphNode = {
|
|
id: "node_2",
|
|
type: "file",
|
|
name: "index.ts",
|
|
properties: {},
|
|
sourceObservationIds: ["obs_c"],
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
};
|
|
await kv.set("mem:graph:nodes", "node_2", unrelatedNode);
|
|
|
|
const result = (await sdk.trigger("mem::cascade-update", {
|
|
supersededMemoryId: "mem_old",
|
|
})) as { success: boolean; flagged: { nodes: number; edges: number } };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.flagged.nodes).toBe(1);
|
|
|
|
const updated = await kv.get<GraphNode>("mem:graph:nodes", "node_1");
|
|
expect(updated!.stale).toBe(true);
|
|
|
|
const unchanged = await kv.get<GraphNode>("mem:graph:nodes", "node_2");
|
|
expect(unchanged!.stale).toBeUndefined();
|
|
});
|
|
|
|
it("flags graph edges referencing superseded observation IDs", async () => {
|
|
const memory: Memory = {
|
|
id: "mem_old2",
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
updatedAt: "2026-03-01T00:00:00Z",
|
|
type: "pattern",
|
|
title: "Old pattern",
|
|
content: "Old pattern content",
|
|
concepts: ["testing"],
|
|
files: [],
|
|
sessionIds: [],
|
|
strength: 5,
|
|
version: 1,
|
|
isLatest: false,
|
|
sourceObservationIds: ["obs_x"],
|
|
};
|
|
await kv.set("mem:memories", "mem_old2", memory);
|
|
|
|
const edge: GraphEdge = {
|
|
id: "edge_1",
|
|
type: "uses",
|
|
sourceNodeId: "node_a",
|
|
targetNodeId: "node_b",
|
|
weight: 1,
|
|
sourceObservationIds: ["obs_x", "obs_y"],
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
};
|
|
await kv.set("mem:graph:edges", "edge_1", edge);
|
|
|
|
const result = (await sdk.trigger("mem::cascade-update", {
|
|
supersededMemoryId: "mem_old2",
|
|
})) as { success: boolean; flagged: { edges: number } };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.flagged.edges).toBe(1);
|
|
|
|
const updated = await kv.get<GraphEdge>("mem:graph:edges", "edge_1");
|
|
expect(updated!.stale).toBe(true);
|
|
});
|
|
|
|
it("counts sibling memories sharing 2+ concepts", async () => {
|
|
const superseded: Memory = {
|
|
id: "mem_superseded",
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
updatedAt: "2026-03-01T00:00:00Z",
|
|
type: "architecture",
|
|
title: "React architecture",
|
|
content: "Old arch",
|
|
concepts: ["react", "frontend", "typescript"],
|
|
files: [],
|
|
sessionIds: [],
|
|
strength: 5,
|
|
version: 1,
|
|
isLatest: false,
|
|
};
|
|
await kv.set("mem:memories", "mem_superseded", superseded);
|
|
|
|
const sibling: Memory = {
|
|
id: "mem_sibling",
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
updatedAt: "2026-03-01T00:00:00Z",
|
|
type: "pattern",
|
|
title: "React patterns",
|
|
content: "Sibling memory sharing concepts",
|
|
concepts: ["react", "typescript"],
|
|
files: [],
|
|
sessionIds: [],
|
|
strength: 6,
|
|
version: 1,
|
|
isLatest: true,
|
|
};
|
|
await kv.set("mem:memories", "mem_sibling", sibling);
|
|
|
|
const unrelated: Memory = {
|
|
id: "mem_unrelated",
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
updatedAt: "2026-03-01T00:00:00Z",
|
|
type: "fact",
|
|
title: "Python setup",
|
|
content: "Unrelated memory",
|
|
concepts: ["python", "backend"],
|
|
files: [],
|
|
sessionIds: [],
|
|
strength: 5,
|
|
version: 1,
|
|
isLatest: true,
|
|
};
|
|
await kv.set("mem:memories", "mem_unrelated", unrelated);
|
|
|
|
const result = (await sdk.trigger("mem::cascade-update", {
|
|
supersededMemoryId: "mem_superseded",
|
|
})) as { success: boolean; flagged: { siblingMemories: number }; total: number };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.flagged.siblingMemories).toBe(1);
|
|
expect(result.total).toBeGreaterThanOrEqual(1);
|
|
});
|
|
|
|
it("skips already stale nodes", async () => {
|
|
const memory: Memory = {
|
|
id: "mem_skip",
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
updatedAt: "2026-03-01T00:00:00Z",
|
|
type: "fact",
|
|
title: "Skip test",
|
|
content: "Content",
|
|
concepts: [],
|
|
files: [],
|
|
sessionIds: [],
|
|
strength: 5,
|
|
version: 1,
|
|
isLatest: false,
|
|
sourceObservationIds: ["obs_s"],
|
|
};
|
|
await kv.set("mem:memories", "mem_skip", memory);
|
|
|
|
const node: GraphNode = {
|
|
id: "node_stale",
|
|
type: "concept",
|
|
name: "already stale",
|
|
properties: {},
|
|
sourceObservationIds: ["obs_s"],
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
stale: true,
|
|
};
|
|
await kv.set("mem:graph:nodes", "node_stale", node);
|
|
|
|
const result = (await sdk.trigger("mem::cascade-update", {
|
|
supersededMemoryId: "mem_skip",
|
|
})) as { success: boolean; flagged: { nodes: number } };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.flagged.nodes).toBe(0);
|
|
});
|
|
|
|
it("does not flag siblings when fewer than 2 shared concepts", async () => {
|
|
const memory: Memory = {
|
|
id: "mem_one_concept",
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
updatedAt: "2026-03-01T00:00:00Z",
|
|
type: "fact",
|
|
title: "One concept",
|
|
content: "Content",
|
|
concepts: ["react"],
|
|
files: [],
|
|
sessionIds: [],
|
|
strength: 5,
|
|
version: 1,
|
|
isLatest: false,
|
|
};
|
|
await kv.set("mem:memories", "mem_one_concept", memory);
|
|
|
|
const result = (await sdk.trigger("mem::cascade-update", {
|
|
supersededMemoryId: "mem_one_concept",
|
|
})) as { success: boolean; flagged: { siblingMemories: number } };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.flagged.siblingMemories).toBe(0);
|
|
});
|
|
|
|
it("returns zero counts when no sourceObservationIds and < 2 concepts", async () => {
|
|
const memory: Memory = {
|
|
id: "mem_empty",
|
|
createdAt: "2026-03-01T00:00:00Z",
|
|
updatedAt: "2026-03-01T00:00:00Z",
|
|
type: "fact",
|
|
title: "Empty refs",
|
|
content: "No references",
|
|
concepts: [],
|
|
files: [],
|
|
sessionIds: [],
|
|
strength: 5,
|
|
version: 1,
|
|
isLatest: false,
|
|
};
|
|
await kv.set("mem:memories", "mem_empty", memory);
|
|
|
|
const result = (await sdk.trigger("mem::cascade-update", {
|
|
supersededMemoryId: "mem_empty",
|
|
})) as { success: boolean; total: number };
|
|
|
|
expect(result.success).toBe(true);
|
|
expect(result.total).toBe(0);
|
|
});
|
|
});
|