rx-player 4.5.0-dev.2026033100 → 4.5.0-dev.2026041501

package/src/core/stream/representation/utils/__tests__/get_segment_priority.test.ts

@@ -1,17 +1,14 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import configHandler from "../../../../../config";
 import getSegmentPriority from "../get_segment_priority";
 
-const mockGetCurrentConfig = vi.hoisted(() => vi.fn());
-vi.mock("../../../../../config", () => ({
-  default: {
-    getCurrent: mockGetCurrentConfig,
-  },
-}));
-
 describe("getSegmentPriority", () => {
+  const originalConfig = configHandler.getCurrent();
+  const mockGetCurrentConfig = vi.spyOn(configHandler, "getCurrent");
   beforeEach(() => {
     // Default configuration for most tests
     mockGetCurrentConfig.mockReturnValue({
+      ...originalConfig,
       SEGMENT_PRIORITIES_STEPS: [1, 5, 10, 20],
     });
   });
@@ -88,6 +85,7 @@ describe("getSegmentPriority", () => {
   describe("different config values", () => {
     it("should work with empty priority steps array", () => {
       mockGetCurrentConfig.mockReturnValue({
+        ...originalConfig,
         SEGMENT_PRIORITIES_STEPS: [],
       });
 
@@ -97,6 +95,7 @@ describe("getSegmentPriority", () => {
 
     it("should work with single priority step", () => {
       mockGetCurrentConfig.mockReturnValue({
+        ...originalConfig,
         SEGMENT_PRIORITIES_STEPS: [10],
       });
 
@@ -106,6 +105,7 @@ describe("getSegmentPriority", () => {
 
     it("should work with different step values", () => {
       mockGetCurrentConfig.mockReturnValue({
+        ...originalConfig,
         SEGMENT_PRIORITIES_STEPS: [2, 10, 30, 60],
       });
 

package/src/core/stream/representation/utils/__tests__/push_init_segment.test.ts

@@ -1,70 +1,109 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { Mock } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type Manifest from "../../../../../manifest/classes";
+import {
+  type Adaptation,
+  type Period,
+  type Representation,
+  type ISegment,
+} from "../../../../../manifest/classes";
+import {
+  DummyAdaptation,
+  DummyPeriod,
+  DummyManifest,
+  DummyRepresentation,
+  createSegment,
+} from "../../../../../manifest/classes/__tests__/mocks";
+import {
+  makeReadyOnlyPlaybackObserver,
+  DummyObservationPosition,
+} from "../../../../../playback_observer/__tests__/mocks";
+import type { IRange } from "../../../../../utils/ranges";
+import SharedReference from "../../../../../utils/reference";
+import TaskCanceller from "../../../../../utils/task_canceller";
+import { type SegmentSink } from "../../../../segment_sinks";
+import { DummySegmentSink } from "../../../../segment_sinks/__tests__/mocks";
+import type { IRepresentationStreamPlaybackObservation } from "../../types";
+import type appendSegmentToBuffer from "../append_segment_to_buffer";
 import pushInitSegment from "../push_init_segment";
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-
-const mockAppendSegmentToBuffer = vi.hoisted(() => vi.fn());
-
+const mockAppendSegmentToBuffer = vi.hoisted(
+  (): Mock<typeof appendSegmentToBuffer> =>
+    vi.fn((): Promise<IRange[]> => Promise.resolve([])),
+);
 vi.mock("../append_segment_to_buffer", () => ({
   default: mockAppendSegmentToBuffer,
 }));
 
 describe("pushInitSegment", () => {
-  let mockPlaybackObserver: any;
-  let mockSegmentSink: any;
-  let mockBufferGoal: any;
-  let mockCancelSignal: any;
-  let mockContent: any;
-  let mockSegment: any;
+  const mockedPlaybackObserver =
+    makeReadyOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>({
+      position: new DummyObservationPosition({
+        getWanted: vi.fn(() => 10),
+      }),
+      paused: {
+        last: false,
+        pending: undefined,
+      },
+      speed: 1,
+      canStream: true,
+    });
+  let mockSegmentSink: SegmentSink;
+  let mockBufferGoal: SharedReference<number>;
+  let mockCanceller: TaskCanceller;
+  let mockContent: {
+    adaptation: Adaptation;
+    manifest: Manifest;
+    period: Period;
+    representation: Representation;
+  };
+  let mockSegment: ISegment;
 
   beforeEach(() => {
     vi.resetAllMocks();
 
-    mockPlaybackObserver = {};
-
-    mockSegmentSink = {};
-
-    mockBufferGoal = {
-      getValue: vi.fn().mockReturnValue(30),
-    };
-
-    mockCancelSignal = {
-      signal: { aborted: false },
-      cancellationError: null,
-    };
-
+    mockSegmentSink = new DummySegmentSink();
+    mockBufferGoal = new SharedReference<number>(30);
+    mockCanceller = new TaskCanceller("pushInitSegment tests");
     mockContent = {
-      adaptation: { id: "adaptation-1" },
-      manifest: { id: "manifest-1" },
-      period: { id: "period-1" },
-      representation: {
+      adaptation: new DummyAdaptation({ id: "adaptation-1" }),
+      manifest: new DummyManifest({ id: "manifest-1" }),
+      period: new DummyPeriod({ id: "period-1" }),
+      representation: new DummyRepresentation({
         id: "rep-1",
-        getMimeTypeString: vi.fn().mockReturnValue('video/mp4; codecs="avc1.42E01E"'),
-      },
+      }),
     };
-
-    mockSegment = {
+    mockContent.representation.getMimeTypeString = vi
+      .fn()
+      .mockReturnValue('video/mp4; codecs="avc1.42E01E"');
+    mockSegment = createSegment({
       id: "init-segment",
       isInit: true,
       time: 0,
       duration: 0,
-    };
+    });
+  });
+
+  afterEach(() => {
+    mockBufferGoal.finish();
+    mockCanceller.cancel("test end");
+    mockedPlaybackObserver.reset();
+    vi.resetModules();
   });
 
   it("should call appendSegmentToBuffer with correct data structure", async () => {
-    mockAppendSegmentToBuffer.mockResolvedValue({
-      start: 0,
-      end: 10,
-    });
+    mockAppendSegmentToBuffer.mockResolvedValue([
+      {
+        start: 0,
+        end: 10,
+      },
+    ]);
 
     const initSegmentUniqueId = "unique-init-123";
 
     await pushInitSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         content: mockContent,
         initSegmentUniqueId,
         segmentData: null,
@@ -72,16 +111,16 @@ describe("pushInitSegment", () => {
         segmentSink: mockSegmentSink,
         bufferGoal: mockBufferGoal,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     expect(mockAppendSegmentToBuffer).toHaveBeenCalledTimes(1);
 
     const callArgs = mockAppendSegmentToBuffer.mock.calls[0];
-    expect(callArgs[0]).toBe(mockPlaybackObserver);
+    expect(callArgs[0]).toBe(mockedPlaybackObserver.observer);
     expect(callArgs[1]).toBe(mockSegmentSink);
     expect(callArgs[3]).toBe(mockBufferGoal);
-    expect(callArgs[4]).toBe(mockCancelSignal);
+    expect(callArgs[4]).toBe(mockCanceller.signal);
 
     const { data, inventoryInfos } = callArgs[2];
     expect(data).toEqual({
@@ -105,12 +144,12 @@ describe("pushInitSegment", () => {
   });
 
   it("should return correct payload with buffered result", async () => {
-    const mockBuffered = { start: 0, end: 10 };
+    const mockBuffered = [{ start: 0, end: 10 }];
     mockAppendSegmentToBuffer.mockResolvedValue(mockBuffered);
 
     const result = await pushInitSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         content: mockContent,
         initSegmentUniqueId: "init-456",
         segmentData: null,
@@ -118,7 +157,7 @@ describe("pushInitSegment", () => {
         segmentSink: mockSegmentSink,
         bufferGoal: mockBufferGoal,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     expect(result).toEqual({
@@ -129,11 +168,15 @@ describe("pushInitSegment", () => {
   });
 
   it("should call getMimeTypeString on representation", async () => {
-    mockAppendSegmentToBuffer.mockResolvedValue({ start: 0, end: 0 });
+    const mockGetMimeTypeString = vi.spyOn(
+      mockContent.representation,
+      "getMimeTypeString",
+    );
+    mockAppendSegmentToBuffer.mockResolvedValue([{ start: 0, end: 0 }]);
 
     await pushInitSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         content: mockContent,
         initSegmentUniqueId: "init-789",
         segmentData: null,
@@ -141,18 +184,18 @@ describe("pushInitSegment", () => {
         segmentSink: mockSegmentSink,
         bufferGoal: mockBufferGoal,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
-    expect(mockContent.representation.getMimeTypeString).toHaveBeenCalledTimes(1);
+    expect(mockGetMimeTypeString).toHaveBeenCalledTimes(1);
   });
 
   it("should set chunk to null for init segments", async () => {
-    mockAppendSegmentToBuffer.mockResolvedValue({});
+    mockAppendSegmentToBuffer.mockResolvedValue([]);
 
     await pushInitSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         content: mockContent,
         initSegmentUniqueId: "init-abc",
         segmentData: { someData: "value" },
@@ -160,7 +203,7 @@ describe("pushInitSegment", () => {
         segmentSink: mockSegmentSink,
         bufferGoal: mockBufferGoal,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     const { data } = mockAppendSegmentToBuffer.mock.calls[0][2];
@@ -168,11 +211,11 @@ describe("pushInitSegment", () => {
   });
 
   it("should set timestampOffset to 0", async () => {
-    mockAppendSegmentToBuffer.mockResolvedValue({});
+    mockAppendSegmentToBuffer.mockResolvedValue([]);
 
     await pushInitSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         content: mockContent,
         initSegmentUniqueId: "init-def",
         segmentData: null,
@@ -180,7 +223,7 @@ describe("pushInitSegment", () => {
         segmentSink: mockSegmentSink,
         bufferGoal: mockBufferGoal,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     const { data } = mockAppendSegmentToBuffer.mock.calls[0][2];
@@ -188,11 +231,11 @@ describe("pushInitSegment", () => {
   });
 
   it("should set appendWindow to [undefined, undefined]", async () => {
-    mockAppendSegmentToBuffer.mockResolvedValue({});
+    mockAppendSegmentToBuffer.mockResolvedValue([]);
 
     await pushInitSegment(
       {
-        playbackObserver: mockPlaybackObserver,
+        playbackObserver: mockedPlaybackObserver.observer,
         content: mockContent,
         initSegmentUniqueId: "init-ghi",
         segmentData: null,
@@ -200,7 +243,7 @@ describe("pushInitSegment", () => {
         segmentSink: mockSegmentSink,
         bufferGoal: mockBufferGoal,
       },
-      mockCancelSignal,
+      mockCanceller.signal,
     );
 
     const { data } = mockAppendSegmentToBuffer.mock.calls[0][2];