rx-player 4.5.0-dev.2026012302 → 4.5.0-dev.2026021900

package/src/core/adaptive/utils/__tests__/pending_requests_store.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import PendingRequestsStore from "../pending_requests_store";
+import type {
+  IPendingRequestStoreBegin,
+  IPendingRequestStoreProgress,
+} from "../pending_requests_store";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
+const mocks = vi.hoisted(() => ({
+  warn: vi.fn(),
+}));
+
+// Mock dependencies
+vi.mock("../../../../log", () => ({
+  default: {
+    warn: mocks.warn,
+  },
+}));
+
+describe("PendingRequestsStore", () => {
+  let store: PendingRequestsStore;
+
+  const createMockContent = (segmentTime: number = 0) => ({
+    manifest: {} as any,
+    period: {} as any,
+    adaptation: {} as any,
+    representation: {} as any,
+    segment: { time: segmentTime } as any,
+  });
+
+  const createMockRequest = (
+    id: string = "req-1",
+    requestTimestamp: number = 1000,
+    segmentTime: number = 0,
+  ): IPendingRequestStoreBegin => ({
+    id,
+    requestTimestamp,
+    content: createMockContent(segmentTime),
+  });
+
+  const createMockProgress = (
+    id: string = "req-1",
+    duration: number = 0.5,
+    size: number = 1024,
+    totalSize: number = 2048,
+    timestamp: number = 1500,
+  ): IPendingRequestStoreProgress => ({
+    id,
+    duration,
+    size,
+    totalSize,
+    timestamp,
+  });
+
+  beforeEach(() => {
+    store = new PendingRequestsStore();
+    vi.clearAllMocks();
+  });
+
+  describe("add", () => {
+    it("should add a new pending request", () => {
+      const request = createMockRequest();
+
+      store.add(request);
+
+      const requests = store.getRequests();
+      expect(requests).toHaveLength(1);
+      expect(requests[0]).toEqual({
+        requestTimestamp: request.requestTimestamp,
+        progress: [],
+        content: request.content,
+      });
+    });
+
+    it("should add multiple pending requests", () => {
+      const request1 = createMockRequest("req-1", 1000);
+      const request2 = createMockRequest("req-2", 2000);
+
+      store.add(request1);
+      store.add(request2);
+
+      const requests = store.getRequests();
+      expect(requests).toHaveLength(2);
+    });
+
+    it("should initialize progress as empty array", () => {
+      const request = createMockRequest();
+
+      store.add(request);
+
+      const requests = store.getRequests();
+      expect(requests[0].progress).toEqual([]);
+    });
+  });
+
+  describe("addProgress", () => {
+    it("should add progress to an existing request", () => {
+      const request = createMockRequest("req-1");
+      const progress = createMockProgress("req-1");
+
+      store.add(request);
+      store.addProgress(progress);
+
+      const requests = store.getRequests();
+      expect(requests[0].progress).toHaveLength(1);
+      expect(requests[0].progress[0]).toEqual(progress);
+    });
+
+    it("should add multiple progress updates to the same request", () => {
+      const request = createMockRequest("req-1");
+      const progress1 = createMockProgress("req-1", 0.5, 1024);
+      const progress2 = createMockProgress("req-1", 1.0, 2048);
+
+      store.add(request);
+      store.addProgress(progress1);
+      store.addProgress(progress2);
+
+      const requests = store.getRequests();
+      expect(requests[0].progress).toHaveLength(2);
+      expect(requests[0].progress[0]).toEqual(progress1);
+      expect(requests[0].progress[1]).toEqual(progress2);
+    });
+
+    it("should throw error when adding progress for non-existent request", () => {
+      const progress = createMockProgress("unknown-id");
+
+      expect(() => store.addProgress(progress)).toThrow(
+        "ABR: progress for a request not added",
+      );
+    });
+  });
+
+  describe("remove", () => {
+    it("should remove an existing request", () => {
+      const request = createMockRequest("req-1");
+
+      store.add(request);
+      expect(store.getRequests()).toHaveLength(1);
+
+      store.remove("req-1");
+      expect(store.getRequests()).toHaveLength(0);
+    });
+
+    it("should only remove the specified request", () => {
+      const request1 = createMockRequest("req-1");
+      const request2 = createMockRequest("req-2");
+
+      store.add(request1);
+      store.add(request2);
+
+      store.remove("req-1");
+
+      const requests = store.getRequests();
+      expect(requests).toHaveLength(1);
+      expect(requests[0].content).toBe(request2.content);
+    });
+
+    it("should throw error when removing non-existent request", () => {
+      expect(() => store.remove("unknown-id")).toThrow(
+        "ABR: can't remove unknown request",
+      );
+    });
+  });
+
+  describe("getRequests", () => {
+    it("should return empty array when no requests exist", () => {
+      const requests = store.getRequests();
+      expect(requests).toEqual([]);
+    });
+
+    it("should return all pending requests", () => {
+      const request1 = createMockRequest("req-1");
+      const request2 = createMockRequest("req-2");
+
+      store.add(request1);
+      store.add(request2);
+
+      const requests = store.getRequests();
+      expect(requests).toHaveLength(2);
+    });
+
+    it("should sort requests by segment time in chronological order", () => {
+      const request1 = createMockRequest("req-1", 1000, 300);
+      const request2 = createMockRequest("req-2", 2000, 100);
+      const request3 = createMockRequest("req-3", 3000, 200);
+
+      store.add(request1);
+      store.add(request2);
+      store.add(request3);
+
+      const requests = store.getRequests();
+      expect(requests[0].content.segment.time).toBe(100);
+      expect(requests[1].content.segment.time).toBe(200);
+      expect(requests[2].content.segment.time).toBe(300);
+    });
+
+    it("should return requests with their progress updates", () => {
+      const request = createMockRequest("req-1");
+      const progress1 = createMockProgress("req-1", 0.5, 1024);
+      const progress2 = createMockProgress("req-1", 1.0, 2048);
+
+      store.add(request);
+      store.addProgress(progress1);
+      store.addProgress(progress2);
+
+      const requests = store.getRequests();
+      expect(requests[0].progress).toEqual([progress1, progress2]);
+    });
+
+    it("should not include removed requests", () => {
+      const request1 = createMockRequest("req-1");
+      const request2 = createMockRequest("req-2");
+
+      store.add(request1);
+      store.add(request2);
+      store.remove("req-1");
+
+      const requests = store.getRequests();
+      expect(requests).toHaveLength(1);
+      expect(requests[0].content).toBe(request2.content);
+    });
+
+    it("should filter out null/undefined values", () => {
+      const request = createMockRequest("req-1");
+
+      store.add(request);
+      // Manually corrupt the internal state to test filtering
+      (store as any)._currentRequests.corrupted = null;
+
+      const requests = store.getRequests();
+      expect(requests).toHaveLength(1);
+      expect(requests[0].content).toBe(request.content);
+    });
+  });
+
+  describe("integration scenarios", () => {
+    it("should handle complete request lifecycle", () => {
+      const request = createMockRequest("req-1", 1000);
+      const progress1 = createMockProgress("req-1", 0.5, 1024, 2048, 1500);
+      const progress2 = createMockProgress("req-1", 1.0, 2048, 2048, 2000);
+
+      // Add request
+      store.add(request);
+      expect(store.getRequests()).toHaveLength(1);
+
+      // Add progress updates
+      store.addProgress(progress1);
+      store.addProgress(progress2);
+      expect(store.getRequests()[0].progress).toHaveLength(2);
+
+      // Remove request
+      store.remove("req-1");
+      expect(store.getRequests()).toHaveLength(0);
+    });
+
+    it("should handle multiple concurrent requests with different segment times", () => {
+      const request1 = createMockRequest("req-1", 1000, 500);
+      const request2 = createMockRequest("req-2", 1100, 200);
+      const request3 = createMockRequest("req-3", 1200, 350);
+
+      store.add(request1);
+      store.add(request2);
+      store.add(request3);
+
+      store.addProgress(createMockProgress("req-1", 0.5, 512));
+      store.addProgress(createMockProgress("req-2", 0.3, 300));
+      store.addProgress(createMockProgress("req-3", 0.7, 700));
+
+      const requests = store.getRequests();
+
+      // Should be sorted by segment time: 200, 350, 500
+      expect(requests[0].content.segment.time).toBe(200);
+      expect(requests[1].content.segment.time).toBe(350);
+      expect(requests[2].content.segment.time).toBe(500);
+
+      // Each should have their progress
+      expect(requests[0].progress).toHaveLength(1);
+      expect(requests[1].progress).toHaveLength(1);
+      expect(requests[2].progress).toHaveLength(1);
+    });
+  });
+});

package/src/core/adaptive/utils/__tests__/representation_score_calculator.test.ts

@@ -0,0 +1,247 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { IRepresentation } from "../../../../manifest";
+import RepresentationScoreCalculator, {
+  ScoreConfidenceLevel,
+} from "../representation_score_calculator";
+
+vi.mock("../../../../log", () => ({
+  default: {
+    debug: vi.fn(),
+  },
+}));
+
+vi.mock("../ewma", () => {
+  class EWMA {
+    private _estimate: number;
+    private _samples: Array<{ duration: number; value: number }>;
+    constructor() {
+      this._estimate = 0;
+      this._samples = [];
+    }
+    public addSample = vi.fn((duration: number, value: number) => {
+      this._samples.push({ duration, value });
+      // Simple average for testing purposes
+      this._estimate =
+        this._samples.reduce((sum, s) => sum + s.value, 0) / this._samples.length;
+    });
+    public getEstimate = vi.fn(() => this._estimate);
+  }
+
+  return {
+    default: EWMA,
+  };
+});
+
+describe("RepresentationScoreCalculator", () => {
+  let calculator: RepresentationScoreCalculator;
+  let mockRepresentation1: IRepresentation;
+  let mockRepresentation2: IRepresentation;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    calculator = new RepresentationScoreCalculator();
+
+    mockRepresentation1 = {
+      id: "rep1",
+      bitrate: 1000000,
+    } as IRepresentation;
+
+    mockRepresentation2 = {
+      id: "rep2",
+      bitrate: 2000000,
+    } as IRepresentation;
+  });
+
+  describe("addSample", () => {
+    it("should add a sample for a new representation", () => {
+      calculator.addSample(mockRepresentation1, 2, 4);
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate).toBeDefined();
+      expect(estimate?.score).toBe(2); // 4 / 2 = 2
+    });
+
+    it("should calculate the correct ratio (segmentDuration / requestDuration)", () => {
+      // If we can download 10 seconds of content in 5 seconds, ratio should be 2
+      calculator.addSample(mockRepresentation1, 5, 10);
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate?.score).toBe(2);
+    });
+
+    it("should accumulate samples for the same representation", () => {
+      calculator.addSample(mockRepresentation1, 2, 4); // ratio: 2
+      calculator.addSample(mockRepresentation1, 4, 8); // ratio: 2
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate).toBeDefined();
+      expect(estimate?.score).toBe(2);
+    });
+
+    it("should reset data when switching to a different representation", () => {
+      calculator.addSample(mockRepresentation1, 2, 4);
+      calculator.addSample(mockRepresentation2, 1, 2);
+
+      const estimate1 = calculator.getEstimate(mockRepresentation1);
+      const estimate2 = calculator.getEstimate(mockRepresentation2);
+
+      expect(estimate1).toBeUndefined();
+      expect(estimate2).toBeDefined();
+      expect(estimate2?.score).toBe(2);
+    });
+
+    it("should track loaded segments count", () => {
+      calculator.addSample(mockRepresentation1, 2, 4);
+      calculator.addSample(mockRepresentation1, 2, 4);
+      calculator.addSample(mockRepresentation1, 2, 4);
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate).toBeDefined();
+    });
+
+    it("should track total loaded duration", () => {
+      calculator.addSample(mockRepresentation1, 2, 4);
+      calculator.addSample(mockRepresentation1, 2, 6);
+      calculator.addSample(mockRepresentation1, 2, 5);
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate).toBeDefined();
+      // Total duration should be 4 + 6 + 5 = 15
+    });
+  });
+
+  describe("getEstimate", () => {
+    it("should return undefined for a representation with no samples", () => {
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate).toBeUndefined();
+    });
+
+    it("should return LOW confidence when less than 5 segments loaded", () => {
+      calculator.addSample(mockRepresentation1, 2, 4);
+      calculator.addSample(mockRepresentation1, 2, 4);
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate?.confidenceLevel).toBe(ScoreConfidenceLevel.LOW);
+    });
+
+    it("should return LOW confidence when loaded duration is less than 10 seconds", () => {
+      // Add 5 segments but with short duration
+      for (let i = 0; i < 5; i++) {
+        calculator.addSample(mockRepresentation1, 1, 1);
+      }
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate?.confidenceLevel).toBe(ScoreConfidenceLevel.LOW);
+    });
+
+    it("should return HIGH confidence when > 5 segments and >= 10 seconds loaded", () => {
+      // Add 5 segments with 2 seconds each (total 10 seconds)
+      for (let i = 0; i < 6; i++) {
+        calculator.addSample(mockRepresentation1, 1, 2);
+      }
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate?.confidenceLevel).toBe(ScoreConfidenceLevel.HIGH);
+    });
+
+    it("should return HIGH confidence when > 5 segments and > 10 seconds loaded", () => {
+      // Add 5 segments with 3 seconds each (total 15 seconds)
+      for (let i = 0; i < 6; i++) {
+        calculator.addSample(mockRepresentation1, 1, 3);
+      }
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate?.confidenceLevel).toBe(ScoreConfidenceLevel.HIGH);
+    });
+
+    it("should return undefined after switching representations", () => {
+      calculator.addSample(mockRepresentation1, 2, 4);
+      calculator.addSample(mockRepresentation2, 1, 2);
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate).toBeUndefined();
+    });
+  });
+
+  describe("getLastStableRepresentation", () => {
+    it("should return null initially", () => {
+      expect(calculator.getLastStableRepresentation()).toBeNull();
+    });
+
+    it("should return the representation when score exceeds 1", () => {
+      // Add sample with ratio > 1 (can download faster than playback)
+      calculator.addSample(mockRepresentation1, 2, 5); // ratio: 2.5
+
+      expect(calculator.getLastStableRepresentation()).toBe(mockRepresentation1);
+    });
+
+    it("should not update when score is <= 1", () => {
+      // Add sample with ratio <= 1
+      calculator.addSample(mockRepresentation1, 5, 4); // ratio: 0.8
+
+      expect(calculator.getLastStableRepresentation()).toBeNull();
+    });
+
+    it("should update to new representation with good score", () => {
+      calculator.addSample(mockRepresentation1, 2, 5); // ratio: 2.5
+      expect(calculator.getLastStableRepresentation()).toBe(mockRepresentation1);
+
+      calculator.addSample(mockRepresentation2, 1, 3); // ratio: 3
+      expect(calculator.getLastStableRepresentation()).toBe(mockRepresentation2);
+    });
+
+    it("should not update when adding more samples to same representation", () => {
+      calculator.addSample(mockRepresentation1, 2, 5); // ratio: 2.5
+      const firstStable = calculator.getLastStableRepresentation();
+
+      calculator.addSample(mockRepresentation1, 2, 6); // ratio: 3
+      const secondStable = calculator.getLastStableRepresentation();
+
+      expect(firstStable).toBe(secondStable);
+      expect(secondStable).toBe(mockRepresentation1);
+    });
+
+    it("should persist last stable representation even after switching to worse representation", () => {
+      calculator.addSample(mockRepresentation1, 2, 5); // ratio: 2.5
+      expect(calculator.getLastStableRepresentation()).toBe(mockRepresentation1);
+
+      calculator.addSample(mockRepresentation2, 5, 2); // ratio: 0.4
+      expect(calculator.getLastStableRepresentation()).toBe(mockRepresentation1);
+    });
+  });
+
+  describe("score calculation scenarios", () => {
+    it("should handle score exactly equal to 1", () => {
+      // Can download exactly at playback speed
+      calculator.addSample(mockRepresentation1, 4, 4); // ratio: 1
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate?.score).toBe(1);
+    });
+
+    it("should handle score less than 1 (slow download)", () => {
+      // Takes 10 seconds to download 5 seconds of content
+      calculator.addSample(mockRepresentation1, 10, 5); // ratio: 0.5
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate?.score).toBe(0.5);
+    });
+
+    it("should handle score greater than 1 (fast download)", () => {
+      // Takes 2 seconds to download 10 seconds of content
+      calculator.addSample(mockRepresentation1, 2, 10); // ratio: 5
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      expect(estimate?.score).toBe(5);
+    });
+
+    it("should average multiple samples correctly", () => {
+      calculator.addSample(mockRepresentation1, 2, 4); // ratio: 2
+      calculator.addSample(mockRepresentation1, 2, 6); // ratio: 3
+
+      const estimate = calculator.getEstimate(mockRepresentation1);
+      // Average of 2 and 3 is 2.5
+      expect(estimate?.score).toBe(2.5);
+    });
+  });
+});

package/src/core/entry/FreezeResolver.ts

@@ -1,4 +1,4 @@
-import { config } from "../../experimental";
+import config from "../../config";
 import log from "../../log";
 import type { IAdaptation, IPeriod, IRepresentation } from "../../manifest";
 import type {