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

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

@@ -1,55 +1,70 @@
 import { describe, it, expect, vi } from "vitest";
-import type { IBufferedChunk } from "../../../../segment_sinks";
+import {
+  type Adaptation,
+  type Period,
+  type Representation,
+} from "../../../../../manifest/classes";
+import type Manifest from "../../../../../manifest/classes";
+import {
+  DummyPeriod,
+  DummyManifest,
+  DummyAdaptation,
+  createSegment,
+  DummyRepresentation,
+} from "../../../../../manifest/classes/__tests__/mocks";
+import { ChunkStatus, type IBufferedChunk } from "../../../../segment_sinks";
 import checkForDiscontinuity from "../check_for_discontinuity";
 
-/* 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 */
-
-// Minimal type setup for tests
-interface TestContent {
-  adaptation: { type: string };
-  manifest: any;
-  period: { end?: number };
-  representation: {
-    index: {
-      checkDiscontinuity: (time: number) => number | null;
-      awaitSegmentBetween: (start: number, end: number) => boolean | undefined;
-    };
-  };
-}
-
 describe("checkForDiscontinuity", () => {
-  const createMockContent = (overrides?: Partial<TestContent>): any => ({
-    adaptation: { type: "video" },
-    manifest: {},
-    period: {},
-    representation: {
-      index: {
-        checkDiscontinuity: vi.fn(() => null),
-        awaitSegmentBetween: vi.fn(() => undefined),
-      },
-    },
-    ...overrides,
+  const createMockContent = (): {
+    adaptation: Adaptation;
+    manifest: Manifest;
+    period: Period;
+    representation: Representation;
+  } => ({
+    adaptation: new DummyAdaptation({ type: "video" }),
+    manifest: new DummyManifest(),
+    period: new DummyPeriod(),
+    representation: new DummyRepresentation(),
   });
 
-  const createBufferedChunk = (
-    start: number,
-    end: number,
-    segmentTime: number,
-    segmentEnd: number,
-  ): IBufferedChunk =>
-    ({
-      bufferedStart: start,
-      bufferedEnd: end,
+  function makeBufferedChunk({
+    start,
+    end,
+    bufferedStart = start,
+    bufferedEnd = end,
+    segmentTime,
+    segmentEnd,
+  }: {
+    start: number;
+    end: number;
+    bufferedStart?: number | undefined;
+    bufferedEnd?: number | undefined;
+    segmentTime: number;
+    segmentEnd: number;
+  }): IBufferedChunk {
+    return {
       infos: {
-        segment: {
+        period: new DummyPeriod(),
+        adaptation: new DummyAdaptation(),
+        representation: new DummyRepresentation(),
+        segment: createSegment({
           time: segmentTime,
           end: segmentEnd,
-        },
+        }),
       },
-    }) as IBufferedChunk;
+      bufferedStart,
+      bufferedEnd,
+      start,
+      end,
+      insertionTs: 0,
+      chunkSize: 1024,
+      precizeStart: true,
+      precizeEnd: true,
+      status: ChunkStatus.FullyLoaded,
+      splitted: false,
+    };
+  }
 
   describe("when no segments are buffered in range", () => {
     it("should return null when nextSegmentStart is provided", () => {
@@ -61,14 +76,12 @@ describe("checkForDiscontinuity", () => {
         false,
         [],
       );
-
       expect(result).toBeNull();
     });
 
     it("should return discontinuity to period end when finished loading and at period end", () => {
-      const content = createMockContent({
-        period: { end: 100 },
-      });
+      const content = createMockContent();
+      content.period.end = 100;
       const result = checkForDiscontinuity(
         content,
         { start: 90, end: 105 },
@@ -76,20 +89,17 @@ describe("checkForDiscontinuity", () => {
         true, // hasFinishedLoading
         [],
       );
-
       expect(result).toEqual({ start: undefined, end: null });
     });
 
     it("should return manifest discontinuity when no next segment", () => {
-      const content = createMockContent({
-        representation: {
-          index: {
-            checkDiscontinuity: vi.fn(() => 25),
-            awaitSegmentBetween: vi.fn(() => false),
-          },
-        },
-      });
-
+      const content = createMockContent();
+      const mockCheckDiscontinuity = vi
+        .spyOn(content.representation.index, "checkDiscontinuity")
+        .mockReturnValue(25);
+      vi.spyOn(content.representation.index, "awaitSegmentBetween").mockReturnValue(
+        false,
+      );
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 30 },
@@ -97,22 +107,17 @@ describe("checkForDiscontinuity", () => {
         false,
         [],
       );
-
       expect(result).toEqual({ start: undefined, end: 25 });
-      expect(content.representation.index.checkDiscontinuity).toHaveBeenCalledWith(10);
+      expect(mockCheckDiscontinuity).toHaveBeenCalledWith(10);
     });
 
     it("should return discontinuity to Period's end when has finished loading without segment and range after Period's end", () => {
-      const content = createMockContent({
-        period: { end: 29 },
-        representation: {
-          index: {
-            checkDiscontinuity: vi.fn(() => null),
-            awaitSegmentBetween: vi.fn(() => false),
-          },
-        },
-      });
-
+      const content = createMockContent();
+      content.period.end = 29;
+      vi.spyOn(content.representation.index, "checkDiscontinuity").mockReturnValue(null);
+      vi.spyOn(content.representation.index, "awaitSegmentBetween").mockReturnValue(
+        false,
+      );
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 30 },
@@ -120,21 +125,16 @@ describe("checkForDiscontinuity", () => {
         true, // hasFinishedLoading
         [],
       );
-
       expect(result).toEqual({ start: undefined, end: null });
     });
 
     it("should return discontinuity to Period's end when has finished loading without segment and range equal to Period's end", () => {
-      const content = createMockContent({
-        period: { end: 30 },
-        representation: {
-          index: {
-            checkDiscontinuity: vi.fn(() => null),
-            awaitSegmentBetween: vi.fn(() => false),
-          },
-        },
-      });
-
+      const content = createMockContent();
+      vi.spyOn(content.representation.index, "checkDiscontinuity").mockReturnValue(null);
+      vi.spyOn(content.representation.index, "awaitSegmentBetween").mockReturnValue(
+        false,
+      );
+      content.period.end = 30;
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 30 },
@@ -142,21 +142,16 @@ describe("checkForDiscontinuity", () => {
         true, // hasFinishedLoading
         [],
       );
-
       expect(result).toEqual({ start: undefined, end: null });
     });
 
     it("should not return discontinuity when has finished loading without segment and range before Period's end", () => {
-      const content = createMockContent({
-        period: { end: 31 },
-        representation: {
-          index: {
-            checkDiscontinuity: vi.fn(() => null),
-            awaitSegmentBetween: vi.fn(() => false),
-          },
-        },
-      });
-
+      const content = createMockContent();
+      content.period.end = 31;
+      vi.spyOn(content.representation.index, "checkDiscontinuity").mockReturnValue(null);
+      vi.spyOn(content.representation.index, "awaitSegmentBetween").mockReturnValue(
+        false,
+      );
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 30 },
@@ -164,7 +159,6 @@ describe("checkForDiscontinuity", () => {
         true, // hasFinishedLoading
         [],
       );
-
       expect(result).toEqual(null);
     });
   });
@@ -172,8 +166,9 @@ describe("checkForDiscontinuity", () => {
   describe("when there's a hole before the first buffered segment", () => {
     it("should detect discontinuity when hole won't be filled", () => {
       const content = createMockContent();
-      const bufferedSegments = [createBufferedChunk(15, 20, 15, 20)];
-
+      const bufferedSegments = [
+        makeBufferedChunk({ start: 15, end: 20, segmentTime: 15, segmentEnd: 20 }),
+      ];
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 25 },
@@ -181,14 +176,14 @@ describe("checkForDiscontinuity", () => {
         true,
         bufferedSegments,
       );
-
       expect(result).toEqual({ start: undefined, end: 15 });
     });
 
     it("should detect discontinuity when next segment won't fill the hole", () => {
       const content = createMockContent();
-      const bufferedSegments = [createBufferedChunk(15, 20, 15, 20)];
-
+      const bufferedSegments = [
+        makeBufferedChunk({ start: 15, end: 20, segmentTime: 15, segmentEnd: 20 }),
+      ];
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 25 },
@@ -196,14 +191,14 @@ describe("checkForDiscontinuity", () => {
         true,
         bufferedSegments,
       );
-
       expect(result).toEqual({ start: undefined, end: 15 });
     });
 
     it("should return null when a segment is expected to fill the hole", () => {
       const content = createMockContent();
-      const bufferedSegments = [createBufferedChunk(15, 20, 15, 20)];
-
+      const bufferedSegments = [
+        makeBufferedChunk({ start: 15, end: 20, segmentTime: 15, segmentEnd: 20 }),
+      ];
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 25 },
@@ -211,21 +206,18 @@ describe("checkForDiscontinuity", () => {
         false,
         bufferedSegments,
       );
-
       expect(result).toBeNull();
     });
 
     it("should return null when awaiting segment between start and hole", () => {
-      const content = createMockContent({
-        representation: {
-          index: {
-            checkDiscontinuity: vi.fn(() => null),
-            awaitSegmentBetween: vi.fn(() => true),
-          },
-        },
-      });
-      const bufferedSegments = [createBufferedChunk(15, 20, 15, 20)];
-
+      const content = createMockContent();
+      vi.spyOn(content.representation.index, "checkDiscontinuity").mockReturnValue(null);
+      const mockAwaitSegmentBetween = vi
+        .spyOn(content.representation.index, "awaitSegmentBetween")
+        .mockReturnValue(true);
+      const bufferedSegments = [
+        makeBufferedChunk({ start: 15, end: 20, segmentTime: 15, segmentEnd: 20 }),
+      ];
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 25 },
@@ -233,12 +225,8 @@ describe("checkForDiscontinuity", () => {
         false, // not finished loading
         bufferedSegments,
       );
-
       expect(result).toBeNull();
-      expect(content.representation.index.awaitSegmentBetween).toHaveBeenCalledWith(
-        10,
-        15,
-      );
+      expect(mockAwaitSegmentBetween).toHaveBeenCalledWith(10, 15);
     });
   });
 
@@ -246,10 +234,9 @@ describe("checkForDiscontinuity", () => {
     it("should detect discontinuity between consecutive segments", () => {
       const content = createMockContent();
       const bufferedSegments = [
-        createBufferedChunk(10, 15, 10, 15),
-        createBufferedChunk(20, 25, 20, 25), // hole from 15 to 20
+        makeBufferedChunk({ start: 10, end: 15, segmentTime: 10, segmentEnd: 15 }),
+        makeBufferedChunk({ start: 20, end: 25, segmentTime: 20, segmentEnd: 25 }), // hole from 15 to 20
       ];
-
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 30 },
@@ -257,17 +244,15 @@ describe("checkForDiscontinuity", () => {
         true,
         bufferedSegments,
       );
-
       expect(result).toEqual({ start: 15, end: 20 });
     });
 
     it("should detect discontinuity when next segment comes after the hole", () => {
       const content = createMockContent();
       const bufferedSegments = [
-        createBufferedChunk(10, 15, 10, 15),
-        createBufferedChunk(20, 25, 20, 25),
+        makeBufferedChunk({ start: 10, end: 15, segmentTime: 10, segmentEnd: 15 }),
+        makeBufferedChunk({ start: 20, end: 25, segmentTime: 20, segmentEnd: 25 }),
       ];
-
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 30 },
@@ -275,17 +260,15 @@ describe("checkForDiscontinuity", () => {
         true,
         bufferedSegments,
       );
-
       expect(result).toEqual({ start: 15, end: 20 });
     });
 
     it("should return null when next segment will fill the hole", () => {
       const content = createMockContent();
       const bufferedSegments = [
-        createBufferedChunk(10, 15, 10, 15),
-        createBufferedChunk(20, 25, 20, 25),
+        makeBufferedChunk({ start: 10, end: 15, segmentTime: 10, segmentEnd: 15 }),
+        makeBufferedChunk({ start: 20, end: 25, segmentTime: 20, segmentEnd: 25 }),
       ];
-
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 30 },
@@ -293,24 +276,19 @@ describe("checkForDiscontinuity", () => {
         false,
         bufferedSegments,
       );
-
       expect(result).toBeNull();
     });
 
     it("should return null when awaiting segment between holes", () => {
-      const content = createMockContent({
-        representation: {
-          index: {
-            checkDiscontinuity: vi.fn(() => null),
-            awaitSegmentBetween: vi.fn(() => true),
-          },
-        },
-      });
+      const content = createMockContent();
+      vi.spyOn(content.representation.index, "checkDiscontinuity").mockReturnValue(null);
+      const mockAwaitSegmentBetween = vi
+        .spyOn(content.representation.index, "awaitSegmentBetween")
+        .mockReturnValue(true);
       const bufferedSegments = [
-        createBufferedChunk(10, 15, 10, 15),
-        createBufferedChunk(20, 25, 20, 25),
+        makeBufferedChunk({ start: 10, end: 15, segmentTime: 10, segmentEnd: 15 }),
+        makeBufferedChunk({ start: 20, end: 25, segmentTime: 20, segmentEnd: 25 }),
       ];
-
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 30 },
@@ -318,24 +296,18 @@ describe("checkForDiscontinuity", () => {
         false, // not finished loading
         bufferedSegments,
       );
-
       expect(result).toBeNull();
-      expect(content.representation.index.awaitSegmentBetween).toHaveBeenCalledWith(
-        15,
-        20,
-      );
+      expect(mockAwaitSegmentBetween).toHaveBeenCalledWith(15, 20);
     });
   });
 
   describe("when checking for discontinuity at period end", () => {
     it("should detect discontinuity when last segment ends before period end", () => {
-      const content = createMockContent({
-        period: { end: 100 },
-      });
+      const content = createMockContent();
+      content.period.end = 100;
       const bufferedSegments = [
-        createBufferedChunk(80, 90, 80, 90), // ends before period end
+        makeBufferedChunk({ start: 80, end: 90, segmentTime: 80, segmentEnd: 90 }), // ends before period end
       ];
-
       const result = checkForDiscontinuity(
         content,
         { start: 80, end: 105 },
@@ -343,16 +315,15 @@ describe("checkForDiscontinuity", () => {
         true, // hasFinishedLoading
         bufferedSegments,
       );
-
       expect(result).toEqual({ start: 90, end: null });
     });
 
     it("should return null when checked range doesn't reach period end", () => {
-      const content = createMockContent({
-        period: { end: 100 },
-      });
-      const bufferedSegments = [createBufferedChunk(80, 90, 80, 90)];
-
+      const content = createMockContent();
+      content.period.end = 100;
+      const bufferedSegments = [
+        makeBufferedChunk({ start: 80, end: 90, segmentTime: 80, segmentEnd: 90 }),
+      ];
       const result = checkForDiscontinuity(
         content,
         { start: 80, end: 95 }, // doesn't reach period end
@@ -360,16 +331,15 @@ describe("checkForDiscontinuity", () => {
         true,
         bufferedSegments,
       );
-
       expect(result).toBeNull();
     });
 
     it("should return null when last segment reaches period end", () => {
-      const content = createMockContent({
-        period: { end: 100 },
-      });
-      const bufferedSegments = [createBufferedChunk(80, 100, 80, 100)];
-
+      const content = createMockContent();
+      content.period.end = 100;
+      const bufferedSegments = [
+        makeBufferedChunk({ start: 80, end: 100, segmentTime: 80, segmentEnd: 100 }),
+      ];
       const result = checkForDiscontinuity(
         content,
         { start: 80, end: 105 },
@@ -377,23 +347,22 @@ describe("checkForDiscontinuity", () => {
         true,
         bufferedSegments,
       );
-
       expect(result).toBeNull();
     });
   });
 
   describe("when checking for manifest discontinuity at range end", () => {
     it("should detect manifest discontinuity at end of range", () => {
-      const content = createMockContent({
-        representation: {
-          index: {
-            checkDiscontinuity: vi.fn((time) => (time === 50 ? 60 : null)),
-            awaitSegmentBetween: vi.fn(() => undefined),
-          },
-        },
-      });
-      const bufferedSegments = [createBufferedChunk(30, 40, 30, 40)];
-
+      const content = createMockContent();
+      const mockCheckDiscontinuity = vi
+        .spyOn(content.representation.index, "checkDiscontinuity")
+        .mockImplementation((time) => (time === 50 ? 60 : null));
+      vi.spyOn(content.representation.index, "awaitSegmentBetween").mockReturnValue(
+        undefined,
+      );
+      const bufferedSegments = [
+        makeBufferedChunk({ start: 30, end: 40, segmentTime: 30, segmentEnd: 40 }),
+      ];
       const result = checkForDiscontinuity(
         content,
         { start: 30, end: 50 },
@@ -401,22 +370,19 @@ describe("checkForDiscontinuity", () => {
         false,
         bufferedSegments,
       );
-
       expect(result).toEqual({ start: 40, end: 60 });
-      expect(content.representation.index.checkDiscontinuity).toHaveBeenCalledWith(50);
+      expect(mockCheckDiscontinuity).toHaveBeenCalledWith(50);
     });
 
     it("should return null when no manifest discontinuity at range end", () => {
-      const content = createMockContent({
-        representation: {
-          index: {
-            checkDiscontinuity: vi.fn(() => null),
-            awaitSegmentBetween: vi.fn(() => false),
-          },
-        },
-      });
-      const bufferedSegments = [createBufferedChunk(30, 40, 30, 40)];
-
+      const content = createMockContent();
+      vi.spyOn(content.representation.index, "checkDiscontinuity").mockReturnValue(null);
+      vi.spyOn(content.representation.index, "awaitSegmentBetween").mockReturnValue(
+        false,
+      );
+      const bufferedSegments = [
+        makeBufferedChunk({ start: 30, end: 40, segmentTime: 30, segmentEnd: 40 }),
+      ];
       const result = checkForDiscontinuity(
         content,
         { start: 30, end: 50 },
@@ -424,7 +390,6 @@ describe("checkForDiscontinuity", () => {
         false,
         bufferedSegments,
       );
-
       expect(result).toBeNull();
     });
   });
@@ -432,14 +397,20 @@ describe("checkForDiscontinuity", () => {
   describe("edge cases", () => {
     it("should handle segments with undefined bufferedStart", () => {
       const content = createMockContent();
+      vi.spyOn(content.representation.index, "checkDiscontinuity").mockReturnValue(null);
+      vi.spyOn(content.representation.index, "awaitSegmentBetween").mockReturnValue(
+        undefined,
+      );
       const bufferedSegments = [
-        {
+        makeBufferedChunk({
           bufferedStart: undefined,
           bufferedEnd: 15,
-          infos: { segment: { time: 10, end: 15 } },
-        } as IBufferedChunk,
+          segmentTime: 10,
+          segmentEnd: 15,
+          start: 10,
+          end: 15,
+        }),
       ];
-
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 20 },
@@ -447,20 +418,25 @@ describe("checkForDiscontinuity", () => {
         false,
         bufferedSegments,
       );
-
       expect(result).toBeNull();
     });
 
     it("should handle segments with undefined bufferedEnd", () => {
       const content = createMockContent();
+      vi.spyOn(content.representation.index, "checkDiscontinuity").mockReturnValue(null);
+      vi.spyOn(content.representation.index, "awaitSegmentBetween").mockReturnValue(
+        undefined,
+      );
       const bufferedSegments = [
-        {
+        makeBufferedChunk({
           bufferedStart: 10,
           bufferedEnd: undefined,
-          infos: { segment: { time: 10, end: 15 } },
-        } as IBufferedChunk,
+          segmentTime: 10,
+          segmentEnd: 15,
+          start: 10,
+          end: 15,
+        }),
       ];
-
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 20 },
@@ -468,18 +444,16 @@ describe("checkForDiscontinuity", () => {
         false,
         bufferedSegments,
       );
-
       expect(result).toBeNull();
     });
 
     it("should handle multiple segments where only some overlap with range", () => {
       const content = createMockContent();
       const bufferedSegments = [
-        createBufferedChunk(5, 8, 5, 8), // before range
-        createBufferedChunk(10, 15, 10, 15), // in range
-        createBufferedChunk(20, 25, 20, 25), // in range
+        makeBufferedChunk({ start: 5, end: 8, segmentTime: 5, segmentEnd: 8 }), // before range
+        makeBufferedChunk({ start: 10, end: 15, segmentTime: 10, segmentEnd: 15 }), // in range
+        makeBufferedChunk({ start: 20, end: 25, segmentTime: 20, segmentEnd: 25 }), // in range
       ];
-
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 30 },
@@ -487,18 +461,20 @@ describe("checkForDiscontinuity", () => {
         true,
         bufferedSegments,
       );
-
       expect(result).toEqual({ start: 15, end: 20 });
     });
 
     it("should handle consecutive segments without gaps", () => {
       const content = createMockContent();
+      vi.spyOn(content.representation.index, "checkDiscontinuity").mockReturnValue(null);
+      vi.spyOn(content.representation.index, "awaitSegmentBetween").mockReturnValue(
+        undefined,
+      );
       const bufferedSegments = [
-        createBufferedChunk(10, 15, 10, 15),
-        createBufferedChunk(15, 20, 15, 20),
-        createBufferedChunk(20, 25, 20, 25),
+        makeBufferedChunk({ start: 10, end: 15, segmentTime: 10, segmentEnd: 15 }),
+        makeBufferedChunk({ start: 15, end: 20, segmentTime: 15, segmentEnd: 20 }),
+        makeBufferedChunk({ start: 20, end: 25, segmentTime: 20, segmentEnd: 25 }),
       ];
-
       const result = checkForDiscontinuity(
         content,
         { start: 10, end: 30 },
@@ -506,7 +482,6 @@ describe("checkForDiscontinuity", () => {
         false,
         bufferedSegments,
       );
-
       expect(result).toBeNull();
     });
   });