[Init] Initial commit - NetMesh terminal manager

application/state/sftp/ensureRemoteSftpSession.test.ts

@@ -0,0 +1,260 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { Host } from "../../../domain/models";
+import { ensureRemoteSftpSession, probeSftpSession } from "./ensureRemoteSftpSession";
+import type { SftpPane } from "./types";
+
+const host = {
+  id: "host-1",
+  label: "CI-Build-01",
+  hostname: "ci.example",
+  port: 22,
+  username: "root",
+  protocol: "ssh",
+} as Host;
+
+const remotePane = (connectionId: string): SftpPane => ({
+  id: "pane-1",
+  connection: {
+    id: connectionId,
+    hostId: "host-1",
+    hostLabel: "CI-Build-01",
+    isLocal: false,
+    status: "connected",
+    currentPath: "/root",
+  },
+  files: [],
+  loading: false,
+  reconnecting: false,
+  error: null,
+  selectedFiles: new Set(),
+  filter: "",
+  filenameEncoding: "auto",
+  showHiddenFiles: false,
+  connectionLogs: [],
+} as unknown as SftpPane);
+
+const noopReleaseConnection = async () => {};
+
+test("SFTP session probe accepts a virtual root directory", async () => {
+  const calls: Array<[string, string]> = [];
+  const ok = await probeSftpSession({
+    realpathSftp: async (sftpId, remotePath) => {
+      calls.push([sftpId, remotePath]);
+      return "/";
+    },
+  }, "sftp-jumpserver");
+
+  assert.equal(ok, true);
+  assert.deepEqual(calls, [["sftp-jumpserver", "."]]);
+});
+
+test("SFTP session probe does not require home discovery", async () => {
+  const ok = await probeSftpSession(undefined, "sftp-live");
+  assert.equal(ok, true);
+});
+
+test("returns an existing mapped SFTP session without reconnecting", async () => {
+  let connectCalls = 0;
+  const sftpId = await ensureRemoteSftpSession({
+    side: "left",
+    getActivePane: () => remotePane("conn-1"),
+    sftpSessionsRef: { current: new Map([["conn-1", "sftp-live"]]) },
+    lastConnectedHostRef: { current: { left: host, right: null } },
+    connect: async () => { connectCalls += 1; },
+    releaseConnection: noopReleaseConnection,
+  });
+  assert.equal(sftpId, "sftp-live");
+  assert.equal(connectCalls, 0);
+});
+
+test("reconnects when the mapped session is missing", async () => {
+  let connectCalls = 0;
+  const sessions = { current: new Map<string, string>() };
+  const sftpId = await ensureRemoteSftpSession({
+    side: "left",
+    getActivePane: () => {
+      // After reconnect, connection id stays and mapping is filled by connect mock.
+      return remotePane("conn-1");
+    },
+    sftpSessionsRef: sessions,
+    lastConnectedHostRef: { current: { left: host, right: null } },
+    connect: async () => {
+      connectCalls += 1;
+      sessions.current.set("conn-1", "sftp-reconnected");
+    },
+    releaseConnection: noopReleaseConnection,
+  });
+  assert.equal(connectCalls, 1);
+  assert.equal(sftpId, "sftp-reconnected");
+});
+
+test("resolves source session when restoring a missing browse session", async () => {
+  let connectOptions: { initialPath?: string; sourceSessionId?: string } | undefined;
+  let resolvedHost: Host | undefined;
+  const sessions = { current: new Map<string, string>() };
+  const sftpId = await ensureRemoteSftpSession({
+    side: "left",
+    getActivePane: () => remotePane("conn-1"),
+    sftpSessionsRef: sessions,
+    lastConnectedHostRef: { current: { left: host, right: null } },
+    resolveSourceSessionId: (hostId, reconnectHost) => {
+      resolvedHost = reconnectHost;
+      return hostId === "host-1" ? "term-1" : undefined;
+    },
+    connect: async (_side, _host, options) => {
+      connectOptions = options;
+      sessions.current.set("conn-1", "sftp-restored");
+    },
+    releaseConnection: noopReleaseConnection,
+  });
+  assert.equal(sftpId, "sftp-restored");
+  assert.equal(resolvedHost?.hostname, "ci.example");
+  assert.equal(connectOptions?.initialPath, "/root");
+  assert.equal(connectOptions?.sourceSessionId, "term-1");
+});
+
+test("forceReconnect reopens even when a mapping exists", async () => {
+  let connectCalls = 0;
+  const released: string[] = [];
+  const sessions = { current: new Map([["conn-1", "sftp-stale"]]) };
+  const sftpId = await ensureRemoteSftpSession({
+    side: "left",
+    getActivePane: () => remotePane("conn-1"),
+    sftpSessionsRef: sessions,
+    lastConnectedHostRef: { current: { left: host, right: null } },
+    forceReconnect: true,
+    releaseConnection: async (connectionId) => { released.push(connectionId); },
+    connect: async () => {
+      connectCalls += 1;
+      sessions.current.set("conn-1", "sftp-new");
+    },
+  });
+  assert.equal(connectCalls, 1);
+  assert.deepEqual(released, ["conn-1"]);
+  assert.equal(sftpId, "sftp-new");
+});
+
+test("probe failure triggers reconnect", async () => {
+  let connectCalls = 0;
+  const released: string[] = [];
+  const sessions = { current: new Map([["conn-1", "sftp-dead"]]) };
+  const sftpId = await ensureRemoteSftpSession({
+    side: "left",
+    getActivePane: () => remotePane("conn-1"),
+    sftpSessionsRef: sessions,
+    lastConnectedHostRef: { current: { left: host, right: null } },
+    probeSession: async () => {
+      throw new Error("SFTP session not found");
+    },
+    releaseConnection: async (connectionId) => { released.push(connectionId); },
+    connect: async () => {
+      connectCalls += 1;
+      sessions.current.set("conn-1", "sftp-fresh");
+    },
+  });
+  assert.equal(connectCalls, 1);
+  assert.deepEqual(released, ["conn-1"]);
+  assert.equal(sftpId, "sftp-fresh");
+});
+
+test("uses resolveHostById when lastConnectedHostRef is empty", async () => {
+  let connectedHost: Host | "local" | null = null;
+  const sessions = { current: new Map<string, string>() };
+  const sftpId = await ensureRemoteSftpSession({
+    side: "left",
+    getActivePane: () => remotePane("conn-1"),
+    sftpSessionsRef: sessions,
+    lastConnectedHostRef: { current: { left: null, right: null } },
+    resolveHostById: (id) => (id === "host-1" ? host : null),
+    connect: async (_side, resolved) => {
+      connectedHost = resolved;
+      sessions.current.set("conn-1", "sftp-vault");
+    },
+    releaseConnection: noopReleaseConnection,
+  });
+  assert.equal(sftpId, "sftp-vault");
+  assert.equal((connectedHost as Host).hostname, "ci.example");
+  assert.equal((connectedHost as Host).username, "root");
+});
+
+test("prefers per-tab connect-time host over vault base endpoint", async () => {
+  const vaultHost = {
+    ...host,
+    hostname: "vault.example",
+    port: 22,
+    username: "root",
+  } as Host;
+  const sessionHost = {
+    ...host,
+    hostname: "session.example",
+    port: 2222,
+    username: "override",
+  } as Host;
+  let connectedHost: Host | "local" | null = null;
+  const sessions = { current: new Map<string, string>() };
+  await ensureRemoteSftpSession({
+    side: "left",
+    getActivePane: () => remotePane("conn-1"),
+    sftpSessionsRef: sessions,
+    lastConnectedHostRef: { current: { left: null, right: null } },
+    resolveConnectedHost: (id) => (id === "pane-1" ? sessionHost : null),
+    resolveHostById: () => vaultHost,
+    connect: async (_side, resolved) => {
+      connectedHost = resolved;
+      sessions.current.set("conn-1", "sftp-session");
+    },
+    releaseConnection: noopReleaseConnection,
+  });
+  assert.equal((connectedHost as Host).hostname, "session.example");
+  assert.equal((connectedHost as Host).port, 2222);
+  assert.equal((connectedHost as Host).username, "override");
+});
+
+test("does not retarget background reconnect via side-wide lastConnectedHost overrides", async () => {
+  const vaultHost = {
+    ...host,
+    hostname: "vault.example",
+    port: 22,
+    username: "root",
+  } as Host;
+  const activeTabOverrides = {
+    ...host,
+    hostname: "other-tab.example",
+    port: 2222,
+    username: "other",
+  } as Host;
+  let connectedHost: Host | "local" | null = null;
+  const sessions = { current: new Map<string, string>() };
+  await ensureRemoteSftpSession({
+    side: "left",
+    getActivePane: () => remotePane("conn-1"),
+    sftpSessionsRef: sessions,
+    lastConnectedHostRef: { current: { left: activeTabOverrides, right: null } },
+    resolveHostById: () => vaultHost,
+    connect: async (_side, resolved) => {
+      connectedHost = resolved;
+      sessions.current.set("conn-1", "sftp-vault");
+    },
+    releaseConnection: noopReleaseConnection,
+  });
+  assert.equal((connectedHost as Host).hostname, "vault.example");
+  assert.equal((connectedHost as Host).port, 22);
+});
+
+test("refuses synthetic root@label:22 when host metadata is missing", async () => {
+  await assert.rejects(
+    () => ensureRemoteSftpSession({
+      side: "left",
+      getActivePane: () => remotePane("conn-1"),
+      sftpSessionsRef: { current: new Map() },
+      lastConnectedHostRef: { current: { left: null, right: null } },
+      connect: async () => {
+        throw new Error("should not connect");
+      },
+      releaseConnection: noopReleaseConnection,
+    }),
+    /credentials are unavailable/,
+  );
+});