@torrent-tv/proxy 2.74.1 → 2.76.0

package/test/sidecar-naming.test.js

@@ -0,0 +1,142 @@
+/**
+ * @file What a torrent's own names say about a track shipped as its own file.
+ *
+ * The rule worth pinning is the releaser one, because getting it wrong invents
+ * an author. In the field case — `[HorribleSubs] Drifters - 02 [1080p].mka` in
+ * `Rus Sound/`, beside `[HorribleSubs] Drifters - 02 [1080p].mkv` — the dub
+ * carries the picture's own brackets and nothing else, so there is nothing
+ * truthful to say about who made it. The subtitles of the same release sit in
+ * `Sub/[Stan WarHammer & Nesitach]/`, a bracket the picture does not carry, and
+ * that one IS their author.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  languageFromFolderNames,
+  releaserFrom,
+  sidecarNaming
+} from "../services/torrent/naming.js";
+/**
+ * Read a whole path, the way the pairing does. `code` is `"und"` where nothing
+ * was read, and `group` is what the browser calls the releaser.
+ *
+ * @param {string} relativePath
+ * @param {string} [videoName]
+ * @returns {{ code: string, group: string | null }}
+ */
+function readPath(relativePath, videoName = "") {
+  const parts = String(relativePath).split("/");
+  const naming = sidecarNaming({
+    folders: parts.slice(0, -1),
+    fileName: parts[parts.length - 1],
+    videoName
+  });
+  return { ...naming, code: naming.code ?? "und", group: naming.releaser };
+}
+
+
+const VIDEO_NAME = "[HorribleSubs] Drifters - 02 [1080p].mkv";
+
+test("a folder naming a language is read, whole segment or word", () => {
+  assert.equal(languageFromFolderNames(["ENG"])?.code, "en");
+  assert.equal(languageFromFolderNames(["Rus Sound"])?.code, "ru");
+  assert.equal(languageFromFolderNames(["Sub", "Russian"])?.code, "ru");
+  assert.equal(languageFromFolderNames([])?.code, undefined);
+});
+
+test("the innermost folder answers first", () => {
+  assert.equal(languageFromFolderNames(["Russian", "English Dub"])?.code, "en");
+});
+
+test("a two-letter word inside a longer folder name is not taken for a language", () => {
+  // "No" is Norwegian as a whole segment, but a word in `No Subs` is a word.
+  assert.equal(languageFromFolderNames(["No Subs"]), null);
+  assert.equal(languageFromFolderNames(["no"])?.code, "no");
+});
+
+test("a bracket the picture also carries is not the sidecar's author", () => {
+  assert.equal(
+    releaserFrom({
+      folders: ["Rus Sound"],
+      fileName: "[HorribleSubs] Drifters - 02 [1080p].mka",
+      videoName: VIDEO_NAME
+    }),
+    null
+  );
+});
+
+test("a bracket only the sidecar carries is its author", () => {
+  assert.equal(
+    releaserFrom({
+      folders: ["Sub", "[Stan WarHammer & Nesitach]"],
+      fileName: "[HorribleSubs] Drifters - 02 [1080p].ass",
+      videoName: VIDEO_NAME
+    }),
+    "Stan WarHammer & Nesitach"
+  );
+});
+
+test("a bracket describing the encode is never an author", () => {
+  for (const token of ["1080p", "x264", "HEVC", "WEB-DL", "AAC", "5.1", "10bit", "78EFD746", "RUS"]) {
+    assert.equal(
+      releaserFrom({ folders: [], fileName: `Film [${token}].mka`, videoName: "Other.mkv" }),
+      null,
+      `[${token}] should not be read as a releaser`
+    );
+  }
+});
+
+test("the innermost folder is preferred to the file name", () => {
+  assert.equal(
+    releaserFrom({ folders: ["[TeamA]"], fileName: "[TeamB] ep.ass", videoName: "ep.mkv" }),
+    "TeamA"
+  );
+});
+
+test("language and author together, for the field case", () => {
+  assert.deepEqual(
+    sidecarNaming({
+      folders: ["Rus Sound"],
+      fileName: "[HorribleSubs] Drifters - 02 [1080p].mka",
+      videoName: VIDEO_NAME
+    }),
+    { code: "ru", name: "Russian", releaser: null, isForced: false, isHearingImpaired: false, isDefault: false }
+  );
+  assert.deepEqual(
+    sidecarNaming({
+      folders: ["Sub", "[Stan WarHammer & Nesitach]"],
+      fileName: "[HorribleSubs] Drifters - 02 [1080p].ass",
+      videoName: VIDEO_NAME
+    }),
+    {
+      code: null,
+      name: null,
+      releaser: "Stan WarHammer & Nesitach",
+      isForced: false,
+      isHearingImpaired: false,
+      isDefault: false
+    }
+  );
+});
+
+test("a subtitle file takes its author from the folder the release put it in", () => {
+  const info = readPath("Sub/[Stan WarHammer & Nesitach]/[HorribleSubs] Drifters - 02 [1080p].ass", VIDEO_NAME);
+  assert.equal(info.group, "Stan WarHammer & Nesitach");
+});
+
+test("the picture's own release group is never reported as the translator", () => {
+  const info = readPath("Sub/[HorribleSubs] Drifters - 02 [1080p].ass", VIDEO_NAME);
+  assert.equal(info.group, null);
+});
+
+test("the language of a subtitle folder is read where the whole segment is not a language", () => {
+  const info = readPath("Rus Sub/ep.srt", "ep.mkv");
+  assert.equal(info.code, "ru");
+});
+
+test("what the rules answer with nothing to go on", () => {
+  const info = readPath("ep.srt");
+  assert.equal(info.code, "und");
+  assert.equal(info.group, null);
+});

package/test/source-file.test.js

@@ -0,0 +1,133 @@
+/**
+ * @file The file as a handle: its key, its name, what a probe said about it,
+ * and the address this proxy serves it at.
+ *
+ * The reason this object exists is the key. Twenty places in the session
+ * manager assembled `${sourceKey}:${fileIndex}` by hand, through five different
+ * spellings, to reach caches that are keyed by a file. These checks pin the
+ * shape those call sites now depend on, and the one property the registry has
+ * to have: the same file asked for twice is the same object, or a fact learned
+ * through one reference would be invisible through the other.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { SourceFile, SourceFiles, sourceDecodeCharacteristics } from "../services/source/SourceFile.js";
+
+test("a file's key is the pair that identifies it, spelled in one place", () => {
+  const file = new SourceFile({ sourceKey: "abc123", fileIndex: 4 });
+  assert.equal(file.key, "abc123:4");
+  assert.equal(SourceFiles.keyFor("abc123", 4), file.key);
+});
+
+test("a file with no name is named by its index, so no log line is about a nameless thing", () => {
+  assert.equal(new SourceFile({ sourceKey: "s", fileIndex: 7 }).name, "file#7");
+  assert.equal(new SourceFile({ sourceKey: "s", fileIndex: 7, name: "  Film.mkv  " }).name, "Film.mkv");
+});
+
+test("facts are absent until a probe answers, and 'absent' is not 'zero'", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  assert.equal(file.width, null, "an unread frame size is unknown, not 0x0");
+  assert.equal(file.height, null);
+  assert.equal(file.fps, null);
+  assert.equal(file.durationSeconds, null);
+  assert.equal(file.hasDuration, false);
+  assert.equal(file.isHdr, false, "a file nobody has read is not claimed to be HDR");
+  assert.equal(file.startTime, 0, "no stated start time means the timeline begins at zero");
+  assert.equal(file.decode, null, "and nothing is priced from facts that were never read");
+});
+
+test("readings are merged, because two readers answer about different things", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  // ffmpeg's banner: the frame size and rate, and no start time.
+  file.learn({ width: 1920, height: 1080, fps: 24 });
+  // The container's own header, read for one field — a sidecar soundtrack is
+  // read for exactly this and nothing else.
+  file.learn({ startTime: 0.083 });
+  assert.equal(file.startTime, 0.083);
+  assert.equal(file.width, 1920, "the second reader must not erase what the first found");
+});
+
+test("a fresher reading replaces the first, because a cold torrent answers incompletely", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  file.learn({ width: 1920, height: 1080, fps: 24, durationSeconds: 0, startTime: 1.5 });
+  assert.equal(file.width, 1920);
+  assert.equal(file.hasDuration, false, "a duration of zero is no duration");
+  assert.equal(file.startTime, 1.5);
+
+  file.learn({ width: 1920, height: 1080, fps: 24, durationSeconds: 5400, startTime: 1.5 });
+  assert.equal(file.durationSeconds, 5400);
+  assert.equal(file.hasDuration, true);
+
+  file.learn(null);
+  assert.equal(file.durationSeconds, 5400, "nothing is unlearned by an answer that did not come");
+});
+
+test("what decoding costs is derived from the file's own facts, per codec family", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  file.learn({ width: 1920, height: 1080, fps: 24, bitrateKbps: 8000, codec: "hevc", bitDepth: 10 });
+  assert.deepEqual(file.decode, {
+    megapixelsPerSecond: (1920 * 1080 * 24) / 1e6,
+    megabitsPerSecond: 8,
+    codec: "hevc",
+    bitDepth: 10
+  });
+  // The same arithmetic, still callable on a plain reading — the offer prices a
+  // file it has not made a session for.
+  assert.deepEqual(sourceDecodeCharacteristics({ width: 1920, height: 1080, fps: 24, bitrateKbps: 8000 }), {
+    megapixelsPerSecond: (1920 * 1080 * 24) / 1e6,
+    megabitsPerSecond: 8,
+    codec: "",
+    bitDepth: null
+  });
+});
+
+test("the address carries the file and the session, and the proxy's own base is a parameter", () => {
+  const file = new SourceFile({ sourceKey: "abc", fileIndex: 2 });
+  const url = file.streamUrl("http://127.0.0.1:9090", { sessionId: "sess-1" });
+  assert.equal(url.pathname, "/stream");
+  assert.equal(url.searchParams.get("sourceKey"), "abc");
+  assert.equal(url.searchParams.get("fileIndex"), "2");
+  assert.equal(url.searchParams.get("session"), "sess-1");
+
+  const noSession = file.streamUrl("http://127.0.0.1:9090");
+  assert.equal(noSession.searchParams.has("session"), false, "a read nobody is accounting for says so");
+});
+
+test("the same file asked for twice is the same object, or a fact learned once is lost", () => {
+  const files = new SourceFiles();
+  const first = files.get("abc", 1, "Film.mkv");
+  first.learn({ width: 1280, height: 720, fps: 25, durationSeconds: 60 });
+
+  const second = files.get("abc", 1);
+  assert.equal(second, first, "two viewers of one file must not hold two copies of its facts");
+  assert.equal(second.width, 1280);
+  assert.equal(second.name, "Film.mkv");
+
+  const other = files.get("abc", 2);
+  assert.notEqual(other, first, "and a different file in the same torrent is a different file");
+});
+
+test("a name learned later is kept, since the first caller often has only an index", () => {
+  const files = new SourceFiles();
+  const bare = files.get("abc", 1);
+  assert.equal(bare.name, "file#1");
+  files.get("abc", 1, "Film.mkv");
+  assert.equal(bare.name, "Film.mkv");
+  files.get("abc", 1, "Something.else.mkv");
+  assert.equal(bare.name, "Film.mkv", "and it is not renamed underneath a log line already written");
+});
+
+test("files nobody names are dropped, and a file still named survives the sweep", () => {
+  const files = new SourceFiles();
+  const kept = files.get("abc", 1);
+  files.get("abc", 2);
+  files.get("def", 9);
+  assert.equal(files.size, 3);
+
+  const dropped = files.forgetUnused(new Set([kept]));
+  assert.equal(dropped, 2);
+  assert.equal(files.size, 1);
+  assert.equal(files.peek(kept.key), kept);
+  assert.equal(files.peek("abc:2"), null);
+});

package/test/stale-request-after-seek.test.js

@@ -17,13 +17,15 @@
  */
 
 import assert from "node:assert/strict";
+import { SourceFile } from "../services/source/SourceFile.js";
+import { Timeline } from "../services/output/Timeline.js";
 import test from "node:test";
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
 import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { ENCODE_RUN_STATE } from "../services/encode-run-state.js";
+import { startRunOn } from "./helpers/encode-run.js";
 import { fmp4Format } from "../services/segment-formats/fmp4.js";
 
 const SEGMENT_SECONDS = 4;
@@ -52,23 +54,26 @@ async function sessionWithRunAt373() {
   const session = {
     id: SESSION_ID,
     dirPath,
+    // Where this file is cut, held by the file. A fixture that stated it
+    // on the session was describing what production no longer does.
+    timeline: new Timeline({
+      boundaries: boundaries,
+      cutGrid: "uniform"
+    }),
     state: "ready",
-    runState: ENCODE_RUN_STATE.PRODUCING,
-    fileName: "film.mkv",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
+    // An ordinary session reads its own file, and its sound is inside it. The
+    // three differ only for a soundtrack shipped as a file of its own.
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
     createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
     consumers: new Set(),
     segmentFormat: fmp4Format,
-    usesExplicitCuts: true,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    segmentBoundaries: boundaries,
     segmentCount: boundaries.length - 1,
-    encodeStartIndex: RUN_STARTS_AT,
-    // A live process: the repair refuses outright when nothing is encoding.
-    ffmpeg: { pid: 1234, killed: false, exitCode: null, signalCode: null, kill() { this.killed = true; } },
-    encodeRunGeneration: 0,
-    runSerial: 1,
+    runs: new Set(),
     behindHeadAsks: new Map(),
     firstWantedAt: new Map(),
     holdExplainedAt: new Map(),
@@ -81,6 +86,8 @@ async function sessionWithRunAt373() {
     progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS, speed: "1.0x", startPositionSeconds: RUN_STARTS_AT * SEGMENT_SECONDS }
   };
   manager.sessionsById.set(SESSION_ID, session);
+  // A live run: the repair refuses outright when nothing is encoding.
+  startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true });
   return { manager, session, dirPath };
 }
 
@@ -125,7 +132,6 @@ test("a request behind where the viewer said they are does not move the encoder"
 
   // The viewer stated their position: 2083.4 s, which is segment #520 here.
   manager.requestSeek(SESSION_ID, 2083.4);
-  session.encodeStartIndex = RUN_STARTS_AT;
   askedTwiceLongEnough(session);
 
   const answer = await manager.getFileStream(
@@ -176,7 +182,7 @@ test("a request cannot move the viewer's position backwards", async (t) => {
   await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX), { requestSeq: 1 });
 
   assert.equal(
-    session.viewerPositionSeconds,
+    session.furthestViewerSeconds,
     2083.4,
     "a stale request must not rewrite what the viewer reported — that is how the repair came to believe it"
   );