@torrent-tv/proxy 2.89.17 → 2.89.18

package/test/available-share.test.js

@@ -1,76 +0,0 @@
-/**
- * @file What the machine can spare for a new encoder — and what must not be
- * charged twice.
- *
- * The numbers are the addon host's own, measured 2026-08-17 while a 240p step
- * ran at 1.01-1.12x against a prediction of 1.83x.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { availableShareFrom, correctForAvailability } from "../services/encode/available-share.js";
-
-test("only the work nobody has been charged for is subtracted", () => {
-  // The field reading: the box is saturated, our encoder has more than half of
-  // it, and the proxy's own work a fifth.
-  const availability = availableShareFrom({ systemBusy: 0.99, encoderShare: 0.56, proxyShare: 0.2 });
-
-  assert.equal(availability.known, true);
-  // 0.99 − 0.76 = 0.23 belongs to the kernel, the container and whatever else
-  // the owner runs. Our own encoders are priced by the concurrency arithmetic
-  // and the proxy's work per megabyte moved; charging them here as well is the
-  // double counting that emptied the quality menu in 2.21.0.
-  assert.ok(Math.abs(availability.unattributed - 0.23) < 1e-9, `${availability.unattributed}`);
-  assert.ok(Math.abs(availability.share - 0.77) < 1e-9, `${availability.share}`);
-});
-
-test("a quiet machine is not corrected at all", () => {
-  const availability = availableShareFrom({ systemBusy: 0.05, encoderShare: 0.04, proxyShare: 0.01 });
-  assert.equal(availability.unattributed, 0);
-  assert.equal(availability.share, 1);
-  assert.equal(correctForAvailability(4, availability), 4);
-});
-
-test("a host that cannot say says so, and nothing is corrected", () => {
-  // Not every host has /proc. An uncorrected figure is honest; a figure
-  // corrected by an invented share is not.
-  const availability = availableShareFrom({ systemBusy: null, encoderShare: null, proxyShare: null });
-  assert.equal(availability.known, false);
-  assert.equal(availability.share, 1);
-  assert.equal(correctForAvailability(2.5, availability), 2.5, "an unknown machine leaves the prediction alone");
-  assert.equal(availableShareFrom().known, false);
-});
-
-test("readings that overlap by a rounding do not produce a negative machine", () => {
-  // The two samples are taken microseconds apart, so our own share can come out
-  // fractionally above the system total.
-  const availability = availableShareFrom({ systemBusy: 0.60, encoderShare: 0.58, proxyShare: 0.05 });
-  assert.equal(availability.unattributed, 0);
-  assert.equal(availability.share, 1);
-});
-
-test("a machine given over entirely to other work leaves nothing", () => {
-  const availability = availableShareFrom({ systemBusy: 1, encoderShare: 0, proxyShare: 0 });
-  assert.equal(availability.share, 0);
-  assert.equal(correctForAvailability(4, availability), 0, "a step cannot be offered on a machine with nothing left");
-});
-
-test("the correction is proportional, and only ever downwards", () => {
-  const availability = availableShareFrom({ systemBusy: 0.99, encoderShare: 0.56, proxyShare: 0.2 });
-  // The field case: a step predicted at 1.83x on a quiet box.
-  const corrected = correctForAvailability(1.83, availability);
-  assert.ok(Math.abs(corrected - 1.4091) < 0.001, `${corrected}`);
-  // And the honest note this test exists to record: 1.41x is still above the
-  // 1.01-1.12x that step actually ran at. This correction closes part of the
-  // gap, not all of it — which is why the per-step field comparison ships with
-  // it rather than after it.
-  assert.ok(corrected > 1.12, "the remaining difference is what the field check is for");
-});
-
-test("nothing is corrected without a prediction to correct", () => {
-  const availability = availableShareFrom({ systemBusy: 0.99, encoderShare: 0.5, proxyShare: 0.2 });
-  assert.equal(correctForAvailability(0, availability), 0);
-  assert.equal(correctForAvailability(Number.NaN, availability), Number.NaN);
-  assert.equal(correctForAvailability(-1, availability), -1);
-});

package/test/background-fill.test.js

@@ -1,190 +0,0 @@
-/**
- * Fetching a file nobody is playing yet, without taking anything from the
- * viewer.
- *
- * The ordering these checks pin is the whole point of the thing: what plays now
- * comes first, the other soundtracks and subtitle files next, and reading the
- * film far ahead last. The middle tier stays below the first by standing aside
- * whenever a reader on the torrent is inside a wait.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-import { EventEmitter } from "node:events";
-import { fillFileInBackground, fillIsRunning } from "../services/torrent/worker/background-fill.js";
-
-/**
- * A file whose reads resolve when the test says so, recording what was asked
- * for.
- *
- * @param {{ length: number, name?: string }} params
- */
-function fakeFile({ length, name = "dub.mka" }) {
-  const reads = [];
-  return {
-    name,
-    length,
-    reads,
-    createReadStream({ start, end }) {
-      const stream = new EventEmitter();
-      stream.destroy = () => {};
-      reads.push({ start, end });
-      // Deliver on the next turn, so a test can observe the read in flight.
-      queueMicrotask(() => {
-        stream.emit("data", Buffer.alloc(end - start + 1));
-        stream.emit("end");
-      });
-      return stream;
-    }
-  };
-}
-
-/**
- * @param {() => boolean} until
- * @param {number} [limit]
- */
-async function waitFor(until, limit = 2000) {
-  const deadline = Date.now() + limit;
-  while (!until()) {
-    if (Date.now() > deadline) {
-      throw new Error("condition was never reached");
-    }
-    await new Promise((resolve) => setTimeout(resolve, 5));
-  }
-}
-
-test("a file is walked whole, a piece at a time", async () => {
-  const file = fakeFile({ length: 10 });
-  const torrent = { infoHash: "aaa", pieceLength: 4, files: [file] };
-
-  const started = fillFileInBackground(torrent, 0, "source-a", { chunkBytes: 4 });
-
-  assert.equal(started, true);
-  await waitFor(() => !fillIsRunning("source-a", 0));
-  // 0-3, 4-7, 8-9: the last chunk is short because the file ends, and its end
-  // is the last byte rather than one past it.
-  assert.deepEqual(file.reads, [
-    { start: 0, end: 3 },
-    { start: 4, end: 7 },
-    { start: 8, end: 9 }
-  ]);
-});
-
-test("one fill per file, however many times it is asked for", async () => {
-  const file = fakeFile({ length: 8 });
-  const torrent = { infoHash: "bbb", pieceLength: 4, files: [file] };
-
-  const first = fillFileInBackground(torrent, 0, "source-b", { chunkBytes: 4 });
-  const second = fillFileInBackground(torrent, 0, "source-b", { chunkBytes: 4 });
-
-  assert.equal(first, true);
-  assert.equal(second, false, "the second call does not start a second walk");
-  await waitFor(() => !fillIsRunning("source-b", 0));
-  assert.equal(file.reads.length, 2, "the file was walked once");
-});
-
-test("a file that is gone is not read, and does not throw", async () => {
-  const torrent = { infoHash: "ccc", pieceLength: 4, files: [] };
-
-  const started = fillFileInBackground(torrent, 0, "source-c", { chunkBytes: 4 });
-
-  assert.equal(started, false);
-  assert.equal(fillIsRunning("source-c", 0), false);
-});
-
-test("a read that returns nothing stops the walk instead of spinning", async () => {
-  const file = {
-    name: "dub.mka",
-    length: 100,
-    reads: [],
-    createReadStream({ start, end }) {
-      const stream = new EventEmitter();
-      stream.destroy = () => {};
-      this.reads.push({ start, end });
-      queueMicrotask(() => stream.emit("error", new Error("gone")));
-      return stream;
-    }
-  };
-  const torrent = { infoHash: "ddd", pieceLength: 10, files: [file] };
-
-  fillFileInBackground(torrent, 0, "source-d", { chunkBytes: 10 });
-
-  await waitFor(() => !fillIsRunning("source-d", 0));
-  assert.equal(file.reads.length, 1, "it gave up after the first failed read");
-});
-
-test("it stands aside while the viewer's own reading is blocked", async () => {
-  const file = fakeFile({ length: 8 });
-  const torrent = { infoHash: "eee", pieceLength: 4, files: [file] };
-  let blocked = true;
-
-  fillFileInBackground(torrent, 0, "source-e", { chunkBytes: 4, isBlocked: () => blocked });
-
-  // The picture is starving, so nothing is asked of the swarm on the
-  // soundtrack's behalf — however long that lasts.
-  await new Promise((resolve) => setTimeout(resolve, 120));
-  assert.deepEqual(file.reads, [], "not one read while a reader is inside a wait");
-
-  blocked = false;
-  await waitFor(() => !fillIsRunning("source-e", 0));
-  assert.equal(file.reads.length, 2, "and it resumes once the room is there");
-});
-
-test("the gate is re-asked before every chunk, not once at the start", async () => {
-  const file = fakeFile({ length: 12 });
-  const torrent = { infoHash: "fff", pieceLength: 4, files: [file] };
-  // Starve the viewer again the moment the first chunk has been read, and stay
-  // that way until the test lifts it.
-  let starvedAfterFirstChunk = false;
-  let lifted = false;
-  const isBlocked = () => {
-    if (file.reads.length >= 1 && !lifted) {
-      starvedAfterFirstChunk = true;
-    }
-    return starvedAfterFirstChunk && !lifted;
-  };
-
-  fillFileInBackground(torrent, 0, "source-f", { chunkBytes: 4, isBlocked });
-
-  await waitFor(() => file.reads.length === 1);
-  await new Promise((resolve) => setTimeout(resolve, 120));
-  assert.equal(file.reads.length, 1, "a torrent healthy a moment ago is not evidence about now");
-
-  lifted = true;
-  await waitFor(() => !fillIsRunning("source-f", 0));
-  assert.equal(file.reads.length, 3);
-});
-
-test("a stall during a chunk makes the next one wait, not just a stall in progress", async () => {
-  // The case this exists for: a swarm delivering exactly what the film needs.
-  // Nothing is blocked at the moment the gate is asked, but the viewer stalled
-  // while the last chunk was in flight — which is the proof there was no room.
-  const file = fakeFile({ length: 12 });
-  const torrent = { infoHash: "ggg", pieceLength: 4, files: [file] };
-  let stalls = 0;
-  let starving = true;
-  // A stall happens DURING every chunk, exactly as it does on a swarm with no
-  // surplus — and nothing is blocked at the moment the gate is asked.
-  const originalRead = file.createReadStream.bind(file);
-  file.createReadStream = (range) => {
-    if (starving) {
-      stalls += 1;
-    }
-    return originalRead(range);
-  };
-
-  fillFileInBackground(torrent, 0, "source-g", {
-    chunkBytes: 4,
-    isBlocked: () => false,
-    stallsSeen: () => stalls
-  });
-
-  await waitFor(() => file.reads.length === 1);
-  await new Promise((resolve) => setTimeout(resolve, 300));
-  assert.equal(file.reads.length, 1, "a stall during the chunk holds the next one back");
-
-  // The swarm settles: no further stalls, so it may go on.
-  starving = false;
-  await waitFor(() => !fillIsRunning("source-g", 0), 8000);
-  assert.equal(file.reads.length, 3);
-});

package/test/client-log-file.test.js

@@ -1,126 +0,0 @@
-/**
- * @file The browser's log, written beside the proxy's.
- *
- * What these hold is the naming, because the name is the whole point: the two
- * halves of a session have to join without guessing, and a torrent name is
- * arbitrary bytes chosen by a stranger that is about to become a path.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, readdirSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { createClientLogConsole, createClientLogFiles } from "../utils/client-log-file.js";
-
-/** A directory with a proxy log in it, which is what the sink is given. */
-function aDirectory() {
-  const dir = mkdtempSync(join(tmpdir(), "ttv-client-log-"));
-  return { dir, proxyLog: join(dir, "proxy.log") };
-}
-
-const aSession = (over = {}) => ({
-  sessionId: "abcd1234",
-  startedAt: "2026-09-13T16:05:24.123Z",
-  torrentName: "Reacher.S04E07.1080p.rus.LostFilm.TV.mkv",
-  infoHash: "94dda59fdf252447d6ca5a8775dab2d11a832da5",
-  ...over
-});
-
-test("the file lands beside the proxy log, named by when it started and what is watched", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession(), ["first line"]);
-  await logs.close();
-
-  const [name] = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.ok(name, "a client log file was written");
-  // The stamp is UTC and sorts; the session id joins it to the proxy's lines;
-  // the film says which one it is without opening the file.
-  assert.match(name, /^client-20260913-160524-abcd1234-Reacher\.S04E07\.1080p\.rus\.LostFilm\.TV\.mkv-94dda59f\.log$/);
-  assert.equal(readFileSync(join(dir, name), "utf8"), "first line\n");
-});
-
-test("lines from one session go on appending to the one file", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession(), ["one", "two"]);
-  logs.write(aSession(), ["three"]);
-  await logs.close();
-
-  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.equal(names.length, 1);
-  assert.equal(readFileSync(join(dir, names[0]), "utf8"), "one\ntwo\nthree\n");
-});
-
-test("a session that has not chosen a film yet still gets its own file", async () => {
-  // The page opening, a proxy being chosen, a connection failing — all before
-  // any torrent exists, and all worth keeping.
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ torrentName: "", infoHash: "" }), ["before any film"]);
-  await logs.close();
-
-  const [name] = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.match(name, /-no-torrent-yet\.log$/);
-});
-
-test("the file keeps its name when the film arrives mid-session", async () => {
-  // Keyed by the session, not by the name: the earlier lines belong to the same
-  // viewing and must not start a second file.
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ torrentName: "", infoHash: "" }), ["before"]);
-  logs.write(aSession(), ["after"]);
-  await logs.close();
-
-  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.equal(names.length, 1);
-  assert.match(names[0], /-no-torrent-yet\.log$/);
-  assert.equal(readFileSync(join(dir, names[0]), "utf8"), "before\nafter\n");
-});
-
-test("a hostile torrent name cannot escape the directory", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ torrentName: "../../etc/passwd" }), ["x"]);
-  await logs.close();
-
-  const names = readdirSync(dir).filter((f) => f.startsWith("client-"));
-  assert.equal(names.length, 1);
-  assert.ok(!names[0].includes(".."), `no traversal in ${names[0]}`);
-  assert.ok(!names[0].includes("/"), `no separator in ${names[0]}`);
-});
-
-test("two sessions of one film are two files", async () => {
-  const { dir, proxyLog } = aDirectory();
-  const logs = createClientLogFiles(proxyLog);
-  logs.write(aSession({ sessionId: "aaaa1111" }), ["one viewer"]);
-  logs.write(aSession({ sessionId: "bbbb2222", startedAt: "2026-09-13T16:07:11.000Z" }), ["another"]);
-  await logs.close();
-
-  assert.equal(readdirSync(dir).filter((f) => f.startsWith("client-")).length, 2);
-});
-
-test("no proxy log path means nothing is written and nothing throws", async () => {
-  const logs = createClientLogFiles("");
-  logs.write(aSession(), ["dropped"]);
-  await logs.close();
-});
-
-test("without a log file the lines go to the console, each naming its session", async () => {
-  // A proxy started from npm or Docker names no file; the browser's half of
-  // the viewing must still reach the output the host keeps.
-  const printed = [];
-  const logs = createClientLogConsole((message) => printed.push(message));
-  logs.write(aSession(), ["first line", "second line"]);
-  logs.write(aSession({ sessionId: "" }), ["no id"]);
-  await logs.close();
-
-  assert.deepEqual(printed, [
-    "client abcd1234 first line",
-    "client abcd1234 second line",
-    "client unknown no id"
-  ]);
-});

package/test/client-logs-route.test.js

@@ -1,34 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { handleApiClientLogsPost } from "../routes/api/client-logs/post.js";
-
-/**
- * Post one body and return the lines the route wrote.
- *
- * @param {object} body
- * @returns {Promise<string[]>}
- */
-async function linesWrittenFor(body) {
-  /** @type {string[]} */
-  const written = [];
-  const reply = { code: () => reply, send: () => reply };
-  await handleApiClientLogsPost({ body }, reply, {
-    clientLogs: { write: (_session, lines) => written.push(...lines) }
-  });
-  return written;
-}
-
-const line = { level: "info", ts: "12:00:00.000", msg: "hello" };
-
-test("each line names the page's send it came in, so the two receivers can be compared", async () => {
-  assert.deepEqual(await linesWrittenFor({ tag: "Windows/Chrome", seq: 12, lines: [line] }), [
-    "[Windows/Chrome batch=12] 12:00:00.000 info: hello"
-  ]);
-});
-
-test("a page that numbers nothing is written as before", async () => {
-  assert.deepEqual(await linesWrittenFor({ tag: "Windows/Chrome", seq: "12", lines: [line] }), [
-    "[Windows/Chrome] 12:00:00.000 info: hello"
-  ]);
-});

package/test/coalesce.test.js

@@ -1,39 +0,0 @@
-/**
- * @file A request that arrives during a run gives one more run, never a lost
- * one and never a queue.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { coalescing } from "../utils/coalesce.js";
-
-test("asked during a run: one more run after it, however often it was asked", async () => {
-  const runs = [];
-  let release;
-  const run = coalescing(async (label) => {
-    runs.push(label);
-    if (runs.length === 1) {
-      await new Promise((resolve) => {
-        release = resolve;
-      });
-    }
-  });
-  const first = run("file", "first");
-  await run("file", "second");
-  await run("file", "third");
-  assert.deepEqual(runs, ["first"], "nothing ran beside the run in progress");
-  release();
-  await first;
-  await new Promise((resolve) => setImmediate(resolve));
-  assert.deepEqual(runs, ["first", "third"], "exactly one more run, with the latest arguments");
-});
-
-test("different keys run side by side", async () => {
-  const runs = [];
-  const run = coalescing(async (label) => {
-    runs.push(label);
-  });
-  await Promise.all([run("a", "a"), run("b", "b")]);
-  assert.deepEqual(runs.sort(), ["a", "b"]);
-});

package/test/completed-files.test.js

@@ -1,115 +0,0 @@
-/**
- * @file Files downloaded whole are files, and outlive the torrent that fetched
- * them.
- *
- * Asked for in these words on 2026-09-11: as soon as a torrent is fully
- * downloaded, downloading stops, the torrent is deleted, and the artefacts —
- * what was downloaded — stay for as long as they are wanted.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { Readable } from "node:stream";
-import { CompletedFiles } from "../services/storage/files/CompletedFiles.js";
-
-const INFO_HASH = "abcdef0123456789abcdef0123456789abcdef01";
-
-/** @returns {Promise<string>} */
-const directory = () => fs.mkdtemp(path.join(os.tmpdir(), "whole-files-"));
-
-/**
- * @param {Buffer} bytes
- * @param {number} [chunk]
- * @returns {() => NodeJS.ReadableStream}
- */
-const opens = (bytes, chunk = 7) => () => {
-  const parts = [];
-  for (let at = 0; at < bytes.length; at += chunk) {
-    parts.push(bytes.subarray(at, Math.min(at + chunk, bytes.length)));
-  }
-  return Readable.from(parts);
-};
-
-test("a file read whole is kept whole, and reads back byte for byte", async () => {
-  const root = await directory();
-  const files = new CompletedFiles({ root });
-  const bytes = Buffer.from("the whole of a small film", "utf8");
-  try {
-    const kept = await files.keep({ infoHash: INFO_HASH, fileIndex: 3, length: bytes.length, name: "film.mkv", open: opens(bytes) });
-    assert.ok(kept, "the file was not kept");
-    assert.equal(kept.length, bytes.length);
-
-    const found = files.find(INFO_HASH, 3);
-    assert.deepEqual(found, kept, "what was kept is not what is found");
-    assert.deepEqual(await fs.readFile(found.path), bytes, "the bytes came back changed");
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("a read that ends early leaves nothing that looks whole", async () => {
-  const root = await directory();
-  const files = new CompletedFiles({ root });
-  const bytes = Buffer.from("half a film", "utf8");
-  try {
-    // The torrent says the file is longer than what its read produced — the
-    // data went away mid-write, which over a torrent is ordinary.
-    const kept = await files.keep({
-      infoHash: INFO_HASH,
-      fileIndex: 0,
-      length: bytes.length + 100,
-      open: opens(bytes)
-    });
-    assert.equal(kept, null, "a short file was kept as whole");
-    assert.equal(files.find(INFO_HASH, 0), null);
-    assert.deepEqual(
-      (await fs.readdir(path.join(root, INFO_HASH))).filter((entry) => entry !== "manifest.json"),
-      [],
-      "a partial file was left behind"
-    );
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("what a previous life left is taken up, and what is the wrong size is not", async () => {
-  const root = await directory();
-  const bytes = Buffer.from("a film from the last time this ran", "utf8");
-  try {
-    const first = new CompletedFiles({ root });
-    await first.keep({ infoHash: INFO_HASH, fileIndex: 2, length: bytes.length, name: "film.mkv", open: opens(bytes) });
-    // And one that was being written when the process died, under a name that
-    // says it is whole — the only way to tell is its size.
-    await fs.writeFile(path.join(root, INFO_HASH, "5"), Buffer.alloc(3));
-
-    const second = new CompletedFiles({ root });
-    const adopted = await second.adopt((infoHash, fileIndex) =>
-      infoHash === INFO_HASH && fileIndex === 2 ? bytes.length : 999
-    );
-    assert.equal(adopted, 1, "the whole file was not taken up, or the short one was");
-    assert.equal(second.find(INFO_HASH, 2)?.name, "film.mkv", "the name the torrent gave it was lost");
-    assert.equal(second.find(INFO_HASH, 5), null, "a file of the wrong size was taken up");
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});
-
-test("forgetting a torrent removes its files and nobody else's", async () => {
-  const root = await directory();
-  const files = new CompletedFiles({ root });
-  const other = "0123456789abcdef0123456789abcdef01234567";
-  const bytes = Buffer.from("kept", "utf8");
-  try {
-    await files.keep({ infoHash: INFO_HASH, fileIndex: 1, length: bytes.length, name: "one.mkv", open: opens(bytes) });
-    await files.keep({ infoHash: other, fileIndex: 1, length: bytes.length, name: "two.mkv", open: opens(bytes) });
-
-    await files.forget(INFO_HASH);
-    assert.equal(files.find(INFO_HASH, 1), null);
-    assert.ok(files.find(other, 1), "another torrent's file went with it");
-  } finally {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});