rx-player 3.26.2 → 3.27.0-dev.20220317

package/src/core/{eme → decrypt}/__tests__/__global__/media_key_system_access.test.ts

@@ -22,31 +22,24 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-restricted-properties */
 
-import {
-  EMPTY,
-  Observable,
-  of as observableOf,
-  Subject,
-  takeUntil,
-  throwError as observableThrow,
-} from "rxjs";
 import { ICustomMediaKeySystemAccess } from "../../../../compat";
 import {
   defaultKSConfig,
   defaultWidevineConfig,
   mockCompat,
-  testEMEManagerImmediateError,
+  testContentDecryptorError,
 } from "./utils";
 
 export function requestMediaKeySystemAccessNoMediaKeys(
   keySystem : string,
   config : MediaKeySystemConfiguration[]
-) : Observable<ICustomMediaKeySystemAccess> {
+) : Promise<ICustomMediaKeySystemAccess> {
   if (config.length === 0) {
     throw new Error("requestMediaKeySystemAccessNoMediaKeys: no config given");
   }
-  return observableOf({
+  return Promise.resolve({
     keySystem,
     getConfiguration() { return config[0]; },
     createMediaKeys() { return new Promise(() => { /* noop */ }); },
@@ -58,7 +51,7 @@ const incompatibleMKSAErrorMessage =
   "with your wanted configuration has been found in the current browser.";
 
 /**
- * Check that the given `keySystemsConfigs` lead directly to an
+ * Check that the given `keySystemsConfigs` lead to an
  * `INCOMPATIBLE_KEYSYSTEMS` error.
  * @param {Array.<Object>} keySystemsConfigs
  * @returns {Promise}
@@ -67,19 +60,18 @@ async function checkIncompatibleKeySystemsErrorMessage(
   keySystemsConfigs : unknown[]
 ) : Promise<void> {
   const mediaElement = document.createElement("video");
-  const EMEManager = require("../../eme_manager").default;
+  const ContentDecryptor = require("../../content_decryptor").default;
 
-  const error : any = await testEMEManagerImmediateError(EMEManager,
-                                                         mediaElement,
-                                                         keySystemsConfigs,
-                                                         EMPTY);
+  const error : any = await testContentDecryptorError(ContentDecryptor,
+                                                      mediaElement,
+                                                      keySystemsConfigs);
   expect(error).not.toBe(null);
   expect(error.message).toEqual(incompatibleMKSAErrorMessage);
   expect(error.name).toEqual("EncryptedMediaError");
   expect(error.code).toEqual("INCOMPATIBLE_KEYSYSTEMS");
 }
 
-describe("core - eme - global tests - media key system access", () => {
+describe("core - decrypt - global tests - media key system access", () => {
   // Used to implement every functions that should never be called.
   const neverCalledFn = jest.fn();
 
@@ -100,7 +92,7 @@ describe("core - eme - global tests - media key system access", () => {
   });
 
   it("should throw if given a single incompatible keySystemsConfigs", async () => {
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     const getLicenseFn = neverCalledFn;
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
@@ -110,7 +102,7 @@ describe("core - eme - global tests - media key system access", () => {
   });
 
   it("should throw if given multiple incompatible keySystemsConfigs", async () => {
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     const config = [ { type: "foo", getLicense: neverCalledFn },
                      { type: "bar", getLicense: neverCalledFn },
@@ -130,20 +122,19 @@ describe("core - eme - global tests - media key system access", () => {
   /* eslint-enable max-len */
     mockCompat({ requestMediaKeySystemAccess: undefined });
     const mediaElement = document.createElement("video");
-    const EMEManager = require("../../eme_manager").default;
+    const ContentDecryptor = require("../../content_decryptor").default;
 
     const config = [{ type: "foo", getLicense: neverCalledFn }];
-    const error : any = await testEMEManagerImmediateError(EMEManager,
-                                                           mediaElement,
-                                                           config,
-                                                           EMPTY);
+    const error : any = await testContentDecryptorError(ContentDecryptor,
+                                                        mediaElement,
+                                                        config);
     expect(error).not.toBe(null);
     expect(error.message)
       .toEqual("requestMediaKeySystemAccess is not implemented in your browser.");
   });
 
   it("should throw if given a single incompatible keySystemsConfigs", async () => {
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: neverCalledFn }]);
@@ -154,7 +145,7 @@ describe("core - eme - global tests - media key system access", () => {
   /* eslint-disable max-len */
   it("should change persistentState value if persistentStateRequired is set to true", async () => {
   /* eslint-enable max-len */
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: neverCalledFn,
@@ -170,7 +161,7 @@ describe("core - eme - global tests - media key system access", () => {
   /* eslint-disable max-len */
   it("should not change persistentState value if persistentStateRequired is set to false", async () => {
   /* eslint-enable max-len */
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: neverCalledFn,
@@ -182,7 +173,7 @@ describe("core - eme - global tests - media key system access", () => {
   /* eslint-disable max-len */
   it("should change distinctiveIdentifier value if distinctiveIdentifierRequired is set to true", async () => {
   /* eslint-enable max-len */
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{
       type: "foo",
@@ -200,7 +191,7 @@ describe("core - eme - global tests - media key system access", () => {
   /* eslint-disable max-len */
   it("should not change distinctiveIdentifier value if distinctiveIdentifierRequired is set to false", async () => {
   /* eslint-enable max-len */
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{
       type: "foo",
@@ -212,7 +203,7 @@ describe("core - eme - global tests - media key system access", () => {
   });
 
   it("should do nothing if just licenseStorage is set", async () => {
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     const licenseStorage = { save() { throw new Error("Should not save."); },
                              load() { throw new Error("Should not load."); } };
@@ -226,7 +217,7 @@ describe("core - eme - global tests - media key system access", () => {
   /* eslint-disable max-len */
   it("should want persistent sessions if both persistentLicense and licenseStorage are set", async () => {
   /* eslint-enable max-len */
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     const licenseStorage = { save() { throw new Error("Should not save."); },
                              load() { throw new Error("Should not load."); } };
@@ -248,7 +239,7 @@ describe("core - eme - global tests - media key system access", () => {
   /* eslint-disable max-len */
   it("should want persistent sessions if just persistentLicense is set to true", async () => {
   /* eslint-enable max-len */
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: neverCalledFn,
@@ -264,7 +255,7 @@ describe("core - eme - global tests - media key system access", () => {
   });
 
   it("should do nothing if persistentLicense is set to false", async () => {
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "foo",
                                                      getLicense: neverCalledFn,
@@ -274,7 +265,7 @@ describe("core - eme - global tests - media key system access", () => {
   });
 
   it("should translate a `clearkey` keySystem", async () => {
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "clearkey",
                                                      getLicense: neverCalledFn }]);
@@ -286,7 +277,7 @@ describe("core - eme - global tests - media key system access", () => {
   });
 
   it("should translate a `widevine` keySystem", async () => {
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "widevine",
                                                      getLicense: neverCalledFn }]);
@@ -296,7 +287,7 @@ describe("core - eme - global tests - media key system access", () => {
   });
 
   it("should translate a `playready` keySystem", async () => {
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "playready",
                                                      getLicense: neverCalledFn }]);
@@ -310,7 +301,7 @@ describe("core - eme - global tests - media key system access", () => {
   });
 
   it("should translate a `fairplay` keySystem", async () => {
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "fairplay",
                                                      getLicense: neverCalledFn }]);
@@ -320,7 +311,7 @@ describe("core - eme - global tests - media key system access", () => {
   });
 
   it("should translate a multiple keySystems at the same time", async () => {
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "playready",
                                                      getLicense: neverCalledFn },
@@ -342,7 +333,7 @@ describe("core - eme - global tests - media key system access", () => {
   /* eslint-disable max-len */
   it("should translate a multiple keySystems at the same time with different configs", async () => {
   /* eslint-enable max-len */
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "playready",
                                                      persistentLicense: true,
@@ -375,7 +366,7 @@ describe("core - eme - global tests - media key system access", () => {
   /* eslint-disable max-len */
   it("should set widevine robustnesses for a `com.widevine.alpha` keySystem", async () => {
   /* eslint-enable max-len */
-    const requestMediaKeySystemAccessSpy = jest.fn(() => observableThrow(() => "nope"));
+    const requestMediaKeySystemAccessSpy = jest.fn(() => Promise.reject("nope"));
     mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
     await checkIncompatibleKeySystemsErrorMessage([{ type: "playready",
                                                      persistentLicense: true,
@@ -416,20 +407,17 @@ describe("core - eme - global tests - media key system access", () => {
                         getLicense: neverCalledFn }];
 
       const mediaElement = document.createElement("video");
-      const EMEManager = require("../../eme_manager").default;
-      EMEManager(mediaElement, config, new Subject<void>())
-        .subscribe(
-          (evt : unknown) => {
-            const eventStr = JSON.stringify(evt as any);
-            rej(new Error("Received an EMEManager event: " + eventStr));
-          },
-          (err : unknown) => { rej(err); },
-          () => rej(new Error("EMEManager completed."))
-        );
-      expect(requestMediaKeySystemAccessSpy).toHaveBeenCalledTimes(1);
-      expect(requestMediaKeySystemAccessSpy)
-        .toHaveBeenCalledWith("com.widevine.alpha", defaultWidevineConfig);
-      res();
+      const ContentDecryptor = require("../../content_decryptor").default;
+      const contentDecryptor = new ContentDecryptor(mediaElement, config);
+      contentDecryptor.addEventListener("error", (error: any) => {
+        rej(error);
+      });
+      setTimeout(() => {
+        expect(requestMediaKeySystemAccessSpy).toHaveBeenCalledTimes(1);
+        expect(requestMediaKeySystemAccessSpy)
+          .toHaveBeenCalledWith("com.widevine.alpha", defaultWidevineConfig);
+        res();
+      }, 10);
     });
   });
 
@@ -442,7 +430,7 @@ describe("core - eme - global tests - media key system access", () => {
         if (++callNb === 2) {
           return requestMediaKeySystemAccessNoMediaKeys(keyType, conf);
         }
-        return observableThrow(() => "nope");
+        return Promise.reject("nope");
       });
       mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
       const config = [{ type: "com.widevine.alpha",
@@ -451,55 +439,74 @@ describe("core - eme - global tests - media key system access", () => {
                         getLicense: neverCalledFn }];
 
       const mediaElement = document.createElement("video");
-      const EMEManager = require("../../eme_manager").default;
-      EMEManager(mediaElement, config, new Subject<void>())
-        .subscribe(
-          (evt : unknown) => {
-            const eventStr = JSON.stringify(evt as any);
-            rej(new Error("Received an EMEManager event: " + eventStr));
-          },
-          (err : unknown) => { rej(err); },
-          () => rej(new Error("EMEManager completed."))
-        );
-      expect(requestMediaKeySystemAccessSpy).toHaveBeenCalledTimes(2);
-      expect(requestMediaKeySystemAccessSpy)
-        .toHaveBeenNthCalledWith(1, "com.widevine.alpha", defaultWidevineConfig);
-      expect(requestMediaKeySystemAccessSpy)
-        .toHaveBeenNthCalledWith(2, "some-other-working-key-system", defaultKSConfig);
-      res();
+      const ContentDecryptor = require("../../content_decryptor").default;
+      const contentDecryptor = new ContentDecryptor(mediaElement, config);
+      contentDecryptor.addEventListener("error", (error: any) => {
+        rej(error);
+      });
+      setTimeout(() => {
+        expect(requestMediaKeySystemAccessSpy).toHaveBeenCalledTimes(2);
+        expect(requestMediaKeySystemAccessSpy)
+          .toHaveBeenNthCalledWith(1, "com.widevine.alpha", defaultWidevineConfig);
+        expect(requestMediaKeySystemAccessSpy)
+          .toHaveBeenNthCalledWith(2, "some-other-working-key-system", defaultKSConfig);
+        res();
+      }, 10);
     });
   });
 
-  xit("should not continue to check if the observable is unsubscribed from", () => {
+  it("should not continue to check if the ContentDecryptor is disposed from", () => {
     return new Promise<void>((res, rej) => {
-      const killSubject$ = new Subject<void>();
+      let contentDecryptor : any = null;
       let rmksHasBeenCalled = false;
       const requestMediaKeySystemAccessSpy = jest.fn(() => {
-        if (rmksHasBeenCalled) {
-          rej("requestMediaKeySystemAccess has already been called.");
-        }
-        rmksHasBeenCalled = true;
-        killSubject$.next();
-        killSubject$.complete();
-        return observableThrow(() => "nope");
+        return Promise.resolve().then(() => {
+          rmksHasBeenCalled = true;
+          contentDecryptor.dispose();
+          return Promise.reject("nope");
+        });
       });
       mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
       const mediaElement = document.createElement("video");
-      const EMEManager = require("../../eme_manager").default;
+      const ContentDecryptor = require("../../content_decryptor").default;
 
       const config = [ { type: "foo", getLicense: neverCalledFn },
                        { type: "bar", getLicense: neverCalledFn },
                        { type: "baz", getLicense: neverCalledFn } ];
-      EMEManager(mediaElement, config, EMPTY)
-        .pipe(takeUntil(killSubject$))
-        .subscribe(
-          () => { rej("We should not have received an event"); },
-          () => { rej("We should not have received an error."); },
-          () =>  {
-            expect(rmksHasBeenCalled).toBe(true);
-            setTimeout(() => { res(); }, 10);
-          }
-        );
+      contentDecryptor = new ContentDecryptor(mediaElement, config);
+      contentDecryptor.addEventListener("error", (error: any) => {
+        rej(error);
+      });
+      setTimeout(() => {
+        expect(rmksHasBeenCalled).toEqual(true);
+        expect(requestMediaKeySystemAccessSpy).toHaveBeenCalledTimes(1);
+        expect(requestMediaKeySystemAccessSpy)
+          .toHaveBeenNthCalledWith(1, "foo", defaultKSConfig);
+        res();
+      }, 10);
+    });
+  });
+
+  it("should trigger error even if requestMediaKeySystemAccess throws", () => {
+    return new Promise<void>((res, rej) => {
+      let rmksHasBeenCalled = false;
+      const requestMediaKeySystemAccessSpy = jest.fn(() => {
+        rmksHasBeenCalled = true;
+        throw new Error("nope");
+      });
+      mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessSpy });
+      const mediaElement = document.createElement("video");
+      const ContentDecryptor = require("../../content_decryptor").default;
+
+      const config = [{ type: "foo", getLicense: neverCalledFn }];
+      const contentDecryptor = new ContentDecryptor(mediaElement, config);
+      contentDecryptor.addEventListener("error", () => {
+        expect(rmksHasBeenCalled).toEqual(true);
+        res();
+      });
+      setTimeout(() => {
+        rej(new Error("timeout exceeded"));
+      }, 10);
     });
   });
 });

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

@@ -0,0 +1,156 @@
+/**
+ * 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/no-explicit-any */
+/* eslint-disable no-restricted-properties */
+
+import {
+  MediaKeysImpl,
+  mockCompat,
+  testContentDecryptorError,
+} from "./utils";
+
+describe("core - decrypt - global tests - media key system access", () => {
+  /** Used to implement every functions that should never be called. */
+  const neverCalledFn = jest.fn();
+
+  /** Default video element used in our tests. */
+  const videoElt = document.createElement("video");
+
+  /** Default keySystems configuration used in our tests. */
+  const ksConfig = [{ type: "com.widevine.alpha", getLicense: neverCalledFn }];
+
+  beforeEach(() => {
+    jest.resetModules();
+    jest.restoreAllMocks();
+    jest.mock("../../set_server_certificate", () => ({ __esModule: true as const,
+                                                       default: neverCalledFn }));
+  });
+
+  afterEach(() => {
+    expect(neverCalledFn).not.toHaveBeenCalled();
+  });
+
+  it("should throw if createMediaKeys throws", async () => {
+    // == mocks ==
+    function requestMediaKeySystemAccessBadMediaKeys(
+      keySystem : string,
+      conf : MediaKeySystemConfiguration[]
+    ) {
+      return Promise.resolve({ keySystem,
+                               getConfiguration() { return conf; },
+                               createMediaKeys() { throw new Error("No non no"); } });
+    }
+    mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessBadMediaKeys });
+
+    // == test ==
+    const ContentDecryptor = require("../../content_decryptor").default;
+    const error : any =
+      await testContentDecryptorError(ContentDecryptor, videoElt, ksConfig);
+    expect(error).toBeInstanceOf(Error);
+    expect(error.message).toEqual(
+      "EncryptedMediaError (CREATE_MEDIA_KEYS_ERROR) No non no"
+    );
+    expect(error.name).toEqual("EncryptedMediaError");
+    expect(error.code).toEqual("CREATE_MEDIA_KEYS_ERROR");
+  });
+
+  it("should throw if createMediaKeys rejects", async () => {
+    // == mocks ==
+    function requestMediaKeySystemAccessRejMediaKeys(
+      keySystem : string,
+      conf : MediaKeySystemConfiguration[]
+    ) {
+      return Promise.resolve({
+        keySystem,
+        getConfiguration: () => conf,
+        createMediaKeys: () => Promise.reject(new Error("No non no")),
+      });
+    }
+    mockCompat({ requestMediaKeySystemAccess: requestMediaKeySystemAccessRejMediaKeys });
+
+    // == test ==
+    const ContentDecryptor = require("../../content_decryptor").default;
+    const error : any =
+      await testContentDecryptorError(ContentDecryptor, videoElt, ksConfig);
+    expect(error).toBeInstanceOf(Error);
+    expect(error.message).toEqual(
+      "EncryptedMediaError (CREATE_MEDIA_KEYS_ERROR) No non no"
+    );
+    expect(error.name).toEqual("EncryptedMediaError");
+    expect(error.code).toEqual("CREATE_MEDIA_KEYS_ERROR");
+  });
+
+  /* eslint-disable max-len */
+  it("should go into the WaitingForAttachment state if createMediaKeys resolves", () => {
+  /* eslint-enable max-len */
+    return new Promise<void>((res, rej) => {
+      mockCompat({});
+      const { ContentDecryptorState } = require("../../content_decryptor");
+      const ContentDecryptor = require("../../content_decryptor").default;
+      const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
+      let receivedStateChange = 0;
+      contentDecryptor.addEventListener("stateChange", (newState: any) => {
+        receivedStateChange++;
+        try {
+          expect(newState).toEqual(ContentDecryptorState.WaitingForAttachment);
+        } catch (err) { rej(err); }
+        setTimeout(() => {
+          try {
+            expect(receivedStateChange).toEqual(1);
+            expect(contentDecryptor.getState())
+              .toEqual(ContentDecryptorState.WaitingForAttachment);
+            contentDecryptor.dispose();
+          } catch (err) { rej(err); }
+          res();
+        });
+      });
+    });
+  });
+
+  /* eslint-disable max-len */
+  it("should not create any session if no encrypted event was received", (done) => {
+  /* eslint-enable max-len */
+
+    // == mocks ==
+    const setMediaKeysSpy = jest.fn(() => Promise.resolve());
+    mockCompat({ setMediaKeys: setMediaKeysSpy });
+    const createSessionSpy = jest.spyOn(MediaKeysImpl.prototype, "createSession");
+
+    // == test ==
+    const { ContentDecryptorState } = require("../../content_decryptor");
+    const ContentDecryptor = require("../../content_decryptor").default;
+    const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
+    contentDecryptor.addEventListener("stateChange", (newState: any) => {
+      if (newState === ContentDecryptorState.WaitingForAttachment) {
+        contentDecryptor.removeEventListener("stateChange");
+        contentDecryptor.attach();
+        setTimeout(() => {
+          expect(setMediaKeysSpy).toHaveBeenCalledTimes(1);
+          expect(setMediaKeysSpy).toHaveBeenCalledWith(videoElt, new MediaKeysImpl());
+          expect(createSessionSpy).not.toHaveBeenCalled();
+          done();
+        }, 5);
+      }
+    });
+  });
+});