rx-player 3.33.0 → 3.33.1

package/src/core/api/utils.ts

@@ -1,216 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import config from "../../config";
-import { IPlayerState } from "../../public_types";
-import arrayIncludes from "../../utils/array_includes";
-import SharedReference, {
-  IReadOnlySharedReference,
-} from "../../utils/reference";
-import { CancellationSignal } from "../../utils/task_canceller";
-import {
-  ContentInitializer,
-  IStallingSituation,
-} from "../init";
-import {
-  IPlaybackObservation,
-  IReadOnlyPlaybackObserver,
-} from "./playback_observer";
-
-/**
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} playbackObserver - Observes playback conditions on
- * `mediaElement`.
- * @param {function} onSeeking - Callback called when a seeking operation starts
- * on `mediaElement`.
- * @param {function} onSeeked - Callback called when a seeking operation ends
- * on `mediaElement`.
- * @param {Object} cancelSignal - When triggered, stop calling callbacks and
- * remove all listeners this function has registered.
- */
-export function emitSeekEvents(
-  mediaElement : HTMLMediaElement | null,
-  playbackObserver : IReadOnlyPlaybackObserver<IPlaybackObservation>,
-  onSeeking: () => void,
-  onSeeked: () => void,
-  cancelSignal : CancellationSignal
-) : void {
-  if (cancelSignal.isCancelled() || mediaElement === null) {
-    return ;
-  }
-
-  let wasSeeking = playbackObserver.getReference().getValue().seeking;
-  if (wasSeeking) {
-    onSeeking();
-    if (cancelSignal.isCancelled()) {
-      return;
-    }
-  }
-  playbackObserver.listen((obs) => {
-    if (obs.event === "seeking") {
-      wasSeeking = true;
-      onSeeking();
-    } else if (wasSeeking && obs.event === "seeked") {
-      wasSeeking = false;
-      onSeeked();
-    }
-  }, { includeLastObservation: true, clearSignal: cancelSignal });
-}
-
-/**
- * @param {HTMLMediaElement} mediaElement
- * @param {function} onPlay - Callback called when a play operation has started
- * on `mediaElement`.
- * @param {function} onPause - Callback called when a pause operation has
- * started on `mediaElement`.
- * @param {Object} cancelSignal - When triggered, stop calling callbacks and
- * remove all listeners this function has registered.
- */
-export function emitPlayPauseEvents(
-  mediaElement : HTMLMediaElement | null,
-  onPlay: () => void,
-  onPause: () => void,
-  cancelSignal : CancellationSignal
-) : void {
-  if (cancelSignal.isCancelled() || mediaElement === null) {
-    return ;
-  }
-  mediaElement.addEventListener("play", onPlay);
-  mediaElement.addEventListener("pause", onPause);
-  cancelSignal.register(() => {
-    mediaElement.removeEventListener("play", onPlay);
-    mediaElement.removeEventListener("pause", onPause);
-  });
-}
-
-/** Player state dictionnary. */
-export const enum PLAYER_STATES {
-  STOPPED = "STOPPED",
-  LOADED = "LOADED",
-  LOADING = "LOADING",
-  PLAYING = "PLAYING",
-  PAUSED = "PAUSED",
-  ENDED = "ENDED",
-  BUFFERING = "BUFFERING",
-  SEEKING = "SEEKING",
-  RELOADING = "RELOADING",
-}
-
-export function constructPlayerStateReference(
-  initializer : ContentInitializer,
-  mediaElement : HTMLMediaElement,
-  playbackObserver : IReadOnlyPlaybackObserver<IPlaybackObservation>,
-  cancelSignal : CancellationSignal
-) : IReadOnlySharedReference<IPlayerState> {
-  const playerStateRef = new SharedReference<IPlayerState>(PLAYER_STATES.LOADING,
-                                                           cancelSignal);
-  initializer.addEventListener("loaded", () => {
-    if (playerStateRef.getValue() === PLAYER_STATES.LOADING) {
-      playerStateRef.setValue(PLAYER_STATES.LOADED);
-      if (!cancelSignal.isCancelled()) {
-        const newState = getLoadedContentState(mediaElement, null);
-        if (newState !== PLAYER_STATES.PAUSED) {
-          playerStateRef.setValue(newState);
-        }
-      }
-    } else {
-      playerStateRef.setValueIfChanged(getLoadedContentState(mediaElement, null));
-    }
-  }, cancelSignal);
-
-  initializer.addEventListener("reloadingMediaSource", () => {
-    if (isLoadedState(playerStateRef.getValue())) {
-      playerStateRef.setValueIfChanged(PLAYER_STATES.RELOADING);
-    }
-  }, cancelSignal);
-
-  /**
-   * Keep track of the last known stalling situation.
-   * `null` if playback is not stalled.
-   */
-  let prevStallReason : IStallingSituation | null = null;
-  initializer.addEventListener("stalled", (s) => {
-    if (s !== prevStallReason) {
-      if (isLoadedState(playerStateRef.getValue())) {
-        playerStateRef.setValueIfChanged(getLoadedContentState(mediaElement, s));
-      }
-      prevStallReason = s;
-    }
-  }, cancelSignal);
-  initializer.addEventListener("unstalled", () => {
-    if (prevStallReason !== null) {
-      if (isLoadedState(playerStateRef.getValue())) {
-        playerStateRef.setValueIfChanged(getLoadedContentState(mediaElement, null));
-      }
-      prevStallReason = null;
-    }
-  }, cancelSignal);
-
-  playbackObserver.listen((observation) => {
-    if (isLoadedState(playerStateRef.getValue()) &&
-        arrayIncludes(["seeking", "ended", "play", "pause"], observation.event))
-    {
-      playerStateRef.setValueIfChanged(
-        getLoadedContentState(mediaElement, prevStallReason)
-      );
-    }
-  }, { clearSignal: cancelSignal });
-  return playerStateRef;
-}
-
-/**
- * Get state string for a _loaded_ content.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} stalledStatus - Current stalled state:
- *   - null when not stalled
- *   - a description of the situation if stalled.
- * @returns {string}
- */
-export function getLoadedContentState(
-  mediaElement : HTMLMediaElement,
-  stalledStatus : IStallingSituation |
-                  null
-) : IPlayerState {
-  const { FORCED_ENDED_THRESHOLD } = config.getCurrent();
-  if (mediaElement.ended) {
-    return PLAYER_STATES.ENDED;
-  }
-
-  if (stalledStatus !== null) {
-    // On some old browsers (e.g. Chrome 54), the browser does not
-    // emit an 'ended' event in some conditions. Detect if we
-    // reached the end by comparing the current position and the
-    // duration instead.
-    const gapBetweenDurationAndCurrentTime = Math.abs(mediaElement.duration -
-                                                      mediaElement.currentTime);
-    if (FORCED_ENDED_THRESHOLD != null &&
-        gapBetweenDurationAndCurrentTime < FORCED_ENDED_THRESHOLD
-    ) {
-      return PLAYER_STATES.ENDED;
-    }
-
-    return stalledStatus === "seeking" ? PLAYER_STATES.SEEKING :
-                                         PLAYER_STATES.BUFFERING;
-  }
-  return mediaElement.paused ? PLAYER_STATES.PAUSED :
-                               PLAYER_STATES.PLAYING;
-}
-
-export function isLoadedState(state : IPlayerState) : boolean {
-  return state !== PLAYER_STATES.LOADING &&
-         state !== PLAYER_STATES.RELOADING &&
-         state !== PLAYER_STATES.STOPPED;
-}

package/src/core/decrypt/README.md

@@ -1,22 +0,0 @@
-# The ContentDecryptor #########################################################
-
-
-## Overview ####################################################################
-
-This directory exports the `ContentDecryptor`, which allows to easily interface
-with the browser APIs for decrypting an encrypted content, it follows the
-[Encrypted Media Extensions recommandations](https://www.w3.org/TR/encrypted-media/).
-
-The `ContentDecryptor` is a module isolated from the rest of the player taking
-a form of a class.
-It starts initializing decryption capabilities as soon as it is instanciated and
-emits various events to communicate with external code.
-
-A central concept of the `ContentDecryptor` is its states.
-As decryption initialization goes on, it reaches multiple steps on which the
-rest of the RxPlayer code might want to react.
-
-Before going in, you're encouraged to read a little about the Encrypted Media
-Extensions (EME). This code is heavy on EME APIs and may be difficult to follow
-if you don't have a vague understanding of the concept of a `MediaKeySession`
-or of a `MediaKeySystemAccess`.

package/src/core/decrypt/__tests__/__global__/get_license.test.ts

@@ -1,422 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
-/* eslint-disable no-restricted-properties */
-
-import { IPlayerError } from "../../../../public_types";
-import { concat } from "../../../../utils/byte_parsing";
-import {
-  formatFakeChallengeFromInitData,
-  MediaKeySessionImpl,
-  MediaKeysImpl,
-  mockCompat,
-} from "./utils";
-
-/** Default video element used in our tests. */
-const videoElt = document.createElement("video");
-
-/* eslint-disable max-len */
-describe("core - decrypt - global tests - getLicense", () => {
-
-  afterEach(() => {
-    jest.resetModules();
-    jest.restoreAllMocks();
-  });
-
-  it("should update the session after getLicense resolves with a license", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 0,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should update the session after getLicense returns a license directly", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: false,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 0,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should not update the session after getLicense resolves with null", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 0,
-                            ignoreLicenseRequests: true });
-  });
-
-  it("should not update the session after getLicense returns null directly", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: false,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 0,
-                            ignoreLicenseRequests: true });
-  });
-
-  it("should be able to retry maximum two times and fail after 3 tries with a rejected promise", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 3,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should be able to retry maximum two times and fail after 3 tries with a thrown error", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: false,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 3,
-                            ignoreLicenseRequests: true });
-  });
-
-  it("should be able to retry two times and succeed after a time with a resolved license", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 2,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should be able to retry two times and succeed after a time with a returned license", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: false,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 2,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should be able to retry two times and succeed after a time with a resolved null", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 2,
-                            ignoreLicenseRequests: true });
-  });
-
-  it("should be able to retry two times and succeed after a time with a returned null", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: false,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 2,
-                            ignoreLicenseRequests: true });
-  });
-
-  it("should be able to retry one time and succeed after a time with a resolved license", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 1,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should be able to retry one time and succeed after a time with a returned license", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: false,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 1,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should be able to retry two times and succeed after a time with a resolved null", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 1,
-                            ignoreLicenseRequests: true });
-  });
-
-  it("should be able to retry two times and succeed after a time with a returned null", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: false,
-                            configuredRetries: undefined,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 1,
-                            ignoreLicenseRequests: true });
-  });
-
-  it("should be able to fetch a license directly even when getLicenseConfig.retry is set to `0`", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: 0,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 0,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should fail after first failure when getLicenseConfig.retry is set to `0`", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: 0,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 1,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should fail after two failures when getLicenseConfig.retry is set to `1`", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: 1,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 2,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should not fail after one failure when getLicenseConfig.retry is set to `1`", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: 1,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 1,
-                            ignoreLicenseRequests: false });
-  });
-
-  it("should not fail after 6 failures when getLicenseConfig.retry is set to `6`", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: 6,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 6,
-                            ignoreLicenseRequests: false });
-  }, 25000);
-
-  it("should fail after 7 failures when getLicenseConfig.retry is set to `6`", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: 6,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 7,
-                            ignoreLicenseRequests: false });
-  }, 25000);
-
-  it("should not fail after 5 failures when getLicenseConfig.retry is set to `Infinity`", async () => {
-    await checkGetLicense({ isGetLicensePromiseBased: true,
-                            configuredRetries: Infinity,
-                            configuredTimeout: undefined,
-                            getTimeout: () => undefined,
-                            nbRetries: 5,
-                            ignoreLicenseRequests: false });
-  }, 15000);
-
-});
-
-/**
- * HUGE function to check most getLicense scenarios.
- * @param {Object} opts
- */
-function checkGetLicense(
-  { isGetLicensePromiseBased,
-    configuredRetries,
-    configuredTimeout,
-    getTimeout,
-    nbRetries,
-    ignoreLicenseRequests } : {
-      /**
-       * Set it to false if you want to return directly a value from
-       * `getLicense` (i.e. not wrapped in a Promise).
-       * This is valable both for success, and errors (which will be either
-       * thrown directly or wrapped in a rejecting Promise).
-       *
-       * This value will be forced to `true` if the `getTimeout` call for the
-       * corresponding `getLicense` returns something other than `undefined`.
-       */
-    isGetLicensePromiseBased : boolean;
-      /** Maximum amount of retries: value of getLicenseConfig.retry. */
-    configuredRetries : number | undefined;
-      /**
-       * Return getLicense timeout after which the response will be emitted, in
-       * milliseconds.
-       * Put to `undefined` for no timeout at all (synchronous).
-       * Note that if a timeout is given, getLicense will return a Promise.
-       * As such, `isGetLicensePromiseBased` will be ignored.
-       */
-    getTimeout : (callIdx : number) => number | undefined;
-      /** Maximum configured timeout: value of getLicenseConfig.timeout. */
-    configuredTimeout : number | undefined;
-      /**
-       * Nb of times getLicense should fail in a row.
-       * If put at a higher value than `configuredRetries`, no license will be
-       * obtained.
-       */
-    nbRetries : number;
-      /**
-       * If `true`, getLicense will return `null` - to ignore a request - when
-       * it succeed.
-       */
-    ignoreLicenseRequests : boolean; }
-) : Promise<void> {
-  return new Promise((res, rej) => {
-    // == mocks ==
-    mockCompat();
-    const mediaKeySession = new MediaKeySessionImpl();
-    jest.spyOn(MediaKeysImpl.prototype, "createSession").mockReturnValue(mediaKeySession);
-    const mockUpdate = jest.spyOn(mediaKeySession, "update");
-    let remainingRetries = nbRetries;
-    const mockGetLicense = jest.fn(() => {
-      const callIdx = nbRetries - remainingRetries;
-      const timeout = getTimeout(callIdx);
-      if (remainingRetries === 0) {
-        const challengeU8 = new Uint8Array(challenge);
-        const result = ignoreLicenseRequests ? null :
-                                               concat(challengeU8, challengeU8);
-        if (timeout !== undefined) {
-          return new Promise(resolve => {
-            setTimeout(() => resolve(result), timeout);
-          });
-        }
-        return isGetLicensePromiseBased ? Promise.resolve(result) :
-                                          result;
-      }
-      remainingRetries--;
-      if (timeout !== undefined) {
-        return new Promise((_, reject) => {
-          setTimeout(() => {
-            reject("AAAA");
-          }, timeout);
-        });
-      }
-      if (!isGetLicensePromiseBased) {
-        throw new Error("AAAA");
-      }
-      return Promise.reject(new Error("AAAA"));
-    });
-
-    // == vars ==
-    /** Default keySystems configuration used in our tests. */
-    const maxRetries = configuredRetries === undefined ? 2 :
-                                                         configuredRetries;
-    const shouldFail = nbRetries > maxRetries;
-    let warningsLeft = nbRetries;
-    const ksConfig = [{ type: "com.widevine.alpha",
-                        getLicense: mockGetLicense,
-                        getLicenseConfig: configuredRetries !== undefined ||
-                                          configuredTimeout !== undefined ?
-                                            { retry: configuredRetries,
-                                              timeout: configuredTimeout } :
-                                            undefined }];
-    const initData = new Uint8Array([54, 55, 75]);
-    const initDataEvent = { type: "cenc", values: [ { systemId: "15", data: initData } ] };
-    const challenge = formatFakeChallengeFromInitData(initData, "cenc");
-    function checkKeyLoadError(error : unknown) {
-      try {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as IPlayerError).name).toEqual("EncryptedMediaError");
-        expect((error as IPlayerError).type).toEqual("ENCRYPTED_MEDIA_ERROR");
-        expect((error as IPlayerError).code).toEqual("KEY_LOAD_ERROR");
-        expect((error as IPlayerError).message).toEqual("AAAA");
-      } catch (e) {
-        rej(e);
-      }
-    }
-
-    // == test ==
-    const { ContentDecryptorState } = jest.requireActual("../../types");
-    const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
-    const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
-
-    contentDecryptor.addEventListener("stateChange", (newState: number) => {
-      if (newState !== ContentDecryptorState.WaitingForAttachment) {
-        rej(new Error(`Unexpected state: ${newState}`));
-      }
-      contentDecryptor.removeEventListener("stateChange");
-      contentDecryptor.attach();
-    });
-
-    contentDecryptor.addEventListener("error", (error: unknown) => {
-      if (shouldFail) {
-        try {
-          checkKeyLoadError(error);
-          expect(mockGetLicense).toHaveBeenCalledTimes(maxRetries + 1);
-          for (let i = 1; i <= maxRetries + 1; i++) {
-            expect(mockGetLicense).toHaveBeenNthCalledWith(i, challenge, "license-request");
-          }
-          expect(mockUpdate).toHaveBeenCalledTimes(0);
-          res();
-        } catch (e) {
-          rej(e);
-        }
-      } else {
-        rej(new Error(`Unexpected error: ${error}`));
-      }
-    });
-
-    contentDecryptor.addEventListener("warning", (warning: Error) => {
-      if (warningsLeft-- > 0) {
-        try {
-          checkKeyLoadError(warning);
-          const requestIdx = nbRetries - remainingRetries;
-          expect(mockGetLicense).toHaveBeenCalledTimes(requestIdx);
-          expect(mockGetLicense).toHaveBeenNthCalledWith(requestIdx, challenge, "license-request");
-        } catch (e) {
-          rej(e);
-        }
-      } else {
-        rej(new Error(`Unexpected warning: ${warning}`));
-      }
-    });
-
-    contentDecryptor.onInitializationData(initDataEvent);
-
-    if (!shouldFail) {
-      const timeout = nbRetries === 0 ? 100 :
-                      nbRetries === 1 ? 300 :
-                      nbRetries === 2 ? 800 :
-                      nbRetries === 3 ? 1200 :
-                      nbRetries === 4 ? 3000 :
-                                        10000;
-      setTimeout(() => {
-        try {
-          if (ignoreLicenseRequests) {
-            expect(mockUpdate).toHaveBeenCalledTimes(0);
-          } else {
-            const license = concat(challenge, challenge);
-            expect(mockUpdate).toHaveBeenCalledTimes(1);
-            expect(mockUpdate).toHaveBeenCalledWith(license);
-          }
-          expect(mockGetLicense).toHaveBeenCalledTimes(nbRetries + 1);
-          for (let i = 1; i <= nbRetries + 1; i++) {
-            expect(mockGetLicense).toHaveBeenNthCalledWith(i, challenge, "license-request");
-          }
-          contentDecryptor.dispose();
-          res();
-        } catch (e) {
-          rej(e);
-        }
-      }, timeout);
-    }
-  });
-}