@torrent-tv/proxy 2.72.1 → 2.73.0

package/test/piece-store-reservations.test.js

@@ -156,7 +156,12 @@ test("a spill that fails gives back the slot the eviction claimed", async () =>
   }
 });
 
-test("a claim that cannot be met ends in an error, not in waiting for ever", async () => {
+// A bound, because the failure this catches is a claim that never ends: without
+// it the check does not fail, it HANGS, and `node --test` then cannot finish at
+// all — which is what happened between 2026-08-31 and 2026-09-03 (roadmap item
+// 54). The store gives up after PINNED_WAIT_MS, so 30 s is ample for the answer
+// and short enough to be a failure rather than a stoppage.
+test("a claim that cannot be met ends in an error, not in waiting for ever", { timeout: 30_000 }, async () => {
   const disk = makeDisk({ holdWrites: true });
   const { store } = makeStore({ pieces: 2, disk });
   try {
@@ -183,7 +188,7 @@ test("a claim that cannot be met ends in an error, not in waiting for ever", asy
   }
 });
 
-test("closing the store fails whoever is waiting for room", async () => {
+test("closing the store fails whoever is waiting for room", { timeout: 30_000 }, async () => {
   const disk = makeDisk({ holdWrites: true });
   const { store } = makeStore({ pieces: 2, disk });
   try {
@@ -194,7 +199,15 @@ test("closing the store fails whoever is waiting for room", async () => {
     store.pin(1);
 
     const waiting = put(store, 3);
-    await until(() => store.stats().waitedForPins > 0, "the claim is waiting");
+    // Either counter: the claim waits for the disk first — a block is in flight
+    // and the store is full, so evicting another piece would only raise the
+    // memory in use — and reaches the pinned wait five seconds later. Asking for
+    // `waitedForPins` alone named one of the two ways of waiting and timed out
+    // while the store was demonstrably doing the other.
+    await until(
+      () => store.stats().waitedForPins + store.stats().waitedForDisk > 0,
+      "the claim is waiting"
+    );
 
     await new Promise((resolve) => store.close(resolve));
     await assert.rejects(() => waiting, /closed/);
@@ -207,20 +220,30 @@ test("closing the store fails whoever is waiting for room", async () => {
   }
 });
 
-test("a piece written back to memory is not resurrected on disk by its own spill", async () => {
+test("a piece written back to memory is not resurrected on disk by its own spill", { timeout: 30_000 }, async () => {
   const disk = makeDisk({ holdWrites: true });
-  const { store } = makeStore({ pieces: 3, disk });
+  const { store } = makeStore({ pieces: 4, disk });
   try {
     await put(store, 0);
     await put(store, 1);
     await put(store, 2);
 
     // Piece 0 leaves memory because the machine's allowance fell; its write is
-    // still in flight. The allowance then recovers, so there is room again
-    // without waiting for that write.
+    // still in flight. The allowance then recovers to MORE than it was, so the
+    // piece coming back needs no eviction and no wait for that write.
+    //
+    // Four blocks, not three, and the reason is what this check is about. A
+    // block being written out is still memory in use, so with a ceiling of three
+    // and one block in flight the store is full, and the claim correctly waits
+    // for the disk — which the earlier setup did not allow for, so the check
+    // timed out on an admission policy it never meant to measure. Whether a
+    // piece arriving while its OWN spill is in flight should be admitted without
+    // taking a second block is a real question about the accounting and is
+    // roadmap item 9, not this check's subject: the subject is that the spill,
+    // when it completes, must not put the stale copy back on disk.
     store.reviseGrowthCeiling(CHUNK * 2);
     await until(() => disk.heldCount > 0, "the spill of piece 0 is in flight");
-    store.reviseGrowthCeiling(CHUNK * 3);
+    store.reviseGrowthCeiling(CHUNK * 4);
 
     // The swarm hands piece 0 back while that write is still going. The store
     // must drop the disk copy AFTER the write has recorded it, not before —

package/test/resume-warm.test.js

@@ -0,0 +1,39 @@
+/**
+ * @file Where a viewer's resume position falls in the file, in bytes.
+ *
+ * The warm-up fetches a file's two edges, because that is what the codec probe
+ * reads. The region the VIEWER will resume at was asked for by nobody until the
+ * encoder opened its input — field 2026-09-03, 53 s after the Retry button on a
+ * cold torrent, and the piece it then needed took another 46.3 s to arrive.
+ * Turning the position into an offset is the only arithmetic in that path, so it
+ * is the only part with anything to get wrong.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { resumeByteOffset } from "../services/torrent-worker/container-tracks.js";
+
+test("a position halfway through a film is halfway through its file", () => {
+  assert.equal(resumeByteOffset(1000, 100, 50), 500);
+});
+
+test("the field case lands where the encoder went looking", () => {
+  // The measured session: 171.338 s into a 23:41 episode of 541 MB, and the
+  // read that blocked was at 63 MB.
+  const at = resumeByteOffset(541 * 1024 * 1024, 23 * 60 + 41, 171.338);
+  const megabytes = at / (1024 * 1024);
+  assert.ok(megabytes > 60 && megabytes < 68, `landed at ${megabytes.toFixed(1)}MB`);
+});
+
+test("a position past the end reads the end, rather than past it", () => {
+  const length = 1000;
+  const at = resumeByteOffset(length, 100, 10_000);
+  assert.equal(at, length - 1);
+});
+
+test("nothing is known, nothing is guessed", () => {
+  assert.equal(resumeByteOffset(0, 100, 50), 0, "no file length");
+  assert.equal(resumeByteOffset(1000, 0, 50), 0, "no duration — the container did not declare one");
+  assert.equal(resumeByteOffset(1000, 100, 0), 0, "the viewer is at the beginning, where the edges already are");
+});

package/test/tail-duplication.test.js

@@ -60,7 +60,7 @@ test("the missing blocks are freed and asked of a second wire", () => {
 });
 
 test("at most one duplicate per wire, however long the tail", () => {
-  const target = piece(512, 40);
+  const target = piece(512, 16);
   const torrent = {
     pieces: [target],
     wires: [wire(), wire()],
@@ -73,7 +73,29 @@ test("at most one duplicate per wire, however long the tail", () => {
   assert.equal(target.cancelled.length, 2, "and no reservation is freed that nobody was asked for");
 });
 
-test("a wire whose pipeline is full ends the attempt", () => {
+test("a piece still arriving normally is not duplicated at all", () => {
+  // Forty blocks outstanding is not a tail, it is a piece in transit. Asking
+  // for a second copy of it would spend the shared link on bytes that are
+  // already on their way — which is the whole difference between this and the
+  // 2-14 blocks a blocked reader was measured waiting on.
+  const target = piece(512, 40);
+  const torrent = {
+    pieces: [target],
+    wires: [wire(), wire()],
+    _request: () => true
+  };
+
+  const result = duplicateTailFor(torrent, 0);
+
+  assert.equal(result.duplicated, 0);
+  assert.equal(target.cancelled.length, 0, "and nothing is freed either");
+});
+
+test("a wire whose pipeline is full does not end the attempt", () => {
+  // Pipelines are per wire, so one wire being full says nothing about the next.
+  // This used to stop the whole pass on the first refusal, on the stated
+  // reasoning that the remaining wires were "no emptier" — an assumption about
+  // other peers' queues that nothing measures.
   const target = piece(512, 5);
   const torrent = {
     pieces: [target],
@@ -88,11 +110,33 @@ test("a wire whose pipeline is full ends the attempt", () => {
   assert.equal(result.duplicated, 0);
   assert.equal(
     target.cancelled.length,
-    1,
-    "only the block that was actually offered is freed; the rest keep their reservations"
+    3,
+    "every wire was offered a block; a freed reservation nobody took is handed to whoever asks next"
   );
 });
 
+test("a refusal by one wire does not cost the block a faster wire would have taken", () => {
+  const target = piece(512, 3);
+  const placed = [];
+  const torrent = {
+    pieces: [target],
+    wires: [wire({ speed: 900_000 }), wire({ speed: 800_000 })],
+    _request: (wireAsked, index) => {
+      // The first wire is full; the second is not.
+      if (wireAsked === torrent.wires[0]) {
+        return false;
+      }
+      placed.push(index);
+      return true;
+    }
+  };
+
+  const result = duplicateTailFor(torrent, 0);
+
+  assert.equal(result.duplicated, 1);
+  assert.deepEqual(placed, [0], "the second wire was still asked");
+});
+
 test("a piece with nothing missing is left alone", () => {
   const target = piece(4, 0);
   const torrent = { pieces: [target], wires: [wire()], _request: () => true };