[Init] Initial commit - NetMesh terminal manager

application/state/sftp/transferRuntime.test.ts

@@ -0,0 +1,318 @@
+/**
+ * TransferRuntime unification tests — drive the shipped entry surface.
+ * Covers: no-owner control, post-teardown pause/resume with live walk,
+ * single resume API soft vs hard strategy selection.
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { TransferTask } from "../../../domain/models";
+import { createSftpTransferCenterStore } from "../sftpTransferCenterStore";
+import {
+  createTransferRuntime,
+  resetTransferRuntimeRunsForTests,
+} from "./transferRuntime";
+import {
+  isTransferCancelledFlag,
+  markTransferCancelledTree,
+  resetTransferCancelLatchesForTests,
+} from "./transferCancelLatch";
+import {
+  bumpTransferControlEpoch,
+  isTransferControlEpochCurrent,
+  resetTransferControlEpochsForTests,
+} from "./transferControlEpoch";
+import {
+  isTransferPauseLatched,
+  resetTransferPauseLatchesForTests,
+} from "./transferPauseLatch";
+import {
+  isTransferWalkInFlight,
+  registerTransferWalk,
+  resetTransferWalkRegistryForTests,
+  unregisterTransferWalk,
+} from "./transferWalkRegistry";
+
+function makeTask(
+  id: string,
+  status: TransferTask["status"] = "transferring",
+  extras: Partial<TransferTask> = {},
+): TransferTask {
+  return {
+    id,
+    fileName: `${id}.bin`,
+    sourcePath: `/src/${id}`,
+    targetPath: `/dst/${id}`,
+    sourceConnectionId: "local",
+    targetConnectionId: "remote",
+    direction: "upload",
+    status,
+    totalBytes: 100,
+    transferredBytes: 10,
+    speed: 1,
+    startTime: 1,
+    isDirectory: false,
+    resumable: true,
+    ownerId: extras.ownerId ?? "panel-closed",
+    ...extras,
+  };
+}
+
+function installBridge(t: test.TestContext, handlers: {
+  pauseTransfer?: (id: string) => Promise<{ success: boolean; reason?: string; checkpointBytes?: number }>;
+  resumeTransfer?: (id: string) => Promise<{ success: boolean; reason?: string }>;
+  cancelTransfer?: (id: string) => Promise<unknown>;
+  clearPendingTransferCancel?: (id: string) => Promise<void>;
+}) {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  t.after(() => {
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
+    else Reflect.deleteProperty(globalThis, "window");
+  });
+  Object.defineProperty(globalThis, "window", {
+    configurable: true,
+    value: { netcatty: handlers },
+  });
+}
+
+function resetGlobals() {
+  resetTransferCancelLatchesForTests();
+  resetTransferPauseLatchesForTests();
+  resetTransferWalkRegistryForTests();
+  resetTransferControlEpochsForTests();
+  resetTransferRuntimeRunsForTests();
+}
+
+test("runtime pause/resume works with no registered panel owner", async (t) => {
+  resetGlobals();
+  const pauseCalls: string[] = [];
+  const resumeCalls: string[] = [];
+  installBridge(t, {
+    pauseTransfer: async (id) => {
+      pauseCalls.push(id);
+      return { success: true, checkpointBytes: 40, lifecycleEpoch: 1 };
+    },
+    resumeTransfer: async (id) => {
+      resumeCalls.push(id);
+      return { success: true, lifecycleEpoch: 2 };
+    },
+  });
+
+  const store = createSftpTransferCenterStore();
+  const runtime = createTransferRuntime(store);
+  // No registerOwner — panel never mounted / already torn down.
+  runtime.enqueue([makeTask("live-file", "transferring", { transferredBytes: 40 })]);
+
+  await runtime.pause("live-file");
+  assert.equal(runtime.getTask("live-file")?.status, "paused");
+  assert.equal(isTransferPauseLatched("live-file"), true);
+  assert.ok(pauseCalls.includes("live-file"));
+
+  await runtime.resume("live-file");
+  assert.equal(runtime.getTask("live-file")?.status, "transferring");
+  assert.equal(isTransferPauseLatched("live-file"), false);
+  assert.ok(resumeCalls.includes("live-file"));
+  // Bridge-aligned epoch (not control-plane bumps).
+  assert.equal(runtime.getTask("live-file")?.lifecycleEpoch, 2);
+
+  resetGlobals();
+});
+
+test("runtime soft-resumes live walk after owner teardown simulation (no dedicated re-entry)", async (t) => {
+  resetGlobals();
+  const resumeCalls: string[] = [];
+  let dedicatedHandlerCalls = 0;
+  installBridge(t, {
+    pauseTransfer: async () => ({ success: true, checkpointBytes: 5 }),
+    resumeTransfer: async (id) => {
+      resumeCalls.push(id);
+      return { success: true };
+    },
+  });
+
+  const store = createSftpTransferCenterStore();
+  store.setDedicatedResumeHandler(async () => {
+    dedicatedHandlerCalls += 1;
+    return { success: false, error: "should not hard-reconnect live walk" };
+  });
+  const runtime = createTransferRuntime(store);
+
+  // Simulate panel started a walk then unmounted: walk still in-flight, no owner.
+  registerTransferWalk("folder");
+  runtime.enqueue([
+    makeTask("folder", "transferring", {
+      isDirectory: true,
+      progressMode: "files",
+      totalBytes: 3,
+      transferredBytes: 1,
+      ownerId: "gone-panel",
+    }),
+    makeTask("child", "transferring", { parentTaskId: "folder", ownerId: "gone-panel" }),
+  ]);
+
+  await runtime.pause("folder");
+  assert.equal(runtime.getTask("folder")?.status, "paused");
+  assert.equal(isTransferPauseLatched("folder"), true);
+  assert.equal(isTransferWalkInFlight("folder"), true);
+
+  await runtime.resume("folder");
+  assert.equal(runtime.getTask("folder")?.status, "transferring");
+  assert.equal(isTransferPauseLatched("folder"), false);
+  assert.equal(dedicatedHandlerCalls, 0, "live walk must soft-resume only");
+  assert.ok(resumeCalls.length >= 0); // bridge may resume children
+
+  unregisterTransferWalk("folder");
+  resetGlobals();
+});
+
+test("runtime resume chooses hard reconnect when walk is dead and reconnectRequired", async (t) => {
+  resetGlobals();
+  installBridge(t, {
+    resumeTransfer: async () => ({ success: false, reason: "not active" }),
+    clearPendingTransferCancel: async () => {},
+  });
+
+  const store = createSftpTransferCenterStore();
+  let dedicatedCalls = 0;
+  store.setDedicatedResumeHandler(async (task) => {
+    dedicatedCalls += 1;
+    assert.equal(task.id, "dead-file");
+    // Simulate successful hard reconnect completion.
+    store.patchTask(task.id, {
+      status: "completed",
+      transferredBytes: 100,
+      reconnectRequired: false,
+      ownerId: "dedicated-resume",
+    });
+    return { success: true };
+  });
+  const runtime = createTransferRuntime(store);
+
+  // Dead walk (not registered), reconnect required — single resume API.
+  assert.equal(runtime.isWalkInFlight("dead-file"), false);
+  runtime.enqueue([makeTask("dead-file", "interrupted", {
+    reconnectRequired: true,
+    checkpointBytes: 50,
+    transferredBytes: 50,
+    sourceHostId: "host-a",
+  })]);
+
+  await runtime.resume("dead-file");
+  assert.equal(dedicatedCalls, 1, "dead walk must use hard reconnect under same resume entry");
+  assert.equal(runtime.getTask("dead-file")?.status, "completed");
+
+  resetGlobals();
+});
+
+test("runWalk registers process-global walk and survives without a panel owner", async () => {
+  resetGlobals();
+  const store = createSftpTransferCenterStore();
+  const runtime = createTransferRuntime(store);
+  let sawInFlight = false;
+  let steps = 0;
+
+  const run = runtime.runWalk("walk-1", async () => {
+    sawInFlight = runtime.isWalkInFlight("walk-1");
+    steps += 1;
+    // Mid-walk pause via runtime (no owner).
+    runtime.enqueue([makeTask("walk-1", "transferring")]);
+    await runtime.pause("walk-1");
+    assert.equal(isTransferPauseLatched("walk-1"), true);
+    await runtime.resume("walk-1");
+    assert.equal(isTransferPauseLatched("walk-1"), false);
+    steps += 1;
+  });
+
+  assert.equal(runtime.isWalkInFlight("walk-1"), true);
+  await run;
+  assert.equal(sawInFlight, true);
+  assert.equal(steps, 2);
+  assert.equal(runtime.isWalkInFlight("walk-1"), false);
+
+  resetGlobals();
+});
+
+test("runWalk keeps tree controls live until settle and then releases parent and children", async () => {
+  resetGlobals();
+  const store = createSftpTransferCenterStore();
+  const runtime = createTransferRuntime(store);
+  runtime.enqueue([
+    makeTask("settling-root", "transferring", { isDirectory: true, progressMode: "files" }),
+    makeTask("settling-child", "transferring", { parentTaskId: "settling-root" }),
+  ]);
+  let markEntered!: () => void;
+  let finishRun!: () => void;
+  const entered = new Promise<void>((resolve) => { markEntered = resolve; });
+  const finish = new Promise<void>((resolve) => { finishRun = resolve; });
+  let rootEpoch = 0;
+  let childEpoch = 0;
+
+  const run = runtime.runWalk("settling-root", async () => {
+    markTransferCancelledTree("settling-root", ["settling-child"]);
+    rootEpoch = bumpTransferControlEpoch("settling-root");
+    childEpoch = bumpTransferControlEpoch("settling-child");
+    // Renderer lifecycle paint can become terminal before final callbacks and
+    // resource release finish. Store cleanup must wait for runWalk settlement.
+    store.patchTask("settling-root", { status: "completed", endTime: Date.now() });
+    markEntered();
+    await finish;
+  });
+
+  await entered;
+  assert.equal(isTransferCancelledFlag("settling-root"), true);
+  assert.equal(isTransferCancelledFlag("settling-child"), true);
+  assert.equal(isTransferControlEpochCurrent("settling-root", rootEpoch), true);
+  assert.equal(isTransferControlEpochCurrent("settling-child", childEpoch), true);
+
+  finishRun();
+  await run;
+  assert.equal(isTransferCancelledFlag("settling-root"), false);
+  assert.equal(isTransferCancelledFlag("settling-child"), false);
+  assert.equal(isTransferControlEpochCurrent("settling-root", rootEpoch), false);
+  assert.equal(isTransferControlEpochCurrent("settling-child", childEpoch), false);
+
+  resetGlobals();
+});
+
+test("publishOwner cannot strip runtime-owned live rows after panel empty publish", () => {
+  resetGlobals();
+  const store = createSftpTransferCenterStore();
+  registerTransferWalk("keep-me");
+  store.publishOwner("panel-a", [makeTask("keep-me", "transferring", { ownerId: "panel-a" })]);
+  // Panel "unmounts" and publishes empty list — live walk row must remain.
+  store.publishOwner("panel-a", []);
+  const row = store.getSnapshot().tasks.find((task) => task.id === "keep-me");
+  assert.ok(row, "runtime-owned live task must not be dropped by empty panel publish");
+  assert.equal(row?.status, "transferring");
+  unregisterTransferWalk("keep-me");
+  resetGlobals();
+});
+
+test("soft resume bridge epoch beats sticky panel paused merge", async (t) => {
+  resetGlobals();
+  installBridge(t, {
+    pauseTransfer: async () => ({ success: true, lifecycleEpoch: 2 }),
+    resumeTransfer: async () => ({ success: true, lifecycleEpoch: 3 }),
+  });
+  const store = createSftpTransferCenterStore();
+  const runtime = createTransferRuntime(store);
+  registerTransferWalk("sticky");
+  runtime.enqueue([makeTask("sticky", "transferring", { ownerId: "panel-a", lifecycleEpoch: 1 })]);
+
+  await runtime.pause("sticky");
+  assert.equal(runtime.getTask("sticky")?.lifecycleEpoch, 2);
+
+  await runtime.resume("sticky");
+  const resumed = runtime.getTask("sticky");
+  assert.equal(resumed?.status, "transferring");
+  assert.equal(resumed?.lifecycleEpoch, 3, "bridge resume epoch must win over pause epoch");
+
+  // Stale panel re-publish of paused at older epoch must not win.
+  store.publishOwner("panel-a", [{
+    ...makeTask("sticky", "paused", { ownerId: "panel-a", lifecycleEpoch: 2 }),
+  }]);
+  assert.equal(store.getSnapshot().tasks.find((t) => t.id === "sticky")?.status, "transferring");
+
+  unregisterTransferWalk("sticky");
+  resetGlobals();
+});