test(client): couverture comportementale des 3 changements SDK (fake déterministe)
Les fix récents (anti-fork, open-repo, access-log) n'avaient AUCUN test de comportement dans le domaine de la lib. Ajout de tests DÉTERMINISTES à base de `ng` factice modélisant la condition d'échec (pas de broker réel — le harness e2e réel réhydrate trop vite et ne reproduit pas ces cas). - anti-fork.test.ts : fake avec lag de sync (0 lignes les K premières lectures du record de compte, puis les vraies). Asserte le cœur du fix : compte retrouvé au retry → réutilisé, 0 doc_create (pas de fork) ; compte réellement neuf → 1 seul jeu de docs provisionné, budget de retry prouvé consommé ; idempotence de session ; cas limite « trouvé à la dernière tentative ». - open-repo.test.ts : fake où une requête ancrée rend vide tant que doc_subscribe n'a pas ouvert le repo. Asserte subscribe-avant-read + idempotence (Set des repos ouverts) + no-op si le ng n'a pas doc_subscribe. - access-log.test.ts : off par défaut (silencieux), on via config ET via env NG_EVENTUALLY_ACCESS_LOG, préfixe = identité active (suit setCurrentUser), row-count sur READ. Restaure console.log/env fidèlement. bun test : 91 → 117 pass, 0 fail. tsc --noEmit propre. src/ non touché. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Sylvain Duchesne
@@ -0,0 +1,267 @@
|
||||
/**
|
||||
* anti-fork.test.ts — behavioral tests for the ANTI-FORK guard in ensureAccount /
|
||||
* resolveAccountReliably (src/store-registry.ts).
|
||||
*
|
||||
* The guard is: before treating a 0-row read as "genuinely new account" and
|
||||
* provisioning a new set of scope docs, the registry retries a bounded number of
|
||||
* times (with ensureRepoOpen + backoff between each). If the account IS found on
|
||||
* any attempt, it is reused (no second set of docs = no fork). Only if EVERY
|
||||
* attempt still reads 0 rows does the registry treat it as a first-time account
|
||||
* and provision exactly once.
|
||||
*
|
||||
* This file uses a FAKE `ng` that simulates broker sync lag: the sparql_query for
|
||||
* the account record returns 0 rows for the first K calls, then returns real rows.
|
||||
* We control the retry budget via `provisionRetry.attempts`.
|
||||
*/
|
||||
|
||||
import { describe, it, expect, mock, beforeEach, afterAll } from "bun:test";
|
||||
import {
|
||||
ensureAccount,
|
||||
resetRegistryCache,
|
||||
} from "../src/store-registry";
|
||||
import type { RegistrySession } from "../src/store-registry";
|
||||
import {
|
||||
configure,
|
||||
configureStoreRegistry,
|
||||
resetStoreRegistry,
|
||||
resetConfig,
|
||||
} from "../src/polyfill";
|
||||
import { resetOpenedRepos } from "../src/open-repo";
|
||||
|
||||
afterAll(() => {
|
||||
resetConfig();
|
||||
resetStoreRegistry();
|
||||
resetRegistryCache();
|
||||
resetOpenedRepos();
|
||||
});
|
||||
|
||||
const SESSION: RegistrySession = { sessionId: "sid-af", privateStoreId: "PRIV-AF" };
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fake ng with sync-lag simulation
|
||||
//
|
||||
// `lagCalls` controls how many account-record reads return 0 rows before the
|
||||
// real data is visible. Each call to sparql_query that matches the account
|
||||
// SELECT decrements the counter; once it hits 0 the real data is returned.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
interface Quad { g: string; s: string; p: string; o: string }
|
||||
|
||||
function unescapeLiteral(s: string): string {
|
||||
let out = "";
|
||||
for (let i = 0; i < s.length; i++) {
|
||||
if (s[i] === "\\" && i + 1 < s.length) {
|
||||
const next = s[++i];
|
||||
out += next === "n" ? "\n" : next === "r" ? "\r" : next === "t" ? "\t" : next;
|
||||
} else {
|
||||
out += s[i];
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function makeLaggedNg(lagCalls: number) {
|
||||
const quads: Quad[] = [];
|
||||
let docCounter = 0;
|
||||
let accountQueryCount = 0;
|
||||
|
||||
const doc_create = mock(async (..._a: unknown[]) => `did:ng:o:doc${++docCounter}`);
|
||||
|
||||
const sparql_update = mock(async (...a: unknown[]) => {
|
||||
const query = a[1] as string;
|
||||
const anchor = a[2] as string | undefined;
|
||||
const gm = query.match(/GRAPH <([^>]+)>\s*\{([\s\S]*)\}/);
|
||||
let g: string;
|
||||
let body: string;
|
||||
if (gm) {
|
||||
g = gm[1]!;
|
||||
body = gm[2]!;
|
||||
} else {
|
||||
if (!anchor) return undefined;
|
||||
g = anchor;
|
||||
body = query.replace(/^\s*INSERT DATA\s*\{/, "").replace(/\}\s*$/, "");
|
||||
}
|
||||
const sm = body.match(/<([^>]+)>/);
|
||||
if (!sm) return undefined;
|
||||
const s = sm[1]!;
|
||||
const pairRe = /(?:a|<([^>]+)>)\s+(?:"((?:[^"\\]|\\.)*)"|<([^>]+)>)/g;
|
||||
let m: RegExpExecArray | null;
|
||||
const after = body.slice(body.indexOf(sm[0]) + sm[0].length);
|
||||
while ((m = pairRe.exec(after)) !== null) {
|
||||
const p = m[1] ?? "urn:ng-eventually:shim:Account";
|
||||
const o = m[2] !== undefined ? unescapeLiteral(m[2]) : (m[3] ?? "");
|
||||
quads.push({ g, s, p, o });
|
||||
}
|
||||
return undefined;
|
||||
});
|
||||
|
||||
const sparql_query = mock(async (...a: unknown[]) => {
|
||||
const query = a[1] as string;
|
||||
const anchor = a[3] as string | undefined;
|
||||
|
||||
if (query.includes("<urn:ng-eventually:shim:id>")) {
|
||||
// This is an account SELECT (resolveAccount / loadShim)
|
||||
accountQueryCount++;
|
||||
|
||||
// Still in the lag window → pretend the store hasn't synced yet
|
||||
if (accountQueryCount <= lagCalls) {
|
||||
return { results: { bindings: [] } };
|
||||
}
|
||||
|
||||
// Lag lifted → return real data from the quads store
|
||||
const subjM = query.match(/GRAPH <[^>]+>\s*\{\s*<([^>]+)>\s+a\s+<urn:ng-eventually:shim:Account>/);
|
||||
const onlySubject = subjM ? subjM[1]! : null;
|
||||
const bySubject = new Map<string, Record<string, string>>();
|
||||
for (const q of quads) {
|
||||
if (q.g !== anchor) continue;
|
||||
if (onlySubject !== null && q.s !== onlySubject) continue;
|
||||
const rec = bySubject.get(q.s) ?? {};
|
||||
if (q.p === "urn:ng-eventually:shim:id") rec.id = q.o;
|
||||
if (q.p === "urn:ng-eventually:shim:docPublic") rec.docPublic = q.o;
|
||||
if (q.p === "urn:ng-eventually:shim:docProtected") rec.docProtected = q.o;
|
||||
if (q.p === "urn:ng-eventually:shim:docPrivate") rec.docPrivate = q.o;
|
||||
bySubject.set(q.s, rec);
|
||||
}
|
||||
const bindings = [...bySubject.values()]
|
||||
.filter((r) => r.id)
|
||||
.map((r) => ({
|
||||
id: { value: r.id! },
|
||||
docPublic: { value: r.docPublic ?? "" },
|
||||
docProtected: { value: r.docProtected ?? "" },
|
||||
docPrivate: { value: r.docPrivate ?? "" },
|
||||
}));
|
||||
return { results: { bindings } };
|
||||
}
|
||||
|
||||
// Entity-index SELECT
|
||||
const bindings = quads
|
||||
.filter((q) => q.g === anchor && q.p === "urn:ng-eventually:shim:contains")
|
||||
.map((q) => ({ e: { value: q.o } }));
|
||||
return { results: { bindings } };
|
||||
});
|
||||
|
||||
return {
|
||||
doc_create,
|
||||
sparql_update,
|
||||
sparql_query,
|
||||
_quads: quads,
|
||||
getAccountQueryCount: () => accountQueryCount,
|
||||
};
|
||||
}
|
||||
|
||||
function inject(laggedNg: ReturnType<typeof makeLaggedNg>, attempts: number) {
|
||||
configure({ ng: laggedNg as any, useShape: (() => {}) as any });
|
||||
configureStoreRegistry({
|
||||
getSession: async () => SESSION,
|
||||
normalizeId: (u) => u.trim().toLowerCase(),
|
||||
provisionRetry: { attempts, baseMs: 0, maxStepMs: 0 },
|
||||
});
|
||||
resetRegistryCache();
|
||||
resetOpenedRepos();
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
describe("anti-fork: resolveAccountReliably / ensureAccount", () => {
|
||||
beforeEach(() => {
|
||||
resetRegistryCache();
|
||||
resetOpenedRepos();
|
||||
});
|
||||
|
||||
it("(a) sync lag: 0 rows for K-1 calls then real rows → reuses existing docs (no fork)", async () => {
|
||||
// budget = 3 attempts; lag = 1 call (the first targeted read returns 0,
|
||||
// but the second (after retry) returns the real data written in the same
|
||||
// session before the cache was dropped). We simulate a scenario where the
|
||||
// account IS already provisioned (written to quads by a previous
|
||||
// ensureAccount call in an earlier "session"), then we reset the cache and
|
||||
// re-call with lag to simulate broker sync delay.
|
||||
|
||||
const laggedNg = makeLaggedNg(0); // no lag — first provision a real account
|
||||
inject(laggedNg, 1);
|
||||
const first = await ensureAccount("LauraLag");
|
||||
expect(laggedNg.doc_create).toHaveBeenCalledTimes(3);
|
||||
|
||||
// Now simulate a fresh session with lag: cache cleared, first K reads are 0
|
||||
// We reuse the SAME quads store (same laggedNg with quads intact) but
|
||||
// rebuild with lag > 0 so the first read returns 0, then real data.
|
||||
const laggedNg2 = makeLaggedNg(1); // 1 empty read before real data
|
||||
// Copy the quads from the first ng into laggedNg2 so it "knows" the account
|
||||
for (const q of laggedNg._quads) {
|
||||
laggedNg2._quads.push(q);
|
||||
}
|
||||
inject(laggedNg2, 3); // 3 attempts, lag=1 → second attempt succeeds
|
||||
|
||||
const second = await ensureAccount("LauraLag");
|
||||
|
||||
// ANTI-FORK: must return the SAME scope docs — no new doc_create
|
||||
expect(second.docPublic).toBe(first.docPublic);
|
||||
expect(second.docProtected).toBe(first.docProtected);
|
||||
expect(second.docPrivate).toBe(first.docPrivate);
|
||||
// doc_create must NOT have been called (the lagged ng2 finds the account on retry)
|
||||
expect(laggedNg2.doc_create).toHaveBeenCalledTimes(0);
|
||||
});
|
||||
|
||||
it("(b) always-0 rows (genuinely new account): provisions exactly ONCE (1 set of docs)", async () => {
|
||||
// Lag longer than the retry budget → account is treated as new
|
||||
const laggedNg = makeLaggedNg(999); // always returns 0 for account queries
|
||||
inject(laggedNg, 2); // budget: 2 attempts, both see 0 → provision
|
||||
|
||||
const rec = await ensureAccount("NewUser");
|
||||
|
||||
// Exactly 3 doc_create calls (1 set of scope docs)
|
||||
expect(laggedNg.doc_create).toHaveBeenCalledTimes(3);
|
||||
expect(rec.docPublic).toMatch(/^did:ng:o:doc/);
|
||||
expect(rec.docProtected).not.toBe(rec.docPublic);
|
||||
expect(rec.docPrivate).not.toBe(rec.docProtected);
|
||||
// Verify budget was fully consumed: both attempts fired before provisioning
|
||||
expect(laggedNg.getAccountQueryCount()).toBe(2);
|
||||
});
|
||||
|
||||
it("idempotence within a session: calling ensureAccount twice never creates 2 sets", async () => {
|
||||
const laggedNg = makeLaggedNg(0); // no lag
|
||||
inject(laggedNg, 1);
|
||||
|
||||
const a = await ensureAccount("SameUser");
|
||||
const b = await ensureAccount("SameUser");
|
||||
|
||||
expect(b).toEqual(a);
|
||||
// Must still be exactly 3 (not 6)
|
||||
expect(laggedNg.doc_create).toHaveBeenCalledTimes(3);
|
||||
});
|
||||
|
||||
it("retry budget of 1 (sync fake): a genuinely-absent account provisions without extra retries", async () => {
|
||||
const laggedNg = makeLaggedNg(0); // will never return lag (account not in quads)
|
||||
inject(laggedNg, 1);
|
||||
|
||||
await ensureAccount("BrandNew");
|
||||
|
||||
// 3 scope docs created exactly once
|
||||
expect(laggedNg.doc_create).toHaveBeenCalledTimes(3);
|
||||
// The targeted account query was called exactly once (no retries at attempts=1)
|
||||
const accountQueryCalls = laggedNg.getAccountQueryCount();
|
||||
expect(accountQueryCalls).toBe(1);
|
||||
});
|
||||
|
||||
it("lag of exactly (attempts-1): found on last allowed attempt → reused, not forked", async () => {
|
||||
// 3 attempts, lag=2 (first 2 calls return 0, 3rd returns real data).
|
||||
// We pre-populate the quads by provisioning with a fresh no-lag ng first.
|
||||
const seedNg = makeLaggedNg(0);
|
||||
inject(seedNg, 1);
|
||||
const original = await ensureAccount("EdgeUser");
|
||||
expect(seedNg.doc_create).toHaveBeenCalledTimes(3);
|
||||
|
||||
// Now re-inject with the same quads but with lag=2, budget=3
|
||||
const laggedNg = makeLaggedNg(2);
|
||||
for (const q of seedNg._quads) laggedNg._quads.push(q);
|
||||
inject(laggedNg, 3);
|
||||
|
||||
const retried = await ensureAccount("EdgeUser");
|
||||
|
||||
// Found on the 3rd attempt (lag=2 means first 2 return 0, 3rd returns real)
|
||||
expect(retried.docPublic).toBe(original.docPublic);
|
||||
expect(retried.docProtected).toBe(original.docProtected);
|
||||
expect(laggedNg.doc_create).toHaveBeenCalledTimes(0); // no new provisioning
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user