[Init] Initial commit - NetMesh terminal manager

components/GlobalSftpTransferCenter.test.ts

@@ -0,0 +1,241 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { TransferTask } from "../domain/models";
+import {
+  buildGlobalTransferProgressDisplay,
+  getGlobalConflictActionPresentation,
+  getGlobalTransferBadge,
+  getGlobalTransferBatchEligibility,
+  getGlobalTransferStatusOverride,
+  getGlobalTransferBucket,
+  getTasksForGlobalTransferBucket,
+  isDirectoryParentTask,
+  listChildTasksForParent,
+  pickActiveChildSummaries,
+  shouldShowCollapsedActiveChildren,
+  splitBackgroundTransfers,
+} from "./GlobalSftpTransferCenter";
+
+test("folder conflicts emphasize merge and mark replace as destructive in the transfer center", () => {
+  assert.deepEqual(getGlobalConflictActionPresentation("merge", true), {
+    variant: "default",
+    destructiveReplace: false,
+  });
+  assert.deepEqual(getGlobalConflictActionPresentation("replace", true), {
+    variant: "outline",
+    destructiveReplace: true,
+  });
+  assert.deepEqual(getGlobalConflictActionPresentation("replace", false), {
+    variant: "default",
+    destructiveReplace: false,
+  });
+});
+
+const task = (id: string, status: TransferTask["status"], background = false) => ({
+  id,
+  fileName: id,
+  sourcePath: "/a",
+  targetPath: "/b",
+  sourceConnectionId: "local",
+  targetConnectionId: "remote",
+  direction: "upload" as const,
+  status,
+  totalBytes: 10,
+  transferredBytes: 1,
+  speed: 1,
+  startTime: 1,
+  isDirectory: false,
+  background,
+});
+
+test("global transfer statuses keep paused work separate from items needing attention", () => {
+  assert.equal(getGlobalTransferBucket(task("a", "transferring")), "active");
+  assert.equal(getGlobalTransferBucket(task("a", "pausing")), "active");
+  assert.equal(getGlobalTransferBucket(task("a", "queued")), "queued");
+  assert.equal(getGlobalTransferBucket(task("a", "paused")), "paused");
+  assert.equal(getGlobalTransferBucket(task("a", "interrupted")), "attention");
+  assert.equal(getGlobalTransferBucket(task("a", "attention")), "attention");
+  assert.equal(getGlobalTransferBucket(task("a", "failed")), "attention");
+  assert.equal(getGlobalTransferBucket(task("a", "completed")), "completed");
+  assert.equal(getGlobalTransferBucket(task("a", "cancelled")), "completed");
+});
+
+test("batch actions are disabled when no task can accept them", () => {
+  assert.deepEqual(getGlobalTransferBatchEligibility([
+    task("done", "completed"),
+    task("cancelled", "cancelled"),
+  ]), { pausableCount: 0, resumableCount: 0 });
+
+  assert.deepEqual(getGlobalTransferBatchEligibility([
+    task("running", "transferring"),
+    task("waiting", "queued"),
+    task("paused", "paused"),
+    { ...task("failed", "failed"), checkpointBytes: 4 },
+  ]), { pausableCount: 2, resumableCount: 2 });
+});
+
+test("paused transfer errors remain visible instead of looking safely paused", () => {
+  assert.equal(getGlobalTransferStatusOverride({
+    error: "Upload resume is unavailable",
+    pauseUnavailableReason: undefined,
+  }), "Upload resume is unavailable");
+});
+
+test("the all bucket includes every top-level task regardless of status", () => {
+  const tasks = [
+    task("a", "transferring"),
+    task("b", "queued"),
+    task("c", "failed"),
+    { ...task("child", "transferring"), parentTaskId: "a" },
+  ];
+  assert.deepEqual(getTasksForGlobalTransferBucket(tasks, "all").map((item) => item.id), ["a", "b", "c"]);
+});
+
+test("badge counts active and queued work while surfacing attention", () => {
+  assert.deepEqual(getGlobalTransferBadge([
+    task("a", "transferring"),
+    task("b", "queued"),
+    task("c", "failed"),
+  ]), { count: 2, hasAttention: true });
+});
+
+test("badge does not double count child files in a folder transfer", () => {
+  assert.deepEqual(getGlobalTransferBadge([
+    task("parent", "transferring"),
+    { ...task("child", "transferring"), parentTaskId: "parent" },
+  ]), { count: 1, hasAttention: false });
+});
+
+test("successful background work is collapsed but failures stay visible", () => {
+  const split = splitBackgroundTransfers([
+    task("a", "completed", true),
+    task("b", "failed", true),
+    task("c", "completed", false),
+  ]);
+  assert.deepEqual(split.visible.map((item) => item.id), ["b", "c"]);
+  assert.deepEqual(split.collapsed.map((item) => item.id), ["a"]);
+});
+
+test("directory parent detection matches side-queue file-count semantics", () => {
+  assert.equal(isDirectoryParentTask({
+    isDirectory: true,
+    parentTaskId: undefined,
+    progressMode: "files",
+  }), true);
+  assert.equal(isDirectoryParentTask({
+    isDirectory: true,
+    parentTaskId: undefined,
+    progressMode: undefined,
+  }), true);
+  assert.equal(isDirectoryParentTask({
+    isDirectory: true,
+    parentTaskId: "p",
+    progressMode: "files",
+  }), false);
+  assert.equal(isDirectoryParentTask({
+    isDirectory: false,
+    parentTaskId: undefined,
+    progressMode: "bytes",
+  }), false);
+  assert.equal(isDirectoryParentTask({
+    isDirectory: true,
+    parentTaskId: undefined,
+    progressMode: "bytes",
+  }), false);
+});
+
+test("folder parent progress uses progressive discovery labels not byte formatting", () => {
+  const t = (key: string, params?: Record<string, string | number>) => {
+    if (key === "sftp.transfers.filesDiscoveredProgress") {
+      return `${params?.completed} done · ${params?.discovered} found`;
+    }
+    if (key === "sftp.transfers.filesProgress") {
+      return `${params?.current}/${params?.total} files`;
+    }
+    if (key === "sftp.transfers.filesCount") {
+      return `${params?.count} files`;
+    }
+    return key;
+  };
+  const display = buildGlobalTransferProgressDisplay({
+    status: "transferring",
+    isDirectory: true,
+    progressMode: "files",
+    totalBytes: 12,
+    transferredBytes: 1,
+    speed: 0,
+    phase: "transferring",
+  }, t);
+  assert.equal(display.percent, (1 / 12) * 100);
+  assert.equal(display.detail, "1 done · 12 found");
+  assert.equal(display.indeterminate, false);
+  // Must not look like "1 Bytes / 12 Bytes"
+  assert.doesNotMatch(display.detail, /Bytes/i);
+});
+
+test("folder parent scanning stays indeterminate while nothing has completed", () => {
+  const t = (key: string, params?: Record<string, string | number>) => {
+    if (key === "sftp.transfers.filesDiscoveredProgress") {
+      return `${params?.completed} done · ${params?.discovered} found`;
+    }
+    return key;
+  };
+  const display = buildGlobalTransferProgressDisplay({
+    status: "transferring",
+    isDirectory: true,
+    progressMode: "files",
+    totalBytes: 40,
+    transferredBytes: 0,
+    speed: 0,
+    phase: "scanning",
+  }, t);
+  assert.equal(display.detail, "0 done · 40 found");
+  assert.equal(display.indeterminate, true);
+});
+
+test("single-file progress still shows byte totals", () => {
+  const t = (key: string) => key;
+  const display = buildGlobalTransferProgressDisplay({
+    status: "transferring",
+    isDirectory: false,
+    progressMode: "bytes",
+    totalBytes: 1024,
+    transferredBytes: 512,
+    speed: 0,
+  }, t);
+  assert.equal(display.percent, 50);
+  assert.match(display.detail, /512\s*Bytes/);
+  assert.match(display.detail, /1(\.00)?\s*KB/);
+});
+
+test("active child summary prefers transferring files over queued", () => {
+  const children = [
+    { ...task("q1", "queued"), parentTaskId: "p", startTime: 1 },
+    { ...task("t1", "transferring"), parentTaskId: "p", startTime: 2 },
+    { ...task("t2", "transferring"), parentTaskId: "p", startTime: 3 },
+    { ...task("done", "completed"), parentTaskId: "p", startTime: 0 },
+  ];
+  assert.deepEqual(
+    pickActiveChildSummaries(children, 2).map((item) => item.id),
+    ["t1", "t2"],
+  );
+});
+
+test("collapsed active children only show while transferring or soft-draining", () => {
+  assert.equal(shouldShowCollapsedActiveChildren("transferring"), true);
+  assert.equal(shouldShowCollapsedActiveChildren("pausing"), true);
+  assert.equal(shouldShowCollapsedActiveChildren("paused"), false);
+  assert.equal(shouldShowCollapsedActiveChildren("interrupted"), false);
+  assert.equal(shouldShowCollapsedActiveChildren("queued"), false);
+});
+
+test("listChildTasksForParent skips cancelled siblings", () => {
+  const tasks = [
+    task("p", "transferring"),
+    { ...task("c1", "transferring"), parentTaskId: "p" },
+    { ...task("c2", "cancelled"), parentTaskId: "p" },
+    { ...task("other", "transferring"), parentTaskId: "x" },
+  ];
+  assert.deepEqual(listChildTasksForParent(tasks, "p").map((item) => item.id), ["c1"]);
+});