Netcatty/application/state/sessionRestoreState.test.ts

import test from "node:test";
import assert from "node:assert/strict";

import {
  buildAndWriteSessionRestorePayload,
  createInitialRestoredSessionState,
  mergeSessionRestoreCwd,
  updateRestoredSessionStatusState,
  shouldPersistSessionRestoreState,
} from "./sessionRestoreState.ts";
import type { SessionRestorePayload } from "../../domain/sessionRestore.ts";

const payload: SessionRestorePayload = {
  version: 1,
  savedAt: 1,
  activeTabId: "ws-1",
  tabOrder: ["ws-1"],
  sessions: [{
    id: "s1",
    hostId: "host-s1",
    hostLabel: "Host s1",
    hostname: "s1.example.test",
    username: "root",
    status: "disconnected",
    workspaceId: "ws-1",
    restoreState: "restored-disconnected",
  }],
  workspaces: [{
    id: "ws-1",
    title: "Workspace",
    root: { id: "pane-1", type: "pane", sessionId: "s1" },
  }],
};

test("restored session state hydrates sessions, workspaces, tab order, and active tab", () => {
  const restored = createInitialRestoredSessionState({
    restoreEnabled: true,
    payload,
  });

  assert.equal(restored.sessions[0].status, "disconnected");
  assert.equal(restored.sessions[0].restoreState, "restored-disconnected");
  assert.equal(restored.workspaces[0].id, "ws-1");
  assert.deepEqual(restored.tabOrder, ["ws-1"]);
  assert.equal(restored.activeTabId, "ws-1");
});

test("restored session state is empty when restore is disabled", () => {
  const restored = createInitialRestoredSessionState({ restoreEnabled: false, payload });
  assert.deepEqual(restored.sessions, []);
  assert.deepEqual(restored.workspaces, []);
  assert.deepEqual(restored.tabOrder, []);
  assert.equal(restored.activeTabId, "vault");
});

test("mergeSessionRestoreCwd records latest cwd metadata without terminal data", () => {
  const next = mergeSessionRestoreCwd(payload, "s1", "/usr/local/src");
  assert.equal(next.sessions[0].lastCwd, "/usr/local/src");
  assert.equal("terminalData" in next.sessions[0], false);
});

test("mergeSessionRestoreCwd removes cwd when terminal reports null", () => {
  const next = mergeSessionRestoreCwd({
    ...payload,
    sessions: [{ ...payload.sessions[0], lastCwd: "/tmp" }],
  }, "s1", null);
  assert.equal(next.sessions[0].lastCwd, undefined);
});

test("updateRestoredSessionStatusState clears restore marker after reconnect starts", () => {
  const next = updateRestoredSessionStatusState(payload.sessions, "s1", "connecting");

  assert.equal(next[0].status, "connecting");
  assert.equal(next[0].restoreState, undefined);
});

test("updateRestoredSessionStatusState keeps restore marker for disconnected placeholders", () => {
  const next = updateRestoredSessionStatusState(payload.sessions, "s1", "disconnected");

  assert.equal(next[0].status, "disconnected");
  assert.equal(next[0].restoreState, "restored-disconnected");
});

test("shouldPersistSessionRestoreState skips transient empty startup state", () => {
  assert.equal(shouldPersistSessionRestoreState([], [], []), false);
  assert.equal(shouldPersistSessionRestoreState(payload.sessions, payload.workspaces, payload.tabOrder), true);
});

test("restored session state preserves lightweight workspace chrome only", () => {
  const restored = createInitialRestoredSessionState({
    restoreEnabled: true,
    payload: {
      ...payload,
      workspaces: [{
        ...payload.workspaces[0],
        viewMode: "focus",
        focusedSessionId: "s1",
        focusSessionOrder: ["s1"],
        broadcastEnabled: true,
        transientPanelState: { selected: "history" },
      } as never],
    },
  });

  assert.equal(restored.workspaces[0].viewMode, "focus");
  assert.equal(restored.workspaces[0].focusedSessionId, "s1");
  assert.deepEqual(restored.workspaces[0].focusSessionOrder, ["s1"]);
  assert.equal("transientPanelState" in restored.workspaces[0], false);
});

test("session restore flush writes through the same sanitized payload path", () => {
  const writes: SessionRestorePayload[] = [];
  const storage = {
    write: (next: SessionRestorePayload) => {
      writes.push(next);
      return true;
    },
    clear: () => {
      throw new Error("should not clear non-empty restore state");
    },
  };

  const wrote = buildAndWriteSessionRestorePayload({
    sessions: [{
      ...payload.sessions[0],
      status: "connected",
      terminalData: "do-not-store",
    } as never],
    workspaces: [{
      ...payload.workspaces[0],
      transientPanelState: { selected: "history" },
    } as never],
    tabOrder: ["ws-1"],
    activeTabId: "ws-1",
    now: 42,
    storage,
  });

  assert.equal(wrote, true);
  assert.equal(writes.length, 1);
  assert.equal(writes[0].sessions[0].status, "disconnected");
  assert.equal("terminalData" in writes[0].sessions[0], false);
  assert.equal("transientPanelState" in writes[0].workspaces[0], false);
  assert.equal(writes[0].savedAt, 42);
});

test("session restore flush clears storage instead of writing when restore is disabled", () => {
  const writes: SessionRestorePayload[] = [];
  let clearCount = 0;
  const storage = {
    write: (next: SessionRestorePayload) => {
      writes.push(next);
      return true;
    },
    clear: () => {
      clearCount += 1;
    },
  };

  const wrote = buildAndWriteSessionRestorePayload({
    restoreEnabled: false,
    sessions: payload.sessions,
    workspaces: payload.workspaces,
    tabOrder: payload.tabOrder,
    activeTabId: payload.activeTabId,
    storage,
  });

  assert.equal(wrote, false);
  assert.equal(clearCount, 1);
  assert.equal(writes.length, 0);
});

test("session restore flush skips empty transient windows without clearing existing snapshots", () => {
  const writes: SessionRestorePayload[] = [];
  let clearCount = 0;
  const storage = {
    write: (next: SessionRestorePayload) => {
      writes.push(next);
      return true;
    },
    clear: () => {
      clearCount += 1;
    },
  };

  const wrote = buildAndWriteSessionRestorePayload({
    sessions: [],
    workspaces: [],
    tabOrder: [],
    activeTabId: "vault",
    storage,
  });

  assert.equal(wrote, false);
  assert.equal(clearCount, 0);
  assert.equal(writes.length, 0);
});

test("session restore flush clears stale snapshots when main window becomes empty after restorable state existed", () => {
  const writes: SessionRestorePayload[] = [];
  let clearCount = 0;
  const storage = {
    write: (next: SessionRestorePayload) => {
      writes.push(next);
      return true;
    },
    clear: () => {
      clearCount += 1;
    },
  };

  const wrote = buildAndWriteSessionRestorePayload({
    sessions: [],
    workspaces: [],
    tabOrder: [],
    activeTabId: "vault",
    clearOnEmpty: true,
    storage,
  });

  assert.equal(wrote, false);
  assert.equal(clearCount, 1);
  assert.equal(writes.length, 0);
});