[Init] Initial commit - NetMesh terminal manager

electron/mainDeepLinkDelivery.test.cjs

@@ -0,0 +1,156 @@
+const assert = require("node:assert/strict");
+const { readFileSync } = require("node:fs");
+const test = require("node:test");
+const vm = require("node:vm");
+const deepLink = require("./deepLink.cjs");
+
+const source = readFileSync(require.resolve("./main.cjs"), "utf8");
+
+function section(start, end) {
+  const from = source.indexOf(start);
+  const to = source.indexOf(end, from);
+  assert.ok(from >= 0 && to > from);
+  return source.slice(from, to);
+}
+
+// Execute the main process's actual queue, preference handler, and delivery
+// functions. Only desktop services and renderer readiness are controlled here.
+function createHarness() {
+  const handlers = new Map();
+  const deliveries = [];
+  const waiting = [];
+  const timers = [];
+  const sandbox = {
+    ...deepLink,
+    process: { argv: ["netcatty"] },
+    app: { isReady: () => false },
+    ipcMain: { handle: (name, handler) => handlers.set(name, handler) },
+    isDev: false,
+    readSshDeepLinkEnabledPreference: () => true,
+    readJmsDeepLinkEnabledPreference: () => false,
+    resolveOpenTerminalPathsFromArgs: () => [],
+    resolveExplorerContextMenuEnabled: () => ({ enabled: false }),
+    applySshProtocolClientPreference: () => true,
+    writeSshDeepLinkEnabledPreference: () => true,
+    createAndShowMainWindow: async () => ({}),
+    focusMainWindow: () => {},
+    getWindowManager: () => ({
+      sendWhenRendererReady: (_win, channel, payload, options) => new Promise((resolve) => {
+        waiting.push({ channel, payload, options, resolve });
+      }),
+    }),
+    setTimeout: (callback) => timers.push(callback),
+    console: { warn: () => {} },
+  };
+  const context = vm.createContext(sandbox);
+  vm.runInContext([
+    section("let sshDeepLinkEnabled =", 'ipcMain?.handle?.("netcatty:deepLink:jms:setEnabled"'),
+    section("async function deliverSshDeepLink(", "async function deliverOpenTerminalPath("),
+    `globalThis.launch = {
+      ssh: { queue: queueSshDeepLink, flush: flushPendingSshDeepLinks, pending: pendingSshDeepLinkUrls },
+      telnet: { queue: queueTelnetDeepLink, flush: flushPendingTelnetDeepLinks, pending: pendingTelnetDeepLinkUrls },
+    };`,
+  ].join("\n"), context);
+
+  return {
+    launch: context.launch,
+    deliveries,
+    timers,
+    async setEnabled(enabled) {
+      await handlers.get("netcatty:deepLink:ssh:setEnabled")(null, { enabled });
+    },
+    async nextDelivery() {
+      for (let attempt = 0; attempt < 20 && waiting.length === 0; attempt++) await Promise.resolve();
+      assert.ok(waiting.length > 0, "delivery must reach renderer readiness");
+      const item = waiting.shift();
+      return {
+        finish(result) {
+          if (result) return item.resolve(result);
+          if (!item.options.shouldSend()) {
+            return item.resolve({ success: false, reason: item.options.cancelReason });
+          }
+          deliveries.push({ channel: item.channel, url: item.payload.url });
+          item.resolve({ success: true });
+        },
+      };
+    },
+  };
+}
+
+for (const protocol of ["ssh", "telnet"]) {
+  test(`${protocol}: disable/re-enable permanently cancels an in-flight scheme request`, async () => {
+    const h = createHarness();
+    const queue = h.launch[protocol];
+    queue.queue(`${protocol}://old.example`);
+    const flushing = queue.flush();
+    const old = await h.nextDelivery();
+    await h.setEnabled(false);
+    await h.setEnabled(true);
+    old.finish();
+    await flushing;
+    assert.deepEqual(h.deliveries, []);
+    assert.equal(queue.pending.length, 0);
+    assert.equal(h.timers.length, 0);
+  });
+
+  test(`${protocol}: cancelled schemes cannot return through a failed-delivery retry`, async () => {
+    const h = createHarness();
+    const queue = h.launch[protocol];
+    queue.queue(`${protocol}://old.example`);
+    const flushing = queue.flush();
+    const old = await h.nextDelivery();
+    await h.setEnabled(false);
+    await h.setEnabled(true);
+    old.finish({ success: false, reason: "window-destroyed" });
+    await flushing;
+    assert.equal(queue.pending.length, 0, "a cancelled request must not be requeued");
+    assert.equal(h.timers.length, 0);
+  });
+
+  test(`${protocol}: disabling removes queued schemes but preserves queued CLI and new requests`, async () => {
+    const h = createHarness();
+    const queue = h.launch[protocol];
+    queue.queue(`${protocol}://old.example`);
+    queue.queue(`${protocol}://queued-old.example`);
+    queue.queue(`${protocol}://cli.example`, { viaCommandLine: true });
+    const flushing = queue.flush();
+    const old = await h.nextDelivery();
+    await h.setEnabled(false);
+    await h.setEnabled(true);
+    queue.queue(`${protocol}://new.example`);
+    old.finish();
+    (await h.nextDelivery()).finish();
+    (await h.nextDelivery()).finish();
+    await flushing;
+    assert.deepEqual(h.deliveries.map((item) => item.url), [
+      `${protocol}://cli.example`, `${protocol}://new.example`,
+    ]);
+  });
+
+  test(`${protocol}: an in-flight CLI request survives disabling and re-enabling schemes`, async () => {
+    const h = createHarness();
+    const queue = h.launch[protocol];
+    queue.queue(`${protocol}://cli.example`, { viaCommandLine: true });
+    const flushing = queue.flush();
+    const cli = await h.nextDelivery();
+    await h.setEnabled(false);
+    await h.setEnabled(true);
+    cli.finish();
+    await flushing;
+    assert.deepEqual(h.deliveries.map((item) => item.url), [`${protocol}://cli.example`]);
+  });
+
+  test(`${protocol}: CLI retries remain queued when schemes are disabled`, async () => {
+    const h = createHarness();
+    const queue = h.launch[protocol];
+    queue.queue(`${protocol}://cli.example`, { viaCommandLine: true });
+    const flushing = queue.flush();
+    const cli = await h.nextDelivery();
+    await h.setEnabled(false);
+    cli.finish({ success: false, reason: "window-destroyed" });
+    await flushing;
+    assert.equal(queue.pending.length, 1);
+    assert.equal(h.timers.length, 1);
+    assert.equal(queue.pending[0].rawUrl, `${protocol}://cli.example`);
+  });
+}