@mh-gg/relay-runtime 0.1.1-alpha.20260613T085325975Z

package/test/relay-runtime.test.cjs

@@ -0,0 +1,219 @@
+const assert = require("node:assert/strict");
+const { EventEmitter } = require("node:events");
+const test = require("node:test");
+
+const {
+  createEncryptedRoomRuntimeManager,
+  createPeerReconnectTracker,
+  isNewerStore,
+  relayRoomStoreSnapshot,
+  waitForPeerOpen
+} = require("..");
+
+function hexId(prefix) {
+  return String(prefix).padStart(64, "0");
+}
+
+function operationEvent(id, overrides = {}) {
+  const eventId = hexId(id);
+  return {
+    id: eventId,
+    pubkey: overrides.pubkey || "pk_" + eventId.slice(0, 8),
+    created_at: 1760000000,
+    kind: overrides.kind ?? 9001,
+    tags: [
+      ["scheme", overrides.scheme ?? "matterhorn.operation.v2"],
+      ["d", overrides.roomName || "room"],
+      ["stream", overrides.stream || "stream:general"],
+      ["hlc", overrides.hlc || `000000000000001:000000:${overrides.nodeId || "node"}`],
+      ["member", overrides.member || "alice"],
+      ["device", overrides.device || "d1"],
+      ["seq", String(overrides.seq ?? 0)],
+      ["plugin", overrides.plugin || "chat"],
+      ["type", overrides.type || "message.send"],
+      ["role", overrides.role || "member"],
+      ["epoch", overrides.epoch || "e1"],
+      ["op-id", overrides.opId || `op_${id}`],
+      ["payload-hash", overrides.payloadHash || `ph_${id}`]
+    ],
+    content: "encrypted"
+  };
+}
+
+function roomStore(roomName, version = 1) {
+  return {
+    roomName,
+    roomPeerId: `${roomName}-peer`,
+    roomSecret: "secret",
+    admins: {},
+    seenMutations: [],
+    state: {
+      version,
+      updatedAt: version,
+      details: {},
+      guests: {},
+      posts: [],
+      comments: [],
+      adminIds: []
+    }
+  };
+}
+
+test("relay room store snapshots clone matching room stores", () => {
+  const store = roomStore("runtime-room", 1);
+  store.state.guests.alice = { id: "alice", name: "Alice", avatar: "A" };
+
+  const snapshot = relayRoomStoreSnapshot("runtime-room", store);
+  assert.equal(snapshot.roomName, "runtime-room");
+  assert.notEqual(snapshot, store);
+  assert.deepEqual(snapshot.state.guests.alice, { id: "alice", name: "Alice", avatar: "A" });
+  assert.equal(relayRoomStoreSnapshot("other-room", store), undefined);
+});
+
+test("encrypted room runtime manager creates, snapshots, restores, and removes rooms", () => {
+  const manager = createEncryptedRoomRuntimeManager({ maxEventsPerStream: 2 });
+  assert.equal(manager.hasRoom("room-a"), false);
+  assert.deepEqual(manager.searchNgrams("missing", { tokens: ["t"] }), { events: [], matches: [], total: 0, queryTokenCount: 0 });
+  assert.deepEqual(manager.ngramIndexStats("missing"), { targets: 0, indexEvents: 0, tokenPostingLists: 0, postings: 0 });
+
+  const inserted = manager.insertEvent("room-a", operationEvent("e1", { roomName: "room-a" }));
+  assert.equal(inserted.ok, true);
+  assert.equal(inserted.inserted, true);
+  assert.equal(manager.hasRoom("room-a"), true);
+  assert.deepEqual(manager.listRooms(), ["room-a"]);
+
+  const snapshot = manager.snapshot();
+  assert.equal(snapshot["room-a"].roomName, "room-a");
+  assert.equal(snapshot["room-a"].events.length, 1);
+
+  const restored = createEncryptedRoomRuntimeManager();
+  assert.deepEqual(restored.restore(snapshot), { ok: true, rooms: 1, inserted: 1 });
+  assert.deepEqual(restored.listRooms(), ["room-a"]);
+  assert.equal(restored.removeRoom("room-a"), true);
+  assert.equal(restored.removeRoom("room-a"), false);
+  assert.deepEqual(restored.restore(null), { ok: true, rooms: 0, inserted: 0 });
+});
+
+test("encrypted room runtime manager rebuilds only mapped room events", () => {
+  const warnings = [];
+  const manager = createEncryptedRoomRuntimeManager({ logger: { warn: (...args) => warnings.push(args) } });
+  const validOperation = operationEvent("e2", { roomName: "room-b", stream: "s1" });
+  const validNgram = {
+    ...operationEvent("e3", { roomName: "room-b", kind: 9013, stream: "s2" }),
+    tags: [
+      ["room", "room-b"],
+      ["stream", "s2"],
+      ["hlc", "000000000000002:000000:node"],
+      ["member", "alice"]
+    ],
+    content: JSON.stringify({
+      kind: "matterhorn.room-index-ngram",
+      version: 1,
+      suite: "matterhorn.ngram.hmac-sha256.v1",
+      targetEventId: "target",
+      tokens: ["abcdefghijklmnopqrstuvwxyz"]
+    })
+  };
+  const ignoredBadScheme = operationEvent("e4", { roomName: "room-b", scheme: "legacy" });
+  const ignoredKind = operationEvent("e5", { roomName: "room-b", kind: 1 });
+
+  const result = manager.rebuildFromEvents((filters) => {
+    assert.deepEqual(filters, [{ kinds: [9001, 9013] }]);
+    return [validOperation, validNgram, ignoredBadScheme, ignoredKind, null];
+  });
+
+  assert.deepEqual(result, { ok: true, inserted: 2, operationEvents: 1, ngramIndexEvents: 1 });
+  assert.deepEqual(manager.listRooms(), ["room-b"]);
+  assert.equal(manager.getRoom("room-b").get(validOperation.id).id, validOperation.id);
+  assert.deepEqual(warnings, []);
+
+  const failed = manager.rebuildFromEvents(() => {
+    throw new Error("boom");
+  });
+  assert.deepEqual(failed, { ok: true, inserted: 0, operationEvents: 0, ngramIndexEvents: 0 });
+  assert.equal(warnings.length, 1);
+});
+
+test("isNewerStore compares version before timestamp", () => {
+  assert.equal(isNewerStore(roomStore("newer", 2), roomStore("newer", 1)), true);
+  assert.equal(isNewerStore(roomStore("older", 1), roomStore("older", 2)), false);
+  const left = roomStore("same", 1);
+  const right = roomStore("same", 1);
+  left.updatedAt = 3;
+  right.updatedAt = 2;
+  assert.equal(isNewerStore(left, right), true);
+  right.updatedAt = 4;
+  assert.equal(isNewerStore(left, right), false);
+  left.updatedAt = 4;
+  assert.equal(isNewerStore(left, right), false);
+});
+
+test("waitForPeerOpen resolves on open and rejects on error", async () => {
+  const openingPeer = new EventEmitter();
+  openingPeer.open = false;
+  openingPeer.id = "opening-peer";
+  const opened = waitForPeerOpen(openingPeer, "opening peer", 100);
+  openingPeer.emit("open", "opening-peer");
+  assert.equal(await opened, "opening-peer");
+
+  const failingPeer = new EventEmitter();
+  failingPeer.open = false;
+  const failed = waitForPeerOpen(failingPeer, "failing peer", 100);
+  failingPeer.emit("error", new Error("failed"));
+  await assert.rejects(failed, /failed/);
+
+  const openPeer = { open: true, id: "already-open" };
+  assert.equal(await waitForPeerOpen(openPeer, "open peer", 100), "already-open");
+
+  const timeoutPeer = new EventEmitter();
+  timeoutPeer.open = false;
+  await assert.rejects(waitForPeerOpen(timeoutPeer, "timeout peer", 1), /timeout peer did not open/);
+
+  const listenerPeer = new EventEmitter();
+  listenerPeer.open = false;
+  listenerPeer.off = undefined;
+  const openedWithRemoveListener = waitForPeerOpen(listenerPeer, "listener peer", 100);
+  listenerPeer.emit("open", "listener-peer");
+  assert.equal(await openedWithRemoveListener, "listener-peer");
+});
+
+test("peer reconnect tracker logs once and warns after repeated reconnects", () => {
+  const warnings = [];
+  const debugs = [];
+  const logs = [];
+  const previousLog = console.log;
+  const previousNow = Date.now;
+  let now = previousNow();
+  Date.now = () => now;
+  console.log = (message) => logs.push(message);
+  try {
+    const tracker = createPeerReconnectTracker({
+      debug: (message) => debugs.push(message),
+      warn: (message) => warnings.push(message),
+      threshold: 2,
+      windowMs: 1000
+    });
+    const peer = { id: "peer-a" };
+    tracker.logOpen("relay peer", "peer-a", peer);
+    tracker.logOpen("relay peer", "peer-a", peer);
+    tracker.warn(peer, "relay peer", "network");
+    now += 1;
+    tracker.warn(peer, "relay peer", "network");
+
+    assert.deepEqual(logs, ["relay peer is live as peer-a"]);
+    assert.equal(debugs.some((message) => message.includes("reopened as peer-a")), true);
+    assert.equal(warnings.length, 1);
+    assert.equal(tracker.summary()[0].warned, true);
+    assert.equal(tracker.stablePeerId(peer), "peer-a");
+    assert.equal(tracker.stablePeerId({}), "unknown");
+  } finally {
+    Date.now = previousNow;
+    console.log = previousLog;
+  }
+});
+
+test("peer reconnect tracker defaults do not warn before threshold", () => {
+  const tracker = createPeerReconnectTracker();
+  tracker.warn({ MatterhornStableId: "peer-b" }, "relay peer", "network");
+  assert.equal(tracker.summary()[0].warned, false);
+});