[Init] Initial commit - NetMesh terminal manager

electron/bridges/dirtyEditorGuard.test.cjs

@@ -0,0 +1,223 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const { queryDirtyEditors } = require("./dirtyEditorGuard.cjs");
+
+/**
+ * Minimal ipcMain stand-in. Records on/removeListener so a test can both drive
+ * a reply (by invoking the captured listener) and assert the listener was
+ * cleaned up afterwards.
+ */
+function makeIpcMain() {
+  const listeners = new Map(); // channel -> Set<fn>
+  return {
+    on(channel, fn) {
+      if (!listeners.has(channel)) listeners.set(channel, new Set());
+      listeners.get(channel).add(fn);
+    },
+    removeListener(channel, fn) {
+      listeners.get(channel)?.delete(fn);
+    },
+    emit(channel, evt, payload) {
+      for (const fn of listeners.get(channel) || []) fn(evt, payload);
+    },
+    listenerCount(channel) {
+      return listeners.get(channel)?.size ?? 0;
+    },
+  };
+}
+
+/** Fake webContents that records sends and is alive by default. */
+function makeWebContents() {
+  const sent = [];
+  return {
+    sent,
+    send(channel) {
+      sent.push(channel);
+    },
+    isDestroyed() {
+      return false;
+    },
+    isCrashed() {
+      return false;
+    },
+  };
+}
+
+test("resolves true when the renderer reports dirty editors", async () => {
+  const ipcMain = makeIpcMain();
+  const wc = makeWebContents();
+
+  const promise = queryDirtyEditors(wc, 5000, { ipcMain });
+  // The request is sent on the queried webContents.
+  assert.deepEqual(wc.sent, ["app:query-dirty-editors"]);
+  // Renderer replies from the same webContents.
+  ipcMain.emit("app:dirty-editors-result", { sender: wc }, { hasDirty: true });
+
+  assert.equal(await promise, true);
+  // Listener was torn down.
+  assert.equal(ipcMain.listenerCount("app:dirty-editors-result"), 0);
+});
+
+test("resolves false when the renderer reports no dirty editors", async () => {
+  const ipcMain = makeIpcMain();
+  const wc = makeWebContents();
+
+  const promise = queryDirtyEditors(wc, 5000, { ipcMain });
+  ipcMain.emit("app:dirty-editors-result", { sender: wc }, { hasDirty: false });
+
+  assert.equal(await promise, false);
+  assert.equal(ipcMain.listenerCount("app:dirty-editors-result"), 0);
+});
+
+test("a missing hasDirty payload is treated as not-dirty (fail open)", async () => {
+  const ipcMain = makeIpcMain();
+  const wc = makeWebContents();
+
+  const promise = queryDirtyEditors(wc, 5000, { ipcMain });
+  ipcMain.emit("app:dirty-editors-result", { sender: wc }, undefined);
+
+  assert.equal(await promise, false);
+});
+
+test("ignores replies from a different webContents, then times out to false", async () => {
+  const ipcMain = makeIpcMain();
+  const wc = makeWebContents();
+  const otherWc = makeWebContents();
+
+  const originalSetTimeout = global.setTimeout;
+  let timeoutFn = null;
+  global.setTimeout = (fn) => {
+    timeoutFn = fn;
+    return { unref() {} };
+  };
+  try {
+    const promise = queryDirtyEditors(wc, 5000, { ipcMain });
+
+    // A rogue reply from another window claims dirty — it must be ignored, and
+    // the listener must remain installed (we use .on, not .once).
+    ipcMain.emit("app:dirty-editors-result", { sender: otherWc }, { hasDirty: true });
+    assert.equal(ipcMain.listenerCount("app:dirty-editors-result"), 1);
+
+    // No real reply ever arrives → the timeout fires and resolves false.
+    assert.equal(typeof timeoutFn, "function");
+    timeoutFn();
+    assert.equal(await promise, false);
+    assert.equal(ipcMain.listenerCount("app:dirty-editors-result"), 0);
+  } finally {
+    global.setTimeout = originalSetTimeout;
+  }
+});
+
+test("a falsy sender on the reply is rejected (treated as wrong window)", async () => {
+  const ipcMain = makeIpcMain();
+  const wc = makeWebContents();
+
+  const originalSetTimeout = global.setTimeout;
+  let timeoutFn = null;
+  global.setTimeout = (fn) => {
+    timeoutFn = fn;
+    return { unref() {} };
+  };
+  try {
+    const promise = queryDirtyEditors(wc, 5000, { ipcMain });
+    ipcMain.emit("app:dirty-editors-result", { sender: null }, { hasDirty: true });
+    // Not settled by the anomalous reply.
+    assert.equal(ipcMain.listenerCount("app:dirty-editors-result"), 1);
+    timeoutFn();
+    assert.equal(await promise, false);
+  } finally {
+    global.setTimeout = originalSetTimeout;
+  }
+});
+
+test("a late timeout cannot override an already-received reply", async () => {
+  const ipcMain = makeIpcMain();
+  const wc = makeWebContents();
+
+  const originalSetTimeout = global.setTimeout;
+  let timeoutFn = null;
+  global.setTimeout = (fn) => {
+    timeoutFn = fn;
+    return { unref() {} };
+  };
+  try {
+    const promise = queryDirtyEditors(wc, 5000, { ipcMain });
+    // Real reply: dirty=true.
+    ipcMain.emit("app:dirty-editors-result", { sender: wc }, { hasDirty: true });
+    // A stale timeout fires afterwards — it must be a no-op (settled guard).
+    timeoutFn();
+    assert.equal(await promise, true);
+  } finally {
+    global.setTimeout = originalSetTimeout;
+  }
+});
+
+test("resolves false without sending when there is no webContents", async () => {
+  const ipcMain = makeIpcMain();
+  assert.equal(await queryDirtyEditors(null, 5000, { ipcMain }), false);
+  assert.equal(ipcMain.listenerCount("app:dirty-editors-result"), 0);
+});
+
+test("resolves false without sending when the webContents is destroyed", async () => {
+  const ipcMain = makeIpcMain();
+  const wc = {
+    sent: [],
+    send(channel) {
+      this.sent.push(channel);
+    },
+    isDestroyed() {
+      return true;
+    },
+    isCrashed() {
+      return false;
+    },
+  };
+  assert.equal(await queryDirtyEditors(wc, 5000, { ipcMain }), false);
+  assert.deepEqual(wc.sent, []);
+  assert.equal(ipcMain.listenerCount("app:dirty-editors-result"), 0);
+});
+
+test("resolves false without sending when the renderer is crashed", async () => {
+  const ipcMain = makeIpcMain();
+  const wc = {
+    sent: [],
+    send(channel) {
+      this.sent.push(channel);
+    },
+    isDestroyed() {
+      return false;
+    },
+    isCrashed() {
+      return true;
+    },
+  };
+  assert.equal(await queryDirtyEditors(wc, 5000, { ipcMain }), false);
+  assert.deepEqual(wc.sent, []);
+});
+
+test("resolves false and tears down when webContents.send throws", async () => {
+  const ipcMain = makeIpcMain();
+  const wc = {
+    send() {
+      throw new Error("renderer gone");
+    },
+    isDestroyed() {
+      return false;
+    },
+    isCrashed() {
+      return false;
+    },
+  };
+  assert.equal(await queryDirtyEditors(wc, 5000, { ipcMain }), false);
+  // Listener must be removed even on the throw path.
+  assert.equal(ipcMain.listenerCount("app:dirty-editors-result"), 0);
+});
+
+test("resolves false when no ipcMain can be resolved", async () => {
+  // No ipcMain injected and electron isn't loadable in `node --test`, so
+  // resolveIpcMain() returns null → fail open.
+  const wc = makeWebContents();
+  assert.equal(await queryDirtyEditors(wc, 5000), false);
+  assert.deepEqual(wc.sent, []);
+});