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

package/src/core/fetchers/thumbnails/__tests__/thumbnail_fetcher.test.ts

@@ -0,0 +1,435 @@
+import type { Mock } from "vitest";
+import { describe, it, expect, vi, afterEach } from "vitest";
+import type { ICdnMetadata } from "../../../../parsers/manifest";
+import type {
+  IRequestedData,
+  IThumbnailLoader,
+  IThumbnailParser,
+} from "../../../../transports";
+import type { CancellationSignal } from "../../../../utils/task_canceller";
+import TaskCanceller, { CancellationError } from "../../../../utils/task_canceller";
+import type CdnPrioritizer from "../../cdn_prioritizer";
+import type { IBackoffSettings } from "../../utils/schedule_request";
+import createThumbnailFetcher from "../thumbnail_fetcher";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+const {
+  mockConfig,
+  mockLog,
+  mockScheduleRequestWithCdns,
+  mockFormatError,
+  mockErrorSelector,
+} = vi.hoisted(() => {
+  return {
+    mockConfig: {
+      getCurrent: vi.fn(() => ({
+        DEFAULT_MAX_THUMBNAIL_REQUESTS_RETRY_ON_ERROR: 3,
+        DEFAULT_THUMBNAIL_REQUEST_TIMEOUT: 10000,
+        DEFAULT_THUMBNAIL_CONNECTION_TIMEOUT: 5000,
+        INITIAL_BACKOFF_DELAY_BASE: { REGULAR: 200 },
+        MAX_BACKOFF_DELAY_BASE: { REGULAR: 3000 },
+      })),
+    },
+    mockLog: {
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    },
+    mockScheduleRequestWithCdns: vi.fn(
+      (
+        cdns: ICdnMetadata[] | null,
+        _cdnPrioritizer: CdnPrioritizer | null,
+        performRequest: (
+          cdn: ICdnMetadata | null,
+          cancellationSignal: CancellationSignal,
+        ) => Promise<IRequestedData<ArrayBuffer>>,
+        _options: IBackoffSettings,
+        globalCancellationSignal: CancellationSignal,
+      ): Promise<IRequestedData<ArrayBuffer>> => {
+        if (globalCancellationSignal.isCancelled()) {
+          return Promise.reject(globalCancellationSignal.cancellationError);
+        }
+        return performRequest(cdns?.[0] ?? null, new TaskCanceller("test task").signal);
+      },
+    ),
+    mockFormatError: vi.fn((err: unknown): any => err),
+    mockErrorSelector: vi.fn((err: unknown): any => err),
+  };
+});
+
+vi.mock("../../../../config", () => ({ default: mockConfig }));
+vi.mock("../../../../log", () => ({ default: mockLog }));
+vi.mock("../../utils/schedule_request", () => ({
+  scheduleRequestWithCdns: mockScheduleRequestWithCdns,
+}));
+vi.mock("../../../../errors", () => ({ formatError: mockFormatError }));
+vi.mock("../../utils/error_selector", () => ({ default: mockErrorSelector }));
+
+describe("createThumbnailFetcher", () => {
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("returns a function (fetchThumbnail)", () => {
+    const fetcher = createThumbnailFetcher(makePipeline(), null);
+    expect(typeof fetcher).toBe("function");
+  });
+
+  describe("successful fetch", () => {
+    it("calls loadThumbnail and parseThumbnail, returns parsed result", async () => {
+      const pipeline = makePipeline(
+        () =>
+          Promise.resolve({
+            responseData: new Uint8Array([0, 1, 2]).buffer,
+            size: 3,
+            requestDuration: 1000,
+          }),
+        (d) => ({ data: d, mimeType: "image/png", thumbnails: [] }),
+      );
+      pipeline.loadThumbnail.mockResolvedValue({
+        responseData: new Uint8Array([7, 7, 7]).buffer,
+        size: 3,
+        requestDuration: 500,
+      });
+
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller = new TaskCanceller("test");
+      const ctx = makeThumbnailContext();
+
+      const result = await fetcher(ctx, canceller.signal);
+      expect(result).toEqual({
+        data: new Uint8Array([7, 7, 7]).buffer,
+        mimeType: "image/png",
+        thumbnails: [],
+      });
+      expect(pipeline.parseThumbnail).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("request deduplication", () => {
+    it("shares the same promise when the same thumbnail is requested twice concurrently", async () => {
+      const pipeline = makePipeline();
+      let resolveRequest!: (v: IRequestedData<ArrayBuffer>) => void;
+      mockScheduleRequestWithCdns.mockReturnValue(
+        new Promise((res) => {
+          resolveRequest = res;
+        }),
+      );
+      pipeline.parseThumbnail.mockReturnValue({
+        mimeType: "image/gif",
+        data: new Uint8Array([4, 2, 2]).buffer,
+        thumbnails: [],
+      });
+
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller1 = new TaskCanceller("test1");
+      const canceller2 = new TaskCanceller("test2");
+      const ctx = makeThumbnailContext();
+
+      const p1 = fetcher(ctx, canceller1.signal);
+      const p2 = fetcher(ctx, canceller2.signal);
+
+      // Only one network call should have been made
+      expect(mockScheduleRequestWithCdns).toHaveBeenCalledTimes(1);
+
+      resolveRequest({
+        responseData: new Uint8Array([5, 6, 7]).buffer,
+        size: 3,
+        requestDuration: 900,
+      });
+
+      const [r1, r2] = await Promise.all([p1, p2]);
+      expect(r1).toEqual({
+        mimeType: "image/gif",
+        data: new Uint8Array([4, 2, 2]).buffer,
+        thumbnails: [],
+      });
+      expect(r2).toEqual({
+        mimeType: "image/gif",
+        data: new Uint8Array([4, 2, 2]).buffer,
+        thumbnails: [],
+      });
+    });
+
+    it("makes a new request when thumbnails differ", async () => {
+      const pipeline = makePipeline();
+      mockScheduleRequestWithCdns.mockResolvedValue({
+        responseData: new Uint8Array([7, 8, 7]).buffer,
+        size: 3,
+        requestDuration: 500,
+      });
+
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller1 = new TaskCanceller("test1");
+      const canceller2 = new TaskCanceller("test2");
+
+      // Fetch sequentially so there is no overlap
+      await fetcher(makeThumbnailContext({ segmentId: "seg-1" }), canceller1.signal);
+      await fetcher(makeThumbnailContext({ segmentId: "seg-2" }), canceller2.signal);
+
+      expect(mockScheduleRequestWithCdns).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("cancellation", () => {
+    it("rejects with CancellationError when the signal is already cancelled on entry", async () => {
+      const pipeline = makePipeline();
+      let resolveRequest!: (v: IRequestedData<ArrayBuffer>) => void;
+      mockScheduleRequestWithCdns.mockReturnValue(
+        new Promise((res) => {
+          resolveRequest = res;
+        }),
+      );
+
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller = new TaskCanceller("test");
+      const ctx = makeThumbnailContext();
+
+      const fetchPromise = fetcher(ctx, canceller.signal);
+      canceller.cancel("cancelled");
+      resolveRequest({
+        responseData: new Uint8Array([9, 7, 7]).buffer,
+        size: 3,
+        requestDuration: 500,
+      });
+
+      await expect(fetchPromise).rejects.toBeInstanceOf(CancellationError);
+    });
+
+    it("cancels the underlying request when all callers cancel", async () => {
+      const pipeline = makePipeline();
+      let rejectRequest!: (e: unknown) => void;
+      mockScheduleRequestWithCdns.mockReturnValue(
+        new Promise((_res, rej) => {
+          rejectRequest = rej;
+        }),
+      );
+
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller1 = new TaskCanceller("test1");
+      const canceller2 = new TaskCanceller("test2");
+      const ctx = makeThumbnailContext();
+
+      const p1 = fetcher(ctx, canceller1.signal);
+      const p2 = fetcher(ctx, canceller2.signal);
+
+      // Only one network request made
+      expect(mockScheduleRequestWithCdns).toHaveBeenCalledTimes(1);
+
+      canceller1.cancel("cancel1");
+      // Request should still be live because p2 is still pending
+      canceller2.cancel("cancel2");
+
+      // Trigger the underlying rejection to settle the promises
+      const cancelErr = new CancellationError("test task", "aborted");
+      rejectRequest(cancelErr);
+
+      await expect(p1).rejects.toBeInstanceOf(CancellationError);
+      await expect(p2).rejects.toBeInstanceOf(CancellationError);
+    });
+
+    it("keeps the request alive when only one of two callers cancels", async () => {
+      const pipeline = makePipeline();
+      let resolveRequest!: (v: IRequestedData<ArrayBuffer>) => void;
+      mockScheduleRequestWithCdns.mockReturnValue(
+        new Promise((res) => {
+          resolveRequest = res;
+        }),
+      );
+
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller1 = new TaskCanceller("test1");
+      const canceller2 = new TaskCanceller("test2");
+      const ctx = makeThumbnailContext();
+
+      const p1 = fetcher(ctx, canceller1.signal);
+      const p2 = fetcher(ctx, canceller2.signal);
+
+      canceller1.cancel("only first cancels");
+      resolveRequest({
+        responseData: new Uint8Array([4, 7, 7]).buffer,
+        size: 3,
+        requestDuration: 500,
+      });
+
+      // p2 should still resolve
+      const result = await p2;
+      expect(result).toEqual({
+        data: new Uint8Array([4, 7, 7]).buffer,
+
+        // Default mocked characteristics
+        mimeType: "image/png",
+        thumbnails: [
+          {
+            height: 720,
+            width: 1280,
+            offsetX: 0,
+            offsetY: 0,
+            start: 0,
+            end: Number.MAX_SAFE_INTEGER,
+          },
+        ],
+      });
+
+      // p1 should reject
+      await expect(p1).rejects.toBeInstanceOf(CancellationError);
+    });
+  });
+
+  describe("error handling", () => {
+    it("throws a formatted error when the network request fails with a non-cancellation error", async () => {
+      const networkError = new Error("network failure");
+      const formattedError = new Error("formatted request error");
+      mockScheduleRequestWithCdns.mockRejectedValue(networkError);
+      mockErrorSelector.mockReturnValue(formattedError);
+
+      const pipeline = makePipeline();
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller = new TaskCanceller("test");
+
+      await expect(fetcher(makeThumbnailContext(), canceller.signal)).rejects.toBe(
+        formattedError,
+      );
+      expect(mockErrorSelector).toHaveBeenCalledWith(networkError);
+    });
+
+    it("throws a formatted error when parseThumbnail throws", async () => {
+      const parseError = new Error("parse boom");
+      const formattedParseError = new Error("formatted parse error");
+      const pipeline = makePipeline();
+      pipeline.loadThumbnail.mockResolvedValue({
+        responseData: new Uint8Array([0, 1, 2]).buffer,
+        size: 3,
+        requestDuration: 1100,
+      });
+      pipeline.parseThumbnail.mockImplementation(() => {
+        throw parseError;
+      });
+      mockFormatError.mockReturnValue(formattedParseError);
+
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller = new TaskCanceller("test");
+
+      await expect(fetcher(makeThumbnailContext(), canceller.signal)).rejects.toBe(
+        formattedParseError,
+      );
+      expect(mockFormatError).toHaveBeenCalledWith(
+        parseError,
+        expect.objectContaining({
+          defaultCode: "PIPELINE_PARSE_ERROR",
+        }),
+      );
+    });
+
+    it("propagates CancellationError from scheduleRequestWithCdns without wrapping", async () => {
+      const cancelErr = new CancellationError("test task", "aborted");
+      mockScheduleRequestWithCdns.mockRejectedValue(cancelErr);
+
+      const pipeline = makePipeline();
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller = new TaskCanceller("test");
+
+      await expect(fetcher(makeThumbnailContext(), canceller.signal)).rejects.toBe(
+        cancelErr,
+      );
+      // errorSelector should not be called for CancellationError
+      expect(mockErrorSelector).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("retry logging", () => {
+    it("calls onRetry and logs a warning when the request retries", async () => {
+      const retryError = new Error("retry me");
+      const formattedRetryError = new Error("formatted retry");
+      mockErrorSelector.mockReturnValue(formattedRetryError);
+
+      mockScheduleRequestWithCdns.mockImplementation(
+        async (
+          _cdns: ICdnMetadata[] | null,
+          _cdnPrioritizer: CdnPrioritizer | null,
+          _performRequest: (
+            cdn: ICdnMetadata | null,
+            cancellationSignal: CancellationSignal,
+          ) => Promise<IRequestedData<ArrayBuffer>>,
+          options: IBackoffSettings,
+          _globalCancellationSignal: CancellationSignal,
+        ) => {
+          // Simulate the retry callback being invoked before eventual failure
+          options.onRetry?.(retryError);
+          throw retryError;
+        },
+      );
+      mockErrorSelector.mockReturnValue(formattedRetryError);
+
+      const pipeline = makePipeline();
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller = new TaskCanceller("test");
+
+      await expect(
+        fetcher(makeThumbnailContext(), canceller.signal),
+      ).rejects.toBeDefined();
+      expect(mockLog.warn).toHaveBeenCalledWith(
+        "Thumbnails",
+        "Thumbnail request retry ",
+        expect.any(Object),
+        formattedRetryError,
+      );
+    });
+  });
+});
+
+/**
+ * Construct `pipeline` argument for a ThumbnailFetcher
+ */
+function makePipeline(
+  loadThumbnailImpl?: IThumbnailLoader,
+  parseThumbnailImpl?: IThumbnailParser,
+): {
+  loadThumbnail: Mock<IThumbnailLoader>;
+  parseThumbnail: Mock<IThumbnailParser>;
+} {
+  return {
+    loadThumbnail: vi.fn(
+      loadThumbnailImpl ??
+        (() =>
+          Promise.resolve({
+            responseData: new Uint8Array([0, 1, 2]).buffer,
+            requestDuration: undefined,
+            url: undefined,
+            sendingTime: undefined,
+            receivedTime: undefined,
+            size: undefined,
+          })),
+    ),
+    parseThumbnail: vi.fn(
+      parseThumbnailImpl ??
+        ((data: ArrayBuffer) => ({
+          data,
+          mimeType: "image/png",
+          thumbnails: [
+            {
+              height: 720,
+              width: 1280,
+              offsetX: 0,
+              offsetY: 0,
+              start: 0,
+              end: Number.MAX_SAFE_INTEGER,
+            },
+          ],
+        })),
+    ),
+  };
+}
+
+function makeThumbnailContext(
+  overrides: { segmentId?: string; trackId?: string; periodId?: string } = {},
+): any {
+  return {
+    segment: { id: overrides.segmentId ?? "seg-1", time: 0 },
+    track: { id: overrides.trackId ?? "track-1", cdnMetadata: [] },
+    period: { id: overrides.periodId ?? "period-1" },
+  };
+}

package/src/core/fetchers/thumbnails/thumbnail_fetcher.ts

@@ -5,6 +5,7 @@ import type { ISegment, IThumbnailTrack } from "../../../manifest";
 import type { ICdnMetadata } from "../../../parsers/manifest";
 import type { IPeriod } from "../../../public_types";
 import type {
+  IRequestedData,
   IThumbnailLoader,
   IThumbnailLoaderOptions,
   IThumbnailPipeline,
@@ -46,7 +47,7 @@ export default function createThumbnailFetcher(
 
   interface IPendingThumbnailRequestInfo {
     /** Promise behind the thumbnail request. */
-    promise: Promise<IThumbnailResponse>;
+    promise: Promise<IRequestedData<ArrayBuffer>>;
     /**
      * Multiple caller might share the same request promise.
      * This reference counter keeps track of the number of caller that are
@@ -86,6 +87,8 @@ export default function createThumbnailFetcher(
   ): Promise<IThumbnailResponse> {
     cancellationSignal.register(onCancellation);
 
+    const { segment: thumbnail, track: thumbnailTrack } = thumbnailContext;
+
     let currRequestInfo: IPendingThumbnailRequestInfo;
 
     // First check if we're not requesting again the last thumbnail
@@ -113,10 +116,12 @@ export default function createThumbnailFetcher(
         throw err;
       }
       cancellationSignal.deregister(onCancellation);
-      return response;
-    }
 
-    const { segment: thumbnail, track: thumbnailTrack } = thumbnailContext;
+      if (cancellationSignal.isCancelled()) {
+        throw cancellationSignal.cancellationError;
+      }
+      return parseThumbnailStep(response);
+    }
 
     // NOTE: For now, as multiple `fetchThumbnail` calls might rely on the
     // same request, it is difficult to let different request options
@@ -144,7 +149,7 @@ export default function createThumbnailFetcher(
      * as several calls might share the same request.
      */
     const requestCanceller = new TaskCanceller("Thumbnail request");
-    const fetchPromise = doFetch();
+    const fetchPromise = fetchThumbnailStep();
     currRequestInfo = {
       thumbnailContext,
       promise: fetchPromise,
@@ -157,37 +162,37 @@ export default function createThumbnailFetcher(
         pendingRequestsInfo.splice(currRequestIdx, 1);
       }
     };
+    let fetchResult;
     try {
-      const fetchResult = await fetchPromise;
-      clearRequestInfo();
-      return fetchResult;
+      fetchResult = await fetchPromise;
     } catch (err) {
       clearRequestInfo();
+      cancellationSignal.deregister(onCancellation);
       throw err;
     }
 
-    async function doFetch() {
+    clearRequestInfo();
+    cancellationSignal.deregister(onCancellation);
+    if (cancellationSignal.isCancelled()) {
+      throw cancellationSignal.cancellationError;
+    }
+    return parseThumbnailStep(fetchResult);
+
+    async function fetchThumbnailStep(): Promise<IRequestedData<ArrayBuffer>> {
       log.debug("Thumbnails", "Beginning thumbnail request", { time: thumbnail.time });
-      let res;
       try {
-        res = await scheduleRequestWithCdns(
+        const res = await scheduleRequestWithCdns(
           thumbnailTrack.cdnMetadata,
           cdnPrioritizer,
           callLoaderWithUrl,
           objectAssign({ onRetry }, requestOptions),
           requestCanceller.signal,
         );
-
-        if (cancellationSignal.isCancelled()) {
-          return Promise.reject(cancellationSignal.cancellationError);
-        }
-
         log.debug("Thumbnails", "Thumbnail request ended with success", {
           time: thumbnail.time,
         });
-        cancellationSignal.deregister(onCancellation);
+        return res;
       } catch (err) {
-        cancellationSignal.deregister(onCancellation);
         if (err instanceof CancellationError) {
           log.debug("Thumbnails", "Thumbnail request aborted", { time: thumbnail.time });
           throw err;
@@ -195,13 +200,16 @@ export default function createThumbnailFetcher(
         log.debug("Thumbnails", "Thumbnail request failed", { time: thumbnail.time });
         throw errorSelector(err);
       }
+    }
 
+    function parseThumbnailStep(
+      rawResponse: IRequestedData<ArrayBuffer>,
+    ): IThumbnailResponse {
       try {
-        const parsed = pipeline.parseThumbnail(res.responseData, {
+        return pipeline.parseThumbnail(rawResponse.responseData, {
           thumbnail,
           thumbnailTrack,
         });
-        return parsed;
       } catch (error) {
         throw formatError(error, {
           defaultCode: "PIPELINE_PARSE_ERROR",