mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 07:04:53 +00:00
Share dedicated resume with the renderer admission pool, preserve queued pause checkpoints, refuse to resurrect cancelled agent rows, and complete dedicated resumes that finish after a reconnect-spinner pause.
474 lines
16 KiB
TypeScript
474 lines
16 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("store routes controls to the task owner", 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.pause("a");
|
|
await store.resume("a");
|
|
await store.cancel("a");
|
|
await store.retry("a");
|
|
await store.prioritize("a");
|
|
store.dismiss("a");
|
|
|
|
assert.deepEqual(calls, [
|
|
"pause:a",
|
|
"resume:a",
|
|
"cancel:a",
|
|
"retry:a",
|
|
"prioritize:a",
|
|
"dismiss:a",
|
|
]);
|
|
});
|
|
|
|
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 still uses the live owner when canAdopt is false", async () => {
|
|
// Downloads often have only the remote pane open, so canAdopt (which wants
|
|
// both endpoints) returns false. Pause/resume must still unpause the live
|
|
// backend transfer through the owning panel instead of failing with
|
|
// "server no longer exists".
|
|
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 () => {},
|
|
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(calls, ["resume:download-paused"]);
|
|
assert.equal(store.getSnapshot().tasks[0]?.status, "paused");
|
|
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("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("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("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("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("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("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("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("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");
|
|
});
|