rx-player 4.2.0-dev.2024080600 → 4.2.0-dev.2024080900

package/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts

@@ -41,6 +41,22 @@ const incompatibleMKSAErrorMessage =
   "INCOMPATIBLE_KEYSYSTEMS: No key system compatible " +
   "with your wanted configuration has been found in the current browser.";
 
+function removeCapabiltiesFromConfig(
+  baseConfig: MediaKeySystemConfiguration[],
+): MediaKeySystemConfiguration[] {
+  return baseConfig.map(
+    (config) =>
+      ({
+        ...config,
+        audioCapabilities: undefined,
+        videoCapabilities: undefined,
+        // Note: TypeScript is wrong here (2024-08-07), it thinks that
+        // `audioCapabilities` and `videoCapabilities` cannot be set to
+        // `undefined`, though they definitely can.
+      }) as unknown as MediaKeySystemConfiguration,
+  );
+}
+
 /**
  * Check that the given `keySystemsConfigs` lead to an
  * `INCOMPATIBLE_KEYSYSTEMS` error.
@@ -97,8 +113,17 @@ describe("decrypt - global tests - media key system access", () => {
     await checkIncompatibleKeySystemsErrorMessage([
       { type: "foo", getLicense: getLicenseFn },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", defaultKSConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      defaultKSConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
   });
 
   it("should throw if given multiple incompatible keySystemsConfigs", async () => {
@@ -114,7 +139,7 @@ describe("decrypt - global tests - media key system access", () => {
       { type: "baz", getLicense: neverCalledFn },
     ];
     await checkIncompatibleKeySystemsErrorMessage(config);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(3);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(6);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       1,
       "foo",
@@ -122,14 +147,29 @@ describe("decrypt - global tests - media key system access", () => {
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       2,
+      "foo",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      3,
       "bar",
       defaultKSConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      3,
+      4,
+      "bar",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      5,
       "baz",
       defaultKSConfig,
     );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      6,
+      "baz",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
   });
 
   it("should throw if given a single incompatible keySystemsConfigs", async () => {
@@ -142,8 +182,17 @@ describe("decrypt - global tests - media key system access", () => {
     await checkIncompatibleKeySystemsErrorMessage([
       { type: "foo", getLicense: neverCalledFn },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", defaultKSConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      defaultKSConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
   });
 
   it('should set persistentState value if persistentState is set to "required"', async () => {
@@ -156,12 +205,21 @@ describe("decrypt - global tests - media key system access", () => {
     await checkIncompatibleKeySystemsErrorMessage([
       { type: "foo", getLicense: neverCalledFn, persistentState: "required" },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
 
-    const expectedConfig = defaultKSConfig.map((conf) => {
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
       return { ...conf, persistentState: "required" };
     });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", expectedConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
   });
 
   it('should set persistentState value if persistentState is set to "not-allowed"', async () => {
@@ -178,12 +236,21 @@ describe("decrypt - global tests - media key system access", () => {
         persistentState: "not-allowed",
       },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
 
-    const expectedConfig = defaultKSConfig.map((conf) => {
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
       return { ...conf, persistentState: "not-allowed" };
     });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", expectedConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
   });
 
   it('should set persistentState value if persistentState is set to "optional"', async () => {
@@ -196,12 +263,21 @@ describe("decrypt - global tests - media key system access", () => {
     await checkIncompatibleKeySystemsErrorMessage([
       { type: "foo", getLicense: neverCalledFn, persistentState: "optional" },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
 
-    const expectedConfig = defaultKSConfig.map((conf) => {
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
       return { ...conf, persistentState: "optional" };
     });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", expectedConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
   });
 
   it('should set distinctiveIdentifier value if distinctiveIdentifier is set to "required"', async () => {
@@ -218,12 +294,21 @@ describe("decrypt - global tests - media key system access", () => {
         distinctiveIdentifier: "required",
       },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
 
-    const expectedConfig = defaultKSConfig.map((conf) => {
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
       return { ...conf, distinctiveIdentifier: "required" };
     });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", expectedConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
   });
 
   it('should set distinctiveIdentifier value if distinctiveIdentifier is set to "not-allowed"', async () => {
@@ -240,12 +325,21 @@ describe("decrypt - global tests - media key system access", () => {
         distinctiveIdentifier: "not-allowed",
       },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
 
-    const expectedConfig = defaultKSConfig.map((conf) => {
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
       return { ...conf, distinctiveIdentifier: "not-allowed" };
     });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", expectedConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
   });
 
   it('should set distinctiveIdentifier value if distinctiveIdentifier is set to "optional"', async () => {
@@ -262,12 +356,21 @@ describe("decrypt - global tests - media key system access", () => {
         distinctiveIdentifier: "optional",
       },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
 
-    const expectedConfig = defaultKSConfig.map((conf) => {
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
       return { ...conf, distinctiveIdentifier: "optional" };
     });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", expectedConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
   });
 
   it("should want persistent sessions if persistentLicenseConfig is set", async () => {
@@ -288,16 +391,25 @@ describe("decrypt - global tests - media key system access", () => {
     await checkIncompatibleKeySystemsErrorMessage([
       { type: "foo", getLicense: neverCalledFn, persistentLicenseConfig },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
 
-    const expectedConfig = defaultKSConfig.map((conf) => {
+    const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
       return {
         ...conf,
         persistentState: "required",
         sessionTypes: ["temporary", "persistent-license"],
       };
     });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", expectedConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      expectedConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(expectedConfig),
+    );
   });
 
   it("should do nothing if persistentLicenseConfig is set to null", async () => {
@@ -310,8 +422,17 @@ describe("decrypt - global tests - media key system access", () => {
     await checkIncompatibleKeySystemsErrorMessage([
       { type: "foo", getLicense: neverCalledFn, persistentLicenseConfig: null },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", defaultKSConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      defaultKSConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
   });
 
   it("should do nothing if persistentLicenseConfig is set to undefined", async () => {
@@ -328,8 +449,17 @@ describe("decrypt - global tests - media key system access", () => {
         persistentLicenseConfig: undefined,
       },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith("foo", defaultKSConfig);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
+      "foo",
+      defaultKSConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "foo",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
   });
 
   it("should translate a `clearkey` keySystem", async () => {
@@ -342,7 +472,7 @@ describe("decrypt - global tests - media key system access", () => {
     await checkIncompatibleKeySystemsErrorMessage([
       { type: "clearkey", getLicense: neverCalledFn },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(4);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       1,
       "webkit-org.w3.clearkey",
@@ -350,9 +480,19 @@ describe("decrypt - global tests - media key system access", () => {
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       2,
+      "webkit-org.w3.clearkey",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      3,
       "org.w3.clearkey",
       defaultKSConfig,
     );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      4,
+      "org.w3.clearkey",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
   });
 
   it("should translate a `widevine` keySystem", async () => {
@@ -365,11 +505,17 @@ describe("decrypt - global tests - media key system access", () => {
     await checkIncompatibleKeySystemsErrorMessage([
       { type: "widevine", getLicense: neverCalledFn },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith(
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      1,
       "com.widevine.alpha",
       defaultWidevineConfig,
     );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "com.widevine.alpha",
+      removeCapabiltiesFromConfig(defaultWidevineConfig),
+    );
   });
 
   it("should translate a `playready` keySystem", async () => {
@@ -382,7 +528,7 @@ describe("decrypt - global tests - media key system access", () => {
     await checkIncompatibleKeySystemsErrorMessage([
       { type: "playready", getLicense: neverCalledFn },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(4);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(8);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       1,
       "com.microsoft.playready.recommendation",
@@ -390,19 +536,39 @@ describe("decrypt - global tests - media key system access", () => {
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       2,
+      "com.microsoft.playready.recommendation",
+      removeCapabiltiesFromConfig(defaultPRRecommendationKSConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      3,
       "com.microsoft.playready",
       defaultKSConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      3,
+      4,
+      "com.microsoft.playready",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      5,
       "com.chromecast.playready",
       defaultKSConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      4,
+      6,
+      "com.chromecast.playready",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      7,
       "com.youtube.playready",
       defaultKSConfig,
     );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      8,
+      "com.youtube.playready",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
   });
 
   it("should translate a `fairplay` keySystem", async () => {
@@ -415,11 +581,15 @@ describe("decrypt - global tests - media key system access", () => {
     await checkIncompatibleKeySystemsErrorMessage([
       { type: "fairplay", getLicense: neverCalledFn },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith(
       "com.apple.fps.1_0",
       defaultKSConfig,
     );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledWith(
+      "com.apple.fps.1_0",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
   });
 
   it("should translate a multiple keySystems at the same time", async () => {
@@ -433,7 +603,7 @@ describe("decrypt - global tests - media key system access", () => {
       { type: "playready", getLicense: neverCalledFn },
       { type: "clearkey", getLicense: neverCalledFn },
     ]);
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(6);
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(12);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       1,
       "com.microsoft.playready.recommendation",
@@ -441,29 +611,49 @@ describe("decrypt - global tests - media key system access", () => {
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       2,
-      "com.microsoft.playready",
-      defaultKSConfig,
+      "com.microsoft.playready.recommendation",
+      removeCapabiltiesFromConfig(defaultPRRecommendationKSConfig),
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       3,
-      "com.chromecast.playready",
+      "com.microsoft.playready",
       defaultKSConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       4,
-      "com.youtube.playready",
-      defaultKSConfig,
+      "com.microsoft.playready",
+      removeCapabiltiesFromConfig(defaultKSConfig),
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       5,
-      "webkit-org.w3.clearkey",
+      "com.chromecast.playready",
       defaultKSConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       6,
+      "com.chromecast.playready",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      9,
+      "webkit-org.w3.clearkey",
+      defaultKSConfig,
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      10,
+      "webkit-org.w3.clearkey",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      11,
       "org.w3.clearkey",
       defaultKSConfig,
     );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      12,
+      "org.w3.clearkey",
+      removeCapabiltiesFromConfig(defaultKSConfig),
+    );
   });
 
   it("should translate a multiple keySystems at the same time with different configs", async () => {
@@ -492,7 +682,15 @@ describe("decrypt - global tests - media key system access", () => {
         getLicense: neverCalledFn,
       },
     ]);
-    const expectedPRRecommendationPersistentConfig = defaultPRRecommendationKSConfig.map(
+    const expectedPRRecommendationPersistentConfig: MediaKeySystemConfiguration[] =
+      defaultPRRecommendationKSConfig.map((conf) => {
+        return {
+          ...conf,
+          persistentState: "required",
+          sessionTypes: ["temporary", "persistent-license"],
+        };
+      });
+    const expectedPersistentConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map(
       (conf) => {
         return {
           ...conf,
@@ -501,17 +699,12 @@ describe("decrypt - global tests - media key system access", () => {
         };
       },
     );
-    const expectedPersistentConfig = defaultKSConfig.map((conf) => {
-      return {
-        ...conf,
-        persistentState: "required",
-        sessionTypes: ["temporary", "persistent-license"],
-      };
-    });
-    const expectedIdentifierConfig = defaultKSConfig.map((conf) => {
-      return { ...conf, distinctiveIdentifier: "required" };
-    });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(6);
+    const expectedIdentifierConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map(
+      (conf) => {
+        return { ...conf, distinctiveIdentifier: "required" };
+      },
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(12);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       1,
       "com.microsoft.playready.recommendation",
@@ -519,29 +712,59 @@ describe("decrypt - global tests - media key system access", () => {
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       2,
+      "com.microsoft.playready.recommendation",
+      removeCapabiltiesFromConfig(expectedPRRecommendationPersistentConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      3,
       "com.microsoft.playready",
       expectedPersistentConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      3,
+      4,
+      "com.microsoft.playready",
+      removeCapabiltiesFromConfig(expectedPersistentConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      5,
       "com.chromecast.playready",
       expectedPersistentConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      4,
+      6,
+      "com.chromecast.playready",
+      removeCapabiltiesFromConfig(expectedPersistentConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      7,
       "com.youtube.playready",
       expectedPersistentConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      5,
+      8,
+      "com.youtube.playready",
+      removeCapabiltiesFromConfig(expectedPersistentConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      9,
       "webkit-org.w3.clearkey",
       expectedIdentifierConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      6,
+      10,
+      "webkit-org.w3.clearkey",
+      removeCapabiltiesFromConfig(expectedIdentifierConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      11,
       "org.w3.clearkey",
       expectedIdentifierConfig,
     );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      12,
+      "org.w3.clearkey",
+      removeCapabiltiesFromConfig(expectedIdentifierConfig),
+    );
   });
 
   it("should set widevine robustnesses for a `com.widevine.alpha` keySystem", async () => {
@@ -565,19 +788,25 @@ describe("decrypt - global tests - media key system access", () => {
         getLicense: neverCalledFn,
       },
     ]);
-    const expectedPersistentConfig = defaultWidevineConfig.map((conf) => {
-      return {
-        ...conf,
-        persistentState: "required",
-        sessionTypes: ["temporary", "persistent-license"],
-      };
-    });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
+    const expectedPersistentConfig: MediaKeySystemConfiguration[] =
+      defaultWidevineConfig.map((conf) => {
+        return {
+          ...conf,
+          persistentState: "required",
+          sessionTypes: ["temporary", "persistent-license"],
+        };
+      });
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       1,
       "com.widevine.alpha",
       expectedPersistentConfig,
     );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "com.widevine.alpha",
+      removeCapabiltiesFromConfig(expectedPersistentConfig),
+    );
   });
 
   it("should set playready robustnesses for a `playready` keySystem", async () => {
@@ -606,24 +835,29 @@ describe("decrypt - global tests - media key system access", () => {
         getLicense: neverCalledFn,
       },
     ]);
-    const expectedPersistentConfig = defaultKSConfig.map((conf) => {
-      return {
-        ...conf,
-        persistentState: "required",
-        sessionTypes: ["temporary", "persistent-license"],
-      };
-    });
-    const expectedRecoPersistentConfig = defaultPRRecommendationKSConfig.map((conf) => {
-      return {
-        ...conf,
-        persistentState: "required",
-        sessionTypes: ["temporary", "persistent-license"],
-      };
-    });
-    const expectedIdentifierConfig = defaultKSConfig.map((conf) => {
-      return { ...conf, distinctiveIdentifier: "required" };
-    });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(6);
+    const expectedPersistentConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map(
+      (conf) => {
+        return {
+          ...conf,
+          persistentState: "required",
+          sessionTypes: ["temporary", "persistent-license"],
+        };
+      },
+    );
+    const expectedRecoPersistentConfig: MediaKeySystemConfiguration[] =
+      defaultPRRecommendationKSConfig.map((conf) => {
+        return {
+          ...conf,
+          persistentState: "required",
+          sessionTypes: ["temporary", "persistent-license"],
+        };
+      });
+    const expectedIdentifierConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map(
+      (conf) => {
+        return { ...conf, distinctiveIdentifier: "required" };
+      },
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(12);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       1,
       "com.microsoft.playready.recommendation",
@@ -631,29 +865,59 @@ describe("decrypt - global tests - media key system access", () => {
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       2,
+      "com.microsoft.playready.recommendation",
+      removeCapabiltiesFromConfig(expectedRecoPersistentConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      3,
       "com.microsoft.playready",
       expectedPersistentConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      3,
+      4,
+      "com.microsoft.playready",
+      removeCapabiltiesFromConfig(expectedPersistentConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      5,
       "com.chromecast.playready",
       expectedPersistentConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      4,
+      6,
+      "com.chromecast.playready",
+      removeCapabiltiesFromConfig(expectedPersistentConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      7,
       "com.youtube.playready",
       expectedPersistentConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      5,
+      8,
+      "com.youtube.playready",
+      removeCapabiltiesFromConfig(expectedPersistentConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      9,
       "webkit-org.w3.clearkey",
       expectedIdentifierConfig,
     );
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
-      6,
+      10,
+      "webkit-org.w3.clearkey",
+      removeCapabiltiesFromConfig(expectedIdentifierConfig),
+    );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      11,
       "org.w3.clearkey",
       expectedIdentifierConfig,
     );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      12,
+      "org.w3.clearkey",
+      removeCapabiltiesFromConfig(expectedIdentifierConfig),
+    );
   });
 
   it("should set playready robustnesses for a `com.microsoft.playready.recommendation` keySystem", async () => {
@@ -677,19 +941,25 @@ describe("decrypt - global tests - media key system access", () => {
         getLicense: neverCalledFn,
       },
     ]);
-    const expectedRecoPersistentConfig = defaultPRRecommendationKSConfig.map((conf) => {
-      return {
-        ...conf,
-        persistentState: "required",
-        sessionTypes: ["temporary", "persistent-license"],
-      };
-    });
-    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
+    const expectedRecoPersistentConfig: MediaKeySystemConfiguration[] =
+      defaultPRRecommendationKSConfig.map((conf) => {
+        return {
+          ...conf,
+          persistentState: "required",
+          sessionTypes: ["temporary", "persistent-license"],
+        };
+      });
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
     expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
       1,
       "com.microsoft.playready.recommendation",
       expectedRecoPersistentConfig,
     );
+    expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+      2,
+      "com.microsoft.playready.recommendation",
+      removeCapabiltiesFromConfig(expectedRecoPersistentConfig),
+    );
   });
 
   it("should successfully create a MediaKeySystemAccess if given the right configuration", async () => {
@@ -723,11 +993,10 @@ describe("decrypt - global tests - media key system access", () => {
   });
 
   it("should successfully create a MediaKeySystemAccess if given multiple configurations where one works", async () => {
-    let callNb = 0;
     const mockRequestMediaKeySystemAccess = vi
       .fn()
       .mockImplementation((keyType, conf) => {
-        if (++callNb === 2) {
+        if (keyType === "some-other-working-key-system") {
           return requestMediaKeySystemAccessNoMediaKeys(keyType, conf);
         }
         return Promise.reject("nope");
@@ -749,7 +1018,7 @@ describe("decrypt - global tests - media key system access", () => {
         rej(error);
       });
       setTimeout(() => {
-        expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
+        expect(mockRequestMediaKeySystemAccess).toHaveBeenCalledTimes(3);
         expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
           1,
           "com.widevine.alpha",
@@ -757,6 +1026,11 @@ describe("decrypt - global tests - media key system access", () => {
         );
         expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
           2,
+          "com.widevine.alpha",
+          removeCapabiltiesFromConfig(defaultWidevineConfig),
+        );
+        expect(mockRequestMediaKeySystemAccess).toHaveBeenNthCalledWith(
+          3,
           "some-other-working-key-system",
           defaultKSConfig,
         );