大海
244 lines
12 KiB
JavaScript
244 lines
12 KiB
JavaScript
/**
|
|
* PR-2 MemoryCore Facade Test Suite
|
|
*
|
|
* Run: node --test test/memory-core/facade.test.mjs
|
|
*
|
|
* Tests the MemoryCore facade contract:
|
|
* 1. Module importable
|
|
* 2. health() returns ok:true
|
|
* 3. stats() returns stable structure
|
|
* 4. search() returns unified contract
|
|
* 5. get("MEMORY.md") returns unified contract
|
|
* 6. get("missing-file") returns ok:false
|
|
* 7. write() only writes to test namespace
|
|
* 8. delete() only deletes from test namespace
|
|
* 9. Does not modify real MEMORY.md
|
|
* 10. Does not change memory_search old tool behavior (verified by baseline)
|
|
* 11. Does not change memory_get old tool behavior (verified by baseline)
|
|
* 12. production-check still passes (verified in facade-health.test.mjs)
|
|
*/
|
|
|
|
import { describe, it, before, after } from "node:test";
|
|
import assert from "node:assert";
|
|
import { readFileSync, existsSync, unlinkSync, writeFileSync } from "node:fs";
|
|
import { join, resolve } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const __dirname = join(fileURLToPath(import.meta.url), "..", "..", "..");
|
|
const ROOT = resolve(__dirname);
|
|
|
|
// Dynamic import because facade uses ESM
|
|
let createMemoryCore;
|
|
let mc;
|
|
|
|
before(async () => {
|
|
const mod = await import(join(ROOT, "src", "memory-core", "memory-core-facade.mjs"));
|
|
createMemoryCore = mod.createMemoryCore;
|
|
mc = createMemoryCore(ROOT);
|
|
});
|
|
|
|
describe("PR-2: MemoryCore Facade", () => {
|
|
|
|
// ─── Test 1: Module importable ────────────────────
|
|
it("facade module is importable", () => {
|
|
assert.ok(typeof createMemoryCore === "function", "createMemoryCore should be a function");
|
|
assert.ok(mc !== undefined, "facade instance should exist");
|
|
assert.ok(typeof mc.search === "function", "mc.search should be a function");
|
|
assert.ok(typeof mc.get === "function", "mc.get should be a function");
|
|
assert.ok(typeof mc.write === "function", "mc.write should be a function");
|
|
assert.ok(typeof mc.delete === "function", "mc.delete should be a function");
|
|
assert.ok(typeof mc.stats === "function", "mc.stats should be a function");
|
|
assert.ok(typeof mc.health === "function", "mc.health should be a function");
|
|
});
|
|
|
|
// ─── Test 2: health() returns ok:true ──────────────
|
|
it("health() returns ok:true", async () => {
|
|
const h = await mc.health();
|
|
assert.ok(h.ok === true, `Expected health.ok=true, got ${JSON.stringify(h)}`);
|
|
assert.ok(h.memoryCoreAvailable === true, "memoryCoreAvailable should be true");
|
|
assert.ok(h.canSearch === true, "canSearch should be true");
|
|
assert.ok(h.canGet === true, "canGet should be true");
|
|
assert.ok(h.canWriteTestNamespace === true, "canWriteTestNamespace should be true");
|
|
});
|
|
|
|
// ─── Test 3: stats() returns stable structure ──────
|
|
it("stats() returns stable structure", async () => {
|
|
const s = await mc.stats();
|
|
|
|
assert.ok(typeof s.memoryFileCount === "number", "memoryFileCount should be number");
|
|
assert.ok(s.memoryFileCount > 0, `Expected >0 files, got ${s.memoryFileCount}`);
|
|
assert.ok(typeof s.memoryTotalSizeBytes === "number", "memoryTotalSizeBytes should be number");
|
|
assert.ok(s.memoryTotalSizeBytes > 0, "memoryTotalSizeBytes should be > 0");
|
|
assert.ok(typeof s.knownPluginCount === "number", "knownPluginCount should be number");
|
|
assert.ok(s.knownPluginCount >= 2, `Expected >=2 plugins, got ${s.knownPluginCount}`);
|
|
assert.ok(typeof s.legacyItemCount === "number", "legacyItemCount should be number");
|
|
assert.ok(s.legacyItemCount >= 1, `Expected >=1 legacy items, got ${s.legacyItemCount}`);
|
|
|
|
// Breakdown
|
|
assert.ok(s.breakdown !== undefined, "breakdown should exist");
|
|
assert.ok(typeof s.breakdown.daily === "number", "breakdown.daily should be number");
|
|
assert.ok(typeof s.breakdown.registers === "number", "breakdown.registers should be number");
|
|
assert.ok(typeof s.breakdown.vault === "number", "breakdown.vault should be number");
|
|
assert.ok(typeof s.breakdown.core === "number", "breakdown.core should be number");
|
|
});
|
|
|
|
// ─── Test 4: search() returns unified contract ─────
|
|
it("search() returns unified contract", async () => {
|
|
const result = await mc.search("memory", { maxResults: 5 });
|
|
|
|
assert.equal(result.ok, true, `search ok should be true: ${JSON.stringify(result.error)}`);
|
|
assert.ok(Array.isArray(result.results), "results should be array");
|
|
assert.ok(["fts5-search", "memory-core-facade"].includes(result.source), `source should be fts5-search or memory-core-facade, got ${result.source}`);
|
|
assert.ok(typeof result.latencyMs === "number", "latencyMs should be number");
|
|
assert.ok(result.latencyMs >= 0, "latencyMs should be >= 0");
|
|
|
|
// Each result should have the contract
|
|
for (const r of result.results) {
|
|
assert.ok(typeof r.id === "string", `result.id should be string, got ${typeof r.id}`);
|
|
assert.ok(typeof r.path === "string", `result.path should be string`);
|
|
assert.ok(typeof r.score === "number", `result.score should be number`);
|
|
assert.ok(r.score >= 0 && r.score <= 1, `score should be 0-1, got ${r.score}`);
|
|
}
|
|
});
|
|
|
|
// ─── Test 5: search empty query returns ok:false ────
|
|
it("search empty query returns error contract", async () => {
|
|
const result = await mc.search("");
|
|
assert.equal(result.ok, false, "empty query should fail");
|
|
assert.ok(result.error, "should have error object");
|
|
assert.ok(Array.isArray(result.results), "results should still be array");
|
|
assert.equal(result.results.length, 0, "results should be empty");
|
|
});
|
|
|
|
// ─── Test 6: get("MEMORY.md") returns unified contract ──
|
|
it("get(MEMORY.md) returns unified contract", async () => {
|
|
const result = await mc.get("MEMORY.md");
|
|
|
|
assert.equal(result.ok, true, `get MEMORY.md should succeed: ${JSON.stringify(result.error)}`);
|
|
assert.ok(typeof result.content === "string", "content should be string");
|
|
assert.ok(result.content.length > 100, `content too short: ${result.content.length} chars`);
|
|
assert.ok(result.metadata, "should have metadata");
|
|
assert.equal(result.metadata.path, "MEMORY.md");
|
|
assert.ok(result.metadata.sizeBytes > 0, "sizeBytes should be > 0");
|
|
assert.ok(typeof result.metadata.modifiedAt === "string", "modifiedAt should be string");
|
|
});
|
|
|
|
// ─── Test 7: get with maxLines truncates ────────────
|
|
it("get with maxLines truncates content", async () => {
|
|
const result = await mc.get("MEMORY.md", { maxLines: 5 });
|
|
|
|
assert.equal(result.ok, true);
|
|
const lines = result.content.split("\n");
|
|
assert.ok(lines.length <= 6, `Expected <=6 lines (5 + truncation notice), got ${lines.length}`);
|
|
});
|
|
|
|
// ─── Test 8: get("missing-file") returns ok:false ───
|
|
it("get(missing-file) returns ok:false", async () => {
|
|
const result = await mc.get("definitely-does-not-exist-99999.md");
|
|
|
|
assert.equal(result.ok, false, "missing file should fail");
|
|
assert.ok(result.error, "should have error object");
|
|
assert.ok(result.error.code, "should have error code");
|
|
// Should not have content on failure
|
|
assert.ok(result.content === undefined, "should not have content on failure");
|
|
});
|
|
|
|
// ─── Test 9: get path traversal is blocked ──────────
|
|
it("get blocks path traversal", async () => {
|
|
const result = await mc.get("../etc/passwd");
|
|
assert.equal(result.ok, false, "path traversal should fail");
|
|
assert.ok(result.error.code.includes("TRAVERSAL") || result.error.code.includes("NOT_ALLOWED"),
|
|
`Expected traversal/allowed error, got ${result.error.code}`);
|
|
});
|
|
|
|
// ─── Test 10: write() only writes to test namespace ─
|
|
it("write only allows test namespace", async () => {
|
|
// Attempt to write to non-test namespace
|
|
const badResult = await mc.write({ namespace: "memory", key: "something", content: "bad" });
|
|
assert.equal(badResult.ok, false, "non-test namespace should fail");
|
|
assert.equal(badResult.error.code, "NAMESPACE_LOCKED");
|
|
|
|
// Write to test namespace should work
|
|
const testKey = `facade-test-${Date.now()}`;
|
|
const goodResult = await mc.write({ namespace: "test", key: testKey, content: "hello from facade test" });
|
|
assert.equal(goodResult.ok, true, `test namespace write should succeed: ${JSON.stringify(goodResult.error)}`);
|
|
assert.ok(goodResult.path, "should return path");
|
|
assert.ok(goodResult.path.includes("test-memory-core-"), "path should contain test prefix");
|
|
|
|
// Clean up
|
|
const delResult = await mc.delete(testKey);
|
|
assert.equal(delResult.ok, true, "cleanup delete should succeed");
|
|
});
|
|
|
|
// ─── Test 11: delete() only deletes test namespace ──
|
|
it("delete only works on test namespace", async () => {
|
|
// Delete non-existent key
|
|
const result = await mc.delete("does-not-exist-key-xyz");
|
|
assert.equal(result.ok, false, "non-existent key should fail");
|
|
assert.equal(result.error.code, "NOT_FOUND");
|
|
|
|
// Write then delete
|
|
const key = `delete-test-${Date.now()}`;
|
|
await mc.write({ namespace: "test", key, content: "to be deleted" });
|
|
const delResult = await mc.delete(key);
|
|
assert.equal(delResult.ok, true, "delete should succeed");
|
|
|
|
// Double delete should fail
|
|
const doubleDel = await mc.delete(key);
|
|
assert.equal(doubleDel.ok, false, "double delete should fail");
|
|
});
|
|
|
|
// ─── Test 12: Does not modify real MEMORY.md ───────
|
|
it("does not modify real MEMORY.md", async () => {
|
|
const originalContent = readFileSync(join(ROOT, "MEMORY.md"), "utf8");
|
|
const originalSize = Buffer.byteLength(originalContent, "utf8");
|
|
|
|
// Run all facade operations
|
|
await mc.search("test query");
|
|
await mc.get("MEMORY.md");
|
|
await mc.stats();
|
|
await mc.health();
|
|
await mc.write({ namespace: "test", key: "integrity-check", content: "check" });
|
|
await mc.delete("integrity-check");
|
|
|
|
// Verify MEMORY.md unchanged
|
|
const currentContent = readFileSync(join(ROOT, "MEMORY.md"), "utf8");
|
|
const currentSize = Buffer.byteLength(currentContent, "utf8");
|
|
|
|
assert.equal(currentContent, originalContent, "MEMORY.md content must not change");
|
|
assert.equal(currentSize, originalSize, "MEMORY.md size must not change");
|
|
});
|
|
|
|
// ─── Test 13: search handles special characters ─────
|
|
it("search handles special characters safely", async () => {
|
|
const result = await mc.search("test * ? [regex] (special)");
|
|
assert.equal(result.ok, true, "special chars should not crash search");
|
|
assert.ok(Array.isArray(result.results), "results should be array");
|
|
// May or may not find results, but must not crash
|
|
});
|
|
|
|
// ─── Test 14: Multiple concurrent searches ──────────
|
|
it("handles multiple concurrent searches", async () => {
|
|
const queries = ["memory", "小龙", "architecture", "MEMORY", "test"];
|
|
const results = await Promise.all(queries.map(q => mc.search(q, { maxResults: 3 })));
|
|
|
|
assert.equal(results.length, 5, "should have 5 results");
|
|
for (const r of results) {
|
|
assert.equal(r.ok, true, `each search should be ok: ${JSON.stringify(r.error)}`);
|
|
assert.ok(Array.isArray(r.results), "each should have results array");
|
|
assert.ok(["fts5-search", "memory-core-facade"].includes(r.source), `source should be fts5-search, got ${r.source}`);
|
|
}
|
|
});
|
|
|
|
// ─── Test 15: stats consistency ─────────────────────
|
|
it("stats are consistent between calls", async () => {
|
|
const s1 = await mc.stats();
|
|
const s2 = await mc.stats();
|
|
|
|
assert.equal(s1.memoryFileCount, s2.memoryFileCount, "file count should be consistent");
|
|
assert.equal(s1.memoryTotalSizeBytes, s2.memoryTotalSizeBytes, "total size should be consistent");
|
|
assert.equal(s1.knownPluginCount, s2.knownPluginCount);
|
|
assert.equal(s1.legacyItemCount, s2.legacyItemCount);
|
|
});
|
|
});
|