mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 12:01:13 +00:00
* fix(sftp): preserve successful uploads with backup cleanup warnings Warn only on confirmed backup cleanup permission refusal after final publication. Preserve actionable warnings across transfer events, history restoration and completion ordering without masking deletion or commit failures. Narrow follow-up to #3830; related #3879. * fix(sftp): retain folder cleanup warnings before child completion
4320 lines
153 KiB
TypeScript
4320 lines
153 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import test from "node:test";
|
|
|
|
import type { TransferTask } from "../../domain/models";
|
|
import { createSftpTransferCenterStore } from "./sftpTransferCenterStore";
|
|
|
|
const makeTask = (id: string, status: TransferTask["status"] = "transferring"): TransferTask => ({
|
|
id,
|
|
fileName: `${id}.txt`,
|
|
sourcePath: `/source/${id}.txt`,
|
|
targetPath: `/target/${id}.txt`,
|
|
sourceConnectionId: "local",
|
|
targetConnectionId: `remote-${id}`,
|
|
direction: "upload",
|
|
status,
|
|
totalBytes: 10,
|
|
transferredBytes: 2,
|
|
speed: 1,
|
|
startTime: 1,
|
|
isDirectory: false,
|
|
resumable: true,
|
|
});
|
|
|
|
test("store aggregates owner snapshots without duplicating tasks", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [makeTask("a")]);
|
|
store.publishOwner("panel-b", [makeTask("b")]);
|
|
store.publishOwner("panel-a", [{ ...makeTask("a"), transferredBytes: 5 }]);
|
|
|
|
assert.deepEqual(store.getSnapshot().tasks.map((task) => [task.id, task.transferredBytes]), [
|
|
["a", 5],
|
|
["b", 2],
|
|
]);
|
|
});
|
|
|
|
test("completion cleanup warnings survive owner snapshots and restored history", () => {
|
|
let persisted: string | null = null;
|
|
const store = createSftpTransferCenterStore({ read: () => persisted, write: (value) => { persisted = value; } });
|
|
const source = makeTask("cleanup-warning");
|
|
const warning = "Upload completed; remove backup /target/.netcatty-backup-file manually.";
|
|
store.publishOwner("panel", [source]);
|
|
store.ingestBackgroundEvent({ type: "completed", transferId: source.id, transferred: 10, warning });
|
|
assert.equal(store.getTask(source.id)?.status, "completed");
|
|
assert.equal(store.getTask(source.id)?.warning, warning);
|
|
assert.equal(store.getTask(source.id)?.reconnectRequired, false);
|
|
store.publishOwner("panel", [{ ...source, status: "completed", transferredBytes: 10, endTime: Date.now() }]);
|
|
assert.equal(store.getTask(source.id)?.warning, warning, "a stale renderer completion cannot erase cleanup details");
|
|
const restored = createSftpTransferCenterStore({ read: () => persisted, write: () => {} });
|
|
assert.equal(restored.getTask(source.id)?.warning, warning);
|
|
assert.equal(restored.getTask(source.id)?.status, "completed");
|
|
assert.equal(restored.getTask(source.id)?.error, undefined);
|
|
});
|
|
|
|
test("invoke cleanup warnings survive stale live and completion snapshots until an explicit restart", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const source = makeTask("invoke-warning-snapshot");
|
|
const warning = "Upload completed; remove backup /target/.netcatty-backup-file manually.";
|
|
store.publishOwner("panel", [source]);
|
|
store.patchTask(source.id, { warning });
|
|
store.publishOwner("panel", [{ ...source, transferredBytes: 9 }]);
|
|
assert.equal(store.getTask(source.id)?.warning, warning);
|
|
store.publishOwner("panel", [{ ...source, status: "completed", transferredBytes: 10, endTime: Date.now() }]);
|
|
assert.equal(store.getTask(source.id)?.warning, warning);
|
|
store.publishOwner("panel", [{ ...source, status: "queued", transferredBytes: 0, checkpointBytes: 0 }]);
|
|
assert.equal(store.getTask(source.id)?.warning, undefined, "new attempts do not inherit cleanup warnings");
|
|
});
|
|
|
|
test("a clean completed event cannot erase a warning already returned by the invoke", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const source = makeTask("invoke-warning-event");
|
|
const warning = "Upload completed; remove backup /target/.netcatty-backup-file manually.";
|
|
store.publishOwner("panel", [source]);
|
|
store.patchTask(source.id, { warning });
|
|
store.ingestBackgroundEvent({ type: "completed", transferId: source.id, transferred: 10 });
|
|
assert.equal(store.getTask(source.id)?.status, "completed");
|
|
assert.equal(store.getTask(source.id)?.warning, warning);
|
|
});
|
|
|
|
test("late completion enriches a locally completed task with its cleanup warning", () => {
|
|
let persisted: string | null = null;
|
|
const store = createSftpTransferCenterStore({ read: () => persisted, write: (value) => { persisted = value; } });
|
|
const source = { ...makeTask("result-first-warning"), phase: "transferring" as const };
|
|
const warning = "Upload completed; remove backup /target/.netcatty-backup-file manually.";
|
|
const endTime = Date.now();
|
|
store.publishOwner("panel", [source]);
|
|
// The invoke response can settle the renderer before the completed IPC arrives.
|
|
store.patchTask(source.id, { status: "completed", transferredBytes: 10, endTime });
|
|
let notifications = 0;
|
|
const unsubscribe = store.subscribe(() => { notifications += 1; });
|
|
store.ingestBackgroundEvent({ type: "completed", transferId: source.id, transferred: 10, endedAt: endTime + 1, warning });
|
|
assert.equal(store.getTask(source.id)?.warning, warning);
|
|
assert.equal(store.getTask(source.id)?.status, "completed");
|
|
assert.equal(store.getTask(source.id)?.endTime, endTime, "late metadata does not replace the terminal outcome");
|
|
assert.equal(notifications, 1, "the warning is visible without another transfer triggering a render");
|
|
store.ingestBackgroundEvent({ type: "completed", transferId: source.id, transferred: 10 });
|
|
assert.equal(store.getTask(source.id)?.warning, warning, "a duplicate clean event cannot erase the warning");
|
|
const restored = createSftpTransferCenterStore({ read: () => persisted, write: () => {} });
|
|
assert.equal(restored.getTask(source.id)?.warning, warning);
|
|
unsubscribe();
|
|
});
|
|
|
|
for (const status of ["failed", "cancelled"] as const) {
|
|
test(`late cleanup warnings cannot replace a ${status} terminal outcome`, () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const endTime = Date.now();
|
|
const task = { ...makeTask(`late-warning-${status}`, status), error: "original outcome", endTime };
|
|
store.publishOwner("panel", [task]);
|
|
store.ingestBackgroundEvent({ type: "completed", transferId: task.id, warning: "cleanup warning" });
|
|
assert.equal(store.getTask(task.id)?.status, status);
|
|
assert.equal(store.getTask(task.id)?.error, "original outcome");
|
|
assert.equal(store.getTask(task.id)?.warning, undefined);
|
|
});
|
|
}
|
|
|
|
test("store routes cancel/retry/prioritize/dismiss to the task owner; pause/resume are process-global", async () => {
|
|
const calls: string[] = [];
|
|
const store = createSftpTransferCenterStore();
|
|
store.registerOwner("panel-a", {
|
|
pause: async (id) => { calls.push(`pause:${id}`); },
|
|
resume: async (id) => { calls.push(`resume:${id}`); },
|
|
cancel: async (id) => { calls.push(`cancel:${id}`); },
|
|
retry: async (id) => { calls.push(`retry:${id}`); },
|
|
prioritize: async (id) => { calls.push(`prioritize:${id}`); },
|
|
dismiss: (id) => calls.push(`dismiss:${id}`),
|
|
});
|
|
store.publishOwner("panel-a", [makeTask("a")]);
|
|
|
|
await store.cancel("a");
|
|
await store.retry("a");
|
|
await store.prioritize("a");
|
|
store.dismiss("a");
|
|
|
|
// Pause/resume are process-global (not owner controllers).
|
|
assert.deepEqual(calls, [
|
|
"cancel:a",
|
|
"retry:a",
|
|
"prioritize:a",
|
|
"dismiss:a",
|
|
]);
|
|
assert.ok(!calls.some((c) => c.startsWith("pause:") || c.startsWith("resume:")));
|
|
});
|
|
|
|
test("background-agent retry after restart uses fresh dedicated recovery instead of the dead session controller", async () => {
|
|
let controllerRetryCalls = 0;
|
|
const dedicatedTasks: TransferTask[] = [];
|
|
const store = createSftpTransferCenterStore();
|
|
store.registerOwner("background-agent", {
|
|
pause: async () => {},
|
|
resume: async () => {},
|
|
cancel: async () => {},
|
|
retry: async () => { controllerRetryCalls += 1; },
|
|
prioritize: async () => {},
|
|
dismiss: () => {},
|
|
});
|
|
store.setDedicatedResumeHandler(async (task) => {
|
|
dedicatedTasks.push(task);
|
|
return { success: true };
|
|
});
|
|
store.publishOwner("background-agent", [{
|
|
...makeTask("background-retry", "failed"),
|
|
sourceHostId: "host-a",
|
|
targetConnectionId: "dead-terminal-session",
|
|
checkpointBytes: 7,
|
|
transferredBytes: 7,
|
|
error: "connection closed",
|
|
endTime: Date.now(),
|
|
}]);
|
|
|
|
await store.retry("background-retry");
|
|
|
|
assert.equal(controllerRetryCalls, 0);
|
|
assert.equal(dedicatedTasks.length, 1);
|
|
assert.equal(dedicatedTasks[0]?.checkpointBytes, 0);
|
|
assert.equal(dedicatedTasks[0]?.transferredBytes, 0);
|
|
assert.equal(dedicatedTasks[0]?.reconnectRequired, true);
|
|
assert.equal(store.getTask("background-retry")?.status, "completed");
|
|
});
|
|
|
|
for (const [label, error, expectResume] of [
|
|
["dead channel", "SFTP channel closed", true],
|
|
["lost session", "SFTP session lost. Please reconnect.", true],
|
|
["aborted socket", "read ECONNABORTED", true],
|
|
["hung up socket", "socket hang up", true],
|
|
["closed channel code", "ERR_SFTP_CHANNEL_CLOSED", true],
|
|
["client socket", "client-socket", true],
|
|
["content failure", "Permission denied", false],
|
|
] as const) {
|
|
test(`panel Retry after ${label} ${expectResume ? "resumes the same task from its checkpoint" : "keeps the restart-from-0 retry"}`, async () => {
|
|
const controllerRetries: string[] = [];
|
|
const dedicatedTasks: TransferTask[] = [];
|
|
const store = createSftpTransferCenterStore();
|
|
store.registerOwner("panel-a", {
|
|
pause: async () => {},
|
|
resume: async () => {},
|
|
cancel: async () => {},
|
|
retry: async (id) => { controllerRetries.push(id); },
|
|
prioritize: async () => {},
|
|
dismiss: () => {},
|
|
});
|
|
store.setDedicatedResumeHandler(async (task) => {
|
|
dedicatedTasks.push(task);
|
|
return { success: true };
|
|
});
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("dropped", "failed"),
|
|
totalBytes: 100,
|
|
checkpointBytes: 37,
|
|
transferredBytes: 37,
|
|
error,
|
|
endTime: Date.now(),
|
|
}]);
|
|
|
|
await store.retry("dropped");
|
|
|
|
if (expectResume) {
|
|
assert.deepEqual(controllerRetries, [], "no fresh-id restart");
|
|
assert.equal(dedicatedTasks.length, 1);
|
|
assert.equal(dedicatedTasks[0]?.id, "dropped", "same id keeps the same staged .part");
|
|
assert.equal(dedicatedTasks[0]?.checkpointBytes, 37);
|
|
assert.equal(dedicatedTasks[0]?.reconnectRequired, true);
|
|
} else {
|
|
assert.deepEqual(controllerRetries, ["dropped"]);
|
|
assert.equal(dedicatedTasks.length, 0);
|
|
}
|
|
});
|
|
}
|
|
|
|
test("panel Retry after a dropped download or remote copy keeps the owner restart", async () => {
|
|
for (const direction of ["download", "remote-to-remote"] as const) {
|
|
const controllerRetries: string[] = [];
|
|
const dedicatedTasks: TransferTask[] = [];
|
|
const store = createSftpTransferCenterStore();
|
|
store.registerOwner("panel-a", {
|
|
pause: async () => {},
|
|
resume: async () => {},
|
|
cancel: async () => {},
|
|
retry: async (id) => { controllerRetries.push(id); },
|
|
prioritize: async () => {},
|
|
dismiss: () => {},
|
|
});
|
|
store.setDedicatedResumeHandler(async (task) => {
|
|
dedicatedTasks.push(task);
|
|
return { success: true };
|
|
});
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("dropped", "failed"),
|
|
direction,
|
|
totalBytes: 100,
|
|
checkpointBytes: 37,
|
|
transferredBytes: 37,
|
|
error: "SFTP channel closed",
|
|
endTime: Date.now(),
|
|
}]);
|
|
|
|
await store.retry("dropped");
|
|
|
|
assert.deepEqual(controllerRetries, ["dropped"], direction);
|
|
assert.equal(dedicatedTasks.length, 0, direction);
|
|
}
|
|
});
|
|
|
|
test("resume without an owner uses a live backend transfer session when available", async (t) => {
|
|
const resumeCalls: string[] = [];
|
|
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: {
|
|
resumeTransfer: async (id: string) => {
|
|
resumeCalls.push(id);
|
|
return { success: true };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("orphaned-paused", "paused"),
|
|
direction: "download",
|
|
sourceHostId: "host-a",
|
|
sourceConnectionId: "remote-conn",
|
|
targetConnectionId: "local",
|
|
}]);
|
|
|
|
await store.resume("orphaned-paused");
|
|
|
|
assert.deepEqual(resumeCalls, ["orphaned-paused"]);
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "transferring");
|
|
assert.equal(store.getSnapshot().tasks[0]?.error, undefined);
|
|
});
|
|
|
|
test("resume soft-controls without panel when canAdopt is false", async (t) => {
|
|
// Downloads often have only the remote pane open. Soft-resume is process-global
|
|
// (bridge + latch) and must not require canAdopt / both panes.
|
|
const resumeCalls: string[] = [];
|
|
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: {
|
|
resumeTransfer: async (id: string) => {
|
|
resumeCalls.push(id);
|
|
return { success: true };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
const store = createSftpTransferCenterStore();
|
|
store.registerOwner("panel-a", {
|
|
pause: async () => {},
|
|
resume: async () => {},
|
|
cancel: async () => {},
|
|
retry: async () => {},
|
|
prioritize: async () => {},
|
|
dismiss: () => {},
|
|
canAdopt: () => false,
|
|
canPrepareAdoption: true,
|
|
});
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("download-paused", "paused"),
|
|
direction: "download",
|
|
sourceHostId: "host-a",
|
|
sourceConnectionId: "remote-conn",
|
|
targetConnectionId: "local",
|
|
}]);
|
|
|
|
await store.resume("download-paused");
|
|
|
|
assert.deepEqual(resumeCalls, ["download-paused"]);
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "transferring");
|
|
assert.equal(store.getSnapshot().tasks[0]?.error, undefined);
|
|
});
|
|
|
|
test("persisted unfinished tasks restore as interrupted without controllers", () => {
|
|
let persisted = "";
|
|
const first = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write: (value) => { persisted = value; },
|
|
});
|
|
first.publishOwner("panel-a", [makeTask("a")]);
|
|
|
|
const restored = createSftpTransferCenterStore({
|
|
read: () => persisted,
|
|
write: () => {},
|
|
});
|
|
assert.equal(restored.getSnapshot().tasks[0]?.status, "interrupted");
|
|
assert.equal(restored.getSnapshot().tasks[0]?.ownerId, "panel-a");
|
|
assert.equal(restored.canControl("a"), true);
|
|
});
|
|
|
|
test("paused source fingerprint patches are persisted for restart", () => {
|
|
let persisted = "";
|
|
const first = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write: (value) => { persisted = value; },
|
|
});
|
|
first.publishOwner("panel-a", [makeTask("paused-fingerprint", "paused")]);
|
|
first.patchTask("paused-fingerprint", { sourceFingerprint: "sha256:durable" });
|
|
|
|
const restored = createSftpTransferCenterStore({
|
|
read: () => persisted,
|
|
write: () => {},
|
|
});
|
|
assert.equal(restored.getSnapshot().tasks[0]?.status, "interrupted");
|
|
assert.equal(restored.getSnapshot().tasks[0]?.sourceFingerprint, "sha256:durable");
|
|
});
|
|
|
|
test("background source fingerprint progress is persisted immediately for restart", () => {
|
|
let persisted = "";
|
|
const first = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write: (value) => { persisted = value; },
|
|
});
|
|
first.publishOwner("panel-a", [makeTask("background-fingerprint", "paused")]);
|
|
first.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "background-fingerprint",
|
|
transferred: 2,
|
|
totalBytes: 10,
|
|
speed: 0,
|
|
checkpointBytes: 2,
|
|
sourceFingerprint: "sha256:background-durable",
|
|
lifecycleState: "paused",
|
|
});
|
|
|
|
const restored = createSftpTransferCenterStore({
|
|
read: () => persisted,
|
|
write: () => {},
|
|
});
|
|
assert.equal(restored.getSnapshot().tasks[0]?.sourceFingerprint, "sha256:background-durable");
|
|
});
|
|
|
|
test("background terminal lifecycle releases parent and child cancel and control state", async (t) => {
|
|
const {
|
|
isTransferCancelledFlag,
|
|
markTransferCancelledTree,
|
|
resetTransferCancelLatchesForTests,
|
|
} = await import("./sftp/transferCancelLatch");
|
|
const {
|
|
bumpTransferControlEpoch,
|
|
isTransferControlEpochCurrent,
|
|
resetTransferControlEpochsForTests,
|
|
} = await import("./sftp/transferControlEpoch");
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
t.after(() => {
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
});
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("background-agent", [
|
|
{ ...makeTask("background-root"), isDirectory: true, progressMode: "files" },
|
|
{ ...makeTask("background-child"), parentTaskId: "background-root" },
|
|
]);
|
|
markTransferCancelledTree("background-root", ["background-child"]);
|
|
const rootEpoch = bumpTransferControlEpoch("background-root");
|
|
const childEpoch = bumpTransferControlEpoch("background-child");
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "background-root",
|
|
transferred: 5,
|
|
totalBytes: 10,
|
|
speed: 1,
|
|
});
|
|
assert.equal(isTransferCancelledFlag("background-root"), true);
|
|
assert.equal(isTransferControlEpochCurrent("background-root", rootEpoch), true);
|
|
|
|
store.ingestBackgroundEvent({ type: "completed", transferId: "background-root" });
|
|
|
|
assert.equal(isTransferCancelledFlag("background-root"), false);
|
|
assert.equal(isTransferCancelledFlag("background-child"), false);
|
|
assert.equal(isTransferControlEpochCurrent("background-root", rootEpoch), false);
|
|
assert.equal(isTransferControlEpochCurrent("background-child", childEpoch), false);
|
|
});
|
|
|
|
test("registered background owner still releases a finished parent and child control tree", async (t) => {
|
|
const {
|
|
isTransferCancelledFlag,
|
|
markTransferCancelledTree,
|
|
resetTransferCancelLatchesForTests,
|
|
} = await import("./sftp/transferCancelLatch");
|
|
const {
|
|
bumpTransferControlEpoch,
|
|
isTransferControlEpochCurrent,
|
|
resetTransferControlEpochsForTests,
|
|
} = await import("./sftp/transferControlEpoch");
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
t.after(() => {
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
const unregisterOwner = store.registerOwner("background-agent", {
|
|
pause: async () => {},
|
|
resume: async () => {},
|
|
cancel: async () => {},
|
|
retry: async () => {},
|
|
prioritize: async () => {},
|
|
dismiss: () => {},
|
|
});
|
|
t.after(unregisterOwner);
|
|
store.publishOwner("background-agent", [
|
|
{ ...makeTask("registered-root"), isDirectory: true, progressMode: "files" },
|
|
{ ...makeTask("registered-child"), parentTaskId: "registered-root" },
|
|
]);
|
|
markTransferCancelledTree("registered-root", ["registered-child"]);
|
|
const rootEpoch = bumpTransferControlEpoch("registered-root");
|
|
const childEpoch = bumpTransferControlEpoch("registered-child");
|
|
|
|
store.ingestBackgroundEvent({ type: "completed", transferId: "registered-root" });
|
|
|
|
assert.equal(isTransferCancelledFlag("registered-root"), false);
|
|
assert.equal(isTransferCancelledFlag("registered-child"), false);
|
|
assert.equal(isTransferControlEpochCurrent("registered-root", rootEpoch), false);
|
|
assert.equal(isTransferControlEpochCurrent("registered-child", childEpoch), false);
|
|
});
|
|
|
|
test("registered owner completion waits for its active directory walk before releasing controls", async (t) => {
|
|
const {
|
|
isTransferCancelledFlag,
|
|
markTransferCancelledTree,
|
|
resetTransferCancelLatchesForTests,
|
|
} = await import("./sftp/transferCancelLatch");
|
|
const {
|
|
bumpTransferControlEpoch,
|
|
isTransferControlEpochCurrent,
|
|
resetTransferControlEpochsForTests,
|
|
} = await import("./sftp/transferControlEpoch");
|
|
const {
|
|
registerTransferWalk,
|
|
resetTransferWalkRegistryForTests,
|
|
unregisterTransferWalk,
|
|
} = await import("./sftp/transferWalkRegistry");
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
t.after(() => {
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
const unregisterOwner = store.registerOwner("active-background-agent", {
|
|
pause: async () => {},
|
|
resume: async () => {},
|
|
cancel: async () => {},
|
|
retry: async () => {},
|
|
prioritize: async () => {},
|
|
dismiss: () => {},
|
|
});
|
|
store.publishOwner("active-background-agent", [
|
|
{ ...makeTask("active-root"), isDirectory: true, progressMode: "files" },
|
|
{ ...makeTask("active-child"), parentTaskId: "active-root" },
|
|
]);
|
|
markTransferCancelledTree("active-root", ["active-child"]);
|
|
const rootEpoch = bumpTransferControlEpoch("active-root");
|
|
const childEpoch = bumpTransferControlEpoch("active-child");
|
|
registerTransferWalk("active-root");
|
|
|
|
store.ingestBackgroundEvent({ type: "completed", transferId: "active-root" });
|
|
unregisterOwner();
|
|
|
|
assert.equal(isTransferCancelledFlag("active-root"), true);
|
|
assert.equal(isTransferCancelledFlag("active-child"), true);
|
|
assert.equal(isTransferControlEpochCurrent("active-root", rootEpoch), true);
|
|
assert.equal(isTransferControlEpochCurrent("active-child", childEpoch), true);
|
|
|
|
unregisterTransferWalk("active-root");
|
|
store.upsertTasks(store.getSnapshot().tasks);
|
|
|
|
assert.equal(isTransferCancelledFlag("active-root"), false);
|
|
assert.equal(isTransferCancelledFlag("active-child"), false);
|
|
assert.equal(isTransferControlEpochCurrent("active-root", rootEpoch), false);
|
|
assert.equal(isTransferControlEpochCurrent("active-child", childEpoch), false);
|
|
});
|
|
|
|
test("owner source fingerprint publish is persisted immediately for restart", () => {
|
|
let persisted = "";
|
|
const first = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write: (value) => { persisted = value; },
|
|
});
|
|
const paused = makeTask("owner-fingerprint", "paused");
|
|
first.publishOwner("panel-a", [paused]);
|
|
first.publishOwner("panel-a", [{
|
|
...paused,
|
|
sourceFingerprint: "sha256:owner-durable",
|
|
}]);
|
|
|
|
const restored = createSftpTransferCenterStore({
|
|
read: () => persisted,
|
|
write: () => {},
|
|
});
|
|
assert.equal(restored.getSnapshot().tasks[0]?.sourceFingerprint, "sha256:owner-durable");
|
|
});
|
|
|
|
test("top-level completion is persisted immediately while child completions stay coalesced", () => {
|
|
let writes = 0;
|
|
let persisted = "";
|
|
const first = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write: (value) => {
|
|
writes += 1;
|
|
persisted = value;
|
|
},
|
|
});
|
|
const parent = {
|
|
...makeTask("completed-parent"),
|
|
isDirectory: true,
|
|
progressMode: "files" as const,
|
|
};
|
|
const child = { ...makeTask("completed-child"), parentTaskId: parent.id };
|
|
first.publishOwner("panel-a", [parent, child]);
|
|
first.publishOwner("panel-a", [parent, { ...child, status: "completed", endTime: Date.now() }]);
|
|
assert.equal(writes, 1, "child completion should remain coalesced");
|
|
first.publishOwner("panel-a", [
|
|
{ ...parent, status: "completed", endTime: Date.now() },
|
|
{ ...child, status: "completed", endTime: Date.now() },
|
|
]);
|
|
assert.equal(writes, 2, "parent completion should flush immediately");
|
|
|
|
const restored = createSftpTransferCenterStore({
|
|
read: () => persisted,
|
|
write: () => {},
|
|
});
|
|
assert.equal(restored.getSnapshot().tasks.find((task) => task.id === parent.id)?.status, "completed");
|
|
});
|
|
|
|
test("explicit history deletions are persisted before returning", () => {
|
|
const cases = [
|
|
{
|
|
name: "dismiss",
|
|
task: makeTask("dismissed-history", "failed"),
|
|
remove: (store: ReturnType<typeof createSftpTransferCenterStore>) => store.dismiss("dismissed-history"),
|
|
},
|
|
{
|
|
name: "clear terminal",
|
|
task: makeTask("cleared-history", "completed"),
|
|
remove: (store: ReturnType<typeof createSftpTransferCenterStore>) => store.clearTerminal("completed"),
|
|
},
|
|
{
|
|
name: "owner publish",
|
|
task: makeTask("owner-removed-history", "failed"),
|
|
remove: (store: ReturnType<typeof createSftpTransferCenterStore>) => store.publishOwner("panel-a", []),
|
|
},
|
|
];
|
|
|
|
for (const scenario of cases) {
|
|
let writes = 0;
|
|
let persisted = "";
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write: (value) => {
|
|
writes += 1;
|
|
persisted = value;
|
|
},
|
|
});
|
|
store.publishOwner("panel-a", [scenario.task]);
|
|
assert.equal(writes, 1, `${scenario.name}: setup should write once`);
|
|
|
|
scenario.remove(store);
|
|
|
|
assert.equal(writes, 2, `${scenario.name}: deletion should flush immediately`);
|
|
const restored = createSftpTransferCenterStore({
|
|
read: () => persisted,
|
|
write: () => {},
|
|
});
|
|
assert.equal(restored.getSnapshot().tasks.length, 0, `${scenario.name}: deleted history must not return`);
|
|
}
|
|
});
|
|
|
|
test("dismissing a finished directory releases retained parent and child controls", async (t) => {
|
|
const {
|
|
isTransferCancelledFlag,
|
|
markTransferCancelledTree,
|
|
resetTransferCancelLatchesForTests,
|
|
} = await import("./sftp/transferCancelLatch");
|
|
const {
|
|
bumpTransferControlEpoch,
|
|
isTransferControlEpochCurrent,
|
|
resetTransferControlEpochsForTests,
|
|
} = await import("./sftp/transferControlEpoch");
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
t.after(() => {
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
});
|
|
const store = createSftpTransferCenterStore();
|
|
store.upsertTasks([
|
|
{ ...makeTask("dismiss-root", "completed"), isDirectory: true, progressMode: "files" },
|
|
{ ...makeTask("dismiss-child", "completed"), parentTaskId: "dismiss-root" },
|
|
]);
|
|
markTransferCancelledTree("dismiss-root", ["dismiss-child"]);
|
|
const rootEpoch = bumpTransferControlEpoch("dismiss-root");
|
|
const childEpoch = bumpTransferControlEpoch("dismiss-child");
|
|
|
|
store.dismiss("dismiss-root");
|
|
|
|
assert.equal(isTransferCancelledFlag("dismiss-root"), false);
|
|
assert.equal(isTransferCancelledFlag("dismiss-child"), false);
|
|
assert.equal(isTransferControlEpochCurrent("dismiss-root", rootEpoch), false);
|
|
assert.equal(isTransferControlEpochCurrent("dismiss-child", childEpoch), false);
|
|
});
|
|
|
|
test("history pruning releases retained controls for an evicted directory tree", async (t) => {
|
|
const {
|
|
isTransferCancelledFlag,
|
|
markTransferCancelledTree,
|
|
resetTransferCancelLatchesForTests,
|
|
} = await import("./sftp/transferCancelLatch");
|
|
const {
|
|
bumpTransferControlEpoch,
|
|
isTransferControlEpochCurrent,
|
|
resetTransferControlEpochsForTests,
|
|
} = await import("./sftp/transferControlEpoch");
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
t.after(() => {
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
});
|
|
const store = createSftpTransferCenterStore();
|
|
const now = Date.now();
|
|
store.upsertTasks([
|
|
{ ...makeTask("prune-root", "completed"), isDirectory: true, progressMode: "files", endTime: now - 10_000 },
|
|
{ ...makeTask("prune-child", "completed"), parentTaskId: "prune-root", endTime: now - 9_999 },
|
|
...Array.from({ length: 198 }, (_, index) => ({
|
|
...makeTask(`retained-${index}`, "completed"),
|
|
endTime: now - index,
|
|
})),
|
|
]);
|
|
markTransferCancelledTree("prune-root", ["prune-child"]);
|
|
const rootEpoch = bumpTransferControlEpoch("prune-root");
|
|
const childEpoch = bumpTransferControlEpoch("prune-child");
|
|
|
|
store.upsertTasks([
|
|
{ ...makeTask("newest-1", "completed"), endTime: now + 1 },
|
|
{ ...makeTask("newest-2", "completed"), endTime: now + 2 },
|
|
]);
|
|
|
|
assert.equal(store.getTask("prune-root"), undefined);
|
|
assert.equal(store.getTask("prune-child"), undefined);
|
|
assert.equal(isTransferCancelledFlag("prune-root"), false);
|
|
assert.equal(isTransferCancelledFlag("prune-child"), false);
|
|
assert.equal(isTransferControlEpochCurrent("prune-root", rootEpoch), false);
|
|
assert.equal(isTransferControlEpochCurrent("prune-child", childEpoch), false);
|
|
});
|
|
|
|
test("orphaned unfinished tasks stay controllable so dead rows can be cancelled", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("gone-panel", [
|
|
makeTask("dead-transferring", "transferring"),
|
|
makeTask("dead-paused", "paused"),
|
|
]);
|
|
// No owner controller registered — simulates app restart.
|
|
assert.equal(store.canControl("dead-transferring"), true);
|
|
assert.equal(store.canControl("dead-paused"), true);
|
|
});
|
|
|
|
test("pause on an orphaned transferring task demotes it to interrupted", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("gone-panel", [makeTask("stuck", "transferring")]);
|
|
|
|
await store.pause("stuck");
|
|
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "interrupted");
|
|
assert.equal(store.getSnapshot().tasks[0]?.reconnectRequired, true);
|
|
});
|
|
|
|
test("orphan pause with a live walk latches paused without cancel/demote", async (t) => {
|
|
const {
|
|
isTransferOrRootPauseLatched,
|
|
isTransferPauseLatched,
|
|
resetTransferPauseLatchesForTests,
|
|
} = await import("./sftp/transferPauseLatch");
|
|
const {
|
|
registerTransferWalk,
|
|
unregisterTransferWalk,
|
|
resetTransferWalkRegistryForTests,
|
|
} = await import("./sftp/transferWalkRegistry");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
registerTransferWalk("live-dir");
|
|
t.after(() => {
|
|
unregisterTransferWalk("live-dir");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
const cancelCalls: string[] = [];
|
|
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: {
|
|
// No pauseTransfer → falls to no-bridge branch.
|
|
cancelTransfer: async (id: string) => {
|
|
cancelCalls.push(id);
|
|
return { success: true };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("terminal:closed", [
|
|
{
|
|
...makeTask("live-dir", "transferring"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 2,
|
|
totalBytes: 10,
|
|
},
|
|
{
|
|
...makeTask("live-child", "transferring"),
|
|
parentTaskId: "live-dir",
|
|
transferredBytes: 1,
|
|
totalBytes: 5,
|
|
},
|
|
]);
|
|
|
|
await store.pause("live-dir");
|
|
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "live-dir")?.status, "paused");
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "live-child")?.status, "paused");
|
|
assert.equal(isTransferPauseLatched("live-dir"), true);
|
|
assert.equal(isTransferOrRootPauseLatched("live-dir", "live-child"), true);
|
|
assert.deepEqual(cancelCalls, [], "must not cancelTransfer a still-running walk");
|
|
});
|
|
|
|
test("orphan resume clears full latch tree so walk is not blocked", async (t) => {
|
|
const {
|
|
isTransferOrRootPauseLatched,
|
|
latchTransferPauseTree,
|
|
resetTransferPauseLatchesForTests,
|
|
} = await import("./sftp/transferPauseLatch");
|
|
const {
|
|
registerTransferWalk,
|
|
unregisterTransferWalk,
|
|
resetTransferWalkRegistryForTests,
|
|
} = await import("./sftp/transferWalkRegistry");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
latchTransferPauseTree("dir-latched", ["c1", "c2"]);
|
|
registerTransferWalk("dir-latched");
|
|
t.after(() => {
|
|
unregisterTransferWalk("dir-latched");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
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: {
|
|
resumeTransfer: async () => ({ success: false, reason: "Transfer is no longer active" }),
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("gone", [
|
|
{
|
|
...makeTask("dir-latched", "paused"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 1,
|
|
totalBytes: 5,
|
|
speed: 0,
|
|
},
|
|
{ ...makeTask("c1", "paused"), parentTaskId: "dir-latched", speed: 0 },
|
|
{ ...makeTask("c2", "paused"), parentTaskId: "dir-latched", speed: 0 },
|
|
]);
|
|
|
|
await store.resume("dir-latched");
|
|
|
|
assert.equal(isTransferOrRootPauseLatched("dir-latched", "c1"), false);
|
|
assert.equal(isTransferOrRootPauseLatched("dir-latched", "c2"), false);
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "dir-latched")?.status, "transferring");
|
|
});
|
|
|
|
test("snapshot counts only parent tasks and clearing completed history preserves failures", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [
|
|
makeTask("parent"),
|
|
{ ...makeTask("child"), parentTaskId: "parent" },
|
|
makeTask("done", "completed"),
|
|
makeTask("failed", "failed"),
|
|
]);
|
|
|
|
assert.equal(store.getSnapshot().activeCount, 1);
|
|
store.clearTerminal("completed");
|
|
assert.deepEqual(store.getSnapshot().tasks.map((task) => task.id), ["parent", "child", "failed"]);
|
|
});
|
|
|
|
test("background agent transfers are recorded and retained in history", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const now = Date.now();
|
|
store.ingestBackgroundEvent({
|
|
type: "started",
|
|
transferId: "agent-transfer",
|
|
direction: "upload",
|
|
sourcePath: "/local/report.txt",
|
|
targetPath: "/remote/report.txt",
|
|
startedAt: now - 10,
|
|
});
|
|
assert.equal(store.getSnapshot().tasks[0]?.background, true);
|
|
assert.equal(store.getSnapshot().tasks[0]?.origin, "agent");
|
|
|
|
store.ingestBackgroundEvent({ type: "completed", transferId: "agent-transfer", endedAt: now });
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "completed");
|
|
assert.equal(store.getSnapshot().tasks[0]?.endTime, now);
|
|
});
|
|
|
|
test("unified started event creates a correctly described download and progress preserves pause capability", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.ingestBackgroundEvent({
|
|
type: "started",
|
|
transferId: "download-described",
|
|
direction: "download",
|
|
fileName: "report.bin",
|
|
sourcePath: "/remote/report.bin",
|
|
targetPath: "/tmp/report.bin",
|
|
totalBytes: 100,
|
|
resumable: true,
|
|
});
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "download-described",
|
|
transferred: 10,
|
|
totalBytes: 100,
|
|
speed: 5,
|
|
resumable: false,
|
|
pauseUnavailableReason: "SCP transfers cannot be paused",
|
|
});
|
|
|
|
const task = store.getTask("download-described");
|
|
assert.equal(task?.direction, "download");
|
|
assert.equal(task?.sourcePath, "/remote/report.bin");
|
|
assert.equal(task?.targetPath, "/tmp/report.bin");
|
|
assert.equal(task?.fileName, "report.bin");
|
|
assert.equal(task?.resumable, false);
|
|
assert.equal(task?.pauseUnavailableReason, "SCP transfers cannot be paused");
|
|
});
|
|
|
|
test("main-process progress ingest keeps panel-owned transfers moving without React callbacks", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
// Simulate panel publish then unmount: task remains in store, no live controller needed.
|
|
store.publishOwner("panel-hidden", [{
|
|
...makeTask("upload-1", "queued"),
|
|
transferredBytes: 0,
|
|
totalBytes: 1000,
|
|
}]);
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "upload-1",
|
|
transferred: 400,
|
|
totalBytes: 1000,
|
|
speed: 200,
|
|
checkpointBytes: 400,
|
|
});
|
|
|
|
const task = store.getSnapshot().tasks.find((row) => row.id === "upload-1");
|
|
assert.equal(task?.status, "transferring");
|
|
assert.equal(task?.transferredBytes, 400);
|
|
assert.equal(task?.speed, 200);
|
|
assert.equal(task?.checkpointBytes, 400);
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "completed",
|
|
transferId: "upload-1",
|
|
endedAt: Date.now(),
|
|
});
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "upload-1")?.status, "completed");
|
|
});
|
|
|
|
test("duplicate main-process progress does not notify or persist a second renderer update", async () => {
|
|
let writes = 0;
|
|
let notifications = 0;
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write: () => { writes += 1; },
|
|
});
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("duplicate-progress"),
|
|
transferredBytes: 5,
|
|
totalBytes: 10,
|
|
speed: 2,
|
|
lifecycleEpoch: 0,
|
|
}]);
|
|
store.subscribe(() => { notifications += 1; });
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "duplicate-progress",
|
|
transferred: 5,
|
|
totalBytes: 10,
|
|
speed: 2,
|
|
lifecycleEpoch: 0,
|
|
lifecycleState: "transferring",
|
|
});
|
|
await new Promise((resolve) => setTimeout(resolve, 300));
|
|
|
|
assert.equal(notifications, 0);
|
|
assert.equal(writes, 1);
|
|
});
|
|
|
|
test("owner publish after global progress does not repeat the same renderer update", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("global-first"),
|
|
transferredBytes: 0,
|
|
totalBytes: 10,
|
|
speed: 0,
|
|
lifecycleEpoch: 0,
|
|
}]);
|
|
let lifecycleNotifications = 0;
|
|
let progressNotifications = 0;
|
|
store.subscribe(() => { lifecycleNotifications += 1; });
|
|
store.subscribeProgress(() => { progressNotifications += 1; });
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "global-first",
|
|
transferred: 5,
|
|
totalBytes: 10,
|
|
speed: 2,
|
|
lifecycleEpoch: 0,
|
|
lifecycleState: "transferring",
|
|
});
|
|
// Progress paints are coalesced on the progress channel; a matching panel
|
|
// publish must not force a lifecycle React update.
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("global-first"),
|
|
transferredBytes: 5,
|
|
totalBytes: 10,
|
|
speed: 2,
|
|
lifecycleEpoch: 0,
|
|
}]);
|
|
|
|
// Progress channel is rAF-coalesced (setTimeout 16ms in Node tests).
|
|
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
assert.equal(lifecycleNotifications, 0);
|
|
assert.equal(progressNotifications, 1);
|
|
});
|
|
|
|
test("newer backend lifecycle progress reopens a paused row", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("paused-but-moving", "paused"),
|
|
transferredBytes: 50,
|
|
checkpointBytes: 50,
|
|
lifecycleEpoch: 1,
|
|
totalBytes: 100,
|
|
speed: 0,
|
|
}]);
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "paused-but-moving",
|
|
transferred: 75,
|
|
checkpointBytes: 75,
|
|
totalBytes: 100,
|
|
speed: 10,
|
|
lifecycleEpoch: 2,
|
|
lifecycleState: "transferring",
|
|
});
|
|
|
|
const task = store.getSnapshot().tasks.find((row) => row.id === "paused-but-moving");
|
|
assert.equal(task?.status, "transferring");
|
|
assert.equal(task?.transferredBytes, 75);
|
|
assert.equal(task?.checkpointBytes, 75);
|
|
});
|
|
|
|
test("older in-flight progress cannot reopen a newer confirmed pause", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("paused-with-late-event", "paused"),
|
|
transferredBytes: 50,
|
|
checkpointBytes: 50,
|
|
lifecycleEpoch: 1,
|
|
totalBytes: 100,
|
|
speed: 0,
|
|
}]);
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "paused-with-late-event",
|
|
transferred: 75,
|
|
checkpointBytes: 75,
|
|
totalBytes: 100,
|
|
speed: 10,
|
|
lifecycleEpoch: 0,
|
|
lifecycleState: "transferring",
|
|
});
|
|
|
|
const task = store.getSnapshot().tasks.find((row) => row.id === "paused-with-late-event");
|
|
assert.equal(task?.status, "paused");
|
|
assert.equal(task?.transferredBytes, 50);
|
|
});
|
|
|
|
test("older queued or started events cannot overwrite a newer pause", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("paused-newer", "paused"),
|
|
transferredBytes: 50,
|
|
checkpointBytes: 50,
|
|
lifecycleEpoch: 2,
|
|
totalBytes: 100,
|
|
speed: 0,
|
|
}]);
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "started",
|
|
transferId: "paused-newer",
|
|
lifecycleEpoch: 1,
|
|
});
|
|
store.ingestBackgroundEvent({
|
|
type: "queued",
|
|
transferId: "paused-newer",
|
|
});
|
|
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "paused");
|
|
assert.equal(store.getSnapshot().tasks[0]?.lifecycleEpoch, 2);
|
|
});
|
|
|
|
test("background compressed lifecycle creates and updates the same controllable task in every window", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.ingestBackgroundEvent({
|
|
type: "started",
|
|
transferId: "compressed-global",
|
|
fileName: "photos (compressed)",
|
|
sourcePath: "/local/photos",
|
|
targetPath: "/remote/photos",
|
|
direction: "upload",
|
|
totalBytes: 1_000,
|
|
isDirectory: true,
|
|
controlKind: "compressed-upload",
|
|
phase: "compressing",
|
|
});
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "compressed-global",
|
|
transferred: 650,
|
|
totalBytes: 1_000,
|
|
phase: "uploading",
|
|
});
|
|
|
|
const task = store.getSnapshot().tasks.find((candidate) => candidate.id === "compressed-global");
|
|
assert.equal(task?.fileName, "photos (compressed)");
|
|
assert.equal(task?.isDirectory, true);
|
|
assert.equal(task?.controlKind, "compressed-upload");
|
|
assert.equal(task?.phase, "uploading");
|
|
assert.equal(task?.transferredBytes, 650);
|
|
assert.equal(task?.totalBytes, 1_000);
|
|
});
|
|
|
|
test("a worker compressed progress event can create the task after the source page closed", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "worker-compressed",
|
|
fileName: "worker folder (compressed)",
|
|
sourcePath: "/local/worker folder",
|
|
targetPath: "/remote/worker folder",
|
|
direction: "upload",
|
|
transferred: 250,
|
|
totalBytes: 1_000,
|
|
isDirectory: true,
|
|
controlKind: "compressed-upload",
|
|
phase: "compressing",
|
|
});
|
|
|
|
const task = store.getSnapshot().tasks[0];
|
|
assert.equal(task?.id, "worker-compressed");
|
|
assert.equal(task?.transferredBytes, 250);
|
|
assert.equal(task?.controlKind, "compressed-upload");
|
|
});
|
|
|
|
test("stale panel publishOwner cannot roll back background progress after tab close", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "transferring"),
|
|
transferredBytes: 100,
|
|
totalBytes: 1000,
|
|
speed: 10,
|
|
}]);
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "upload-1",
|
|
transferred: 700,
|
|
totalBytes: 1000,
|
|
speed: 50,
|
|
checkpointBytes: 700,
|
|
});
|
|
assert.equal(store.getSnapshot().tasks[0]?.transferredBytes, 700);
|
|
|
|
// Panel React state still frozen at 100 (unmount / missed setState) — must not clobber.
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "transferring"),
|
|
transferredBytes: 100,
|
|
totalBytes: 1000,
|
|
speed: 0,
|
|
checkpointBytes: 100,
|
|
}]);
|
|
|
|
const task = store.getSnapshot().tasks.find((row) => row.id === "upload-1");
|
|
assert.equal(task?.transferredBytes, 700);
|
|
assert.equal(task?.checkpointBytes, 700);
|
|
assert.equal(task?.status, "transferring");
|
|
});
|
|
|
|
test("stale paused panel snapshot cannot hide progress beyond its pause checkpoint", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "paused"),
|
|
transferredBytes: 50,
|
|
checkpointBytes: 50,
|
|
lifecycleEpoch: 1,
|
|
totalBytes: 100,
|
|
speed: 0,
|
|
}]);
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "upload-1",
|
|
transferred: 75,
|
|
checkpointBytes: 75,
|
|
totalBytes: 100,
|
|
speed: 10,
|
|
lifecycleEpoch: 2,
|
|
lifecycleState: "transferring",
|
|
});
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "transferring");
|
|
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "paused"),
|
|
transferredBytes: 50,
|
|
checkpointBytes: 50,
|
|
lifecycleEpoch: 1,
|
|
totalBytes: 100,
|
|
speed: 0,
|
|
}]);
|
|
|
|
const task = store.getSnapshot().tasks[0];
|
|
assert.equal(task?.status, "transferring");
|
|
assert.equal(task?.transferredBytes, 75);
|
|
assert.equal(task?.checkpointBytes, 75);
|
|
});
|
|
|
|
test("stale panel progress cannot move a bar after a newer backend pause", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-paused", "transferring"),
|
|
transferredBytes: 50,
|
|
checkpointBytes: 50,
|
|
totalBytes: 100,
|
|
}]);
|
|
store.ingestBackgroundEvent({
|
|
type: "paused",
|
|
transferId: "upload-paused",
|
|
transferred: 50,
|
|
checkpointBytes: 50,
|
|
lifecycleEpoch: 1,
|
|
lifecycleState: "paused",
|
|
});
|
|
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-paused", "transferring"),
|
|
transferredBytes: 75,
|
|
checkpointBytes: 75,
|
|
totalBytes: 100,
|
|
speed: 10,
|
|
}]);
|
|
|
|
const task = store.getSnapshot().tasks[0];
|
|
assert.equal(task?.status, "paused");
|
|
assert.equal(task?.transferredBytes, 50);
|
|
assert.equal(task?.checkpointBytes, 50);
|
|
assert.equal(task?.speed, 0);
|
|
});
|
|
|
|
test("progress under a paused folder parent cannot re-open the child as transferring", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [
|
|
{
|
|
...makeTask("folder", "paused"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 1,
|
|
totalBytes: 12,
|
|
speed: 0,
|
|
},
|
|
{
|
|
...makeTask("child", "paused"),
|
|
parentTaskId: "folder",
|
|
transferredBytes: 6_000_000,
|
|
totalBytes: 58_000_000,
|
|
speed: 0,
|
|
lifecycleEpoch: 1,
|
|
},
|
|
]);
|
|
|
|
// Soft-drain progress without a resume epoch must stay paused (no blink row).
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "child",
|
|
transferred: 7_000_000,
|
|
totalBytes: 58_000_000,
|
|
speed: 50,
|
|
checkpointBytes: 7_000_000,
|
|
lifecycleEpoch: 1,
|
|
lifecycleState: "transferring",
|
|
});
|
|
|
|
const child = store.getSnapshot().tasks.find((row) => row.id === "child");
|
|
assert.equal(child?.status, "paused");
|
|
assert.equal(child?.transferredBytes, 6_000_000);
|
|
assert.equal(child?.speed, 0);
|
|
assert.equal(child?.checkpointBytes, 7_000_000);
|
|
});
|
|
|
|
test("publishOwner cannot resurrect a live child under a paused folder parent", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [
|
|
{
|
|
...makeTask("folder", "paused"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 1,
|
|
totalBytes: 12,
|
|
speed: 0,
|
|
},
|
|
{
|
|
...makeTask("child", "paused"),
|
|
parentTaskId: "folder",
|
|
transferredBytes: 1_000,
|
|
totalBytes: 10_000,
|
|
speed: 0,
|
|
},
|
|
]);
|
|
|
|
store.publishOwner("panel-a", [
|
|
{
|
|
...makeTask("folder", "paused"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 1,
|
|
totalBytes: 12,
|
|
speed: 0,
|
|
},
|
|
{
|
|
...makeTask("child", "transferring"),
|
|
parentTaskId: "folder",
|
|
transferredBytes: 2_000,
|
|
totalBytes: 10_000,
|
|
speed: 40,
|
|
},
|
|
]);
|
|
|
|
const child = store.getSnapshot().tasks.find((row) => row.id === "child");
|
|
assert.equal(child?.status, "paused");
|
|
assert.equal(child?.speed, 0);
|
|
});
|
|
|
|
test("intentional panel pause wins even when soft-drain store bytes are ahead", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
// Background soft-drain advanced the global bar past the panel snapshot.
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("folder-parent", "transferring"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 3,
|
|
totalBytes: 12,
|
|
checkpointBytes: 3,
|
|
}]);
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("child-live", "transferring"),
|
|
parentTaskId: "folder-parent",
|
|
transferredBytes: 4_000_000,
|
|
totalBytes: 45_000_000,
|
|
checkpointBytes: 4_000_000,
|
|
speed: 80,
|
|
}]);
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "child-live",
|
|
transferred: 8_000_000,
|
|
totalBytes: 45_000_000,
|
|
speed: 90,
|
|
checkpointBytes: 8_000_000,
|
|
});
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "child-live")?.transferredBytes, 8_000_000);
|
|
|
|
// User hits pause: panel freezes child at a lower snapshot and paints pausing.
|
|
store.publishOwner("panel-a", [
|
|
{
|
|
...makeTask("folder-parent", "pausing"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 3,
|
|
totalBytes: 12,
|
|
checkpointBytes: 3,
|
|
speed: 0,
|
|
},
|
|
{
|
|
...makeTask("child-live", "pausing"),
|
|
parentTaskId: "folder-parent",
|
|
transferredBytes: 4_000_000,
|
|
totalBytes: 45_000_000,
|
|
checkpointBytes: 4_000_000,
|
|
speed: 0,
|
|
},
|
|
]);
|
|
|
|
const parent = store.getSnapshot().tasks.find((row) => row.id === "folder-parent");
|
|
const child = store.getSnapshot().tasks.find((row) => row.id === "child-live");
|
|
assert.equal(parent?.status, "pausing", "folder parent pause must stick in the global center");
|
|
assert.equal(child?.status, "pausing", "child pause must not be rejected for higher store bytes");
|
|
assert.equal(child?.transferredBytes, 8_000_000, "keep soft-drain water mark, freeze further motion");
|
|
assert.equal(child?.speed, 0);
|
|
});
|
|
|
|
test("pause/resume are process-global even when a live owner is registered", async (t) => {
|
|
const {
|
|
registerTransferWalk,
|
|
unregisterTransferWalk,
|
|
resetTransferWalkRegistryForTests,
|
|
} = await import("./sftp/transferWalkRegistry");
|
|
resetTransferWalkRegistryForTests();
|
|
registerTransferWalk("dir");
|
|
t.after(() => {
|
|
unregisterTransferWalk("dir");
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
const controllerCalls: string[] = [];
|
|
let syncCalls = 0;
|
|
store.registerOwner("panel-a", {
|
|
pause: async (id) => { controllerCalls.push(`pause:${id}`); },
|
|
resume: async (id) => { controllerCalls.push(`resume:${id}`); },
|
|
cancel: async () => {},
|
|
retry: async () => {},
|
|
prioritize: async () => {},
|
|
dismiss: () => {},
|
|
ownsTask: () => true,
|
|
syncOwnedTasks: () => { syncCalls += 1; },
|
|
});
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("dir", "transferring"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 2,
|
|
totalBytes: 10,
|
|
}, {
|
|
...makeTask("file", "transferring"),
|
|
parentTaskId: "dir",
|
|
transferredBytes: 100,
|
|
totalBytes: 1000,
|
|
}]);
|
|
|
|
await store.pause("dir");
|
|
assert.deepEqual(controllerCalls, [], "soft-control must not route pause through React owner");
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "dir")?.status, "paused");
|
|
assert.ok(syncCalls >= 1, "owners still get a sync so local lists can mirror store");
|
|
|
|
await store.resume("dir");
|
|
assert.deepEqual(controllerCalls, [], "soft-control must not route resume through React owner");
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "dir")?.status, "transferring");
|
|
});
|
|
|
|
test("pause after terminal close works without any React owner", async () => {
|
|
const {
|
|
isTransferPauseLatched,
|
|
resetTransferPauseLatchesForTests,
|
|
} = await import("./sftp/transferPauseLatch");
|
|
const {
|
|
registerTransferWalk,
|
|
unregisterTransferWalk,
|
|
resetTransferWalkRegistryForTests,
|
|
} = await import("./sftp/transferWalkRegistry");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
registerTransferWalk("stale-dir");
|
|
const pauseCalls: string[] = [];
|
|
const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
|
|
const cleanup = () => {
|
|
unregisterTransferWalk("stale-dir");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
|
|
else Reflect.deleteProperty(globalThis, "window");
|
|
};
|
|
Object.defineProperty(globalThis, "window", {
|
|
configurable: true,
|
|
value: {
|
|
netcatty: {
|
|
pauseTransfer: async (id: string) => {
|
|
pauseCalls.push(id);
|
|
return { success: true, checkpointBytes: 1 };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
// No owner registered — pure process-global control after tab close.
|
|
store.publishOwner("terminal:closed-tab", [{
|
|
...makeTask("stale-dir", "transferring"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 2,
|
|
totalBytes: 12,
|
|
}, {
|
|
...makeTask("stale-child", "transferring"),
|
|
parentTaskId: "stale-dir",
|
|
transferredBytes: 1,
|
|
totalBytes: 10,
|
|
}]);
|
|
|
|
await store.pause("stale-dir");
|
|
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "stale-dir")?.status, "paused");
|
|
assert.equal(isTransferPauseLatched("stale-dir"), true);
|
|
assert.ok(pauseCalls.includes("stale-child"));
|
|
cleanup();
|
|
});
|
|
|
|
test("soft pause checkpoint and source fingerprint persist before pause returns", async (t) => {
|
|
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: {
|
|
pauseTransfer: async () => ({
|
|
success: true,
|
|
checkpointBytes: 7,
|
|
sourceFingerprint: "sha256:pause-return",
|
|
lifecycleEpoch: 1,
|
|
}),
|
|
},
|
|
},
|
|
});
|
|
let persisted = "";
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write: (value) => { persisted = value; },
|
|
});
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("pause-durable", "transferring"),
|
|
transferredBytes: 7,
|
|
totalBytes: 10,
|
|
}]);
|
|
|
|
await store.pause("pause-durable");
|
|
|
|
const restored = createSftpTransferCenterStore({
|
|
read: () => persisted,
|
|
write: () => {},
|
|
});
|
|
const restoredTask = restored.getSnapshot().tasks[0];
|
|
assert.equal(restoredTask?.status, "interrupted");
|
|
assert.equal(restoredTask?.checkpointBytes, 7);
|
|
assert.equal(restoredTask?.sourceFingerprint, "sha256:pause-return");
|
|
});
|
|
|
|
test("publishOwner still allows explicit restart that resets progress to zero", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "transferring"),
|
|
transferredBytes: 500,
|
|
totalBytes: 1000,
|
|
}]);
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "queued"),
|
|
transferredBytes: 0,
|
|
checkpointBytes: 0,
|
|
totalBytes: 1000,
|
|
}]);
|
|
const task = store.getSnapshot().tasks.find((row) => row.id === "upload-1");
|
|
assert.equal(task?.status, "queued");
|
|
assert.equal(task?.transferredBytes, 0);
|
|
});
|
|
|
|
test("stale panel publishOwner cannot un-complete after background completed", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const endedAt = Date.now();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "transferring"),
|
|
transferredBytes: 900,
|
|
totalBytes: 1000,
|
|
startTime: endedAt - 1000,
|
|
}]);
|
|
store.ingestBackgroundEvent({
|
|
type: "completed",
|
|
transferId: "upload-1",
|
|
endedAt,
|
|
});
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "upload-1")?.status, "completed");
|
|
assert.equal(store.getSnapshot().activeCount, 0);
|
|
|
|
// Late panel snapshot still says transferring (React unmount / dual-writer race).
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "transferring"),
|
|
transferredBytes: 900,
|
|
totalBytes: 1000,
|
|
speed: 50,
|
|
startTime: endedAt - 1000,
|
|
}]);
|
|
|
|
const task = store.getSnapshot().tasks.find((row) => row.id === "upload-1");
|
|
assert.equal(task?.status, "completed");
|
|
assert.equal(task?.endTime, endedAt);
|
|
assert.equal(store.getSnapshot().activeCount, 0);
|
|
});
|
|
|
|
test("stale panel publishOwner cannot un-cancel after background cancelled", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const endedAt = Date.now();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "transferring"),
|
|
transferredBytes: 100,
|
|
totalBytes: 1000,
|
|
startTime: endedAt - 1000,
|
|
}]);
|
|
store.ingestBackgroundEvent({
|
|
type: "cancelled",
|
|
transferId: "upload-1",
|
|
endedAt,
|
|
});
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "upload-1")?.status, "cancelled");
|
|
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "transferring"),
|
|
transferredBytes: 150,
|
|
totalBytes: 1000,
|
|
startTime: endedAt - 1000,
|
|
}]);
|
|
|
|
const task = store.getSnapshot().tasks.find((row) => row.id === "upload-1");
|
|
assert.equal(task?.status, "cancelled");
|
|
assert.equal(task?.endTime, endedAt);
|
|
assert.equal(store.getSnapshot().activeCount, 0);
|
|
});
|
|
|
|
test("orphan pause latches process-global pause without a panel controller", async () => {
|
|
const {
|
|
isTransferPauseLatched,
|
|
resetTransferPauseLatchesForTests,
|
|
} = await import("./sftp/transferPauseLatch");
|
|
resetTransferPauseLatchesForTests();
|
|
const store = createSftpTransferCenterStore();
|
|
const started = Date.now();
|
|
store.publishOwner("gone-panel", [{
|
|
...makeTask("live-1", "transferring"),
|
|
transferredBytes: 10,
|
|
totalBytes: 100,
|
|
startTime: started,
|
|
}]);
|
|
// No registerOwner — simulates tab close / panel unmount.
|
|
// pauseTransfer is unavailable in pure unit tests → demote path still latches.
|
|
await store.pause("live-1");
|
|
assert.equal(isTransferPauseLatched("live-1"), true, "pause must latch even without a panel owner");
|
|
const task = store.getSnapshot().tasks.find((row) => row.id === "live-1");
|
|
assert.ok(task);
|
|
assert.ok(
|
|
task!.status === "paused" || task!.status === "interrupted" || task!.status === "pausing",
|
|
`expected paused-like status, got ${task!.status}`,
|
|
);
|
|
resetTransferPauseLatchesForTests();
|
|
});
|
|
|
|
test("orphan pause retries while the backend stream is still arming", async (t) => {
|
|
const pauseCalls: string[] = [];
|
|
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: {
|
|
pauseTransfer: async (id: string) => {
|
|
pauseCalls.push(id);
|
|
return pauseCalls.length === 1
|
|
? { success: false, reason: "This transfer cannot be paused yet" }
|
|
: { success: true, checkpointBytes: 42 };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("arming-upload", "transferring"),
|
|
transferredBytes: 20,
|
|
totalBytes: 100,
|
|
}]);
|
|
|
|
await store.pause("arming-upload");
|
|
|
|
assert.deepEqual(pauseCalls, ["arming-upload", "arming-upload"]);
|
|
const task = store.getSnapshot().tasks.find((candidate) => candidate.id === "arming-upload");
|
|
assert.equal(task?.status, "paused");
|
|
assert.equal(task?.checkpointBytes, 42);
|
|
assert.equal(task?.pauseUnavailableReason, undefined);
|
|
});
|
|
|
|
test("orphan compressed upload pause uses the compression job and reports deferred pause honestly", async (t) => {
|
|
const compressedCalls: string[] = [];
|
|
const streamCalls: string[] = [];
|
|
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: {
|
|
pauseCompressedUpload: async (id: string) => {
|
|
compressedCalls.push(id);
|
|
return { success: true, deferred: true };
|
|
},
|
|
pauseTransfer: async (id: string) => {
|
|
streamCalls.push(id);
|
|
return { success: true };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("compressed-1", "transferring"),
|
|
fileName: "photos (compressed)",
|
|
isDirectory: true,
|
|
phase: "extracting",
|
|
controlKind: "compressed-upload",
|
|
} as TransferTask]);
|
|
|
|
await store.pause("compressed-1");
|
|
|
|
assert.deepEqual(compressedCalls, ["compressed-1"]);
|
|
assert.deepEqual(streamCalls, []);
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "pausing");
|
|
assert.equal(store.getSnapshot().tasks[0]?.pauseUnavailableReason, undefined);
|
|
});
|
|
|
|
test("orphan compressed upload resume and cancel keep using the compression job", async (t) => {
|
|
const calls: string[] = [];
|
|
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: {
|
|
resumeCompressedUpload: async (id: string) => {
|
|
calls.push(`resume:${id}`);
|
|
return { success: true };
|
|
},
|
|
cancelCompressedUpload: async (id: string) => {
|
|
calls.push(`cancel:${id}`);
|
|
return { success: true };
|
|
},
|
|
resumeTransfer: async (id: string) => {
|
|
calls.push(`wrong-resume:${id}`);
|
|
return { success: true };
|
|
},
|
|
cancelTransfer: async (id: string) => {
|
|
calls.push(`wrong-cancel:${id}`);
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("compressed-2", "paused"),
|
|
fileName: "archive (compressed)",
|
|
isDirectory: true,
|
|
phase: "compressing",
|
|
controlKind: "compressed-upload",
|
|
} as TransferTask]);
|
|
|
|
await store.resume("compressed-2");
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "transferring");
|
|
await store.cancel("compressed-2");
|
|
|
|
assert.deepEqual(calls, ["resume:compressed-2", "cancel:compressed-2"]);
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "cancelled");
|
|
});
|
|
|
|
test("compressed upload completing during cancel IPC keeps its completed paint", async (t) => {
|
|
const calls: string[] = [];
|
|
const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
|
|
t.after(() => {
|
|
if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
|
|
else Reflect.deleteProperty(globalThis, "window");
|
|
});
|
|
|
|
let storeRef: ReturnType<typeof createSftpTransferCenterStore> | undefined;
|
|
Object.defineProperty(globalThis, "window", {
|
|
configurable: true,
|
|
value: {
|
|
netcatty: {
|
|
// Inactive-compression responses report success even after the upload
|
|
// already finished; the completion repaint must survive the cancel.
|
|
cancelCompressedUpload: async (id: string) => {
|
|
calls.push(`cancel:${id}`);
|
|
storeRef?.ingestBackgroundEvent({ type: "completed", transferId: id });
|
|
return { success: true };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
storeRef = store;
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("compressed-race", "transferring"),
|
|
fileName: "done (compressed)",
|
|
isDirectory: true,
|
|
phase: "compressing",
|
|
controlKind: "compressed-upload",
|
|
} as TransferTask]);
|
|
|
|
await store.cancel("compressed-race");
|
|
|
|
assert.deepEqual(calls, ["cancel:compressed-race"]);
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "completed");
|
|
});
|
|
|
|
test("orphan cancel marks process-global cancel so surviving walks stop", async (t) => {
|
|
const {
|
|
isTransferCancelledFlag,
|
|
resetTransferCancelLatchesForTests,
|
|
} = await import("./sftp/transferCancelLatch");
|
|
const {
|
|
registerTransferWalk,
|
|
resetTransferWalkRegistryForTests,
|
|
unregisterTransferWalk,
|
|
} = await import("./sftp/transferWalkRegistry");
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
registerTransferWalk("walk-1");
|
|
t.after(() => {
|
|
unregisterTransferWalk("walk-1");
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
const store = createSftpTransferCenterStore();
|
|
const started = Date.now();
|
|
store.publishOwner("gone-panel", [{
|
|
...makeTask("walk-1", "transferring"),
|
|
transferredBytes: 10,
|
|
totalBytes: 100,
|
|
startTime: started,
|
|
}]);
|
|
await store.cancel("walk-1");
|
|
assert.equal(isTransferCancelledFlag("walk-1"), true);
|
|
const resuming = store.resume("walk-1");
|
|
unregisterTransferWalk("walk-1");
|
|
await resuming;
|
|
assert.equal(isTransferCancelledFlag("walk-1"), false);
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "walk-1")?.status, "cancelled");
|
|
});
|
|
|
|
test("orphan resume releases process-global pause latch without a panel owner", async (t) => {
|
|
const {
|
|
isTransferPauseLatched,
|
|
latchTransferPause,
|
|
resetTransferPauseLatchesForTests,
|
|
} = await import("./sftp/transferPauseLatch");
|
|
const {
|
|
registerTransferWalk,
|
|
unregisterTransferWalk,
|
|
resetTransferWalkRegistryForTests,
|
|
} = await import("./sftp/transferWalkRegistry");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
// Live walk: soft-unlatch only (do not fall through to prepareAdopter).
|
|
registerTransferWalk("paused-1");
|
|
t.after(() => {
|
|
unregisterTransferWalk("paused-1");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
const store = createSftpTransferCenterStore();
|
|
const started = Date.now();
|
|
store.publishOwner("gone-panel", [{
|
|
...makeTask("paused-1", "paused"),
|
|
transferredBytes: 10,
|
|
totalBytes: 100,
|
|
checkpointBytes: 10,
|
|
startTime: started,
|
|
}]);
|
|
// Simulate a walk that outlived the panel and is still latched.
|
|
latchTransferPause("paused-1");
|
|
assert.equal(isTransferPauseLatched("paused-1"), true);
|
|
await store.resume("paused-1");
|
|
assert.equal(
|
|
isTransferPauseLatched("paused-1"),
|
|
false,
|
|
"resume without a panel owner must unlatch so surviving walks continue",
|
|
);
|
|
});
|
|
|
|
test("failed rows may reopen via publishOwner for same-id checkpoint resume", () => {
|
|
// failed is not sticky: resumeTransfer paints transferring with preserved checkpoint.
|
|
const store = createSftpTransferCenterStore();
|
|
const endedAt = Date.now();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "transferring"),
|
|
transferredBytes: 100,
|
|
totalBytes: 1000,
|
|
checkpointBytes: 100,
|
|
startTime: endedAt - 1000,
|
|
}]);
|
|
store.ingestBackgroundEvent({
|
|
type: "failed",
|
|
transferId: "upload-1",
|
|
endedAt,
|
|
error: "disk full",
|
|
});
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "upload-1")?.status, "failed");
|
|
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("upload-1", "transferring"),
|
|
transferredBytes: 100,
|
|
totalBytes: 1000,
|
|
checkpointBytes: 100,
|
|
startTime: endedAt - 1000,
|
|
}]);
|
|
const task = store.getSnapshot().tasks.find((row) => row.id === "upload-1");
|
|
assert.equal(task?.status, "transferring");
|
|
assert.equal(task?.checkpointBytes, 100);
|
|
});
|
|
|
|
test("clearing terminal history asks each owner to clean transfer artifacts", () => {
|
|
const dismissed: string[] = [];
|
|
const store = createSftpTransferCenterStore();
|
|
store.registerOwner("panel-a", {
|
|
pause: async () => {}, resume: async () => {}, cancel: async () => {}, retry: async () => {}, prioritize: async () => {},
|
|
dismiss: (id) => { dismissed.push(id); },
|
|
});
|
|
store.publishOwner("panel-a", [makeTask("done", "completed"), makeTask("failed", "failed")]);
|
|
|
|
store.clearTerminal("completed");
|
|
|
|
assert.deepEqual(dismissed, ["done"]);
|
|
assert.deepEqual(store.getSnapshot().tasks.map((task) => task.id), ["failed"]);
|
|
});
|
|
|
|
test("history pruning passes removed task data to background cleanup after snapshot eviction", () => {
|
|
let removedTask: TransferTask | undefined;
|
|
const store = createSftpTransferCenterStore();
|
|
store.registerOwner("background-agent", {
|
|
pause: async () => {},
|
|
resume: async () => {},
|
|
cancel: async () => {},
|
|
retry: async () => {},
|
|
prioritize: async () => {},
|
|
dismiss: (_taskId: string, task?: TransferTask) => {
|
|
removedTask = task;
|
|
},
|
|
});
|
|
const now = Date.now();
|
|
store.publishOwner("background-agent", Array.from({ length: 201 }, (_, index) => ({
|
|
...makeTask(`background-history-${index}`, "failed"),
|
|
startTime: now - index,
|
|
endTime: now - index,
|
|
stagedTargetPath: `/target/.background-history-${index}.part`,
|
|
})));
|
|
|
|
assert.equal(store.getSnapshot().tasks.length, 200);
|
|
assert.equal(removedTask?.id, "background-history-200");
|
|
assert.equal(removedTask?.stagedTargetPath, "/target/.background-history-200.part");
|
|
assert.equal(store.getSnapshot().tasks.some((task) => task.id === removedTask?.id), false);
|
|
});
|
|
|
|
test("failed reauthentication leaves a paused transfer requiring attention with the failure reason", async (t) => {
|
|
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: {
|
|
dispatchEvent(event: CustomEvent<{ reportFailure?: (error: string) => void }>) {
|
|
event.detail.reportFailure?.("Authentication failed");
|
|
return true;
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
// Original panel is gone — resume must open/authenticate a new one.
|
|
// A preparer is present but adoption never becomes ready because auth fails.
|
|
store.registerOwner("visible-preparer", {
|
|
pause: async () => {}, resume: async () => {}, cancel: async () => {}, retry: async () => {}, prioritize: async () => {},
|
|
dismiss: () => {},
|
|
canAdopt: () => false,
|
|
canPrepareAdoption: true,
|
|
adopt: async () => {},
|
|
});
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("paused", "paused"),
|
|
sourceConnectionId: "closed",
|
|
sourceHostId: "host-a",
|
|
}]);
|
|
|
|
await store.resume("paused");
|
|
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "attention");
|
|
assert.equal(store.getSnapshot().tasks[0]?.error, "Authentication failed");
|
|
});
|
|
|
|
test("background events do not resurrect a cancelled agent transfer", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.ingestBackgroundEvent({
|
|
type: "queued",
|
|
transferId: "agent-1",
|
|
direction: "download",
|
|
sourcePath: "/r/a",
|
|
targetPath: "/l/a",
|
|
startedAt: Date.now(),
|
|
});
|
|
store.ingestBackgroundEvent({ type: "cancelled", transferId: "agent-1", endedAt: Date.now() });
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "cancelled");
|
|
|
|
store.ingestBackgroundEvent({ type: "started", transferId: "agent-1" });
|
|
store.ingestBackgroundEvent({ type: "progress", transferId: "agent-1", transferred: 50, totalBytes: 100, speed: 1 });
|
|
store.ingestBackgroundEvent({ type: "completed", transferId: "agent-1", endedAt: Date.now() });
|
|
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "cancelled");
|
|
});
|
|
|
|
test("background lifecycle events keep directory children nested under their parent", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("terminal:folder", [{
|
|
...makeTask("folder-root", "transferring"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
totalBytes: 2,
|
|
}]);
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "started",
|
|
transferId: "folder-child",
|
|
parentTaskId: "folder-root",
|
|
fileName: "nested.txt",
|
|
sourcePath: "/local/nested.txt",
|
|
targetPath: "/remote/nested.txt",
|
|
direction: "upload",
|
|
totalBytes: 12,
|
|
});
|
|
|
|
const snapshot = store.getSnapshot().tasks;
|
|
const child = snapshot.find((task) => task.id === "folder-child");
|
|
assert.equal(child?.parentTaskId, "folder-root");
|
|
assert.deepEqual(
|
|
snapshot.filter((task) => !task.parentTaskId).map((task) => task.id),
|
|
["folder-root"],
|
|
"a directory child must never reappear as a top-level background task",
|
|
);
|
|
});
|
|
|
|
test("orphaned resume prefers a dedicated SFTP session without a panel owner", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("dedicated", "interrupted"),
|
|
direction: "download",
|
|
sourceHostId: "host-a",
|
|
sourceHostLabel: "CI-Build-01",
|
|
targetConnectionId: "local",
|
|
checkpointBytes: 100,
|
|
reconnectRequired: true,
|
|
}]);
|
|
|
|
let sawTaskId = "";
|
|
store.setDedicatedResumeHandler(async (task) => {
|
|
sawTaskId = task.id;
|
|
store.patchTask(task.id, {
|
|
status: "transferring",
|
|
transferredBytes: 100,
|
|
speed: 10,
|
|
});
|
|
return { success: true };
|
|
});
|
|
|
|
await store.resume("dedicated");
|
|
|
|
assert.equal(sawTaskId, "dedicated");
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "completed");
|
|
assert.equal(store.getSnapshot().tasks[0]?.reconnectRequired, false);
|
|
});
|
|
|
|
test("dedicated server-to-server resume failure without a panel owner stays recoverable", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("dedicated-resume", [{
|
|
...makeTask("dedicated-s2s", "interrupted"),
|
|
direction: "remote-to-remote",
|
|
sourceHostId: "host-a",
|
|
targetHostId: "host-b",
|
|
reconnectRequired: true,
|
|
}]);
|
|
store.setDedicatedResumeHandler(async () => ({
|
|
success: false,
|
|
error: "Open the SFTP panel to reconnect both hosts",
|
|
}));
|
|
|
|
await store.resume("dedicated-s2s");
|
|
|
|
const task = store.getSnapshot().tasks.find((candidate) => candidate.id === "dedicated-s2s");
|
|
assert.equal(task?.status, "attention");
|
|
assert.equal(task?.ownerId, "dedicated-resume");
|
|
assert.equal(task?.reconnectRequired, true);
|
|
});
|
|
|
|
test("force-quit continue skips dead soft-resume and uses dedicated handler", async (t) => {
|
|
const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
|
|
t.after(() => {
|
|
if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
|
|
else Reflect.deleteProperty(globalThis, "window");
|
|
});
|
|
let softResumeCalls = 0;
|
|
Object.defineProperty(globalThis, "window", {
|
|
configurable: true,
|
|
value: {
|
|
netcatty: {
|
|
clearPendingTransferCancel: async () => ({ success: true }),
|
|
resumeTransfer: async () => {
|
|
softResumeCalls += 1;
|
|
return { success: true }; // would be wrong to honor after force-quit
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("after-quit", "interrupted"),
|
|
direction: "upload",
|
|
sourceConnectionId: "local",
|
|
targetHostId: "host-a",
|
|
targetHostLabel: "box-a",
|
|
checkpointBytes: 20,
|
|
transferredBytes: 20,
|
|
totalBytes: 100,
|
|
reconnectRequired: true,
|
|
}]);
|
|
|
|
let sawDedicated = false;
|
|
store.setDedicatedResumeHandler(async (task) => {
|
|
sawDedicated = true;
|
|
store.patchTask(task.id, {
|
|
status: "transferring",
|
|
transferredBytes: 40,
|
|
checkpointBytes: 40,
|
|
reconnectRequired: false,
|
|
ownerId: "dedicated-resume",
|
|
});
|
|
return { success: true };
|
|
});
|
|
|
|
await store.resume("after-quit");
|
|
assert.equal(softResumeCalls, 0, "must not soft-resume a dead post-quit transfer");
|
|
assert.equal(sawDedicated, true);
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "completed");
|
|
assert.equal(store.getSnapshot().tasks[0]?.ownerId, "dedicated-resume");
|
|
});
|
|
|
|
test("restart resume waits for the dedicated handler to become ready and keeps progress live", async (t) => {
|
|
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: {
|
|
clearPendingTransferCancel: async () => ({ success: true }),
|
|
resumeTransfer: async () => ({ success: false, reason: "Transfer is no longer active" }),
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("startup-race", "interrupted"),
|
|
direction: "upload",
|
|
sourceConnectionId: "local",
|
|
targetHostId: "host-a",
|
|
targetHostLabel: "box-a",
|
|
checkpointBytes: 20,
|
|
transferredBytes: 20,
|
|
totalBytes: 100,
|
|
reconnectRequired: true,
|
|
}]);
|
|
|
|
let releaseTransfer!: () => void;
|
|
const transferFinished = new Promise<void>((resolve) => { releaseTransfer = resolve; });
|
|
let handlerStarted!: () => void;
|
|
const sawHandlerStart = new Promise<void>((resolve) => { handlerStarted = resolve; });
|
|
|
|
const resume = store.resume("startup-race");
|
|
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "pending");
|
|
|
|
store.setDedicatedResumeHandler(async (task) => {
|
|
store.patchTask(task.id, {
|
|
status: "transferring",
|
|
transferredBytes: 35,
|
|
checkpointBytes: 35,
|
|
reconnectRequired: false,
|
|
});
|
|
handlerStarted();
|
|
await transferFinished;
|
|
return { success: true };
|
|
});
|
|
|
|
await sawHandlerStart;
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "transferring");
|
|
assert.equal(store.getSnapshot().tasks[0]?.transferredBytes, 35);
|
|
|
|
releaseTransfer();
|
|
await resume;
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "completed");
|
|
});
|
|
|
|
test("directory resume uses dedicated handler and rehomes children", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [
|
|
{
|
|
...makeTask("dir-parent", "interrupted"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
direction: "download",
|
|
sourceHostId: "host-a",
|
|
sourceHostLabel: "CI-Build-01",
|
|
targetConnectionId: "local",
|
|
totalBytes: 2,
|
|
transferredBytes: 1,
|
|
reconnectRequired: true,
|
|
},
|
|
{
|
|
...makeTask("dir-child-done", "completed"),
|
|
parentTaskId: "dir-parent",
|
|
sourcePath: "/r/a",
|
|
targetPath: "/l/a",
|
|
},
|
|
{
|
|
...makeTask("dir-child-open", "interrupted"),
|
|
parentTaskId: "dir-parent",
|
|
sourcePath: "/r/b",
|
|
targetPath: "/l/b",
|
|
checkpointBytes: 50,
|
|
reconnectRequired: true,
|
|
},
|
|
]);
|
|
|
|
let sawDirectory = false;
|
|
store.setDedicatedResumeHandler(async (task) => {
|
|
sawDirectory = !!task.isDirectory;
|
|
store.upsertTasks([{
|
|
...makeTask("dir-child-open", "completed"),
|
|
parentTaskId: "dir-parent",
|
|
ownerId: "dedicated-resume",
|
|
sourcePath: "/r/b",
|
|
targetPath: "/l/b",
|
|
}]);
|
|
return { success: true };
|
|
});
|
|
|
|
await store.resume("dir-parent");
|
|
|
|
assert.equal(sawDirectory, true);
|
|
const snapshot = store.getSnapshot().tasks;
|
|
const parent = snapshot.find((task) => task.id === "dir-parent");
|
|
const children = snapshot.filter((task) => task.parentTaskId === "dir-parent");
|
|
assert.equal(parent?.status, "completed");
|
|
assert.equal(parent?.ownerId, "dedicated-resume");
|
|
assert.equal(children.length, 0, "completed resume children stay compacted out of history");
|
|
assert.equal(parent?.directoryResumeCheckpoint?.completedEntries, 2);
|
|
});
|
|
|
|
test("upsertTasks refuses new children under a cancelled directory parent", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("dedicated-resume", [{
|
|
...makeTask("dir", "cancelled"),
|
|
isDirectory: true,
|
|
ownerId: "dedicated-resume",
|
|
}]);
|
|
store.upsertTasks([{
|
|
...makeTask("late-child", "transferring"),
|
|
parentTaskId: "dir",
|
|
ownerId: "dedicated-resume",
|
|
}]);
|
|
assert.equal(store.getSnapshot().tasks.some((task) => task.id === "late-child"), false);
|
|
});
|
|
|
|
test("pause on dedicated directory parent freezes unfinished children", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("dedicated-resume", [
|
|
{
|
|
...makeTask("dir", "transferring"),
|
|
isDirectory: true,
|
|
ownerId: "dedicated-resume",
|
|
direction: "download",
|
|
sourceHostId: "host-a",
|
|
targetConnectionId: "local",
|
|
totalBytes: 2,
|
|
transferredBytes: 0,
|
|
},
|
|
{
|
|
...makeTask("c1", "transferring"),
|
|
parentTaskId: "dir",
|
|
ownerId: "dedicated-resume",
|
|
},
|
|
]);
|
|
|
|
// No live bridge pause — directory soft-pause latches + paints paused without
|
|
// cancel demotion (cancel would kill a still-running dedicated walk).
|
|
await store.pause("dir");
|
|
|
|
const snapshot = store.getSnapshot().tasks;
|
|
assert.equal(snapshot.find((task) => task.id === "dir")?.status, "paused");
|
|
assert.equal(snapshot.find((task) => task.id === "c1")?.status, "paused");
|
|
});
|
|
|
|
test("dedicated directory resume after soft-pause winds down then startFresh (no dead transferring)", async (t) => {
|
|
const store = createSftpTransferCenterStore();
|
|
let resumeCalls = 0;
|
|
const cancelCalls: string[] = [];
|
|
// Models bridge cancel when the child is no longer in activeTransfers: the
|
|
// pendingCancel latch sticks until clearPendingTransferCancel runs.
|
|
const pendingCancel = new Set<string>();
|
|
const clearPendingCalls: string[] = [];
|
|
let firstRunStarted: (() => void) | null = null;
|
|
const firstRunBlocked = new Promise<void>((resolve) => { firstRunStarted = resolve; });
|
|
let releaseFirstRun: (() => void) | null = null;
|
|
const firstRunHold = new Promise<void>((resolve) => { releaseFirstRun = resolve; });
|
|
|
|
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: {
|
|
cancelTransfer: async (id: string) => {
|
|
cancelCalls.push(id);
|
|
// Sticky latch when not active (real bridge behavior for missing handle).
|
|
pendingCancel.add(id);
|
|
return { success: true };
|
|
},
|
|
clearPendingTransferCancel: async (id: string) => {
|
|
clearPendingCalls.push(id);
|
|
pendingCancel.delete(id);
|
|
return { success: true };
|
|
},
|
|
resumeTransfer: async () => ({ success: false, reason: "Transfer is no longer active" }),
|
|
pauseTransfer: async () => ({ success: true, checkpointBytes: 1 }),
|
|
},
|
|
},
|
|
});
|
|
|
|
store.publishOwner("dedicated-resume", [{
|
|
...makeTask("dir", "interrupted"),
|
|
isDirectory: true,
|
|
ownerId: "dedicated-resume",
|
|
direction: "download",
|
|
sourceHostId: "host-a",
|
|
targetConnectionId: "local",
|
|
totalBytes: 2,
|
|
transferredBytes: 0,
|
|
reconnectRequired: true,
|
|
}, {
|
|
...makeTask("c1", "interrupted"),
|
|
parentTaskId: "dir",
|
|
ownerId: "dedicated-resume",
|
|
reconnectRequired: true,
|
|
}]);
|
|
|
|
store.setDedicatedResumeHandler(async () => {
|
|
resumeCalls += 1;
|
|
if (resumeCalls === 1) {
|
|
// Leave reconnectRequired so pause is not skipped only after live transfer.
|
|
store.patchTask("dir", { status: "transferring", reconnectRequired: false });
|
|
store.upsertTasks([{
|
|
...makeTask("c1", "transferring"),
|
|
parentTaskId: "dir",
|
|
ownerId: "dedicated-resume",
|
|
reconnectRequired: false,
|
|
}]);
|
|
firstRunStarted?.();
|
|
await firstRunHold;
|
|
return { success: false, error: "Transfer cancelled" };
|
|
}
|
|
// startFresh reuses the same child transfer id — latch must be clear or
|
|
// startStreamTransfer would immediately cancel (production failure mode).
|
|
assert.equal(
|
|
pendingCancel.has("c1"),
|
|
false,
|
|
"child pendingCancel latch must be cleared before startFresh reuses c1",
|
|
);
|
|
assert.ok(clearPendingCalls.includes("c1"), "must call clearPendingTransferCancel for c1");
|
|
return { success: true };
|
|
});
|
|
|
|
// Start first dedicated run (held in resumeInvocations).
|
|
const first = store.resume("dir");
|
|
await firstRunBlocked;
|
|
assert.equal(store.getSnapshot().tasks.find((task) => task.id === "dir")?.status, "transferring");
|
|
|
|
// Soft-pause paints paused under dedicated-resume.
|
|
await store.pause("dir");
|
|
assert.equal(store.getSnapshot().tasks.find((task) => task.id === "dir")?.status, "paused");
|
|
|
|
// Resume must cancel soft-paused children, clear sticky latches, await wind-down, then startFresh.
|
|
const second = store.resume("dir");
|
|
// Allow the held first run to settle after cancel wind-down begins.
|
|
releaseFirstRun?.();
|
|
await second;
|
|
await first.catch(() => {});
|
|
|
|
assert.ok(cancelCalls.includes("c1"), "must cancel soft-paused children before startFresh");
|
|
assert.equal(resumeCalls, 2, "must startFresh after wind-down");
|
|
assert.equal(pendingCancel.has("c1"), false, "child latch must stay clear after startFresh");
|
|
assert.equal(store.getSnapshot().tasks.find((task) => task.id === "dir")?.status, "completed");
|
|
});
|
|
|
|
test("resume refuses when another active transfer already owns the same path", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [
|
|
{
|
|
...makeTask("live", "transferring"),
|
|
sourcePath: "/root/sing-box",
|
|
targetPath: "/Users/me/Desktop/sing-box",
|
|
fileName: "sing-box",
|
|
direction: "download",
|
|
sourceConnectionId: "remote-live",
|
|
targetConnectionId: "local",
|
|
},
|
|
{
|
|
...makeTask("stale", "interrupted"),
|
|
sourcePath: "/root/other",
|
|
targetPath: "/Users/me/Desktop/sing-box",
|
|
fileName: "sing-box",
|
|
direction: "download",
|
|
sourceConnectionId: "remote-stale",
|
|
targetConnectionId: "local",
|
|
reconnectRequired: true,
|
|
},
|
|
]);
|
|
store.setDedicatedResumeHandler(async () => {
|
|
throw new Error("dedicated resume must not run when path is busy");
|
|
});
|
|
|
|
await store.resume("stale");
|
|
|
|
const stale = store.getSnapshot().tasks.find((task) => task.id === "stale");
|
|
assert.equal(stale?.status, "attention");
|
|
assert.match(stale?.error ?? "", /already in progress/i);
|
|
});
|
|
|
|
test("orphan soft-resume with a live walk does not start dedicated resume", async (t) => {
|
|
const { registerTransferWalk, unregisterTransferWalk, resetTransferWalkRegistryForTests } =
|
|
await import("./sftp/transferWalkRegistry");
|
|
resetTransferWalkRegistryForTests();
|
|
registerTransferWalk("dir-alive");
|
|
t.after(() => {
|
|
unregisterTransferWalk("dir-alive");
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
|
|
const resumeCalls: string[] = [];
|
|
let dedicatedCalls = 0;
|
|
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: {
|
|
// Between files: no active child streams — bridge resume misses.
|
|
resumeTransfer: async (id: string) => {
|
|
resumeCalls.push(id);
|
|
return { success: false, reason: "Transfer is no longer active" };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.setDedicatedResumeHandler(async () => {
|
|
dedicatedCalls += 1;
|
|
return { success: false, error: "should not dedicated-resume a live walk" };
|
|
});
|
|
store.publishOwner("terminal:closed-tab", [{
|
|
...makeTask("dir-alive", "paused"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 3,
|
|
totalBytes: 12,
|
|
speed: 0,
|
|
}, {
|
|
...makeTask("child-done", "completed"),
|
|
parentTaskId: "dir-alive",
|
|
}]);
|
|
|
|
await store.resume("dir-alive");
|
|
|
|
assert.equal(dedicatedCalls, 0, "must not start a second dedicated walk while processTransfer is alive");
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "dir-alive")?.status, "transferring");
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "dir-alive")?.reconnectRequired, false);
|
|
});
|
|
|
|
test("async single-file soft-drain does not re-pause after immediate resume", async (t) => {
|
|
let resolveFilePause!: (value: { success: boolean; checkpointBytes?: number }) => void;
|
|
const filePauseGate = new Promise<{ success: boolean; checkpointBytes?: number }>((resolve) => {
|
|
resolveFilePause = resolve;
|
|
});
|
|
const resumeCalls: string[] = [];
|
|
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: {
|
|
pauseTransfer: async (id: string) => {
|
|
if (id === "file-slow") return filePauseGate;
|
|
return { success: true, checkpointBytes: 1 };
|
|
},
|
|
resumeTransfer: async (id: string) => {
|
|
resumeCalls.push(id);
|
|
return { success: true };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("gone-panel", [{
|
|
...makeTask("file-slow", "transferring"),
|
|
transferredBytes: 10,
|
|
totalBytes: 100,
|
|
checkpointBytes: 10,
|
|
}]);
|
|
|
|
// Pause returns after soft-drain await for single-file (not fire-and-forget).
|
|
// Hold the bridge pause so Resume can win mid-drain.
|
|
const pausePromise = store.pause("file-slow");
|
|
// Yield so pause paints pausing and enters soft-drain.
|
|
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "file-slow")?.status, "pausing");
|
|
|
|
await store.resume("file-slow");
|
|
// Soft-drain finally completes after resume.
|
|
resolveFilePause({ success: true, checkpointBytes: 20 });
|
|
await pausePromise;
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
|
|
const file = store.getSnapshot().tasks.find((row) => row.id === "file-slow");
|
|
assert.equal(file?.status, "transferring", "late single-file soft-drain must not re-paint paused");
|
|
assert.ok(resumeCalls.includes("file-slow"), "must resumeTransfer after superseded single-file pause");
|
|
const {
|
|
isTransferPauseLatched,
|
|
resetTransferPauseLatchesForTests,
|
|
} = await import("./sftp/transferPauseLatch");
|
|
assert.equal(isTransferPauseLatched("file-slow"), false, "latches must be clear after resume wins");
|
|
resetTransferPauseLatchesForTests();
|
|
});
|
|
|
|
test("async folder soft-drain does not re-pause after immediate resume", async (t) => {
|
|
let resolveChildPause!: (value: { success: boolean; checkpointBytes?: number }) => void;
|
|
const childPauseGate = new Promise<{ success: boolean; checkpointBytes?: number }>((resolve) => {
|
|
resolveChildPause = resolve;
|
|
});
|
|
const resumeCalls: string[] = [];
|
|
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: {
|
|
pauseTransfer: async (id: string) => {
|
|
if (id === "child-slow") return childPauseGate;
|
|
return { success: true, checkpointBytes: 1 };
|
|
},
|
|
resumeTransfer: async (id: string) => {
|
|
resumeCalls.push(id);
|
|
return { success: true };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("gone-panel", [
|
|
{
|
|
...makeTask("dir-race", "transferring"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
transferredBytes: 0,
|
|
totalBytes: 2,
|
|
},
|
|
{
|
|
...makeTask("child-slow", "transferring"),
|
|
parentTaskId: "dir-race",
|
|
transferredBytes: 10,
|
|
totalBytes: 100,
|
|
},
|
|
]);
|
|
|
|
// Pause returns immediately (async soft-drain).
|
|
await store.pause("dir-race");
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "dir-race")?.status, "paused");
|
|
|
|
// User hits resume before soft-drain finishes — full store resume (bumps epoch
|
|
// + releases latch tree), which is what the UI does.
|
|
await store.resume("dir-race");
|
|
assert.equal(store.getSnapshot().tasks.find((row) => row.id === "dir-race")?.status, "transferring");
|
|
// Soft-drain pause finally resolves after resume.
|
|
resolveChildPause({ success: true, checkpointBytes: 10 });
|
|
await new Promise((resolve) => setTimeout(resolve, 30));
|
|
|
|
const dir = store.getSnapshot().tasks.find((row) => row.id === "dir-race");
|
|
const child = store.getSnapshot().tasks.find((row) => row.id === "child-slow");
|
|
assert.equal(dir?.status, "transferring", "late soft-drain must not re-paint parent paused");
|
|
assert.equal(child?.status, "transferring", "late soft-drain must not re-paint child paused");
|
|
// Bridge pause that landed after resume must be undone.
|
|
assert.ok(resumeCalls.includes("child-slow"), "must resumeTransfer the child after superseded pause");
|
|
});
|
|
|
|
test("orphan directory pause stays latched even when some children hard-miss pause", async (t) => {
|
|
const pauseCalls: string[] = [];
|
|
const resumeCalls: string[] = [];
|
|
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: {
|
|
pauseTransfer: async (id: string) => {
|
|
pauseCalls.push(id);
|
|
if (id === "c-ok") return { success: true, checkpointBytes: 4 };
|
|
return { success: false, reason: "This transfer cannot be paused safely" };
|
|
},
|
|
resumeTransfer: async (id: string) => {
|
|
resumeCalls.push(id);
|
|
return { success: true };
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("dedicated-resume", [
|
|
{
|
|
...makeTask("dir", "transferring"),
|
|
isDirectory: true,
|
|
ownerId: "dedicated-resume",
|
|
direction: "download",
|
|
sourceHostId: "host-a",
|
|
targetConnectionId: "local",
|
|
totalBytes: 2,
|
|
transferredBytes: 0,
|
|
},
|
|
{
|
|
...makeTask("c-ok", "transferring"),
|
|
parentTaskId: "dir",
|
|
ownerId: "dedicated-resume",
|
|
},
|
|
{
|
|
...makeTask("c-fail", "transferring"),
|
|
parentTaskId: "dir",
|
|
ownerId: "dedicated-resume",
|
|
},
|
|
]);
|
|
|
|
await store.pause("dir");
|
|
|
|
// Folder pause is async: UI is paused immediately; soft-drain may still be running.
|
|
const dir = store.getSnapshot().tasks.find((task) => task.id === "dir");
|
|
assert.equal(dir?.status, "paused", "folder parent must paint paused without waiting on children");
|
|
assert.equal(store.getSnapshot().tasks.find((task) => task.id === "c-ok")?.status, "paused");
|
|
assert.equal(store.getSnapshot().tasks.find((task) => task.id === "c-fail")?.status, "paused");
|
|
// Soft-drain is fire-and-forget — give it a tick to hit the bridge.
|
|
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
assert.deepEqual(pauseCalls.sort(), ["c-fail", "c-ok"]);
|
|
// Latch-first: do not bridge-resume partial successes (that re-opened the queue).
|
|
assert.deepEqual(resumeCalls, []);
|
|
assert.equal(
|
|
store.getSnapshot().tasks.find((task) => task.id === "dir")?.status,
|
|
"paused",
|
|
"hard-miss soft-drain must not demote folder out of paused",
|
|
);
|
|
});
|
|
|
|
test("dedicated resume source-changed marks attention and can reset checkpoint", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("src-changed", "interrupted"),
|
|
direction: "download",
|
|
sourceHostId: "host-a",
|
|
targetConnectionId: "local",
|
|
checkpointBytes: 40,
|
|
transferredBytes: 40,
|
|
totalBytes: 100,
|
|
reconnectRequired: true,
|
|
}]);
|
|
|
|
store.setDedicatedResumeHandler(async () => ({
|
|
success: false,
|
|
needsAttention: true,
|
|
resetCheckpoint: true,
|
|
error: "Source was modified while the transfer was paused",
|
|
}));
|
|
|
|
await store.resume("src-changed");
|
|
|
|
const task = store.getSnapshot().tasks[0];
|
|
assert.equal(task?.status, "attention");
|
|
assert.equal(task?.retryable, true);
|
|
assert.equal(task?.checkpointBytes, 0);
|
|
assert.equal(task?.transferredBytes, 0);
|
|
assert.match(task?.error ?? "", /modified/i);
|
|
});
|
|
|
|
test("reconnectRequired resume skips a retained panel that cannot adopt", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const ownerCalls: string[] = [];
|
|
store.registerOwner("stale-panel", {
|
|
pause: async () => {},
|
|
resume: async (id) => { ownerCalls.push(`resume:${id}`); },
|
|
cancel: async () => {},
|
|
retry: async () => {},
|
|
prioritize: async () => {},
|
|
dismiss: () => {},
|
|
canAdopt: () => false,
|
|
});
|
|
store.publishOwner("stale-panel", [{
|
|
...makeTask("stuck", "attention"),
|
|
direction: "download",
|
|
sourceHostId: "host-a",
|
|
sourceHostLabel: "CI-Build-01",
|
|
targetConnectionId: "local",
|
|
reconnectRequired: true,
|
|
error: "Reconnect the source and target before resuming",
|
|
}]);
|
|
|
|
let dedicated = false;
|
|
store.setDedicatedResumeHandler(async () => {
|
|
dedicated = true;
|
|
return { success: true };
|
|
});
|
|
|
|
await store.resume("stuck");
|
|
|
|
assert.equal(dedicated, true);
|
|
assert.deepEqual(ownerCalls, []);
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "completed");
|
|
});
|
|
|
|
test("resume marks orphaned tasks pending while reconnecting", async (t) => {
|
|
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: {
|
|
dispatchEvent: () => true,
|
|
netcatty: {
|
|
resumeTransfer: async () => ({ success: false }),
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("reconnect-me", "interrupted"),
|
|
sourceHostId: "host-a",
|
|
reconnectRequired: true,
|
|
}]);
|
|
|
|
const resumePromise = store.resume("reconnect-me");
|
|
// Status flips to pending before the long prepare wait finishes.
|
|
await new Promise((resolve) => setTimeout(resolve, 0));
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "pending");
|
|
assert.equal(store.getSnapshot().tasks[0]?.reconnectRequired, true);
|
|
|
|
// Unblock prepare loop by cancelling.
|
|
await store.cancel("reconnect-me");
|
|
await resumePromise;
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "cancelled");
|
|
});
|
|
|
|
test("first dedicated resume progress leaves reconnecting state while transfer keeps running", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("restart-resume", "interrupted"),
|
|
sourceHostId: "host-a",
|
|
checkpointBytes: 2,
|
|
transferredBytes: 2,
|
|
reconnectRequired: true,
|
|
}]);
|
|
|
|
let releaseResume!: () => void;
|
|
const resumeHeld = new Promise<void>((resolve) => {
|
|
releaseResume = resolve;
|
|
});
|
|
let publishProgress!: () => void;
|
|
const progressPublished = new Promise<void>((resolve) => {
|
|
publishProgress = resolve;
|
|
});
|
|
store.setDedicatedResumeHandler(async (task) => {
|
|
store.ingestBackgroundEvent({
|
|
type: "started",
|
|
transferId: task.id,
|
|
direction: "upload",
|
|
transferred: 2,
|
|
totalBytes: 10,
|
|
resumable: true,
|
|
});
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: task.id,
|
|
direction: "upload",
|
|
transferred: 4,
|
|
totalBytes: 10,
|
|
speed: 2,
|
|
checkpointBytes: 4,
|
|
lifecycleState: "transferring",
|
|
resumable: true,
|
|
});
|
|
publishProgress();
|
|
await resumeHeld;
|
|
return { success: true };
|
|
});
|
|
|
|
const resumePromise = store.resume("restart-resume");
|
|
await progressPublished;
|
|
try {
|
|
const live = store.getSnapshot().tasks[0];
|
|
assert.equal(live?.status, "transferring");
|
|
assert.equal(live?.transferredBytes, 4);
|
|
assert.equal(
|
|
live?.reconnectRequired,
|
|
false,
|
|
"real progress must replace the reconnect spinner with live pause controls",
|
|
);
|
|
} finally {
|
|
releaseResume();
|
|
await resumePromise;
|
|
}
|
|
});
|
|
|
|
test("resume waits for a transfer panel that becomes visible after the click", async (t) => {
|
|
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: { dispatchEvent: () => true },
|
|
});
|
|
|
|
const calls: string[] = [];
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("waiting", "paused"),
|
|
sourceHostId: "host-a",
|
|
}]);
|
|
|
|
const resumePromise = store.resume("waiting");
|
|
setTimeout(() => {
|
|
store.registerOwner("visible-panel", {
|
|
pause: async () => {},
|
|
resume: async (id) => { calls.push(`resume:${id}`); },
|
|
cancel: async () => {}, retry: async () => {}, prioritize: async () => {}, dismiss: () => {},
|
|
canAdopt: () => true,
|
|
canPrepareAdoption: true,
|
|
adopt: async (task) => { calls.push(`adopt:${task.id}`); },
|
|
});
|
|
}, 10);
|
|
|
|
await resumePromise;
|
|
|
|
assert.deepEqual(calls, ["adopt:waiting"]);
|
|
assert.equal(store.getSnapshot().tasks[0]?.ownerId, "visible-panel");
|
|
});
|
|
|
|
test("an interrupted task without its old controller can still be cancelled", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [makeTask("interrupted", "interrupted")]);
|
|
|
|
await store.cancel("interrupted");
|
|
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "cancelled");
|
|
});
|
|
|
|
test("orphan cancel keeps failed work visible and leaves completed children alone", async (t) => {
|
|
const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
|
|
t.after(() => {
|
|
if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
|
|
else Reflect.deleteProperty(globalThis, "window");
|
|
});
|
|
const cancelledIds: string[] = [];
|
|
Object.defineProperty(globalThis, "window", {
|
|
configurable: true,
|
|
value: { netcatty: {
|
|
cancelTransfer: async (id: string) => {
|
|
cancelledIds.push(id);
|
|
return { success: id !== "unfinished" };
|
|
},
|
|
} },
|
|
});
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [
|
|
{ ...makeTask("directory", "paused"), isDirectory: true },
|
|
{ ...makeTask("finished", "completed"), parentTaskId: "directory" },
|
|
{ ...makeTask("unfinished", "queued"), parentTaskId: "directory" },
|
|
]);
|
|
const finishedBeforeCancel = store.getTask("finished");
|
|
|
|
await store.cancel("directory");
|
|
|
|
assert.deepEqual(cancelledIds, ["directory", "unfinished"]);
|
|
assert.equal(store.getTask("finished")?.status, finishedBeforeCancel?.status);
|
|
assert.equal(store.getTask("unfinished")?.status, "attention");
|
|
assert.equal(store.getTask("directory")?.status, "attention");
|
|
assert.match(store.getTask("directory")?.error ?? "", /Could not cancel/);
|
|
});
|
|
|
|
test("concurrent resume clicks adopt a task only once", async () => {
|
|
let adoptCount = 0;
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("resume-once", "interrupted"),
|
|
sourceHostId: "host-a",
|
|
}]);
|
|
store.registerOwner("visible-panel", {
|
|
pause: async () => {}, resume: async () => {}, cancel: async () => {}, retry: async () => {}, prioritize: async () => {}, dismiss: () => {},
|
|
canAdopt: () => true,
|
|
adopt: async () => { adoptCount += 1; },
|
|
});
|
|
|
|
await Promise.all([store.resume("resume-once"), store.resume("resume-once")]);
|
|
|
|
assert.equal(adoptCount, 1);
|
|
});
|
|
|
|
test("cancelling while resume waits prevents later adoption", async (t) => {
|
|
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: { dispatchEvent: () => true },
|
|
});
|
|
|
|
let adoptCount = 0;
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("closed-panel", [{
|
|
...makeTask("cancel-waiting", "paused"),
|
|
sourceHostId: "host-a",
|
|
}]);
|
|
|
|
const resumePromise = store.resume("cancel-waiting");
|
|
setTimeout(() => { void store.cancel("cancel-waiting"); }, 10);
|
|
setTimeout(() => {
|
|
store.registerOwner("visible-panel", {
|
|
pause: async () => {}, resume: async () => {}, cancel: async () => {}, retry: async () => {}, prioritize: async () => {}, dismiss: () => {},
|
|
canAdopt: () => true,
|
|
canPrepareAdoption: true,
|
|
adopt: async () => { adoptCount += 1; },
|
|
});
|
|
}, 20);
|
|
|
|
await resumePromise;
|
|
|
|
assert.equal(adoptCount, 0);
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "cancelled");
|
|
});
|
|
|
|
test("patchTask freezes transferredBytes while paused or latched (runtime soft-drain)", async () => {
|
|
const {
|
|
latchTransferPause,
|
|
releaseTransferPause,
|
|
resetTransferPauseLatchesForTests,
|
|
} = await import("./sftp/transferPauseLatch");
|
|
resetTransferPauseLatchesForTests();
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("live", "transferring"),
|
|
transferredBytes: 1000,
|
|
totalBytes: 10_000,
|
|
checkpointBytes: 1000,
|
|
lifecycleEpoch: 1,
|
|
}]);
|
|
// User pause paints + latches (soft-control).
|
|
latchTransferPause("live");
|
|
store.patchTask("live", { status: "paused", speed: 0, lifecycleEpoch: 2 });
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "paused");
|
|
|
|
// Soft-drain still reports higher bytes via runtime writer.
|
|
store.patchTask("live", {
|
|
transferredBytes: 9000,
|
|
speed: 50,
|
|
checkpointBytes: 9000,
|
|
});
|
|
const afterDrain = store.getSnapshot().tasks[0];
|
|
assert.equal(afterDrain?.status, "paused");
|
|
assert.equal(afterDrain?.transferredBytes, 1000, "visible bar must freeze after pause");
|
|
assert.equal(afterDrain?.speed, 0);
|
|
assert.equal(afterDrain?.checkpointBytes, 9000, "durable checkpoint may still advance");
|
|
|
|
releaseTransferPause("live");
|
|
// Explicit resume with epoch may reopen and accept progress.
|
|
store.patchTask("live", {
|
|
status: "transferring",
|
|
lifecycleEpoch: 3,
|
|
transferredBytes: 1500,
|
|
speed: 10,
|
|
});
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "transferring");
|
|
assert.equal(store.getSnapshot().tasks[0]?.transferredBytes, 1500);
|
|
resetTransferPauseLatchesForTests();
|
|
});
|
|
|
|
test("unchanged sourceFingerprint on progress patches coalesces listener notifies", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("fp-live", "transferring"),
|
|
transferredBytes: 0,
|
|
totalBytes: 100 * 1024 * 1024,
|
|
sourceFingerprint: "sha256:stable",
|
|
}]);
|
|
let progressNotifies = 0;
|
|
let lifecycleNotifies = 0;
|
|
store.subscribe(() => {
|
|
lifecycleNotifies += 1;
|
|
});
|
|
store.subscribeProgress(() => {
|
|
progressNotifies += 1;
|
|
});
|
|
for (let i = 1; i <= 80; i += 1) {
|
|
store.patchTask("fp-live", {
|
|
transferredBytes: i * 1024 * 1024,
|
|
speed: 40 * 1024 * 1024,
|
|
status: "transferring",
|
|
// Progress IPC always re-sends the current fingerprint once computed.
|
|
sourceFingerprint: "sha256:stable",
|
|
});
|
|
}
|
|
// All 80 patches are sync; rAF/setTimeout(16) should collapse to one notify.
|
|
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
assert.equal(lifecycleNotifies, 0, "pure progress must not wake lifecycle subscribers");
|
|
assert.ok(
|
|
progressNotifies <= 3,
|
|
`unchanged fingerprint must not bypass progress coalesce (notifies=${progressNotifies})`,
|
|
);
|
|
assert.equal(store.getSnapshot().tasks[0]?.transferredBytes, 80 * 1024 * 1024);
|
|
|
|
progressNotifies = 0;
|
|
lifecycleNotifies = 0;
|
|
store.patchTask("fp-live", {
|
|
transferredBytes: 81 * 1024 * 1024,
|
|
sourceFingerprint: "sha256:rotated",
|
|
});
|
|
assert.equal(lifecycleNotifies, 1, "a real fingerprint change still notifies lifecycle immediately");
|
|
assert.equal(store.getSnapshot().tasks[0]?.sourceFingerprint, "sha256:rotated");
|
|
});
|
|
|
|
test("pure progress patches do not synchronously persist transfer history", async () => {
|
|
let writes = 0;
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write: () => { writes += 1; },
|
|
});
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("no-progress-persist", "transferring"),
|
|
transferredBytes: 0,
|
|
totalBytes: 100,
|
|
}]);
|
|
const writesAfterPublish = writes;
|
|
for (let i = 1; i <= 40; i += 1) {
|
|
store.patchTask("no-progress-persist", {
|
|
transferredBytes: i,
|
|
speed: 10,
|
|
status: "transferring",
|
|
});
|
|
}
|
|
await new Promise((resolve) => setTimeout(resolve, 700));
|
|
assert.equal(
|
|
writes,
|
|
writesAfterPublish,
|
|
"byte progress must not touch localStorage (spinner hitch / CPU)",
|
|
);
|
|
assert.equal(store.getSnapshot().tasks[0]?.transferredBytes, 40);
|
|
});
|
|
|
|
test("publishOwner while latched does not raise transferredBytes after pause", async () => {
|
|
const {
|
|
latchTransferPauseTree,
|
|
resetTransferPauseLatchesForTests,
|
|
} = await import("./sftp/transferPauseLatch");
|
|
resetTransferPauseLatchesForTests();
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("file", "transferring"),
|
|
transferredBytes: 5000,
|
|
totalBytes: 20_000,
|
|
lifecycleEpoch: 1,
|
|
}]);
|
|
latchTransferPauseTree("file", []);
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("file", "paused"),
|
|
transferredBytes: 5000,
|
|
totalBytes: 20_000,
|
|
speed: 0,
|
|
lifecycleEpoch: 2,
|
|
}]);
|
|
// Soft-drain panel snapshot tries to push the bar.
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("file", "paused"),
|
|
transferredBytes: 18_000,
|
|
totalBytes: 20_000,
|
|
speed: 0,
|
|
lifecycleEpoch: 2,
|
|
}]);
|
|
assert.equal(
|
|
store.getSnapshot().tasks[0]?.transferredBytes,
|
|
5000,
|
|
"latched paused row must not take soft-drain higher bytes from panel",
|
|
);
|
|
resetTransferPauseLatchesForTests();
|
|
});
|
|
|
|
test("soft-resume transient bridge miss stays paused without dedicated rehome", async (t) => {
|
|
// Regression: pause→resume was flipping "reconnecting" then stuck paused, and
|
|
// the SFTP panel queue lost the row because soft-fail always hard-reconnected.
|
|
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: {
|
|
resumeTransfer: async () => ({
|
|
success: false,
|
|
reason: "The current file is still finishing. Try resume again.",
|
|
}),
|
|
clearPendingTransferCancel: async () => {},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
let dedicated = 0;
|
|
store.setDedicatedResumeHandler(async () => {
|
|
dedicated += 1;
|
|
return { success: false, error: "should not hard reconnect" };
|
|
});
|
|
store.registerOwner("panel-a", {
|
|
pause: async () => {},
|
|
resume: async () => {},
|
|
cancel: async () => {},
|
|
retry: async () => {},
|
|
prioritize: async () => {},
|
|
dismiss: () => {},
|
|
ownsTask: () => true,
|
|
});
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("live-soft-miss", "paused"),
|
|
sourceHostId: "host-a",
|
|
transferredBytes: 2_000_000,
|
|
checkpointBytes: 2_000_000,
|
|
ownerId: "panel-a",
|
|
}]);
|
|
|
|
await store.resume("live-soft-miss");
|
|
const row = store.getSnapshot().tasks.find((task) => task.id === "live-soft-miss");
|
|
assert.equal(dedicated, 0, "must not rehome to dedicated-resume for transient soft-miss");
|
|
assert.equal(row?.status, "paused");
|
|
assert.equal(row?.ownerId, "panel-a", "panel queue must keep the task");
|
|
assert.equal(row?.reconnectRequired, false);
|
|
assert.match(row?.error || "", /still finishing/i);
|
|
});
|
|
|
|
test("soft-resume failure demotes and uses dedicated handler even with a live owner", async (t) => {
|
|
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: {
|
|
resumeTransfer: async () => ({ success: false, reason: "not active" }),
|
|
clearPendingTransferCancel: async () => {},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
let dedicated = 0;
|
|
store.setDedicatedResumeHandler(async (task) => {
|
|
dedicated += 1;
|
|
store.patchTask(task.id, {
|
|
status: "completed",
|
|
ownerId: "dedicated-resume",
|
|
transferredBytes: task.totalBytes || 10,
|
|
reconnectRequired: false,
|
|
});
|
|
return { success: true };
|
|
});
|
|
// Live owner present but cannot soft-resume a dead stream.
|
|
store.registerOwner("panel-a", {
|
|
pause: async () => {},
|
|
resume: async () => {},
|
|
cancel: async () => {},
|
|
retry: async () => {},
|
|
prioritize: async () => {},
|
|
dismiss: () => {},
|
|
ownsTask: () => true,
|
|
canAdopt: () => false,
|
|
});
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("dead-soft", "paused"),
|
|
sourceHostId: "host-a",
|
|
transferredBytes: 4,
|
|
checkpointBytes: 4,
|
|
}]);
|
|
|
|
await store.resume("dead-soft");
|
|
assert.equal(dedicated, 1, "must not silent-return when soft fails with owner present");
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "completed");
|
|
});
|
|
|
|
test("single-file soft-resume bridge-fail with live walk goes hard reconnect (not stuck transferring)", async (t) => {
|
|
const {
|
|
registerTransferWalk,
|
|
unregisterTransferWalk,
|
|
resetTransferWalkRegistryForTests,
|
|
} = await import("./sftp/transferWalkRegistry");
|
|
const { resetTransferPauseLatchesForTests } = await import("./sftp/transferPauseLatch");
|
|
resetTransferWalkRegistryForTests();
|
|
resetTransferPauseLatchesForTests();
|
|
registerTransferWalk("stuck-file");
|
|
t.after(() => {
|
|
unregisterTransferWalk("stuck-file");
|
|
resetTransferWalkRegistryForTests();
|
|
resetTransferPauseLatchesForTests();
|
|
});
|
|
|
|
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: {
|
|
pauseTransfer: async () => ({ success: true, checkpointBytes: 10, lifecycleEpoch: 1 }),
|
|
resumeTransfer: async () => ({ success: false, reason: "not active" }),
|
|
clearPendingTransferCancel: async () => {},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
let dedicated = 0;
|
|
store.setDedicatedResumeHandler(async (task) => {
|
|
dedicated += 1;
|
|
store.patchTask(task.id, {
|
|
status: "completed",
|
|
ownerId: "dedicated-resume",
|
|
transferredBytes: 100,
|
|
reconnectRequired: false,
|
|
});
|
|
return { success: true };
|
|
});
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("stuck-file", "transferring"),
|
|
sourceHostId: "host-a",
|
|
transferredBytes: 10,
|
|
totalBytes: 100,
|
|
}]);
|
|
|
|
await store.pause("stuck-file");
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "paused");
|
|
|
|
await store.resume("stuck-file");
|
|
assert.equal(dedicated, 1, "hard reconnect must run when soft bridge resume fails");
|
|
const row = store.getSnapshot().tasks[0];
|
|
assert.equal(row?.status, "completed");
|
|
assert.notEqual(row?.status, "transferring");
|
|
});
|
|
|
|
test("ingestBackgroundEvent progress advances after soft pause then soft resume (bridge epochs)", async (t) => {
|
|
const { resetTransferPauseLatchesForTests } = await import("./sftp/transferPauseLatch");
|
|
const { resetTransferControlEpochsForTests } = await import("./sftp/transferControlEpoch");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
|
|
let bridgeEpoch = 0;
|
|
const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
|
|
t.after(() => {
|
|
if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
|
|
else Reflect.deleteProperty(globalThis, "window");
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
});
|
|
Object.defineProperty(globalThis, "window", {
|
|
configurable: true,
|
|
value: {
|
|
netcatty: {
|
|
pauseTransfer: async () => {
|
|
// First pause bumps; second already-paused returns same epoch (bridge behavior).
|
|
if (bridgeEpoch === 0) bridgeEpoch = 1;
|
|
return { success: true, checkpointBytes: 10, lifecycleEpoch: bridgeEpoch };
|
|
},
|
|
resumeTransfer: async () => {
|
|
bridgeEpoch += 1;
|
|
return { success: true, lifecycleEpoch: bridgeEpoch };
|
|
},
|
|
clearPendingTransferCancel: async () => {},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [{
|
|
...makeTask("prog", "transferring"),
|
|
transferredBytes: 10,
|
|
totalBytes: 100,
|
|
speed: 5,
|
|
}]);
|
|
|
|
// Double soft-pause then resume (reproduces control-plane vs bridge epoch skew).
|
|
await store.pause("prog");
|
|
await store.pause("prog");
|
|
await store.resume("prog");
|
|
|
|
const afterResume = store.getSnapshot().tasks.find((t) => t.id === "prog");
|
|
assert.equal(afterResume?.status, "transferring");
|
|
assert.equal(afterResume?.lifecycleEpoch, bridgeEpoch, "store must track bridge epoch after soft resume");
|
|
|
|
// Bridge-shaped progress at bridge epoch must advance the bar (not stale-dropped).
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "prog",
|
|
transferred: 70,
|
|
totalBytes: 100,
|
|
speed: 20,
|
|
lifecycleEpoch: bridgeEpoch,
|
|
lifecycleState: "transferring",
|
|
});
|
|
const afterProgress = store.getSnapshot().tasks.find((t) => t.id === "prog");
|
|
assert.equal(afterProgress?.transferredBytes, 70, "progress after soft resume must move the bar");
|
|
assert.equal(afterProgress?.status, "transferring");
|
|
assert.ok((afterProgress?.speed ?? 0) > 0);
|
|
});
|
|
|
|
test("directory soft resume then new/queued child progress at bridge epoch 0 advances (no dual-epoch freeze)", async (t) => {
|
|
const {
|
|
registerTransferWalk,
|
|
unregisterTransferWalk,
|
|
resetTransferWalkRegistryForTests,
|
|
} = await import("./sftp/transferWalkRegistry");
|
|
const { resetTransferPauseLatchesForTests } = await import("./sftp/transferPauseLatch");
|
|
const { resetTransferControlEpochsForTests } = await import("./sftp/transferControlEpoch");
|
|
resetTransferWalkRegistryForTests();
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
registerTransferWalk("dir-prog");
|
|
t.after(() => {
|
|
unregisterTransferWalk("dir-prog");
|
|
resetTransferWalkRegistryForTests();
|
|
resetTransferPauseLatchesForTests();
|
|
resetTransferControlEpochsForTests();
|
|
});
|
|
|
|
let liveEpoch = 0;
|
|
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: {
|
|
pauseTransfer: async (id: string) => {
|
|
if (id === "live-child") {
|
|
liveEpoch = Math.max(liveEpoch, 1);
|
|
return { success: true, checkpointBytes: 50, lifecycleEpoch: liveEpoch };
|
|
}
|
|
return { success: false, reason: "not active" };
|
|
},
|
|
resumeTransfer: async (id: string) => {
|
|
if (id === "live-child") {
|
|
liveEpoch += 1;
|
|
return { success: true, lifecycleEpoch: liveEpoch };
|
|
}
|
|
return { success: false, reason: "not active" };
|
|
},
|
|
clearPendingTransferCancel: async () => {},
|
|
},
|
|
},
|
|
});
|
|
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel-a", [
|
|
{
|
|
...makeTask("dir-prog", "transferring"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
totalBytes: 3,
|
|
transferredBytes: 1,
|
|
ownerId: "panel-a",
|
|
},
|
|
{
|
|
...makeTask("live-child", "transferring"),
|
|
parentTaskId: "dir-prog",
|
|
transferredBytes: 50,
|
|
totalBytes: 200,
|
|
ownerId: "panel-a",
|
|
},
|
|
{
|
|
...makeTask("queued-child", "queued"),
|
|
parentTaskId: "dir-prog",
|
|
transferredBytes: 0,
|
|
totalBytes: 100,
|
|
ownerId: "panel-a",
|
|
},
|
|
]);
|
|
|
|
await store.pause("dir-prog");
|
|
await store.resume("dir-prog");
|
|
|
|
const afterResume = store.getSnapshot().tasks;
|
|
assert.equal(afterResume.find((t) => t.id === "live-child")?.lifecycleEpoch, liveEpoch);
|
|
assert.equal(
|
|
afterResume.find((t) => t.id === "queued-child")?.lifecycleEpoch,
|
|
undefined,
|
|
"queued sibling must not inherit live-child resume epoch",
|
|
);
|
|
|
|
// Simulate next file arming at bridge epoch 0 (startStreamTransfer default).
|
|
store.upsertTasks([{
|
|
...makeTask("new-child", "transferring"),
|
|
parentTaskId: "dir-prog",
|
|
transferredBytes: 0,
|
|
totalBytes: 80,
|
|
lifecycleEpoch: undefined,
|
|
ownerId: "panel-a",
|
|
}]);
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "new-child",
|
|
transferred: 40,
|
|
totalBytes: 80,
|
|
speed: 12,
|
|
lifecycleEpoch: 0,
|
|
lifecycleState: "transferring",
|
|
});
|
|
const newChild = store.getSnapshot().tasks.find((t) => t.id === "new-child");
|
|
assert.equal(newChild?.transferredBytes, 40, "new child progress at bridge epoch 0 must advance");
|
|
assert.equal(newChild?.status, "transferring");
|
|
|
|
// Queued sibling also starts a stream at epoch 0 after resume.
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: "queued-child",
|
|
transferred: 25,
|
|
totalBytes: 100,
|
|
speed: 8,
|
|
lifecycleEpoch: 0,
|
|
lifecycleState: "transferring",
|
|
});
|
|
// Soft resume left queued status; progress with transferring lifecycle should open bar.
|
|
const queued = store.getSnapshot().tasks.find((t) => t.id === "queued-child");
|
|
assert.equal(queued?.transferredBytes, 25, "queued sibling progress at epoch 0 must not be stale-dropped");
|
|
});
|
|
|
|
test("large directory progress coalesces synchronous persistence work", async () => {
|
|
let writes = 0;
|
|
let writtenCharacters = 0;
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write(value) {
|
|
writes += 1;
|
|
writtenCharacters += value.length;
|
|
},
|
|
});
|
|
const parent = {
|
|
...makeTask("large-folder"),
|
|
isDirectory: true,
|
|
progressMode: "files" as const,
|
|
totalBytes: 2_000,
|
|
transferredBytes: 0,
|
|
};
|
|
let tasks: TransferTask[] = [
|
|
parent,
|
|
...Array.from({ length: 2_000 }, (_, index) => ({
|
|
...makeTask(`large-child-${index}`, index < 1_000 ? "completed" : "queued"),
|
|
parentTaskId: parent.id,
|
|
startTime: index + 2,
|
|
})),
|
|
];
|
|
|
|
store.publishOwner("panel-a", tasks);
|
|
const oneSnapshotCharacters = writtenCharacters;
|
|
for (let tick = 1; tick <= 24; tick += 1) {
|
|
tasks = tasks.map((task) => task.id === parent.id
|
|
? { ...task, transferredBytes: 1_000 + tick }
|
|
: task);
|
|
store.publishOwner("panel-a", tasks);
|
|
}
|
|
|
|
await new Promise((resolve) => setTimeout(resolve, 300));
|
|
assert.ok(writes <= 3, `expected at most 3 storage writes, got ${writes}`);
|
|
assert.ok(
|
|
writtenCharacters <= oneSnapshotCharacters * 3,
|
|
`expected bounded persistence volume, wrote ${writtenCharacters} characters for a ${oneSnapshotCharacters}-character snapshot`,
|
|
);
|
|
});
|
|
|
|
test("store keeps 50,000 completed directory files as one bounded persisted parent", () => {
|
|
let persisted = "";
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write(value) { persisted = value; },
|
|
});
|
|
const startedAt = Date.now();
|
|
const parent: TransferTask = {
|
|
...makeTask("bounded-directory"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
totalBytes: 50_000,
|
|
transferredBytes: 50_000,
|
|
};
|
|
store.publishOwner("panel-a", [
|
|
parent,
|
|
...Array.from({ length: 50_000 }, (_, index): TransferTask => ({
|
|
...makeTask(`bounded-child-${index}`, "completed"),
|
|
parentTaskId: parent.id,
|
|
sourcePath: `/source/file-${index.toString().padStart(5, "0")}`,
|
|
targetPath: `/target/file-${index.toString().padStart(5, "0")}`,
|
|
sourceLastModified: index + 1,
|
|
endTime: Date.now(),
|
|
})),
|
|
]);
|
|
|
|
const snapshot = store.getSnapshot();
|
|
const restored = createSftpTransferCenterStore({ read: () => persisted, write: () => {} });
|
|
assert.equal(snapshot.tasks.length, 1);
|
|
assert.equal(snapshot.tasks[0]?.directoryResumeCheckpoint?.completedEntries, 50_000);
|
|
assert.equal(restored.getSnapshot().tasks.length, 1);
|
|
assert.ok(persisted.length < 10_000, "localStorage payload must stay bounded");
|
|
assert.ok(Date.now() - startedAt < 5_000, "full store compaction should finish within 5 seconds");
|
|
});
|
|
|
|
test("legacy 50,000-file history restores cooperatively and converges to one persisted row", async () => {
|
|
const now = Date.now();
|
|
const parent: TransferTask = {
|
|
...makeTask("legacy-bounded-directory", "paused"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
totalBytes: 50_000,
|
|
transferredBytes: 50_000,
|
|
};
|
|
const legacyRaw = JSON.stringify({
|
|
version: 1,
|
|
tasks: [
|
|
parent,
|
|
...Array.from({ length: 50_000 }, (_, index): TransferTask => ({
|
|
...makeTask(`legacy-bounded-child-${index}`, "completed"),
|
|
parentTaskId: parent.id,
|
|
sourcePath: `/source/file-${index.toString().padStart(5, "0")}`,
|
|
targetPath: `/target/file-${index.toString().padStart(5, "0")}`,
|
|
sourceLastModified: index + 1,
|
|
endTime: now,
|
|
})),
|
|
],
|
|
});
|
|
let persisted = legacyRaw;
|
|
const writes: string[] = [];
|
|
let eventLoopHeartbeats = 0;
|
|
const heartbeat = setInterval(() => { eventLoopHeartbeats += 1; }, 1);
|
|
const createStartedAt = performance.now();
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => persisted,
|
|
write(value) {
|
|
writes.push(value);
|
|
persisted = value;
|
|
},
|
|
});
|
|
const createElapsedMs = performance.now() - createStartedAt;
|
|
|
|
try {
|
|
assert.equal(store.getSnapshot().tasks.length, 0, "large restore must not block initial store creation");
|
|
assert.equal(persisted, legacyRaw, "legacy data must remain untouched until migration succeeds");
|
|
assert.ok(createElapsedMs < 50, `store creation should be fast, took ${createElapsedMs.toFixed(1)}ms`);
|
|
|
|
await new Promise<void>((resolve, reject) => {
|
|
let unsubscribe = () => {};
|
|
const timeout = setTimeout(() => {
|
|
unsubscribe();
|
|
reject(new Error("timed out waiting for legacy transfer history migration"));
|
|
}, 10_000);
|
|
const check = () => {
|
|
const restoredParent = store.getTask(parent.id);
|
|
if (restoredParent?.directoryResumeCheckpoint?.completedEntries !== 50_000) return;
|
|
clearTimeout(timeout);
|
|
unsubscribe();
|
|
resolve();
|
|
};
|
|
unsubscribe = store.subscribe(check);
|
|
check();
|
|
});
|
|
} finally {
|
|
clearInterval(heartbeat);
|
|
}
|
|
|
|
assert.ok(
|
|
eventLoopHeartbeats >= 5,
|
|
`legacy migration must yield repeatedly, observed ${eventLoopHeartbeats} heartbeats`,
|
|
);
|
|
assert.equal(store.getSnapshot().tasks.length, 1);
|
|
assert.equal(writes.length, 1, "migration should publish one final compacted snapshot");
|
|
assert.equal(JSON.parse(persisted).tasks.length, 1, "persisted history must converge to one row");
|
|
assert.ok(persisted.length < 10_000, "migrated localStorage payload must stay bounded");
|
|
});
|
|
|
|
for (const indexed of [false, true]) {
|
|
test(`cooperative ${indexed ? "indexed" : "legacy"} restore retains completed child cleanup warnings`, async () => {
|
|
const now = Date.now();
|
|
const warning = "Upload completed; remove backup /target/.netcatty-backup-file manually.";
|
|
const parent: TransferTask = { ...makeTask("restore-warning-folder", "paused"), isDirectory: true };
|
|
const children: TransferTask[] = [0, 1].map((index) => ({
|
|
...makeTask(`restore-warning-child-${index}`, "completed"),
|
|
parentTaskId: parent.id, endTime: now,
|
|
warning: index === 0 ? warning : undefined,
|
|
...(indexed ? { directoryEntryIndex: index, directoryEntryIdentity: String(index).padStart(64, "0") } : {}),
|
|
}));
|
|
let persisted = JSON.stringify({ version: 1, padding: "x".repeat(600_000), tasks: [parent, ...children] });
|
|
const store = createSftpTransferCenterStore({ read: () => persisted, write: (value) => { persisted = value; } });
|
|
assert.equal(store.getSnapshot().tasks.length, 0, "large history must take cooperative restoration");
|
|
await new Promise<void>((resolve, reject) => {
|
|
let unsubscribe = () => {};
|
|
const timeout = setTimeout(() => {
|
|
unsubscribe();
|
|
reject(new Error("timed out waiting for cleanup-warning history migration"));
|
|
}, 10_000);
|
|
const check = () => {
|
|
if (!store.getTask(parent.id)) return;
|
|
clearTimeout(timeout);
|
|
unsubscribe();
|
|
resolve();
|
|
};
|
|
unsubscribe = store.subscribe(check);
|
|
check();
|
|
});
|
|
assert.equal(store.getTask("restore-warning-child-0")?.warning, warning);
|
|
assert.equal(store.getTask("restore-warning-child-0")?.status, "completed");
|
|
assert.equal(store.getTask("restore-warning-child-1"), undefined, "clean completed children still compact");
|
|
assert.equal(store.getTask(parent.id)?.directoryResumeCheckpoint?.coveredEntries, 2);
|
|
assert.equal(store.getTask(parent.id)?.directoryResumeCheckpoint?.completedEntries, 1);
|
|
const restarted = createSftpTransferCenterStore({ read: () => persisted, write: () => {} });
|
|
assert.equal(restarted.getTask("restore-warning-child-0")?.warning, warning);
|
|
assert.equal(restarted.getTask(parent.id)?.directoryResumeCheckpoint?.completedEntries, 1);
|
|
});
|
|
}
|
|
|
|
test("live mutations wait for cooperative restore and merge without erasing old rows", async () => {
|
|
const legacyOnly = makeTask("legacy-only", "paused");
|
|
const staleCollision = makeTask("collision", "paused");
|
|
const legacyRaw = JSON.stringify({
|
|
version: 1,
|
|
padding: "x".repeat(600_000),
|
|
tasks: [legacyOnly, staleCollision],
|
|
});
|
|
let persisted = legacyRaw;
|
|
const writes: string[] = [];
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => persisted,
|
|
write(value) {
|
|
writes.push(value);
|
|
persisted = value;
|
|
},
|
|
});
|
|
const liveCollision = {
|
|
...makeTask("collision", "transferring"),
|
|
transferredBytes: 9,
|
|
};
|
|
|
|
store.publishOwner("live-owner", [liveCollision]);
|
|
assert.equal(writes.length, 0, "pending migration must hold live persistence writes");
|
|
assert.equal(persisted, legacyRaw, "pending migration must not replace the source snapshot");
|
|
|
|
await new Promise<void>((resolve, reject) => {
|
|
let unsubscribe = () => {};
|
|
const timeout = setTimeout(() => {
|
|
unsubscribe();
|
|
reject(new Error("timed out waiting for cooperative transfer merge"));
|
|
}, 2_000);
|
|
const check = () => {
|
|
if (!store.getTask(legacyOnly.id)) return;
|
|
clearTimeout(timeout);
|
|
unsubscribe();
|
|
resolve();
|
|
};
|
|
unsubscribe = store.subscribe(check);
|
|
check();
|
|
});
|
|
|
|
assert.equal(store.getTask(legacyOnly.id)?.status, "interrupted");
|
|
assert.equal(store.getTask(liveCollision.id)?.status, "transferring");
|
|
assert.equal(store.getTask(liveCollision.id)?.transferredBytes, 9);
|
|
assert.equal(writes.length, 1);
|
|
assert.deepEqual(
|
|
JSON.parse(persisted).tasks.map((task: TransferTask) => task.id).sort(),
|
|
[legacyOnly.id, liveCollision.id].sort(),
|
|
);
|
|
});
|
|
|
|
test("background lifecycle events received during cooperative restore are applied after the snapshot", async () => {
|
|
const restoredTask = {
|
|
...makeTask("restore-event-race", "transferring"),
|
|
ownerId: "background-agent",
|
|
transferredBytes: 4,
|
|
checkpointBytes: 4,
|
|
};
|
|
const legacyRaw = JSON.stringify({
|
|
version: 1,
|
|
padding: "x".repeat(600_000),
|
|
tasks: [restoredTask],
|
|
});
|
|
let persisted = legacyRaw;
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => persisted,
|
|
write(value) { persisted = value; },
|
|
});
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "completed",
|
|
transferId: restoredTask.id,
|
|
transferred: 10,
|
|
totalBytes: 10,
|
|
endedAt: Date.now(),
|
|
});
|
|
|
|
await new Promise<void>((resolve, reject) => {
|
|
let unsubscribe = () => {};
|
|
const timeout = setTimeout(() => {
|
|
unsubscribe();
|
|
reject(new Error("timed out waiting for cooperative lifecycle replay"));
|
|
}, 2_000);
|
|
const check = () => {
|
|
if (store.getTask(restoredTask.id)?.status !== "completed") return;
|
|
clearTimeout(timeout);
|
|
unsubscribe();
|
|
resolve();
|
|
};
|
|
unsubscribe = store.subscribe(check);
|
|
check();
|
|
});
|
|
|
|
const completed = store.getTask(restoredTask.id);
|
|
assert.equal(completed?.status, "completed");
|
|
assert.equal(completed?.reconnectRequired, false, "completion must clear stale reconnect metadata");
|
|
assert.equal(JSON.parse(persisted).tasks[0]?.status, "completed");
|
|
});
|
|
|
|
test("cooperative restore replays lifecycle order without regressing byte watermarks", async () => {
|
|
const restoredTask = {
|
|
...makeTask("restore-progress-race", "transferring"),
|
|
ownerId: "background-agent",
|
|
transferredBytes: 2,
|
|
checkpointBytes: 2,
|
|
lifecycleEpoch: 1,
|
|
};
|
|
const legacyRaw = JSON.stringify({
|
|
version: 1,
|
|
padding: "x".repeat(600_000),
|
|
tasks: [restoredTask],
|
|
});
|
|
const store = createSftpTransferCenterStore({ read: () => legacyRaw, write: () => {} });
|
|
let notifications = 0;
|
|
const unsubscribe = store.subscribe(() => { notifications += 1; });
|
|
|
|
store.ingestBackgroundEvent({
|
|
type: "started",
|
|
transferId: restoredTask.id,
|
|
lifecycleEpoch: 2,
|
|
totalBytes: 20,
|
|
});
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: restoredTask.id,
|
|
transferred: 12,
|
|
totalBytes: 20,
|
|
checkpointBytes: 10,
|
|
lifecycleEpoch: 2,
|
|
lifecycleState: "transferring",
|
|
});
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: restoredTask.id,
|
|
transferred: 8,
|
|
totalBytes: 20,
|
|
checkpointBytes: 7,
|
|
lifecycleEpoch: 2,
|
|
lifecycleState: "transferring",
|
|
});
|
|
store.ingestBackgroundEvent({
|
|
type: "paused",
|
|
transferId: restoredTask.id,
|
|
checkpointBytes: 12,
|
|
lifecycleEpoch: 3,
|
|
});
|
|
store.ingestBackgroundEvent({
|
|
type: "progress",
|
|
transferId: restoredTask.id,
|
|
transferred: 18,
|
|
totalBytes: 20,
|
|
checkpointBytes: 18,
|
|
lifecycleEpoch: 2,
|
|
lifecycleState: "transferring",
|
|
});
|
|
|
|
await new Promise<void>((resolve, reject) => {
|
|
const timeout = setTimeout(() => reject(new Error("timed out waiting for lifecycle replay")), 2_000);
|
|
const check = () => {
|
|
if (store.getTask(restoredTask.id)?.status !== "paused") return;
|
|
clearTimeout(timeout);
|
|
resolve();
|
|
};
|
|
const off = store.subscribe(() => {
|
|
check();
|
|
if (store.getTask(restoredTask.id)?.status === "paused") off();
|
|
});
|
|
check();
|
|
});
|
|
unsubscribe();
|
|
|
|
const paused = store.getTask(restoredTask.id);
|
|
assert.equal(paused?.status, "paused");
|
|
assert.equal(paused?.transferredBytes, 12, "same-epoch delayed progress must not move bytes backwards");
|
|
assert.equal(paused?.checkpointBytes, 12, "older progress must not lower the durable checkpoint");
|
|
assert.equal(paused?.lifecycleEpoch, 3);
|
|
assert.equal(notifications, 1, "migration and buffered events should publish one atomic snapshot");
|
|
});
|
|
|
|
test("completed directory history is pruned with one owner update and no reentrant dismiss storm", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const now = Date.now();
|
|
const parent = {
|
|
...makeTask("finished-folder"),
|
|
isDirectory: true,
|
|
progressMode: "files" as const,
|
|
totalBytes: 250,
|
|
transferredBytes: 250,
|
|
};
|
|
let ownerTasks: TransferTask[] = [
|
|
parent,
|
|
...Array.from({ length: 250 }, (_, index) => ({
|
|
...makeTask(`finished-child-${index}`, "completed"),
|
|
parentTaskId: parent.id,
|
|
startTime: index + 2,
|
|
endTime: now - index,
|
|
})),
|
|
];
|
|
let individualDismisses = 0;
|
|
let batchDismisses = 0;
|
|
let publishDepth = 0;
|
|
let maxPublishDepth = 0;
|
|
const republish = () => {
|
|
publishDepth += 1;
|
|
maxPublishDepth = Math.max(maxPublishDepth, publishDepth);
|
|
store.publishOwner("panel-a", ownerTasks);
|
|
publishDepth -= 1;
|
|
};
|
|
const controls = {
|
|
pause: async () => {},
|
|
resume: async () => {},
|
|
cancel: async () => {},
|
|
retry: async () => {},
|
|
prioritize: async () => {},
|
|
dismiss(id: string) {
|
|
individualDismisses += 1;
|
|
ownerTasks = ownerTasks.filter((task) => task.id !== id && task.parentTaskId !== id);
|
|
republish();
|
|
},
|
|
dismissMany(prunedTasks: readonly TransferTask[]) {
|
|
batchDismisses += 1;
|
|
const removing = new Set(prunedTasks.map((task) => task.id));
|
|
ownerTasks = ownerTasks.filter((task) => !removing.has(task.id) && !removing.has(task.parentTaskId ?? ""));
|
|
republish();
|
|
},
|
|
};
|
|
store.registerOwner("panel-a", controls);
|
|
|
|
republish();
|
|
ownerTasks = ownerTasks.map((task) => task.id === parent.id
|
|
? { ...task, status: "completed", endTime: now }
|
|
: task);
|
|
republish();
|
|
|
|
assert.equal(individualDismisses, 0);
|
|
assert.equal(batchDismisses, 1);
|
|
assert.equal(maxPublishDepth, 2);
|
|
assert.ok(store.getSnapshot().tasks.length <= 200);
|
|
});
|
|
|
|
test("storage exhaustion cannot escape into the renderer update path", () => {
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write() {
|
|
throw new DOMException("quota exceeded", "QuotaExceededError");
|
|
},
|
|
});
|
|
|
|
assert.doesNotThrow(() => {
|
|
store.publishOwner("panel-a", [makeTask("quota-safe")]);
|
|
});
|
|
assert.equal(store.getSnapshot().tasks[0]?.id, "quota-safe");
|
|
});
|
|
|
|
test("patchTask lifecycle failures notify and persist through the full store path", () => {
|
|
const writes: string[] = [];
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write(value) { writes.push(value); },
|
|
});
|
|
store.publishOwner("panel-a", [makeTask("external-open-failure", "completed")]);
|
|
const baselineWrites = writes.length;
|
|
assert.equal(store.getBadgeSnapshot().hasAttention, false);
|
|
let notifications = 0;
|
|
store.subscribe(() => { notifications += 1; });
|
|
|
|
store.patchTask("external-open-failure", {
|
|
status: "failed",
|
|
error: "Could not open the downloaded file",
|
|
endTime: Date.now(),
|
|
});
|
|
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "failed");
|
|
assert.equal(store.getBadgeSnapshot().hasAttention, true, "failed lifecycle must refresh the badge");
|
|
assert.equal(notifications, 1, "lifecycle subscribers must update immediately");
|
|
assert.ok(writes.length > baselineWrites, "terminal lifecycle changes must be persisted");
|
|
const persisted = JSON.parse(writes.at(-1) ?? "{}") as { tasks?: TransferTask[] };
|
|
assert.equal(persisted.tasks?.[0]?.status, "failed", "persisted history must not retain completed");
|
|
assert.equal(persisted.tasks?.[0]?.error, "Could not open the downloaded file");
|
|
});
|
|
|
|
test("clearing a changed directory checkpoint is persisted before resume continues", () => {
|
|
let persisted = "";
|
|
const store = createSftpTransferCenterStore({
|
|
read: () => null,
|
|
write(value) { persisted = value; },
|
|
});
|
|
store.publishOwner("dedicated-resume", [{
|
|
...makeTask("changed-directory", "interrupted"),
|
|
isDirectory: true,
|
|
directoryResumeCheckpoint: {
|
|
version: 1,
|
|
coveredEntries: 2,
|
|
completedEntries: 2,
|
|
manifestHash: "a".repeat(64),
|
|
},
|
|
}]);
|
|
|
|
store.patchTask("changed-directory", { directoryResumeCheckpoint: undefined });
|
|
|
|
const restored = createSftpTransferCenterStore({ read: () => persisted, write: () => {} });
|
|
assert.equal(restored.getTask("changed-directory")?.directoryResumeCheckpoint, undefined);
|
|
});
|
|
|
|
test("hard directory resume failure falls back to bounded fresh retry history", async () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const parent: TransferTask = {
|
|
...makeTask("failed-directory-resume", "interrupted"),
|
|
isDirectory: true,
|
|
progressMode: "files",
|
|
checkpointBytes: 500,
|
|
reconnectRequired: true,
|
|
targetHostId: "host-a",
|
|
targetHostLabel: "box-a",
|
|
directoryResumeCheckpoint: {
|
|
version: 1,
|
|
coveredEntries: 500,
|
|
completedEntries: 0,
|
|
manifestHash: "a".repeat(64),
|
|
},
|
|
};
|
|
store.publishOwner("dedicated-resume", [parent]);
|
|
store.setDedicatedResumeHandler(async () => {
|
|
store.upsertTasks(Array.from({ length: 500 }, (_, index) => ({
|
|
...makeTask(`failed-directory-child-${index}`, "failed"),
|
|
ownerId: "dedicated-resume",
|
|
parentTaskId: parent.id,
|
|
sourcePath: `/source/file-${index}`,
|
|
targetPath: `/target/file-${index}`,
|
|
directoryEntryIndex: index,
|
|
directoryEntryIdentity: index.toString(16).padStart(64, "0"),
|
|
endTime: Date.now() - index,
|
|
})));
|
|
return { success: false, error: "500 files failed to resume" };
|
|
});
|
|
|
|
await store.resume(parent.id);
|
|
|
|
const snapshot = store.getSnapshot().tasks;
|
|
const retainedParent = snapshot.find((task) => task.id === parent.id);
|
|
assert.equal(retainedParent?.status, "failed");
|
|
assert.equal(retainedParent?.directoryResumeCheckpoint, undefined);
|
|
assert.equal(retainedParent?.checkpointBytes, 0);
|
|
assert.ok(snapshot.length <= 200, `failed directory history must stay bounded, got ${snapshot.length}`);
|
|
});
|
|
|
|
|
|
test("held dedicated file resume cannot overwrite a subsequent pause", async (t) => {
|
|
const store = createSftpTransferCenterStore();
|
|
const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
|
|
let releaseRun!: () => void;
|
|
let started!: () => void;
|
|
let releaseResume!: (result: { success: boolean; lifecycleEpoch: number }) => void;
|
|
const runGate = new Promise<void>((resolve) => { releaseRun = resolve; });
|
|
const startGate = new Promise<void>((resolve) => { started = resolve; });
|
|
const resumeGate = new Promise<{ success: boolean; lifecycleEpoch: number }>((resolve) => { releaseResume = resolve; });
|
|
t.after(async () => {
|
|
releaseRun();
|
|
if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
|
|
else Reflect.deleteProperty(globalThis, "window");
|
|
const { resetTransferPauseLatchesForTests } = await import("./sftp/transferPauseLatch");
|
|
resetTransferPauseLatchesForTests();
|
|
});
|
|
Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: {
|
|
pauseTransfer: async () => ({ success: true, checkpointBytes: 2, lifecycleEpoch: 3 }),
|
|
resumeTransfer: () => resumeGate,
|
|
} } });
|
|
store.publishOwner("dedicated-resume", [{
|
|
...makeTask("held-file", "interrupted"),
|
|
ownerId: "dedicated-resume", targetHostId: "host-a", reconnectRequired: true,
|
|
}]);
|
|
store.setDedicatedResumeHandler(async () => {
|
|
store.patchTask("held-file", { status: "transferring", reconnectRequired: false });
|
|
started();
|
|
await runGate;
|
|
return { success: true };
|
|
});
|
|
const first = store.resume("held-file");
|
|
await startGate;
|
|
await store.pause("held-file");
|
|
const second = store.resume("held-file");
|
|
await store.pause("held-file");
|
|
releaseResume({ success: true, lifecycleEpoch: 2 });
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const row = store.getSnapshot().tasks.find((task) => task.id === "held-file");
|
|
releaseRun();
|
|
await Promise.all([first, second]);
|
|
assert.equal(row?.status, "paused", "held transfer must respect the latest pause");
|
|
assert.equal(row?.lifecycleEpoch, 3);
|
|
});
|
|
|
|
for (const outcome of ["rejected", "stream-gone"] as const) {
|
|
test(`held file ${outcome} resume cannot restart after a newer pause during wind-down`, async (t) => {
|
|
const store = createSftpTransferCenterStore();
|
|
const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
|
|
let releaseRun!: () => void;
|
|
let started!: () => void;
|
|
let resolveResume!: (result: { success: boolean; reason: string }) => void;
|
|
let rejectResume!: (error: Error) => void;
|
|
let resumeCalls = 0;
|
|
const runGate = new Promise<void>((resolve) => { releaseRun = resolve; });
|
|
const startGate = new Promise<void>((resolve) => { started = resolve; });
|
|
const resumeGate = new Promise<{ success: boolean; reason: string }>((resolve, reject) => {
|
|
resolveResume = resolve;
|
|
rejectResume = reject;
|
|
});
|
|
t.after(async () => {
|
|
releaseRun();
|
|
if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow);
|
|
else Reflect.deleteProperty(globalThis, "window");
|
|
const { resetTransferPauseLatchesForTests } = await import("./sftp/transferPauseLatch");
|
|
resetTransferPauseLatchesForTests();
|
|
});
|
|
Object.defineProperty(globalThis, "window", { configurable: true, value: { netcatty: {
|
|
pauseTransfer: async () => ({ success: true, checkpointBytes: 2, lifecycleEpoch: 3 }),
|
|
resumeTransfer: () => ++resumeCalls === 1
|
|
? resumeGate
|
|
: Promise.resolve({ success: true, lifecycleEpoch: 4 }),
|
|
} } });
|
|
const id = `held-file-${outcome}`;
|
|
store.publishOwner("dedicated-resume", [{
|
|
...makeTask(id, "interrupted"),
|
|
ownerId: "dedicated-resume", targetHostId: "host-a", reconnectRequired: true,
|
|
}]);
|
|
store.setDedicatedResumeHandler(async () => {
|
|
store.patchTask(id, { status: "transferring", reconnectRequired: false });
|
|
started();
|
|
await runGate;
|
|
return { success: false, error: "Transfer cancelled" };
|
|
});
|
|
const first = store.resume(id);
|
|
await startGate;
|
|
await store.pause(id);
|
|
const second = store.resume(id);
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
if (outcome === "stream-gone") {
|
|
resolveResume({ success: false, reason: "Transfer is no longer active" });
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
}
|
|
await store.pause(id);
|
|
if (outcome === "rejected") {
|
|
rejectResume(new Error("worker channel unavailable"));
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
}
|
|
releaseRun();
|
|
await Promise.all([first, second]);
|
|
assert.equal(store.getSnapshot().tasks.find((task) => task.id === id)?.status, "paused");
|
|
assert.equal(resumeCalls, 1, "obsolete resume must not issue another resume after the held run ends");
|
|
});
|
|
}
|
|
|
|
test("partial cancel failure resets recovered folder children so the re-walk can re-admit them", async (t) => {
|
|
const { netcattyBridge } = await import("../../infrastructure/services/netcattyBridge");
|
|
const { resetTransferCancelLatchesForTests, isTransferOrRootCancelled } =
|
|
await import("./sftp/transferCancelLatch");
|
|
const { resetTransferWalkRegistryForTests } = await import("./sftp/transferWalkRegistry");
|
|
const originalGet = netcattyBridge.get;
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
t.after(() => {
|
|
netcattyBridge.get = originalGet;
|
|
resetTransferCancelLatchesForTests();
|
|
resetTransferWalkRegistryForTests();
|
|
});
|
|
// Only child2 fails to cancel; the folder must stay recoverable via Resume.
|
|
let failChild2 = true;
|
|
netcattyBridge.get = () => ({
|
|
cancelTransfer: async (id: string) => ({ success: id !== "dir-child-2" || !failChild2 }),
|
|
cleanupTransferArtifacts: async () => ({}),
|
|
} as unknown as ReturnType<typeof netcattyBridge.get>);
|
|
const store = createSftpTransferCenterStore();
|
|
const child = (id: string): TransferTask => ({
|
|
...makeTask(id),
|
|
parentTaskId: "dir-root",
|
|
isDirectory: false,
|
|
transferredBytes: 4,
|
|
directoryEntryIndex: 0,
|
|
directoryEntryIdentity: "a".repeat(64),
|
|
});
|
|
store.publishOwner("gone-panel", [
|
|
{ ...makeTask("dir-root"), isDirectory: true, transferredBytes: 10, totalBytes: 20, directoryEntryIndex: 0 },
|
|
child("dir-child-1"),
|
|
child("dir-child-2"),
|
|
]);
|
|
await store.cancel("dir-root");
|
|
|
|
const rows = store.getSnapshot().tasks;
|
|
const parent = rows.find((row) => row.id === "dir-root");
|
|
const child1 = rows.find((row) => row.id === "dir-child-1");
|
|
const child2 = rows.find((row) => row.id === "dir-child-2");
|
|
assert.equal(parent?.status, "attention");
|
|
assert.equal(parent?.error, "Could not cancel transfer. Please try again.");
|
|
// A failed backend cancellation keeps the folder recoverable: successfully
|
|
// cancelled siblings must not settle as terminal "cancelled", or admitTaskRun
|
|
// would reject the recovery re-walk and leave the destination incomplete.
|
|
assert.equal(child1?.status, "interrupted");
|
|
assert.equal(child1?.error, undefined);
|
|
assert.equal(child2?.status, "attention");
|
|
assert.equal(isTransferOrRootCancelled("dir-root"), false, "recovery latch must be cleared");
|
|
|
|
// The directory re-walk (Resume) can re-admit the reset sibling.
|
|
const incoming = { ...child("dir-child-1"), directoryEntryIndex: 0, directoryEntryIdentity: "a".repeat(64) };
|
|
assert.equal(store.admitTaskRun(incoming), "ready");
|
|
assert.equal(store.getTask("dir-child-1")?.status, "transferring");
|
|
|
|
// Without any cancellation failure the tree still settles fully cancelled.
|
|
failChild2 = false;
|
|
await store.cancel("dir-root");
|
|
const afterFullCancel = store.getSnapshot().tasks;
|
|
for (const id of ["dir-root", "dir-child-1", "dir-child-2"]) {
|
|
assert.equal(afterFullCancel.find((row) => row.id === id)?.status, "cancelled");
|
|
}
|
|
});
|
|
|
|
test("lifecycle hierarchy snapshot stays stable on bytes and changes on actual state transitions", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel", [makeTask("hierarchy-live")]);
|
|
const hierarchy = store.getLifecycleSnapshot();
|
|
store.patchTask("hierarchy-live", { transferredBytes: 5, speed: 3 });
|
|
assert.equal(store.getLifecycleSnapshot(), hierarchy);
|
|
assert.equal(store.getTask("hierarchy-live")?.transferredBytes, 5);
|
|
store.getSnapshot(); // Other progress consumers must not invalidate the hierarchy.
|
|
assert.equal(store.getLifecycleSnapshot(), hierarchy);
|
|
store.patchTask("hierarchy-live", { status: "failed", error: "fixture failure" });
|
|
assert.notEqual(store.getLifecycleSnapshot(), hierarchy);
|
|
assert.equal(store.getLifecycleSnapshot().tasks[0].status, "failed");
|
|
});
|
|
|
|
test("progress that admits or changes a task lifecycle also refreshes the hierarchy", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const initial = store.getLifecycleSnapshot();
|
|
store.ingestBackgroundEvent({ type: "progress", transferId: "late-start", transferred: 1 });
|
|
const admitted = store.getLifecycleSnapshot();
|
|
assert.notEqual(admitted, initial);
|
|
assert.equal(admitted.tasks[0].id, "late-start");
|
|
store.publishOwner("panel", [makeTask("queued-progress", "queued")]);
|
|
const queued = store.getLifecycleSnapshot();
|
|
store.ingestBackgroundEvent({ type: "progress", transferId: "queued-progress", transferred: 3 });
|
|
assert.notEqual(store.getLifecycleSnapshot(), queued);
|
|
assert.equal(store.getLifecycleSnapshot().tasks.find((task) => task.id === "queued-progress")?.status, "transferring");
|
|
const live = store.getLifecycleSnapshot();
|
|
store.ingestBackgroundEvent({ type: "progress", transferId: "queued-progress", transferred: 4 });
|
|
assert.equal(store.getLifecycleSnapshot(), live);
|
|
});
|
|
|
|
test("admission updates hierarchy state without forcing full owner lifecycle work", () => {
|
|
const store = createSftpTransferCenterStore();
|
|
const task = makeTask("admitted-hierarchy", "queued");
|
|
store.publishOwner("panel", [task]);
|
|
const queued = store.getLifecycleSnapshot();
|
|
let lifecycleNotifications = 0;
|
|
store.subscribe(() => { lifecycleNotifications += 1; });
|
|
assert.equal(store.admitTaskRun(task), "ready");
|
|
assert.notEqual(store.getLifecycleSnapshot(), queued);
|
|
assert.equal(store.getLifecycleSnapshot().tasks[0].status, "transferring");
|
|
assert.equal(lifecycleNotifications, 0, "dispatch admission keeps its existing lightweight fanout");
|
|
});
|
|
|
|
|
|
test("same-byte and ignored terminal events publish repaired background hierarchy immediately", () => {
|
|
for (const { status, type } of [
|
|
{ status: "transferring", type: "progress" },
|
|
{ status: "completed", type: "progress" },
|
|
{ status: "completed", type: "completed" },
|
|
{ status: "failed", type: "failed" },
|
|
] as const) {
|
|
const store = createSftpTransferCenterStore();
|
|
store.publishOwner("panel", [{ ...makeTask("folder"), isDirectory: true }]);
|
|
store.publishOwner("background-agent", [{ ...makeTask("orphan", status), background: true }]);
|
|
const beforeRepair = store.getLifecycleSnapshot();
|
|
let lifecycleNotifications = 0;
|
|
store.subscribe(() => { lifecycleNotifications += 1; });
|
|
store.ingestBackgroundEvent({ type, transferId: "orphan", parentTaskId: "folder", transferred: 2 });
|
|
const repaired = store.getLifecycleSnapshot();
|
|
assert.notEqual(repaired, beforeRepair, status);
|
|
assert.equal(repaired.tasks.find((task) => task.id === "orphan")?.parentTaskId, "folder", status);
|
|
assert.equal(repaired.tasks.find((task) => task.id === "orphan")?.background, false, status);
|
|
assert.equal(lifecycleNotifications, 0, "hierarchy repair keeps lightweight owner fanout");
|
|
store.ingestBackgroundEvent({ type: "progress", transferId: "orphan", parentTaskId: "folder", transferred: 3 });
|
|
assert.equal(store.getLifecycleSnapshot(), repaired, "subsequent byte ticks preserve the repaired hierarchy without rebuilding it");
|
|
assert.equal(store.getTask("orphan")?.parentTaskId, "folder");
|
|
}
|
|
});
|
|
|
|
test("repaired terminal hierarchy survives restart without another lifecycle event", (t) => {
|
|
t.mock.timers.enable({ apis: ["setTimeout", "Date"], now: Date.now() });
|
|
for (const status of ["completed", "failed", "cancelled"] as const) {
|
|
let persisted = "";
|
|
let writes = 0;
|
|
const store = createSftpTransferCenterStore({ read: () => null, write: (value) => { persisted = value; writes += 1; } });
|
|
store.publishOwner("panel", [{ ...makeTask("folder"), isDirectory: true }]);
|
|
store.publishOwner("background-agent", [{ ...makeTask("orphan", status), background: true }]);
|
|
t.mock.timers.tick(300);
|
|
assert.equal(JSON.parse(persisted).tasks.find((task: TransferTask) => task.id === "orphan")?.parentTaskId, undefined);
|
|
let lifecycleNotifications = 0;
|
|
store.subscribe(() => { lifecycleNotifications += 1; });
|
|
const beforeRepairWrites = writes;
|
|
store.ingestBackgroundEvent({ type: "progress", transferId: "orphan", parentTaskId: "folder", transferred: 2 });
|
|
t.mock.timers.tick(300);
|
|
assert.equal(writes, beforeRepairWrites + 1, "structural repair is saved even when the terminal event is ignored");
|
|
const savedChild = JSON.parse(persisted).tasks.find((task: TransferTask) => task.id === "orphan");
|
|
assert.equal(savedChild?.parentTaskId, "folder", status);
|
|
assert.equal(savedChild?.background, false, status);
|
|
assert.equal(savedChild?.ownerId, "panel", status);
|
|
const restored = createSftpTransferCenterStore({ read: () => persisted, write: () => {} });
|
|
const child = restored.getTask("orphan");
|
|
if (status === "completed") {
|
|
assert.equal(child, undefined, "existing restore compaction retains completed children in their folder checkpoint");
|
|
assert.equal(restored.getTask("folder")?.directoryResumeCheckpoint?.completedEntries, 1);
|
|
} else {
|
|
assert.equal(child?.parentTaskId, "folder", status);
|
|
assert.equal(child?.background, false, status);
|
|
assert.equal(child?.ownerId, "panel", status);
|
|
}
|
|
assert.equal(lifecycleNotifications, 0, "repair retains lightweight owner notifications");
|
|
const settledWrites = writes;
|
|
store.ingestBackgroundEvent({ type: "progress", transferId: "orphan", parentTaskId: "folder", transferred: 3 });
|
|
t.mock.timers.tick(300);
|
|
assert.equal(writes, settledWrites, "unchanged late progress does not schedule recurring writes");
|
|
}
|
|
});
|