@torrent-tv/proxy 2.80.10 → 2.80.12

package/test/tracks-begin-together.test.js

@@ -19,6 +19,7 @@ import { Timeline } from "../services/output/Timeline.js";
 import test from "node:test";
 
 import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { trueStartOf } from "../services/encode/run-command.js";
 import { fmp4Format } from "../services/segment-formats/fmp4.js";
 import { ENCODE_RUN_STATE, INITIAL_RUN_STATE } from "../services/encode/encode-run-state.js";
 
@@ -108,20 +109,38 @@ test("a soundtrack follows the picture to the instant the picture really began",
     10.5,
     "and every member's table with it — one film, one table, nothing to keep in step"
   );
-  // A NEW run, not a seek. A seek decides by index, finds the soundtrack
-  // already begins at #2 and answers "already within the running encode" —
-  // true about the index, false about the instant. The first version of this
-  // fix did exactly that and moved nothing.
-  //
-  // The attempt is the evidence because it is what a run start claims before
-  // it awaits anything: the assertion then holds without the test needing a
-  // filesystem, a process, or a guess about how many ticks to wait for one.
-  assert.ok(
-    sound.pendingRun,
-    "the soundtrack's run must be started again, at the corrected time"
+  // THE RUN AT THE WRONG INSTANT IS STOPPED, and nothing here places its
+  // replacement. What has been learned is that this run is producing in the
+  // wrong place, which nothing but the piece it produced could say — the plan
+  // reasons about numbers and cannot know it. So the fact is acted on as far as
+  // it is known and no further: the run goes, the stretch it held returns to the
+  // map, and where the next one stands follows from where the viewers are.
+  assert.equal(runBefore.state, ENCODE_RUN_STATE.STOPPED, "the run in the wrong place goes");
+  assert.equal(sound.pendingRun, null, "and this path places nothing");
+  // The corrected instant reaches whatever the plan places there through the
+  // table, which every session of the file shares. It used to be passed as an
+  // argument from this one call site, so only a run started by that line ever
+  // had it — a run the plan placed at the same number landed apart again.
+  assert.equal(
+    trueStartOf(sound.timeline, 2),
+    10.5,
+    "the live table holds the measurement and the published one the prediction"
+  );
+});
+
+test("where a number really begins is answered only where it has been measured", () => {
+  const { sound } = familyAtBoundaryTwo();
+
+  assert.equal(
+    trueStartOf(sound.timeline, 2),
+    undefined,
+    "the two tables agree, so there is nothing measured to prefer"
   );
-  assert.equal(sound.pendingRun.startIndex, 2);
-  assert.equal([...sound.runs][0], runBefore, "and the run in force is only replaced once one is built");
+  sound.timeline.boundaries[2] = 10.5;
+  assert.equal(trueStartOf(sound.timeline, 2), 10.5);
+  assert.equal(trueStartOf(sound.timeline, 3), undefined, "and only about the number measured");
+  assert.equal(trueStartOf(sound.timeline, 99), undefined, "a number the file does not have");
+  assert.equal(trueStartOf(null, 0), undefined, "and no table at all");
 });
 
 test("a correction the table already holds moves nobody", () => {

package/test/tunnel-renewal.test.js

@@ -19,6 +19,29 @@ import { WebSocketServer } from "ws";
 
 import { createTunnelClient } from "../services/tunnel-client.js";
 
+/**
+ * Wait for the thing being asserted, not for a length of time.
+ *
+ * A chosen interval followed by an assertion does not test — it samples, and
+ * what it samples is how busy the machine is. The deadline here is a backstop
+ * that turns a hang into a failure; it is never the measurement.
+ *
+ * @param {() => boolean} until
+ * @param {string} what - Named in the failure, since a timeout otherwise says
+ *   only that something did not happen.
+ * @param {number} [limit]
+ * @returns {Promise<void>}
+ */
+async function waitFor(until, what, limit = 10_000) {
+  const deadline = Date.now() + limit;
+  while (!until()) {
+    if (Date.now() > deadline) {
+      throw new Error(`${what} never happened`);
+    }
+    await new Promise((resolve) => { setTimeout(resolve, 5); });
+  }
+}
+
 /**
  * A stand-in for the registry's tunnel endpoint, with the one behaviour that
  * matters here: a new connection for a proxy REPLACES the previous one, which
@@ -92,8 +115,10 @@ test("the connection is replaced before its lifetime runs out, without a gap", a
   });
 
   client.connect();
-  // Long enough for several renewals at 150 ms each.
-  await new Promise((resolve) => { setTimeout(resolve, 700); });
+  // Until the renewals have happened, however long this machine takes over
+  // them. Waited out as 700 ms instead — about four lifetimes — this asserted
+  // how many the scheduler had got round to.
+  await waitFor(() => registry.opened() >= 3, "three connections");
 
   assert.ok(registry.opened() >= 3, `expected several renewals, saw ${registry.opened()}`);
   // The property this exists for: the registry was never left with nothing.
@@ -128,11 +153,15 @@ test("a connection killed from outside is still reconnected", async (t) => {
   });
 
   client.connect();
-  await new Promise((resolve) => { setTimeout(resolve, 200); });
+  await waitFor(() => registry.opened() === 1, "the first connection");
+  // And exactly one: the lifetime above is far longer than this test runs, so
+  // nothing renews and a second would mean something else had opened it.
   assert.equal(registry.opened(), 1);
 
   registry.killCurrent();
-  await new Promise((resolve) => { setTimeout(resolve, 300); });
   // The renewal must not have taken the ordinary reconnect away with it.
-  assert.ok(lines.some((line) => line.includes("Reconnecting in")), lines.join("\n"));
+  await waitFor(
+    () => lines.some((line) => line.includes("Reconnecting in")),
+    "the reconnect after a connection was killed from outside"
+  );
 });