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

package/src/core/fetchers/segment/__tests__/segment_fetcher.test.ts

@@ -0,0 +1,872 @@
+import type { Mock } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { ICdnMetadata } from "../../../../parsers/manifest";
+import type {
+  ISegmentLoader,
+  ISegmentLoaderCallbacks,
+  ISegmentLoaderResultSegmentCreated,
+  ISegmentLoaderResultSegmentLoaded,
+  ISegmentParser,
+} from "../../../../transports";
+import sleep from "../../../../utils/sleep";
+import TaskCanceller, { CancellationError } from "../../../../utils/task_canceller";
+import type { CancellationSignal } from "../../../../utils/task_canceller";
+import type {
+  IMetricsCallbackPayload,
+  IRequestBeginCallbackPayload,
+  IRequestEndCallbackPayload,
+  IRequestProgressCallbackPayload,
+} from "../../../adaptive";
+import type CmcdDataBuilder from "../../../cmcd";
+import type CdnPrioritizer from "../../cdn_prioritizer";
+import type { IBackoffSettings } from "../../utils/schedule_request";
+import createSegmentFetcher, {
+  getSegmentFetcherRequestOptions,
+} from "../segment_fetcher";
+import type { ISegmentFetcherArguments, ISegmentLoaderContent } from "../segment_fetcher";
+import type { IParsedInitSegmentPayload, IParsedSegmentPayload } from "../segment_queue";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+const mockGetCurrent = vi.hoisted(() => vi.fn());
+const mockFormatError = vi.hoisted(() => vi.fn((err: unknown) => err));
+const mockLog = vi.hoisted(() => ({
+  debug: vi.fn(),
+}));
+const mockGetLoggableSegmentId = vi.hoisted(() => vi.fn(() => "seg-id"));
+const mockGetTimestamp = vi.hoisted(() => vi.fn(() => 1000));
+const mockScheduleRequestWithCdns = vi.hoisted(() => {
+  return vi.fn(
+    (
+      cdns: ICdnMetadata[] | null,
+      _cdnPrioritizer: CdnPrioritizer | null,
+      performRequest: (
+        cdn: ICdnMetadata | null,
+        cancellationSignal: CancellationSignal,
+      ) => Promise<ReturnType<ISegmentLoader<ArrayBuffer>>>,
+      _options: IBackoffSettings,
+      globalCancellationSignal: CancellationSignal,
+    ): Promise<ReturnType<ISegmentLoader<ArrayBuffer>>> => {
+      if (globalCancellationSignal.isCancelled()) {
+        return Promise.reject(globalCancellationSignal.cancellationError);
+      }
+      return performRequest(cdns?.[0] ?? null, new TaskCanceller("test task").signal);
+    },
+  );
+});
+const mockErrorSelector = vi.hoisted(() => vi.fn((err: unknown) => err));
+const mockInitializationSegmentCacheGet = vi.hoisted(() => vi.fn((): unknown => null));
+const mockInitializationSegmentCacheAdd = vi.hoisted(() => vi.fn());
+const mockInitializationSegmentCache = vi.hoisted(
+  () =>
+    class {
+      get = mockInitializationSegmentCacheGet;
+      add = mockInitializationSegmentCacheAdd;
+    },
+);
+
+vi.mock("../../../../config", () => ({
+  default: { getCurrent: mockGetCurrent },
+}));
+vi.mock("../../../../errors", () => ({ formatError: mockFormatError }));
+vi.mock("../../../../log", () => ({ default: mockLog }));
+vi.mock("../../../../manifest", () => ({
+  getLoggableSegmentId: mockGetLoggableSegmentId,
+}));
+vi.mock("../../../../utils/monotonic_timestamp", () => ({ default: mockGetTimestamp }));
+vi.mock("../../utils/schedule_request", () => ({
+  scheduleRequestWithCdns: mockScheduleRequestWithCdns,
+}));
+vi.mock("../../utils/error_selector", () => ({ default: mockErrorSelector }));
+vi.mock("../initialization_segment_cache", () => ({
+  default: mockInitializationSegmentCache,
+}));
+vi.mock("../../../../utils/is_null_or_undefined", () => ({
+  default: (val: unknown) => val === null || val === undefined,
+}));
+vi.mock("../../../../utils/object_assign", () => ({
+  // eslint-disable-next-line no-restricted-properties
+  default: (target: object, ...sources: object[]) => Object.assign(target, ...sources),
+}));
+
+function makeContent(): ISegmentLoaderContent {
+  return {
+    manifest: { isLive: false, publishTime: 123 },
+    period: { start: 0, end: 100 },
+    adaptation: { type: "video", language: "fr" },
+    representation: {
+      mimeType: "video/mp4",
+      codecs: ["avc1"],
+      cdnMetadata: [{ url: "http://cdn1.test" }],
+    },
+    segment: { id: "seg1" },
+    nextSegment: undefined,
+  } as any;
+}
+
+function makeParsed(
+  type: "init" | "media" = "media",
+  duration = 2,
+): IParsedSegmentPayload<ArrayBuffer> | IParsedInitSegmentPayload<ArrayBuffer> {
+  if (type === "init") {
+    return {
+      segmentType: "init",
+      initializationData: new Uint8Array([5, 6, 8]).buffer,
+      protectionData: [],
+      initializationDataSize: 3,
+      segment: {} as any,
+    };
+  }
+  return {
+    segmentType: "media",
+    chunkInfos: {
+      duration,
+      time: 0,
+    },
+    appendWindow: [0, Number.MAX_SAFE_INTEGER],
+    protectionData: [],
+    chunkOffset: 0,
+    chunkSize: 3,
+    chunkData: new Uint8Array([7, 7, 7]).buffer,
+    segment: {} as any,
+  };
+}
+
+function makeLoadedResult(
+  responseData: ArrayBuffer = new Uint8Array([1, 2, 3]).buffer,
+): ISegmentLoaderResultSegmentLoaded<ArrayBuffer> {
+  return {
+    resultType: "segment-loaded",
+    resultData: { responseData, size: 3, requestDuration: 1500 },
+  };
+}
+
+function makeCreatedResult(
+  data: ArrayBuffer = new Uint8Array([4, 5, 6]).buffer,
+): ISegmentLoaderResultSegmentCreated<ArrayBuffer> {
+  return {
+    resultType: "segment-created",
+    resultData: data,
+  };
+}
+
+function makePipeline(
+  parsedResult:
+    | IParsedSegmentPayload<ArrayBuffer>
+    | IParsedInitSegmentPayload<ArrayBuffer> = makeParsed(),
+  loadResult:
+    | ISegmentLoaderResultSegmentLoaded<ArrayBuffer>
+    | ISegmentLoaderResultSegmentCreated<ArrayBuffer> = makeLoadedResult(),
+): {
+  loadSegment: Mock<ISegmentLoader<ArrayBuffer>>;
+  parseSegment: Mock<ISegmentParser<ArrayBuffer, ArrayBuffer>>;
+} {
+  return {
+    loadSegment: vi.fn().mockResolvedValue(loadResult),
+    parseSegment: vi.fn().mockReturnValue(parsedResult),
+  };
+}
+
+function makeDefaultSegmentFetcherArgs(): ISegmentFetcherArguments<
+  ArrayBuffer,
+  ArrayBuffer
+> & {
+  pipeline: {
+    loadSegment: Mock<ISegmentLoader<ArrayBuffer>>;
+    parseSegment: Mock<ISegmentParser<ArrayBuffer, ArrayBuffer>>;
+  };
+  eventListeners: {
+    onRequestBegin?: Mock<(arg: IRequestBeginCallbackPayload) => void>;
+    onProgress?: Mock<(arg: IRequestProgressCallbackPayload) => void>;
+    onRequestEnd?: Mock<(arg: IRequestEndCallbackPayload) => void>;
+    onMetrics?: Mock<(arg: IMetricsCallbackPayload) => void>;
+  };
+} {
+  return {
+    bufferType: "video",
+    pipeline: makePipeline(),
+    cdnPrioritizer: null,
+    cmcdDataBuilder: null,
+    eventListeners: {
+      onRequestBegin: vi.fn(),
+      onProgress: vi.fn(),
+      onRequestEnd: vi.fn(),
+      onMetrics: vi.fn(),
+    },
+    requestOptions: {
+      baseDelay: 200,
+      maxDelay: 3000,
+      maxRetry: 3,
+      requestTimeout: 30000,
+      connectionTimeout: 5000,
+    },
+  };
+}
+
+describe("createSegmentFetcher", () => {
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+  describe("cache behavior", () => {
+    it("returns cached data without making a network request when cache hits", async () => {
+      const data = { a: 5 };
+      mockInitializationSegmentCacheGet.mockReturnValue(data);
+      const parsed = makeParsed();
+      const args = makeDefaultSegmentFetcherArgs();
+      const pipeline = makePipeline(parsed);
+      args.pipeline = pipeline;
+      const fetchSegment = createSegmentFetcher(args);
+      const onChunk = vi.fn();
+      const onAllChunksReceived = vi.fn();
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk, onAllChunksReceived, onRetry: vi.fn() },
+        signal,
+      );
+
+      expect(mockScheduleRequestWithCdns).not.toHaveBeenCalled();
+      expect(onChunk).toHaveBeenCalledTimes(1);
+      // The parser function should invoke parseSegment
+      const parseFn = onChunk.mock.calls[0][0];
+      parseFn(undefined);
+      expect(pipeline.parseSegment).toHaveBeenCalledWith(
+        { data, isChunked: false },
+        expect.any(Object),
+        undefined,
+      );
+    });
+  });
+
+  describe("successful segment-loaded flow", () => {
+    it("calls onRequestBegin with a timestamp and id", async () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      expect(args.eventListeners.onRequestBegin).toHaveBeenCalledWith(
+        expect.objectContaining({ requestTimestamp: 1000 }),
+      );
+    });
+
+    it("calls onChunk once with a parse function", async () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const onChunk = vi.fn();
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk, onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      expect(onChunk).toHaveBeenCalledTimes(1);
+      expect(typeof onChunk.mock.calls[0][0]).toBe("function");
+    });
+
+    it("calls onAllChunksReceived after onChunk", async () => {
+      const callOrder: string[] = [];
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        {
+          onChunk: () => callOrder.push("chunk"),
+          onAllChunksReceived: () => callOrder.push("allChunks"),
+          onRetry: vi.fn(),
+        },
+        signal,
+      );
+
+      expect(callOrder).toEqual(["chunk", "allChunks"]);
+    });
+
+    it("adds loaded data to cache", async () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      expect(mockInitializationSegmentCacheAdd).toHaveBeenCalledWith(
+        expect.any(Object),
+        new Uint8Array([1, 2, 3]).buffer,
+      );
+    });
+
+    it("calls onRequestEnd after success", async () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      expect(args.eventListeners.onRequestEnd).toHaveBeenCalledWith(
+        expect.objectContaining({ id: expect.any(String) }),
+      );
+    });
+
+    it("sends metrics after chunk is parsed (media segment with duration)", async () => {
+      const parsed = makeParsed("media", 3);
+      const pipeline = makePipeline(parsed, makeLoadedResult());
+      const args = makeDefaultSegmentFetcherArgs();
+      args.pipeline = pipeline;
+      const fetchSegment = createSegmentFetcher(args);
+      const onChunk = vi.fn();
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk, onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      // parse the chunk to trigger metrics
+      onChunk.mock.calls[0][0](undefined);
+
+      expect(args.eventListeners.onMetrics).toHaveBeenCalledWith(
+        expect.objectContaining({
+          size: 3,
+          requestDuration: 1500,
+          segmentDuration: 3,
+        }),
+      );
+    });
+
+    it("does not send metrics twice for the same chunk", async () => {
+      const parsed = makeParsed("media", 3);
+      const pipeline = makePipeline(parsed, makeLoadedResult());
+      const args = makeDefaultSegmentFetcherArgs();
+      args.pipeline = pipeline;
+      const fetchSegment = createSegmentFetcher(args);
+      const onChunk = vi.fn();
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk, onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      const parseFn = onChunk.mock.calls[0][0];
+      parseFn(undefined);
+      parseFn(undefined);
+
+      expect(args.eventListeners.onMetrics).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("segment-created flow", () => {
+    it("calls onChunk and onAllChunksReceived for created segment", async () => {
+      const createdResult = makeCreatedResult();
+      const pipeline = makePipeline(makeParsed(), createdResult);
+      pipeline.loadSegment.mockResolvedValue(createdResult);
+      mockScheduleRequestWithCdns.mockImplementation(() => {
+        return new Promise<Promise<ISegmentLoaderResultSegmentCreated<ArrayBuffer>>>(
+          (res) => {
+            const response = Promise.resolve(createdResult);
+            res(response);
+          },
+        );
+      });
+
+      const args = makeDefaultSegmentFetcherArgs();
+      args.pipeline = pipeline;
+      const fetchSegment = createSegmentFetcher(args);
+      const onChunk = vi.fn();
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk, onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      expect(onChunk).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not add created segment to cache", async () => {
+      const createdResult = makeCreatedResult();
+      mockScheduleRequestWithCdns.mockResolvedValue(createdResult);
+
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      expect(mockInitializationSegmentCacheAdd).not.toHaveBeenCalled();
+    });
+
+    it("does not send metrics for created segments", async () => {
+      const createdResult = makeCreatedResult();
+      mockScheduleRequestWithCdns.mockResolvedValue(createdResult);
+
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const onChunk = vi.fn();
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk, onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      // parse the chunk
+      if (onChunk.mock.calls.length > 0) {
+        onChunk.mock.calls[0][0](undefined);
+      }
+
+      expect(args.eventListeners.onMetrics).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("progress callback", () => {
+    it("calls onProgress when size < totalSize", async () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      args.pipeline.loadSegment.mockImplementation(
+        async (
+          _cdn: unknown,
+          _ctx: unknown,
+          _opts: unknown,
+          _sig: unknown,
+          callbacks: ISegmentLoaderCallbacks<ArrayBuffer>,
+        ) => {
+          callbacks.onProgress({ duration: 500, size: 1, totalSize: 3 });
+          await sleep(0);
+          return makeLoadedResult();
+        },
+      );
+      const fetchSegment = createSegmentFetcher(args);
+      await fetchSegment(
+        makeContent(),
+        { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        new TaskCanceller("test run").signal,
+      );
+      expect(args.eventListeners.onProgress).toHaveBeenCalledWith(
+        expect.objectContaining({ size: 1, totalSize: 3 }),
+      );
+    });
+
+    it("does not call onProgress when size >= totalSize", async () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      args.pipeline.loadSegment.mockImplementation(
+        async (
+          _cdn: unknown,
+          _ctx: unknown,
+          _opts: unknown,
+          _sig: unknown,
+          callbacks: ISegmentLoaderCallbacks<ArrayBuffer>,
+        ) => {
+          callbacks.onProgress({ duration: 500, size: 3, totalSize: 3 });
+          return makeLoadedResult();
+        },
+      );
+      const fetchSegment = createSegmentFetcher(args);
+      await fetchSegment(
+        makeContent(),
+        { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        new TaskCanceller("test run").signal,
+      );
+      expect(args.eventListeners.onProgress).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("onNewChunk (chunked loading)", () => {
+    it("calls onChunk for each chunk received via onNewChunk", async () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      args.pipeline.loadSegment.mockImplementation(
+        async (
+          _cdn: unknown,
+          _ctx: unknown,
+          _opts: unknown,
+          _sig: unknown,
+          callbacks: ISegmentLoaderCallbacks<ArrayBuffer>,
+        ) => {
+          callbacks.onNewChunk(new Uint8Array([1, 2, 3]).buffer);
+          callbacks.onNewChunk(new Uint8Array([4, 5, 6]).buffer);
+          return makeLoadedResult();
+        },
+      );
+      const fetchSegment = createSegmentFetcher(args);
+      const onChunk = vi.fn();
+      await fetchSegment(
+        makeContent(),
+        { onChunk, onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        new TaskCanceller("test run").signal,
+      );
+      // 2 from onNewChunk + 1 from the final loaded data
+      expect(onChunk).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe("error handling", () => {
+    it("throws and calls onRequestEnd on non-cancellation error", async () => {
+      const networkError = new Error("Network error");
+      mockScheduleRequestWithCdns.mockRejectedValue(networkError);
+      mockErrorSelector.mockReturnValue(networkError);
+
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+
+      await expect(
+        fetchSegment(
+          makeContent(),
+          { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+          new TaskCanceller("test run").signal,
+        ),
+      ).rejects.toThrow("Network error");
+
+      expect(args.eventListeners.onRequestEnd).toHaveBeenCalledWith(
+        expect.objectContaining({ id: expect.any(String) }),
+      );
+    });
+
+    it("re-throws CancellationError without calling onRequestEnd in catch", async () => {
+      const cancellationError = new CancellationError("test task", "test reason");
+      mockScheduleRequestWithCdns.mockRejectedValue(cancellationError);
+
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const signal = new TaskCanceller("test run").signal;
+
+      await expect(
+        fetchSegment(
+          makeContent(),
+          { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+          signal,
+        ),
+      ).rejects.toBeInstanceOf(CancellationError);
+
+      // onRequestEnd should NOT be called from the catch block for cancellation
+      expect(args.eventListeners.onRequestEnd).not.toHaveBeenCalled();
+    });
+
+    it("calls onRetry callback when a retry occurs", async () => {
+      const retryError = new Error("retry error");
+      mockErrorSelector.mockReturnValue(retryError);
+
+      // scheduleRequestWithCdns calls onRetry then succeeds
+      mockScheduleRequestWithCdns.mockImplementation(
+        async (
+          _cdns: unknown,
+          _prio: unknown,
+          // TODO: Why did I not succeed to define this?
+          performRequest: any,
+          opts: IBackoffSettings,
+        ) => {
+          opts.onRetry(retryError);
+          return performRequest(null, new TaskCanceller("test task").signal);
+        },
+      );
+
+      const onRetry = vi.fn();
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry },
+        signal,
+      );
+
+      expect(onRetry).toHaveBeenCalledWith(retryError);
+    });
+
+    it("wraps parse errors with formatError", async () => {
+      const parseError = new Error("parse fail");
+      const wrappedError = new Error("PIPELINE_PARSE_ERROR");
+      mockFormatError.mockReturnValue(wrappedError);
+
+      const pipeline = makePipeline();
+      pipeline.parseSegment.mockImplementation(() => {
+        throw parseError;
+      });
+
+      const args = makeDefaultSegmentFetcherArgs();
+      args.pipeline = pipeline;
+      const fetchSegment = createSegmentFetcher(args);
+      const onChunk = vi.fn();
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk, onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      const parseFn = onChunk.mock.calls[0][0];
+      expect(() => parseFn(undefined)).toThrow(wrappedError);
+      expect(mockFormatError).toHaveBeenCalledWith(parseError, {
+        defaultCode: "PIPELINE_PARSE_ERROR",
+        defaultReason: "Unknown parsing error",
+      });
+    });
+  });
+
+  describe("cancellation", () => {
+    it("calls onRequestEnd from cancellation handler when request is in flight", async () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+
+      const canceller = new TaskCanceller("test run");
+
+      mockScheduleRequestWithCdns.mockImplementation(async () => {
+        // Trigger cancellation callback before resolving
+        canceller.cancel("test reason");
+        throw canceller.signal.cancellationError;
+      });
+
+      await expect(
+        fetchSegment(
+          makeContent(),
+          { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+          canceller.signal,
+        ),
+      ).rejects.toBeInstanceOf(CancellationError);
+
+      // onRequestEnd should have been called by the onCancellation handler
+      expect(args.eventListeners.onRequestEnd).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not call onRequestEnd from main flow if already cancelled", async () => {
+      const canceller = new TaskCanceller("test run");
+      canceller.cancel("test cancel");
+      mockScheduleRequestWithCdns.mockImplementation(async () => {
+        throw canceller.signal.cancellationError;
+      });
+
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+
+      await expect(
+        fetchSegment(
+          makeContent(),
+          { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+          canceller.signal,
+        ),
+      ).rejects.toBeInstanceOf(CancellationError);
+    });
+  });
+
+  describe("CMCD integration", () => {
+    it("passes cmcd payload to loadSegment when cmcdDataBuilder is set", async () => {
+      const cmcdPayload = { sessionId: "abc" };
+      const cmcdDataBuilder: CmcdDataBuilder = {
+        getCmcdDataForSegmentRequest: vi.fn().mockReturnValue(cmcdPayload),
+      } as any;
+
+      const args = makeDefaultSegmentFetcherArgs();
+      args.cmcdDataBuilder = cmcdDataBuilder;
+      const fetchSegment = createSegmentFetcher(args);
+      const signal = new TaskCanceller("test run").signal;
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk: vi.fn(), onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      expect(cmcdDataBuilder.getCmcdDataForSegmentRequest).toHaveBeenCalled();
+    });
+  });
+
+  describe("requestTimeout and connectionTimeout configuration", () => {
+    it("sets timeout to undefined when requestTimeout is negative", () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      args.requestOptions = {
+        baseDelay: 200,
+        maxDelay: 3000,
+        maxRetry: 3,
+        requestTimeout: -1,
+        connectionTimeout: 5000,
+      };
+      // just ensure it doesn't throw
+      expect(() => createSegmentFetcher(args)).not.toThrow();
+    });
+
+    it("sets connectionTimeout to undefined when it is negative", () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      args.requestOptions = {
+        baseDelay: 200,
+        maxDelay: 3000,
+        maxRetry: 3,
+        requestTimeout: 30000,
+        connectionTimeout: -1,
+      };
+      expect(() => createSegmentFetcher(args)).not.toThrow();
+    });
+  });
+
+  describe("segmentDuration accumulation", () => {
+    it("accumulates duration across multiple chunks", async () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const onChunk = vi.fn();
+      const signal = new TaskCanceller("test run").signal;
+
+      // two chunks via onNewChunk, then one final load result suppressed by returning null
+      args.pipeline.loadSegment.mockImplementation(
+        async (
+          _cdn: unknown,
+          _ctx: unknown,
+          _opts: unknown,
+          _sig: unknown,
+          callbacks: ISegmentLoaderCallbacks<ArrayBuffer>,
+        ) => {
+          callbacks.onNewChunk(new Uint8Array([0, 1, 2]).buffer);
+          callbacks.onNewChunk(new Uint8Array([3, 4, 5]).buffer);
+          // return a loaded segment but with 0 size to simplify metrics trigger
+          return {
+            resultType: "segment-loaded",
+            resultData: {
+              responseData: new Uint8Array([4, 6, 7]).buffer,
+              size: 3,
+              requestDuration: 1000,
+            },
+          };
+        },
+      );
+
+      // chunk-a → duration 2, chunk-b → duration 3, final → duration 1
+      let callCount = 0;
+      args.pipeline.parseSegment.mockImplementation(() => {
+        callCount++;
+        return {
+          segmentType: "media",
+          chunkData: new Uint8Array([4, 5, 6]).buffer,
+          chunkOffset: 0,
+          appendWindow: [0, Number.MAX_SAFE_INTEGER],
+          chunkSize: 3,
+          protectionData: [],
+          chunkInfos: { duration: callCount, time: 0 },
+        };
+      });
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk, onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      // parse all chunks
+      onChunk.mock.calls.forEach(([parseFn]: Array<(x?: unknown) => void>) =>
+        parseFn(undefined),
+      );
+
+      expect(args.eventListeners.onMetrics).toHaveBeenCalledWith(
+        expect.objectContaining({ segmentDuration: 1 + 2 + 3 }),
+      );
+    });
+
+    it("sets segmentDuration to undefined if a chunk has no duration info", async () => {
+      const args = makeDefaultSegmentFetcherArgs();
+      const fetchSegment = createSegmentFetcher(args);
+      const onChunk = vi.fn();
+      const signal = new TaskCanceller("test run").signal;
+
+      args.pipeline.parseSegment.mockReturnValue({
+        segmentType: "media",
+        chunkData: new Uint8Array([4, 5, 6]).buffer,
+        chunkOffset: 0,
+        appendWindow: [0, Number.MAX_SAFE_INTEGER],
+        chunkSize: 3,
+        protectionData: [],
+        chunkInfos: { duration: undefined, time: 0 }, // no duration
+      });
+
+      await fetchSegment(
+        makeContent(),
+        { onChunk, onAllChunksReceived: vi.fn(), onRetry: vi.fn() },
+        signal,
+      );
+
+      onChunk.mock.calls.forEach(([parseFn]: Array<(x?: unknown) => void>) =>
+        parseFn(undefined),
+      );
+
+      expect(args.eventListeners.onMetrics).toHaveBeenCalledWith(
+        expect.objectContaining({ segmentDuration: undefined }),
+      );
+    });
+  });
+});
+
+describe("getSegmentFetcherRequestOptions", () => {
+  beforeEach(() => {
+    mockGetCurrent.mockReturnValue({
+      DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR: 4,
+      DEFAULT_REQUEST_TIMEOUT: 10000,
+      DEFAULT_CONNECTION_TIMEOUT: 2000,
+      INITIAL_BACKOFF_DELAY_BASE: { LOW_LATENCY: 100, REGULAR: 200 },
+      MAX_BACKOFF_DELAY_BASE: { LOW_LATENCY: 1000, REGULAR: 3000 },
+    });
+  });
+
+  it("uses defaults from config when options not provided", () => {
+    const result = getSegmentFetcherRequestOptions({ lowLatencyMode: false });
+    expect(result).toEqual({
+      maxRetry: 4,
+      baseDelay: 200,
+      maxDelay: 3000,
+      requestTimeout: 10000,
+      connectionTimeout: 2000,
+    });
+  });
+
+  it("uses low-latency base/max delays when lowLatencyMode is true", () => {
+    const result = getSegmentFetcherRequestOptions({ lowLatencyMode: true });
+    expect(result.baseDelay).toBe(100);
+    expect(result.maxDelay).toBe(1000);
+  });
+
+  it("uses provided maxRetry over default", () => {
+    const result = getSegmentFetcherRequestOptions({
+      lowLatencyMode: false,
+      maxRetry: 10,
+    });
+    expect(result.maxRetry).toBe(10);
+  });
+
+  it("uses provided requestTimeout over default", () => {
+    const result = getSegmentFetcherRequestOptions({
+      lowLatencyMode: false,
+      requestTimeout: 5000,
+    });
+    expect(result.requestTimeout).toBe(5000);
+  });
+
+  it("uses provided connectionTimeout over default", () => {
+    const result = getSegmentFetcherRequestOptions({
+      lowLatencyMode: false,
+      connectionTimeout: 999,
+    });
+    expect(result.connectionTimeout).toBe(999);
+  });
+});