mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-17 21:10:48 +00:00
Pause and resume now go through one process-level control plane that survives panel/terminal close: TransferRuntime + soft latches/epochs/walk registry, soft-then-hard resume, dual-epoch-safe progress, and no-owner soft control.
202 lines
6.8 KiB
TypeScript
202 lines
6.8 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import test from "node:test";
|
|
|
|
import type { TransferTask } from "../domain/models";
|
|
import {
|
|
buildGlobalTransferProgressDisplay,
|
|
getGlobalTransferBadge,
|
|
getGlobalTransferBatchEligibility,
|
|
getGlobalTransferStatusOverride,
|
|
getGlobalTransferBucket,
|
|
getTasksForGlobalTransferBucket,
|
|
isDirectoryParentTask,
|
|
listChildTasksForParent,
|
|
pickActiveChildSummaries,
|
|
shouldShowCollapsedActiveChildren,
|
|
splitBackgroundTransfers,
|
|
} from "./GlobalSftpTransferCenter";
|
|
|
|
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 file counts not byte formatting", () => {
|
|
const t = (key: string, params?: Record<string, string | number>) => {
|
|
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,
|
|
}, t);
|
|
assert.equal(display.percent, (1 / 12) * 100);
|
|
assert.equal(display.detail, "1/12 files");
|
|
assert.equal(display.indeterminate, false);
|
|
// Must not look like "1 Bytes / 12 Bytes"
|
|
assert.doesNotMatch(display.detail, /Bytes/i);
|
|
});
|
|
|
|
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"]);
|
|
});
|