[Init] Initial commit - NetMesh terminal manager

electron/terminalWorker/process.test.cjs

@@ -0,0 +1,219 @@
+const assert = require("node:assert/strict");
+const crypto = require("node:crypto");
+const test = require("node:test");
+
+const {
+  createZmodemDownloadDirectorySelector,
+  createZmodemUploadFileSelector,
+  normalizeParentPortMessage,
+  registerExternalSessionHandlers,
+} = require("./process.cjs");
+
+function createParentPort() {
+  const messages = [];
+  const listeners = new Map();
+  return {
+    messages,
+    on(channel, callback) {
+      listeners.set(channel, callback);
+    },
+    postMessage(message) {
+      messages.push(message);
+    },
+    emitMessage(message) {
+      listeners.get("message")?.(message);
+    },
+  };
+}
+
+test("normalizeParentPortMessage unwraps Electron utility process MessageEvent data", () => {
+  assert.deepEqual(
+    normalizeParentPortMessage({ data: { kind: "zmodem-upload-dialog-result" } }),
+    { kind: "zmodem-upload-dialog-result" },
+  );
+  assert.deepEqual(
+    normalizeParentPortMessage({ kind: "request" }),
+    { kind: "request" },
+  );
+});
+
+test("terminal worker installs DH compatibility before SSH bridges load", () => {
+  assert.equal(crypto.createDiffieHellmanGroup.__boringSslDhCompat, true);
+});
+
+test("ZMODEM upload selector resolves dialog results delivered as MessageEvent data", async () => {
+  const parentPort = createParentPort();
+  const selectUploadFiles = createZmodemUploadFileSelector(parentPort, {
+    randomUUID: () => "dialog-1",
+  });
+
+  const promise = selectUploadFiles(7, "session-1");
+  assert.deepEqual(parentPort.messages, [{
+    kind: "zmodem-upload-dialog",
+    requestId: "dialog-1",
+    webContentsId: 7,
+    sessionId: "session-1",
+  }]);
+
+  parentPort.emitMessage({
+    data: {
+      kind: "zmodem-upload-dialog-result",
+      requestId: "dialog-1",
+      result: { canceled: false, filePaths: ["/tmp/upload.txt"] },
+    },
+  });
+
+  assert.deepEqual(await promise, {
+    canceled: false,
+    filePaths: ["/tmp/upload.txt"],
+  });
+});
+
+test("ZMODEM download selector resolves directory dialog results delivered as MessageEvent data", async () => {
+  const parentPort = createParentPort();
+  const selectDownloadDirectory = createZmodemDownloadDirectorySelector(parentPort, {
+    randomUUID: () => "download-dialog-1",
+  });
+
+  const promise = selectDownloadDirectory(7, "session-1");
+  assert.deepEqual(parentPort.messages, [{
+    kind: "zmodem-download-dialog",
+    requestId: "download-dialog-1",
+    webContentsId: 7,
+    sessionId: "session-1",
+  }]);
+
+  parentPort.emitMessage({
+    data: {
+      kind: "zmodem-download-dialog-result",
+      requestId: "download-dialog-1",
+      result: { canceled: false, filePaths: ["/tmp/downloads"] },
+    },
+  });
+
+  assert.deepEqual(await promise, {
+    canceled: false,
+    filePaths: ["/tmp/downloads"],
+  });
+});
+
+test("external plugin sessions stream auto-save logs through output and lifecycle cleanup", async () => {
+  const handlers = new Map();
+  const sessions = new Map();
+  const parentPort = createParentPort();
+  const observed = [];
+  const token = Symbol("plugin-session-log");
+  const sessionLogStreamManager = {
+    startStream(sessionId, options) {
+      observed.push(["start-log", sessionId, options]);
+      return token;
+    },
+    appendData(sessionId, data) {
+      observed.push(["append-log", sessionId, data]);
+    },
+    async stopStream(sessionId, expectedToken) {
+      observed.push(["stop-log", sessionId, expectedToken]);
+    },
+  };
+  registerExternalSessionHandlers({
+    handle(channel, handler) {
+      handlers.set(channel, handler);
+    },
+  }, {
+    sessions,
+    parentPort,
+    sessionLogStreamManager,
+  });
+  const sender = {
+    id: 7,
+    send(channel, payload) {
+      observed.push(["send", channel, payload]);
+    },
+  };
+
+  assert.deepEqual(await handlers.get("netcatty:external:start")({ sender }, {
+    sessionId: "plugin-log-1",
+    protocol: "plugin:com.example.transport.connection",
+    hostLabel: "Example transport",
+    hostname: "example.test",
+    columns: 80,
+    rows: 24,
+    sessionLog: {
+      enabled: true,
+      directory: "/logs",
+      format: "html",
+      timestampsEnabled: true,
+    },
+  }), { sessionId: "plugin-log-1" });
+  assert.equal(observed[0][0], "start-log");
+  assert.deepEqual(observed[0].slice(1, 3), [
+    "plugin-log-1",
+    {
+      hostLabel: "Example transport",
+      hostname: "example.test",
+      directory: "/logs",
+      format: "html",
+      timestampsEnabled: true,
+      startTime: observed[0][2].startTime,
+    },
+  ]);
+
+  await handlers.get("netcatty:external:output")({ sender }, {
+    sessionId: "plugin-log-1",
+    data: "provider output",
+  });
+  assert.deepEqual(observed.slice(1, 3), [
+    ["append-log", "plugin-log-1", "provider output"],
+    ["send", "netcatty:data", {
+      sessionId: "plugin-log-1",
+      data: "provider output",
+    }],
+  ]);
+
+  await assert.rejects(
+    handlers.get("netcatty:external:output")({ sender }, {
+      sessionId: "plugin-log-1",
+      data: Buffer.from("not a decoded provider string"),
+    }),
+    /output is invalid/,
+  );
+  assert.equal(observed.length, 3);
+
+  await handlers.get("netcatty:external:finish")({ sender }, {
+    sessionId: "plugin-log-1",
+    reason: "closed",
+    diagnostics: [{ severity: "warning", message: "Provider closed after idle timeout" }],
+  });
+  assert.deepEqual(observed.slice(3), [
+    ["stop-log", "plugin-log-1", token],
+    ["send", "netcatty:exit", {
+      sessionId: "plugin-log-1",
+      exitCode: 0,
+      reason: "closed",
+      diagnostics: [{ severity: "warning", message: "Provider closed after idle timeout" }],
+    }],
+  ]);
+  assert.equal(sessions.has("plugin-log-1"), false);
+
+  await handlers.get("netcatty:external:start")({ sender }, {
+    sessionId: "plugin-log-2",
+    protocol: "plugin:com.example.transport.connection",
+    hostLabel: "Example transport",
+    hostname: "example.test",
+    columns: 80,
+    rows: 24,
+    sessionLog: {
+      enabled: true,
+      directory: "/logs",
+      format: "txt",
+    },
+  });
+  sessions.get("plugin-log-2").stream.close();
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(
+    observed.some((entry) => entry[0] === "stop-log"
+      && entry[1] === "plugin-log-2"
+      && entry[2] === token),
+    true,
+  );
+});