@torrent-tv/proxy 2.74.1 → 2.76.0

package/test/helpers/encode-run.js

@@ -0,0 +1,128 @@
+/**
+ * @file A real `EncodeRun` over a process that is not real.
+ *
+ * Tests used to set a session's process fields by hand — `session.ffmpeg`,
+ * `session.runState`, `session.encodeStartIndex` — which is how a test can pass
+ * over code that no longer works: the fields were the thing under test as much
+ * as the behaviour was. A run is an object now, so a test builds the object the
+ * product builds and injects only the one thing a test may not have, which is a
+ * child process.
+ *
+ * The pid is deliberately absent unless a test asks for one. `pause` and
+ * `resume` send signals by pid, and a made-up number is somebody else's process
+ * on the machine running the tests.
+ */
+
+import { EncodeRun } from "../../services/encode/EncodeRun.js";
+
+/**
+ * A child process that records what was done to it.
+ *
+ * @param {object} [options]
+ * @param {number | null} [options.pid] - Only where a test genuinely exercises
+ *   suspend or resume, and then it must be this process's own.
+ * @returns {object}
+ */
+export function fakeProcess({ pid = null, exitsWhenKilled = true } = {}) {
+  /** @type {Map<string, (...args: unknown[]) => void>} */
+  const listeners = new Map();
+  return {
+    pid,
+    killed: false,
+    exitCode: null,
+    signalCode: null,
+    /** Every signal it was sent, in order. */
+    signals: [],
+    stdout: { on() {} },
+    stderr: { on() {} },
+    on(event, handler) {
+      const kept = listeners.get(event) ?? [];
+      kept.push(handler);
+      listeners.set(event, kept);
+      return this;
+    },
+    once(event, handler) {
+      return this.on(event, handler);
+    },
+    kill(signal = "SIGTERM") {
+      this.signals.push(signal);
+      this.killed = true;
+      // A real process answers a signal by exiting, and it does so on a later
+      // turn. A fake that never exits makes every disposal wait out the grace
+      // period, which is two seconds a test spends proving nothing.
+      if (exitsWhenKilled && this.exitCode === null && this.signalCode === null) {
+        queueMicrotask(() => this.exit(null, signal));
+      }
+      return true;
+    },
+    /**
+     * Report an exit, as the real thing would.
+     *
+     * @param {number | null} code
+     * @param {string | null} [signal]
+     */
+    exit(code, signal = null) {
+      this.exitCode = code;
+      this.signalCode = signal;
+      for (const handler of listeners.get("exit") ?? []) {
+        handler(code, signal);
+      }
+    }
+  };
+}
+
+/** A logger that says nothing, for tests that are not about the log. */
+export const silentLogger = { info() {}, warn() {}, error() {} };
+
+/**
+ * Add a run to a session, started, over a fake process.
+ *
+ * A session holds a SET of runs — as many as the machine affords — so a test
+ * that wants two heads on one output calls this twice.
+ *
+ * @param {object} session - The session under test.
+ * @param {object} [options]
+ * @param {number} [options.from] - First segment number it is making.
+ * @param {number} [options.to] - Last, inclusive; below `from` means no end.
+ * @param {object} [options.process] - The process it should own.
+ * @param {boolean} [options.producing] - Whether it has already made its first
+ *   segment, which is what moves it out of starting.
+ * @param {number | null} [options.lastSegmentIndex] - The film's last number,
+ *   for telling a finished file from an input that dried up.
+ * @param {boolean} [options.usesExplicitCuts]
+ * @returns {import("../../services/encode/EncodeRun.js").EncodeRun}
+ */
+export function startRunOn(session, options = {}) {
+  const {
+    from = 0,
+    to = -1,
+    process: child = fakeProcess(),
+    producing = true,
+    lastSegmentIndex = null,
+    usesExplicitCuts = false
+  } = options;
+  const run = new EncodeRun({
+    address: session.outputKey ?? session.id ?? "output",
+    encoder: { name: "libx264", kind: "software" },
+    from,
+    to,
+    buildArgs: () => [],
+    spawn: () => child,
+    logger: silentLogger,
+    lastSegmentIndex: () => lastSegmentIndex,
+    usesExplicitCuts
+  });
+  run.start("a test asked for it");
+  if (producing) {
+    // What moves a run out of starting is its first segment, in the product as
+    // here — so a run that is producing has made one, and its head stands one
+    // past where it began. `from` is still where it started, which is what a
+    // test asserting a run's position asks for.
+    run.noteProduced(from);
+  }
+  if (!(session.runs instanceof Set)) {
+    session.runs = new Set();
+  }
+  session.runs.add(run);
+  return run;
+}

package/test/keyframe-index-accuracy.test.js

@@ -15,6 +15,8 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { SourceFile } from "../services/source/SourceFile.js";
+import { Timeline } from "../services/output/Timeline.js";
 import { newIndexCheck, noteIndexDeviation } from "../services/hls-session-manager.js";
 
 test("an index that describes its file exactly is reported as such", () => {
@@ -65,14 +67,17 @@ test("a boundary the index got wrong is replaced by the time the file really has
     localPort: 9090
   });
   t.after(() => manager.disposeAll());
+  // ONE table for the film, held by both. It used to be a copy each, kept in
+  // step by writing the correction into every member — which is what the shared
+  // table replaces, and what drifted in the field.
+  const boundaries = [0, 10, 20, 30, 40];
   const base = {
     id: "aaaaaaaa-1111-2222-3333-444444444444",
     fileName: "film.mkv",
     state: "ready",
     transcodeVideo: false,
-    segmentBoundaries: [0, 10, 20, 30, 40],
-    indexCheck: newIndexCheck(),
-    variants: new Map(),
+    timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
     segmentFormat: { segmentFileName: (index) => `segment-${index}.mp4` }
   };
   const rung = {
@@ -80,11 +85,13 @@ test("a boundary the index got wrong is replaced by the time the file really has
     fileName: "film.mkv",
     state: "ready",
     transcodeVideo: true,
-    segmentBoundaries: [0, 10, 20, 30, 40],
-    indexCheck: newIndexCheck(),
-    variantBases: new Set([base.id])
+    timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
+    // A step of the picture: the same file, and made as a step.
+    file: base.file,
+    variantHeight: 540,
+    isStep: true
   };
-  base.variants.set(540, rung.id);
+  base.file.stepHeights.set(540, 540);
   manager.sessionsById.set(base.id, base);
   manager.sessionsById.set(rung.id, rung);
 
@@ -93,17 +100,17 @@ test("a boundary the index got wrong is replaced by the time the file really has
   manager.correctBoundaryFromSegment(base, 2, 17.4);
 
   assert.equal(
-    base.segmentBoundaries[2],
+    base.timeline.boundaries[2],
     17.4,
     "the grid must describe the file, not the index — a rung forced onto 20 s would not join the copy"
   );
   assert.equal(
-    rung.segmentBoundaries[2],
+    rung.timeline.boundaries[2],
     17.4,
-    "the family shares one grid, so a correction reaches the rungs cut against it"
+    "the family shares one grid — the same array, so there is nothing to keep in step"
   );
   assert.deepEqual(
-    base.segmentBoundaries,
+    base.timeline.boundaries,
     [0, 10, 17.4, 30, 40],
     "only the boundary that was shown to be wrong moves"
   );
@@ -114,7 +121,7 @@ test("a boundary the index got wrong is replaced by the time the file really has
   manager.correctBoundaryFromSegment(base, 2, 35);
   manager.correctBoundaryFromSegment(base, 2, 5);
   manager.correctBoundaryFromSegment(base, 0, 3);
-  assert.deepEqual(base.segmentBoundaries, [0, 10, 17.4, 30, 40], "out-of-order readings are refused");
+  assert.deepEqual(base.timeline.boundaries, [0, 10, 17.4, 30, 40], "out-of-order readings are refused");
 });
 
 test("a segment requested again is not new evidence", () => {

package/test/keyframes-belong-to-the-file.test.js

@@ -0,0 +1,132 @@
+/**
+ * @file Where a file's keyframes are is a fact of the file, not of a session.
+ *
+ * It is a property of immutable bytes, like the duration and the track list, so
+ * a second reading could only agree. Two sessions created in the same moment
+ * used to read it twice — which is what two viewers opening one film do,
+ * measured 13 ms apart on 2026-09-03 — and the answer decides whether the
+ * picture can be copied at all, so it has to be one answer.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { Container } from "../services/container/Container.js";
+
+/**
+ * @returns {HlsSessionManager}
+ */
+function manager() {
+  return new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+}
+
+test("two sessions asking at once make one read and join one wait", async () => {
+  const session = manager();
+  let reads = 0;
+  let answer = null;
+  session.getContainerKeyframes = () => {
+    reads += 1;
+    return new Promise((resolve) => {
+      answer = resolve;
+    });
+  };
+
+  const first = session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
+  const second = session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
+  assert.equal(reads, 1, "the second asker joined the read already running");
+
+  answer({ times: [0, 4, 8], tolerance: 0 });
+  await Promise.all([first, second]);
+  assert.equal(reads, 1);
+});
+
+test("the answer is remembered for the file, so a later session reads nothing", async () => {
+  const session = manager();
+  let reads = 0;
+  session.getContainerKeyframes = async () => {
+    reads += 1;
+    return { times: [0, 4, 8], tolerance: 0 };
+  };
+
+  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
+  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
+
+  assert.equal(reads, 1);
+});
+
+test("two files of one torrent are two answers", async () => {
+  const session = manager();
+  const asked = [];
+  session.getContainerKeyframes = async ({ fileIndex }) => {
+    asked.push(fileIndex);
+    return { times: [0, 4], tolerance: 0 };
+  };
+
+  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" });
+  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 1, logName: "b.mkv" });
+
+  assert.deepEqual(asked, [0, 1]);
+});
+
+test("a file with no readable index says so once, and keeps saying it", async () => {
+  const session = manager();
+  let reads = 0;
+  session.getContainerKeyframes = async () => {
+    reads += 1;
+    return null;
+  };
+
+  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.ts" });
+  await session.warmKeyframeIndex({ sourceKey: "torrent:abc", fileIndex: 0, logName: "a.ts" });
+
+  // "No index" is an answer about the file — it is what makes a copy of it
+  // re-encode instead — and it must be the same answer for every viewer.
+  assert.equal(reads, 1);
+});
+
+test("a container reads its own table once", async () => {
+  let parses = 0;
+  class OneTable extends Container {
+    async parseKeyframeIndex() {
+      parses += 1;
+      return { times: [0, 2, 4], tolerance: 0 };
+    }
+  }
+  const container = new OneTable({ readRange: async () => null, fileSize: 10 });
+
+  const [first, second] = await Promise.all([
+    container.readKeyframeIndex(),
+    container.readKeyframeIndex()
+  ]);
+  await container.readKeyframeIndex();
+
+  assert.equal(parses, 1);
+  assert.deepEqual(first, second);
+});
+
+test("a read that threw is not remembered as an answer", async () => {
+  let parses = 0;
+  class Late extends Container {
+    async parseKeyframeIndex() {
+      parses += 1;
+      if (parses === 1) {
+        // The bytes it needed had not arrived yet, which is not a statement
+        // about the file.
+        throw new Error("nothing to read there yet");
+      }
+      return { times: [0, 2], tolerance: 0 };
+    }
+  }
+  const container = new Late({ readRange: async () => null, fileSize: 10 });
+
+  await assert.rejects(() => container.readKeyframeIndex());
+  const second = await container.readKeyframeIndex();
+
+  assert.equal(parses, 2);
+  assert.deepEqual(second.times, [0, 2]);
+});