@torrent-tv/proxy 2.85.0 → 2.86.0

package/test/viewer-states.test.js

@@ -111,9 +111,14 @@ test("a page that is not on screen wants nothing now, whatever else it says", ()
   assert.equal(viewer.wantsFilmNow(), false);
 });
 
-test("the intake keeps a link reading only while it describes the link", async () => {
-  const { takeViewerReport } = await import("../services/viewer/report-intake.js");
-  const session = {};
+test("the intake hands the statement to the viewer on the output they are watching", async () => {
+  const { recordViewerReport } = await import("../services/viewer/report-intake.js");
+  const picture = { id: "picture", state: "ready", activeVariantId: "rung" };
+  const rung = { id: "rung", state: "ready" };
+  const sessions = new Map([
+    ["picture", picture],
+    ["rung", rung]
+  ]);
   const viewers = {
     of(target, id) {
       target.viewers ??= new Map();
@@ -124,28 +129,74 @@ test("the intake keeps a link reading only while it describes the link", async (
     }
   };
 
-  takeViewerReport({
+  // The page always addresses the PICTURE — it is never told which rung it is
+  // on — and the statement belongs to the rung actually on screen.
+  const taken = recordViewerReport({
+    sessions,
     viewers,
-    session,
-    consumerId: "one",
-    report: { linkMbps: 8, bufferedAheadSec: 10, positionSeconds: 5, playing: true },
-    now: AT,
-    linkFreshMs: 30_000
+    sessionId: "picture",
+    report: { linkMbps: 8, bufferedAheadSec: 10, positionSeconds: 5, playing: true, consumerId: "one" },
+    now: AT
   });
-  assert.equal(session.viewers.get("one").netReport?.linkMbps, 8);
 
-  // A second report, a minute later, from somebody else: the first viewer's
-  // reading has aged past what it describes and stops deciding for them. Who is
-  // still watching is a different question and is not touched.
-  takeViewerReport({
-    viewers,
-    session,
-    consumerId: "two",
-    report: { bufferedAheadSec: 0, playing: false, waiting: true },
-    now: AT + 60_000,
-    linkFreshMs: 30_000
-  });
-  assert.equal(session.viewers.get("one").netReport, null);
-  assert.equal(session.viewers.get("one").isPresent(), true);
-  assert.equal(session.viewers.get("two").waiting, true);
+  assert.equal(taken, true);
+  assert.equal(rung.viewers.get("one").positionSeconds(AT), 5);
+  assert.equal(picture.viewers?.has("one") ?? false, false);
+});
+
+test("a link reading does not expire — presence is what decides whose it is", () => {
+  const viewer = new Viewer("one", AT);
+  viewer.report({ linkMbps: 8, bufferedAheadSec: 10, positionSeconds: 5, playing: true }, AT);
+
+  // A link does not stop being what it was measured to be because nobody
+  // measured it for a while. The page says as much by keeping its own last
+  // figure rather than reporting nothing.
+  assert.equal(viewer.linkReading()?.linkMbps, 8);
+  assert.equal(viewer.linkReading()?.linkMbps, 8, "and an hour later it is still the last thing known");
+
+  // What ends it is the person leaving, which is a different fact with a
+  // different owner.
+  assert.equal(viewer.isPresent(), true);
+});
+
+test("the worst reading is taken across the people who are still here", async () => {
+  const { worstLinkReading } = await import("../services/viewer/link-readings.js");
+  const output = {};
+  const slow = new Viewer("slow", AT);
+  slow.outputs.add("out");
+  const fast = new Viewer("fast", AT);
+  fast.outputs.add("out");
+  output.viewers = new Map([
+    ["slow", slow],
+    ["fast", fast]
+  ]);
+  slow.report({ linkMbps: 2, bufferedAheadSec: 3, playing: true }, AT);
+  fast.report({ linkMbps: 40, bufferedAheadSec: 90, playing: true }, AT);
+
+  // The slowest link and the emptiest buffer, which may belong to two people.
+  const worst = worstLinkReading(output);
+  assert.equal(worst?.linkMbps, 2);
+  assert.equal(worst?.bufferedAheadSec, 3);
+  assert.equal(worst?.viewers, 2);
+
+  // The slow one leaves. Their reading goes with them, however recent it was.
+  slow.gone = true;
+  const left = worstLinkReading(output);
+  assert.equal(left?.linkMbps, 40);
+  assert.equal(left?.viewers, 1);
+});
+
+test("a report into a session that is gone is refused rather than invented", async () => {
+  const { recordViewerReport } = await import("../services/viewer/report-intake.js");
+  const sessions = new Map([["dead", { id: "dead", state: "disposed" }]]);
+  const viewers = { of() { throw new Error("must not be asked"); } };
+
+  assert.equal(
+    recordViewerReport({ sessions, viewers, sessionId: "dead", report: { bufferedAheadSec: 0 }, now: AT }),
+    false
+  );
+  assert.equal(
+    recordViewerReport({ sessions, viewers, sessionId: "never", report: { bufferedAheadSec: 0 }, now: AT }),
+    false
+  );
 });