[Init] Initial commit - NetMesh terminal manager

electron/bridges/mcpServerBridge/retainOwnedSessions.test.cjs

@@ -0,0 +1,267 @@
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const { retainOwnedSessions, mergeRetentionMeta } = require("./retainOwnedSessions.cjs");
+
+test("retainOwnedSessions keeps host_open-owned sessions dropped by a full scope replace", () => {
+  const previousById = new Map([
+    ["sess-original", {
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    }],
+    ["sess-opened", {
+      hostname: "10.0.0.2",
+      label: "server-b",
+      protocol: "ssh",
+      connected: false,
+      hostId: "host-b",
+    }],
+  ]);
+
+  const retained = retainOwnedSessions({
+    incomingSessions: [{
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+      hostId: "host-a",
+    }],
+    ownedSessionIds: ["sess-opened"],
+    previousById,
+  });
+
+  const ids = retained.map((entry) => entry.sessionId).sort();
+  assert.deepEqual(ids, ["sess-opened", "sess-original"]);
+  const opened = retained.find((entry) => entry.sessionId === "sess-opened");
+  assert.equal(opened.label, "server-b");
+  assert.equal(opened.hostId, "host-b");
+  assert.equal(opened.connected, false);
+});
+
+test("retainOwnedSessions does not alter authoritative empty replaces", () => {
+  const retained = retainOwnedSessions({
+    incomingSessions: [],
+    ownedSessionIds: ["sess-opened"],
+    previousById: new Map([
+      ["sess-opened", { hostname: "10.0.0.2", label: "server-b" }],
+    ]),
+  });
+  assert.deepEqual(retained, []);
+});
+
+test("retainOwnedSessions falls back to cross-scope metadata when needed", () => {
+  const retained = retainOwnedSessions({
+    incomingSessions: [{ sessionId: "sess-original", label: "server-a" }],
+    ownedSessionIds: ["sess-opened"],
+    previousById: new Map(),
+    findFallbackMeta: (sessionId) => (
+      sessionId === "sess-opened"
+        ? { hostname: "10.0.0.2", label: "server-b", hostId: "host-b" }
+        : null
+    ),
+  });
+  assert.equal(retained.length, 2);
+  assert.equal(
+    retained.find((entry) => entry.sessionId === "sess-opened")?.label,
+    "server-b",
+  );
+});
+
+test("retainOwnedSessions ignores owned ids with no recoverable metadata", () => {
+  const retained = retainOwnedSessions({
+    incomingSessions: [{ sessionId: "sess-original", label: "server-a" }],
+    ownedSessionIds: ["sess-ghost"],
+    previousById: new Map(),
+  });
+  assert.deepEqual(retained.map((entry) => entry.sessionId), ["sess-original"]);
+});
+
+test("retainOwnedSessions refreshes connected from fallback even when previous exists", () => {
+  const retained = retainOwnedSessions({
+    incomingSessions: [{
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+    }],
+    ownedSessionIds: ["sess-opened"],
+    previousById: new Map([
+      ["sess-opened", {
+        hostname: "10.0.0.2",
+        label: "server-b",
+        connected: false,
+        hostId: "host-b",
+      }],
+    ]),
+    findFallbackMeta: (sessionId) => (
+      sessionId === "sess-opened"
+        ? {
+          hostname: "10.0.0.2",
+          label: "server-b",
+          connected: true,
+          hostId: "host-b",
+          username: "root",
+        }
+        : null
+    ),
+  });
+
+  const opened = retained.find((entry) => entry.sessionId === "sess-opened");
+  assert.ok(opened);
+  assert.equal(opened.connected, true);
+  assert.equal(opened.username, "root");
+  assert.equal(opened.hostId, "host-b");
+});
+
+test("mergeRetentionMeta lets a later disconnected fallback replace connected:true", () => {
+  const merged = mergeRetentionMeta(
+    {
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      hostId: "host-b",
+    },
+    {
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: false,
+      hostId: "host-b",
+    },
+  );
+  assert.equal(merged.connected, false);
+});
+
+test("retainOwnedSessions applies a later disconnect from fallback metadata", () => {
+  const retained = retainOwnedSessions({
+    incomingSessions: [{
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+    }],
+    ownedSessionIds: ["sess-opened"],
+    previousById: new Map([
+      ["sess-opened", {
+        hostname: "10.0.0.2",
+        label: "server-b",
+        connected: true,
+        hostId: "host-b",
+      }],
+    ]),
+    findFallbackMeta: (sessionId) => (
+      sessionId === "sess-opened"
+        ? {
+          hostname: "10.0.0.2",
+          label: "server-b",
+          connected: false,
+          hostId: "host-b",
+        }
+        : null
+    ),
+  });
+
+  const opened = retained.find((entry) => entry.sessionId === "sess-opened");
+  assert.ok(opened);
+  assert.equal(opened.connected, false);
+});
+
+test("mergeRetentionMeta clears activePortForwards when fallback reports an empty array", () => {
+  const merged = mergeRetentionMeta(
+    {
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      activePortForwards: [{ ruleId: "fwd-1", localPort: 8080, status: "active" }],
+    },
+    {
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      activePortForwards: [],
+    },
+  );
+  assert.deepEqual(merged.activePortForwards, []);
+});
+
+test("mergeRetentionMeta keeps prior activePortForwards when fallback omits them", () => {
+  const prior = [{ ruleId: "fwd-1", localPort: 8080, status: "active" }];
+  const merged = mergeRetentionMeta(
+    {
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+      activePortForwards: prior,
+    },
+    {
+      hostname: "10.0.0.2",
+      label: "server-b",
+      connected: true,
+    },
+  );
+  assert.deepEqual(merged.activePortForwards, prior);
+});
+
+test("retainOwnedSessions applies empty activePortForwards from fallback metadata", () => {
+  const retained = retainOwnedSessions({
+    incomingSessions: [{
+      sessionId: "sess-original",
+      hostname: "10.0.0.1",
+      label: "server-a",
+      connected: true,
+    }],
+    ownedSessionIds: ["sess-opened"],
+    previousById: new Map([
+      ["sess-opened", {
+        hostname: "10.0.0.2",
+        label: "server-b",
+        connected: false,
+        hostId: "host-b",
+        activePortForwards: [{ ruleId: "fwd-1", localPort: 8080, status: "active" }],
+      }],
+    ]),
+    findFallbackMeta: (sessionId) => (
+      sessionId === "sess-opened"
+        ? {
+          hostname: "10.0.0.2",
+          label: "server-b",
+          connected: true,
+          hostId: "host-b",
+          activePortForwards: [],
+        }
+        : null
+    ),
+  });
+
+  const opened = retained.find((entry) => entry.sessionId === "sess-opened");
+  assert.ok(opened);
+  assert.deepEqual(opened.activePortForwards, []);
+  assert.equal(opened.connected, true);
+});
+
+test("mergeRetentionMeta keeps the higher metadata revision in either argument", () => {
+  const oldConnected = {
+    connected: true,
+    username: "old-user",
+    activePortForwards: [{ ruleId: "old-forward" }],
+    _revision: 4,
+  };
+  const newDisconnected = {
+    connected: false,
+    username: "new-user",
+    activePortForwards: [],
+    _revision: 7,
+  };
+
+  for (const merged of [
+    mergeRetentionMeta(oldConnected, newDisconnected),
+    mergeRetentionMeta(newDisconnected, oldConnected),
+  ]) {
+    assert.equal(merged.connected, false);
+    assert.equal(merged.username, "new-user");
+    assert.deepEqual(merged.activePortForwards, []);
+    assert.equal(merged._revision, 7);
+  }
+});