[Init] Initial commit - NetMesh terminal manager

application/state/sftp/transferConcurrency.test.ts

@@ -0,0 +1,194 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  DEFAULT_SFTP_DIRECTORY_LISTING_CONCURRENCY,
+  DEFAULT_SFTP_FILE_TRANSFER_CONCURRENCY,
+  DEFAULT_SFTP_SKIP_UNCHANGED,
+  resolveSftpDirectoryListingConcurrency,
+  resolveSftpSkipUnchangedEnabled,
+  resolveSftpTransferConcurrency,
+  runBoundedConcurrency,
+  runSftpTransferWorkers,
+} from "./transferConcurrency";
+
+test("defaults folder file transfers to six concurrent files", () => {
+  assert.equal(resolveSftpTransferConcurrency(() => null), DEFAULT_SFTP_FILE_TRANSFER_CONCURRENCY);
+  assert.equal(DEFAULT_SFTP_FILE_TRANSFER_CONCURRENCY, 6);
+});
+
+test("defaults directory listing fanout to four concurrent readdirs", () => {
+  assert.equal(
+    resolveSftpDirectoryListingConcurrency(() => null),
+    DEFAULT_SFTP_DIRECTORY_LISTING_CONCURRENCY,
+  );
+  assert.equal(DEFAULT_SFTP_DIRECTORY_LISTING_CONCURRENCY, 4);
+});
+
+test("defaults skip-unchanged to enabled", () => {
+  assert.equal(resolveSftpSkipUnchangedEnabled(() => null), DEFAULT_SFTP_SKIP_UNCHANGED);
+  assert.equal(DEFAULT_SFTP_SKIP_UNCHANGED, true);
+  assert.equal(resolveSftpSkipUnchangedEnabled(() => false), false);
+});
+
+test("keeps explicit folder transfer concurrency within the supported range", () => {
+  assert.equal(resolveSftpTransferConcurrency(() => 1), 1);
+  assert.equal(resolveSftpTransferConcurrency(() => 16), 16);
+  assert.equal(resolveSftpTransferConcurrency(() => 1.5), DEFAULT_SFTP_FILE_TRANSFER_CONCURRENCY);
+  assert.equal(resolveSftpTransferConcurrency(() => 0), DEFAULT_SFTP_FILE_TRANSFER_CONCURRENCY);
+  assert.equal(resolveSftpTransferConcurrency(() => 17), DEFAULT_SFTP_FILE_TRANSFER_CONCURRENCY);
+});
+
+test("keeps directory listing concurrency within the supported range", () => {
+  assert.equal(resolveSftpDirectoryListingConcurrency(() => 1), 1);
+  assert.equal(resolveSftpDirectoryListingConcurrency(() => 8), 8);
+  assert.equal(
+    resolveSftpDirectoryListingConcurrency(() => 0),
+    DEFAULT_SFTP_DIRECTORY_LISTING_CONCURRENCY,
+  );
+  assert.equal(
+    resolveSftpDirectoryListingConcurrency(() => 9),
+    DEFAULT_SFTP_DIRECTORY_LISTING_CONCURRENCY,
+  );
+});
+
+test("limits default multi-file transfer scheduling to six concurrent workers", async () => {
+  let active = 0;
+  let maxActive = 0;
+
+  await runSftpTransferWorkers([1, 2, 3, 4, 5, 6, 7], () => null, async () => {
+    active += 1;
+    maxActive = Math.max(maxActive, active);
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    active -= 1;
+  });
+
+  assert.equal(maxActive, 6);
+});
+
+test("runBoundedConcurrency respects an explicit limit", async () => {
+  let active = 0;
+  let maxActive = 0;
+  await runBoundedConcurrency([1, 2, 3, 4, 5, 6], 3, async () => {
+    active += 1;
+    maxActive = Math.max(maxActive, active);
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    active -= 1;
+  });
+  assert.equal(maxActive, 3);
+});
+
+test("runBoundedConcurrency drains siblings and stops new claims after an error", async () => {
+  const started: number[] = [];
+  const finished: number[] = [];
+  let releaseSlow!: () => void;
+  const slowGate = new Promise<void>((resolve) => {
+    releaseSlow = resolve;
+  });
+
+  const run = runBoundedConcurrency([0, 1, 2, 3, 4], 2, async (item) => {
+    started.push(item);
+    if (item === 0) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      throw new Error("boom");
+    }
+    if (item === 1) {
+      await slowGate;
+    }
+    finished.push(item);
+  });
+
+  await new Promise((resolve) => setTimeout(resolve, 30));
+
+  let settledWhileSiblingRunning = false;
+  await Promise.race([
+    run.then(
+      () => {
+        settledWhileSiblingRunning = true;
+      },
+      () => {
+        settledWhileSiblingRunning = true;
+      },
+    ),
+    new Promise((resolve) => setTimeout(resolve, 5)),
+  ]);
+  assert.equal(
+    settledWhileSiblingRunning,
+    false,
+    "must wait for in-flight siblings before propagating the error",
+  );
+  assert.ok(started.includes(1));
+  assert.equal(finished.includes(1), false);
+
+  releaseSlow();
+  await assert.rejects(run, /boom/);
+  assert.ok(finished.includes(1), "in-flight sibling must finish before reject");
+  assert.deepEqual(
+    [...started].sort((a, b) => a - b),
+    [0, 1],
+    "must not claim additional queue items after the first error",
+  );
+});
+
+test("runSftpTransferWorkers drains siblings and stops new claims after an error", async () => {
+  const started: number[] = [];
+  const finished: number[] = [];
+  let releaseSlow!: () => void;
+  const slowGate = new Promise<void>((resolve) => {
+    releaseSlow = resolve;
+  });
+
+  const run = runSftpTransferWorkers([0, 1, 2, 3, 4], () => 2, async (item) => {
+    started.push(item);
+    if (item === 0) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      throw new Error("session lost");
+    }
+    if (item === 1) {
+      await slowGate;
+    }
+    finished.push(item);
+  });
+
+  await new Promise((resolve) => setTimeout(resolve, 30));
+  let settledEarly = false;
+  await Promise.race([
+    run.then(
+      () => { settledEarly = true; },
+      () => { settledEarly = true; },
+    ),
+    new Promise((resolve) => setTimeout(resolve, 5)),
+  ]);
+  assert.equal(settledEarly, false);
+  releaseSlow();
+  await assert.rejects(run, /session lost/);
+  assert.ok(finished.includes(1));
+  assert.deepEqual([...started].sort((a, b) => a - b), [0, 1]);
+});
+
+test("beforeClaim runs before claiming the next queue index", async () => {
+  const events: string[] = [];
+  let paused = true;
+
+  const run = runSftpTransferWorkers(
+    ["a", "b"],
+    () => 1,
+    async (item) => {
+      events.push(`work:${item}`);
+    },
+    {
+      beforeClaim: async () => {
+        events.push("claim-gate");
+        while (paused) {
+          await new Promise((resolve) => setTimeout(resolve, 5));
+        }
+      },
+    },
+  );
+
+  await new Promise((resolve) => setTimeout(resolve, 20));
+  assert.deepEqual(events, ["claim-gate"]);
+  paused = false;
+  await run;
+  assert.deepEqual(events, ["claim-gate", "work:a", "claim-gate", "work:b"]);
+});