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

package/src/core/adaptive/__tests__/mocks.ts

@@ -0,0 +1,100 @@
+import SharedReference from "../../../utils/reference";
+import type {
+  IABREstimate,
+  IAdaptiveRepresentationSelectorArguments,
+  IRepresentationEstimator,
+} from "../adaptive_representation_selector";
+
+/**
+ * Easily create objects matching the arguments of the `AdaptiveRepresentationSelector`.
+ */
+export function makeAdaptiveRepresensationSelectorArgs(
+  opts: Partial<IAdaptiveRepresentationSelectorArguments> = {},
+): IAdaptiveRepresentationSelectorArguments {
+  return {
+    initialBitrates: {},
+    lowLatencyMode: false,
+    throttlers: {
+      limitResolution: {},
+      throttleBitrate: {},
+    },
+    ...opts,
+  };
+}
+
+/** Easily create objects matching the `IABREstimate` structure. */
+export function makeAbrEstimate(opts: Partial<IABREstimate> = {}): IABREstimate {
+  return {
+    bitrate: undefined,
+    representation: null,
+    urgent: false,
+    knownStableBitrate: undefined,
+    ...opts,
+  };
+}
+
+/**
+ * Object facilitation the usage of a `IRepresentationEstimator`.
+ * /!\ Do not forget to call `reset` when done to ensure no memory leak.
+ */
+export interface IMockedRepresentationEstimator {
+  /** The `IRepresentationEstimator` itself. */
+  estimator: IRepresentationEstimator;
+  /**
+   * Allows to trigger new estimate through **every** objects returned by
+   * `estimator`.
+   */
+  emit: (obj: IABREstimate) => void;
+  /**
+   * Reset `estimator` to its initial state, also removing all estimate
+   * listeners it potentially had.
+   * Intended to be called between each test to clean-up.
+   */
+  reset: () => void;
+}
+
+/**
+ * Allows to create a `IRepresentationEstimator` with TypeScript typechecking
+ * and to obtain a function allowing to emit estimates.
+ * @returns {Object} res
+ */
+export function makeMockedRepresentationEstimator(): {
+  estimator: IRepresentationEstimator;
+  emit: (obj: IABREstimate) => void;
+  reset: () => void;
+} {
+  let ref = new SharedReference<IABREstimate>(makeAbrEstimate());
+  const estimator: IRepresentationEstimator = () => {
+    return {
+      estimates: ref,
+      callbacks: {
+        // TODO: find out how to exploit those after writing some tests
+        addedSegment() {
+          throw new Error("Not implemented");
+        },
+        metrics() {
+          throw new Error("Not implemented");
+        },
+        requestBegin() {
+          throw new Error("Not implemented");
+        },
+        requestEnd() {
+          throw new Error("Not implemented");
+        },
+        requestProgress() {
+          throw new Error("Not implemented");
+        },
+      },
+    };
+  };
+  return {
+    estimator,
+    emit(obj: IABREstimate) {
+      ref.setValue(obj);
+    },
+    reset() {
+      ref.finish();
+      ref = new SharedReference<IABREstimate>(makeAbrEstimate());
+    },
+  };
+}

package/src/core/adaptive/__tests__/network_analyzer.test.ts

@@ -1,34 +1,21 @@
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import configHandler from "../../../config";
+import {
+  DummyAdaptation,
+  DummyPeriod,
+  DummyRepresentation,
+  DummyManifest,
+  createSegment,
+} from "../../../manifest/classes/__tests__/mocks";
+import { DummyObservationPosition } from "../../../playback_observer/__tests__/mocks";
+import { makeMockedClass } from "../../../utils/test-utils";
+import type { IPlaybackConditionsInfo } from "../network_analyzer";
 import NetworkAnalyzer, { estimateRequestBandwidth } from "../network_analyzer";
-import type { IRequestInfo } from "../utils/pending_requests_store";
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-
-vi.mock("../../../config", () => ({
-  default: {
-    getCurrent: vi.fn(() => ({
-      ABR_STARVATION_GAP: {
-        DEFAULT: 2,
-        LOW_LATENCY: 1,
-      },
-      OUT_OF_STARVATION_GAP: {
-        DEFAULT: 3,
-        LOW_LATENCY: 1.5,
-      },
-      ABR_STARVATION_FACTOR: {
-        DEFAULT: 0.72,
-        LOW_LATENCY: 0.8,
-      },
-      ABR_REGULAR_FACTOR: {
-        DEFAULT: 0.8,
-        LOW_LATENCY: 0.85,
-      },
-      ABR_STARVATION_DURATION_DELTA: 5,
-    })),
-  },
-}));
+import type BandwidthEstimator from "../utils/bandwidth_estimator";
+import type {
+  IPendingRequestStoreProgress,
+  IRequestInfo,
+} from "../utils/pending_requests_store";
 
 vi.mock("../../../log", () => ({
   default: {
@@ -36,29 +23,37 @@ vi.mock("../../../log", () => ({
   },
 }));
 
-vi.mock("../../../utils/monotonic_timestamp", () => ({
-  // eslint-disable-next-line no-restricted-properties
-  default: vi.fn(() => performance.now()),
-}));
-
 function createMockRequest(
   segmentTime: number,
   segmentDuration: number,
   requestTimestamp: number,
-  progress: Array<{ size: number; timestamp: number; totalSize: number }> = [],
+  progress: Array<Partial<IPendingRequestStoreProgress>> = [],
   complete = true,
 ): IRequestInfo {
   return {
     content: {
-      segment: {
+      segment: createSegment({
         time: segmentTime,
         duration: segmentDuration,
         complete,
-      },
+      }),
+      adaptation: new DummyAdaptation(),
+      period: new DummyPeriod(),
+      representation: new DummyRepresentation(),
+      manifest: new DummyManifest(),
     },
     requestTimestamp,
-    progress,
-  } as IRequestInfo;
+    progress: progress.map((p) => {
+      return {
+        size: 1000,
+        timestamp: 1000,
+        totalSize: 10000,
+        duration: 2,
+        id: "toto",
+        ...p,
+      };
+    }),
+  };
 }
 
 function createMockPlaybackInfo(
@@ -66,20 +61,71 @@ function createMockPlaybackInfo(
   position: number,
   speed = 1,
   duration = 100,
-): any {
+): IPlaybackConditionsInfo {
   return {
     bufferGap,
-    position: { getWanted: () => position },
+    position: new DummyObservationPosition({
+      getWanted: () => position,
+      getPolled: () => position,
+    }),
     speed,
     duration,
   };
 }
 
-function createMockBandwidthEstimator(estimate?: number): any {
-  return {
-    getEstimate: vi.fn(() => estimate),
-    reset: vi.fn(),
-  };
+function createMockBandwidthEstimator(estimate?: number): BandwidthEstimator {
+  const DummyBandwidthEstimator = makeMockedClass<BandwidthEstimator>(
+    {
+      getEstimate: vi.fn(() => estimate),
+      reset: vi.fn(),
+      addSample: vi.fn(),
+    },
+    {},
+  );
+  return new DummyBandwidthEstimator();
+}
+beforeEach(() => {
+  const originalConfig = configHandler.getCurrent();
+  vi.spyOn(configHandler, "getCurrent").mockReturnValue({
+    ...originalConfig,
+    ABR_STARVATION_GAP: {
+      DEFAULT: 2,
+      LOW_LATENCY: 1,
+    },
+    OUT_OF_STARVATION_GAP: {
+      DEFAULT: 3,
+      LOW_LATENCY: 1.5,
+    },
+    ABR_STARVATION_FACTOR: {
+      DEFAULT: 0.72,
+      LOW_LATENCY: 0.8,
+    },
+    ABR_REGULAR_FACTOR: {
+      DEFAULT: 0.8,
+      LOW_LATENCY: 0.85,
+    },
+    ABR_STARVATION_DURATION_DELTA: 5,
+  });
+});
+afterEach(() => {
+  vi.resetAllMocks();
+});
+
+function createProgressEvents(
+  baseTime: number,
+  totalSize: number,
+  stepSize: number,
+  stepDurationMs: number,
+): Array<{ size: number; timestamp: number; totalSize: number }> {
+  const progress = [{ size: 0, timestamp: baseTime, totalSize }];
+  let size = 0;
+  let timestamp = baseTime;
+  while (size < totalSize) {
+    size = Math.min(size + stepSize, totalSize);
+    timestamp += stepDurationMs;
+    progress.push({ size, timestamp, totalSize });
+  }
+  return progress;
 }
 
 describe("estimateRequestBandwidth", () => {
@@ -274,6 +320,41 @@ describe("NetworkAnalyzer", () => {
       expect(result.bitrateChosen).toBe(2000000 * 0.8);
     });
 
+    it("should allow emergency estimate before 12s for short segments", () => {
+      const analyzer = new NetworkAnalyzer(1000000, false);
+      const bandwidthEstimator = createMockBandwidthEstimator(undefined);
+      const resetSpy = vi.spyOn(bandwidthEstimator, "reset");
+      const requestStart = 1000;
+      const now = 7000;
+      const performanceNowSpy = vi.spyOn(performance, "now").mockReturnValue(now);
+      const currentRepresentation = new DummyRepresentation({
+        bitrate: 1_200_000,
+      });
+      const currentRequests = [
+        createMockRequest(
+          10,
+          2,
+          requestStart,
+          createProgressEvents(requestStart, 1_000_000, 100_000, 100),
+          true,
+        ),
+      ];
+
+      const result = analyzer.getBandwidthEstimate(
+        createMockPlaybackInfo(1, 9),
+        bandwidthEstimator,
+        currentRepresentation,
+        currentRequests,
+        1_100_000,
+      );
+
+      expect(result.bandwidthEstimate).toBeDefined();
+      expect(result.bitrateChosen).toBeLessThan(currentRepresentation.bitrate);
+      expect(resetSpy).toHaveBeenCalled();
+      performanceNowSpy.mockRestore();
+      resetSpy.mockRestore();
+    });
+
     it("should handle infinite buffer gap", () => {
       const analyzer = new NetworkAnalyzer(1000000, false);
       const playbackInfo = createMockPlaybackInfo(Infinity, 0);
@@ -322,7 +403,9 @@ describe("NetworkAnalyzer", () => {
     it("should return false when bitrate is higher than current representation", () => {
       const analyzer = new NetworkAnalyzer(1000000, false);
       const playbackInfo = createMockPlaybackInfo(5, 0);
-      const currentRepresentation = { bitrate: 1000000 } as any;
+      const currentRepresentation = new DummyRepresentation({
+        bitrate: 1000000,
+      });
 
       const result = analyzer.isUrgent(2000000, currentRepresentation, [], playbackInfo);
 
@@ -332,7 +415,9 @@ describe("NetworkAnalyzer", () => {
     it("should return true in low latency mode when switching to lower bitrate", () => {
       const analyzer = new NetworkAnalyzer(1000000, true);
       const playbackInfo = createMockPlaybackInfo(5, 0);
-      const currentRepresentation = { bitrate: 2000000 } as any;
+      const currentRepresentation = new DummyRepresentation({
+        bitrate: 2000000,
+      });
 
       const result = analyzer.isUrgent(1000000, currentRepresentation, [], playbackInfo);
 
@@ -342,7 +427,9 @@ describe("NetworkAnalyzer", () => {
     it("should return true when no pending requests for lower bitrate", () => {
       const analyzer = new NetworkAnalyzer(1000000, false);
       const playbackInfo = createMockPlaybackInfo(5, 10);
-      const currentRepresentation = { bitrate: 2000000 } as any;
+      const currentRepresentation = new DummyRepresentation({
+        bitrate: 2000000,
+      });
 
       const result = analyzer.isUrgent(1000000, currentRepresentation, [], playbackInfo);
 
@@ -354,7 +441,9 @@ describe("NetworkAnalyzer", () => {
       // eslint-disable-next-line no-restricted-properties
       const now = performance.now();
       const playbackInfo = createMockPlaybackInfo(2, 10);
-      const currentRepresentation = { bitrate: 2000000 } as any;
+      const currentRepresentation = new DummyRepresentation({
+        bitrate: 2000000,
+      });
 
       const request = createMockRequest(10, 4, now - 1000, [
         { size: 0, timestamp: now - 1000, totalSize: 10000 },
@@ -377,7 +466,9 @@ describe("NetworkAnalyzer", () => {
     it("should handle requests with zero duration segments", () => {
       const analyzer = new NetworkAnalyzer(1000000, false);
       const playbackInfo = createMockPlaybackInfo(5, 10);
-      const currentRepresentation = { bitrate: 2000000 } as any;
+      const currentRepresentation = new DummyRepresentation({
+        bitrate: 2000000,
+      });
 
       // eslint-disable-next-line no-restricted-properties
       const request = createMockRequest(10, 0, performance.now()); // Zero duration
@@ -395,7 +486,9 @@ describe("NetworkAnalyzer", () => {
     it("should handle infinite buffer gap in urgency check", () => {
       const analyzer = new NetworkAnalyzer(1000000, false);
       const playbackInfo = createMockPlaybackInfo(Infinity, 10);
-      const currentRepresentation = { bitrate: 2000000 } as any;
+      const currentRepresentation = new DummyRepresentation({
+        bitrate: 2000000,
+      });
 
       const result = analyzer.isUrgent(1000000, currentRepresentation, [], playbackInfo);
 
@@ -422,7 +515,7 @@ describe("NetworkAnalyzer", () => {
       result = analyzer.getBandwidthEstimate(
         createMockPlaybackInfo(1.5, 20),
         bandwidthEstimator,
-        { bitrate: 1600000 } as any,
+        new DummyRepresentation({ bitrate: 1600000 }),
         [],
         result.bitrateChosen,
       );
@@ -432,7 +525,7 @@ describe("NetworkAnalyzer", () => {
       result = analyzer.getBandwidthEstimate(
         createMockPlaybackInfo(4, 30),
         bandwidthEstimator,
-        { bitrate: 1440000 } as any,
+        new DummyRepresentation({ bitrate: 1440000 }),
         [],
         result.bitrateChosen,
       );
@@ -458,7 +551,7 @@ describe("NetworkAnalyzer", () => {
       result = analyzer.getBandwidthEstimate(
         createMockPlaybackInfo(5, 10),
         estimator,
-        { bitrate: 2400000 } as any,
+        new DummyRepresentation({ bitrate: 2400000 }),
         [],
         result.bitrateChosen,
       );
@@ -469,7 +562,7 @@ describe("NetworkAnalyzer", () => {
       result = analyzer.getBandwidthEstimate(
         createMockPlaybackInfo(5, 20),
         estimator,
-        { bitrate: 800000 } as any,
+        new DummyRepresentation({ bitrate: 800000 }),
         [],
         result.bitrateChosen,
       );
@@ -494,7 +587,7 @@ describe("NetworkAnalyzer", () => {
       result = analyzer.getBandwidthEstimate(
         createMockPlaybackInfo(5, 10, 2),
         estimator,
-        { bitrate: normalBitrate } as any,
+        new DummyRepresentation({ bitrate: normalBitrate }),
         [],
         result.bitrateChosen,
       );
@@ -504,7 +597,7 @@ describe("NetworkAnalyzer", () => {
       result = analyzer.getBandwidthEstimate(
         createMockPlaybackInfo(5, 20, 0.5),
         estimator,
-        { bitrate: normalBitrate } as any,
+        new DummyRepresentation({ bitrate: normalBitrate }),
         [],
         result.bitrateChosen,
       );

package/src/core/adaptive/network_analyzer.ts

@@ -29,7 +29,7 @@ import type {
 } from "./utils/pending_requests_store";
 
 /** Object describing the current playback conditions. */
-type IPlaybackConditionsInfo = Pick<
+export type IPlaybackConditionsInfo = Pick<
   IRepresentationEstimatorPlaybackObservation,
   "bufferGap" | "position" | "speed" | "duration"
 >;
@@ -166,9 +166,9 @@ function estimateStarvationModeBitrate(
   const concernedRequest = concernedRequests[0];
   const now = getMonotonicTimeStamp();
 
-  let minimumRequestTime = concernedRequest.content.segment.duration * 1.5;
-  minimumRequestTime = Math.min(minimumRequestTime, 3000);
-  minimumRequestTime = Math.max(minimumRequestTime, 12000);
+  let minimumRequestTime = concernedRequest.content.segment.duration * 1500;
+  minimumRequestTime = Math.max(minimumRequestTime, 3000);
+  minimumRequestTime = Math.min(minimumRequestTime, 12000);
   if (now - concernedRequest.requestTimestamp < minimumRequestTime) {
     return undefined;
   }

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

@@ -1,14 +1,14 @@
 import { describe, it, expect } from "vitest";
-import type { IRepresentation } from "../../../../manifest";
+import { DummyRepresentation } from "../../../../manifest/classes/__tests__/mocks";
 import filterByBitrate from "../filter_by_bitrate";
 
 describe("ABR - filterByBitrate", () => {
   const fakeReps = [
-    { bitrate: 100 },
-    { bitrate: 100 },
-    { bitrate: 1000 },
-    { bitrate: 10000 },
-    { bitrate: 100000 },
+    new DummyRepresentation({ bitrate: 100 }),
+    new DummyRepresentation({ bitrate: 100 }),
+    new DummyRepresentation({ bitrate: 1000 }),
+    new DummyRepresentation({ bitrate: 10000 }),
+    new DummyRepresentation({ bitrate: 100000 }),
   ];
 
   describe("filterByBitrate", () => {
@@ -17,25 +17,17 @@ describe("ABR - filterByBitrate", () => {
     });
 
     it("should return all representations when specified bitrate is infinite", () => {
-      expect(filterByBitrate(fakeReps as IRepresentation[], Infinity)).toEqual(fakeReps);
+      expect(filterByBitrate(fakeReps, Infinity)).toEqual(fakeReps);
     });
 
     it("should return the lowest representation when specified bitrate is 0", () => {
-      const expectedFilteredReps = [{ bitrate: 100 }, { bitrate: 100 }];
-      expect(filterByBitrate(fakeReps as IRepresentation[], 0)).toEqual(
-        expectedFilteredReps,
-      );
+      const expectedFilteredReps = [fakeReps[0], fakeReps[1]];
+      expect(filterByBitrate(fakeReps, 0)).toEqual(expectedFilteredReps);
     });
 
     it("should filter representation when specified bitrate is 999", () => {
-      const expectedFilteredReps = [
-        { bitrate: 100 },
-        { bitrate: 100 },
-        { bitrate: 1000 },
-      ];
-      expect(filterByBitrate(fakeReps as IRepresentation[], 1010)).toEqual(
-        expectedFilteredReps,
-      );
+      const expectedFilteredReps = [fakeReps[0], fakeReps[1], fakeReps[2]];
+      expect(filterByBitrate(fakeReps, 1010)).toEqual(expectedFilteredReps);
     });
   });
 });

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

@@ -1,19 +1,19 @@
 import { describe, it, expect } from "vitest";
-import type { IRepresentation } from "../../../../manifest";
+import { DummyRepresentation } from "../../../../manifest/classes/__tests__/mocks";
 import filterByResolution from "../filter_by_resolution";
 
 describe("ABR - filterByResolution", () => {
   const fakeReps = [
-    { height: 80, width: 100 },
-    { height: 800, width: 1000 },
-    { height: 8000, width: 10000 },
-    { height: 80000, width: 100000 },
+    new DummyRepresentation({ height: 80, width: 100 }),
+    new DummyRepresentation({ height: 800, width: 1000 }),
+    new DummyRepresentation({ height: 8000, width: 10000 }),
+    new DummyRepresentation({ height: 80000, width: 100000 }),
   ];
 
   describe("filterByResolution", () => {
     it("should do nothing for a given `undefined` height", () => {
       expect(
-        filterByResolution(fakeReps as IRepresentation[], {
+        filterByResolution(fakeReps, {
           height: undefined,
           width: 10,
           pixelRatio: 1,
@@ -22,7 +22,7 @@ describe("ABR - filterByResolution", () => {
     });
     it("should do nothing for a given `undefined` width", () => {
       expect(
-        filterByResolution(fakeReps as IRepresentation[], {
+        filterByResolution(fakeReps, {
           height: undefined,
           width: 10,
           pixelRatio: 1,
@@ -32,7 +32,7 @@ describe("ABR - filterByResolution", () => {
 
     it("should properly filter until a set resolution", () => {
       expect(
-        filterByResolution(fakeReps as IRepresentation[], {
+        filterByResolution(fakeReps, {
           height: 8000,
           width: 10000,
           pixelRatio: 1,
@@ -42,7 +42,7 @@ describe("ABR - filterByResolution", () => {
 
     it("should include the immediately superior resolution if nothing equal exist", () => {
       expect(
-        filterByResolution(fakeReps as IRepresentation[], {
+        filterByResolution(fakeReps, {
           height: 700,
           width: 900,
           pixelRatio: 1,
@@ -52,7 +52,7 @@ describe("ABR - filterByResolution", () => {
 
     it("should take into account the pixel ratio", () => {
       expect(
-        filterByResolution(fakeReps as IRepresentation[], {
+        filterByResolution(fakeReps, {
           height: 70,
           width: 90,
           pixelRatio: 10,
@@ -62,7 +62,7 @@ describe("ABR - filterByResolution", () => {
 
     it("should take higher resolution if just the height is lower", () => {
       expect(
-        filterByResolution(fakeReps as IRepresentation[], {
+        filterByResolution(fakeReps, {
           height: 801,
           width: 900,
           pixelRatio: 1,
@@ -72,7 +72,7 @@ describe("ABR - filterByResolution", () => {
 
     it("should take higher resolution if just the width is lower", () => {
       expect(
-        filterByResolution(fakeReps as IRepresentation[], {
+        filterByResolution(fakeReps, {
           height: 799,
           width: 1001,
           pixelRatio: 1,

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

@@ -1,10 +1,7 @@
 import { describe, it, expect, beforeEach } from "vitest";
+import { DummyRepresentation } from "../../../../manifest/classes/__tests__/mocks";
 import LastEstimateStorage, { ABRAlgorithmType } from "../last_estimate_storage";
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-
 describe("LastEstimateStorage", () => {
   let storage: LastEstimateStorage;
 
@@ -28,44 +25,60 @@ describe("LastEstimateStorage", () => {
 
   describe("update()", () => {
     it("should update representation with the provided value", () => {
-      const representation = { id: "rep1", bitrate: 1000 } as any;
+      const representation = new DummyRepresentation({
+        id: "rep1",
+        bitrate: 1000,
+      });
       storage.update(representation, 500, ABRAlgorithmType.BandwidthBased);
       expect(storage.representation).toBe(representation);
     });
 
     it("should update bandwidth with the provided value", () => {
-      const representation = { id: "rep1", bitrate: 1000 } as any;
+      const representation = new DummyRepresentation({
+        id: "rep1",
+        bitrate: 1000,
+      });
       storage.update(representation, 500, ABRAlgorithmType.BandwidthBased);
       expect(storage.bandwidth).toBe(500);
     });
 
     it("should update algorithmType with the provided value", () => {
-      const representation = { id: "rep1", bitrate: 1000 } as any;
+      const representation = new DummyRepresentation({
+        id: "rep1",
+        bitrate: 1000,
+      });
       storage.update(representation, 500, ABRAlgorithmType.BandwidthBased);
       expect(storage.algorithmType).toBe(ABRAlgorithmType.BandwidthBased);
     });
 
     it("should allow bandwidth to be undefined", () => {
-      const representation = { id: "rep1", bitrate: 1000 } as any;
+      const representation = new DummyRepresentation({
+        id: "rep1",
+        bitrate: 1000,
+      });
       storage.update(representation, undefined, ABRAlgorithmType.BufferBased);
       expect(storage.bandwidth).toBeUndefined();
     });
 
     it("should correctly reflect a BufferBased algorithm type", () => {
-      const representation = { id: "rep2" } as any;
+      const representation = new DummyRepresentation({
+        id: "rep2",
+      });
       storage.update(representation, 200, ABRAlgorithmType.BufferBased);
       expect(storage.algorithmType).toBe(ABRAlgorithmType.BufferBased);
     });
 
     it("should correctly reflect a GuessBased algorithm type", () => {
-      const representation = { id: "rep3" } as any;
+      const representation = new DummyRepresentation({
+        id: "rep3",
+      });
       storage.update(representation, 300, ABRAlgorithmType.GuessBased);
       expect(storage.algorithmType).toBe(ABRAlgorithmType.GuessBased);
     });
 
     it("should overwrite previous values on subsequent updates", () => {
-      const rep1 = { id: "rep1" } as any;
-      const rep2 = { id: "rep2" } as any;
+      const rep1 = new DummyRepresentation({ id: "rep1" });
+      const rep2 = new DummyRepresentation({ id: "rep2" });
       storage.update(rep1, 100, ABRAlgorithmType.BandwidthBased);
       storage.update(rep2, 999, ABRAlgorithmType.GuessBased);
       expect(storage.representation).toBe(rep2);