rx-player 4.5.0-dev.2026031700 → 4.5.0-dev.2026033100
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +3 -1
- package/VERSION +1 -1
- package/dist/commonjs/__GENERATED_CODE/embedded_worker.d.ts.map +1 -1
- package/dist/commonjs/__GENERATED_CODE/embedded_worker.js +1 -1
- package/dist/commonjs/compat/browser_compatibility_types.d.ts +16 -14
- package/dist/commonjs/compat/browser_compatibility_types.d.ts.map +1 -1
- package/dist/commonjs/compat/browser_compatibility_types.js +7 -4
- package/dist/commonjs/compat/browser_version.d.ts +2 -1
- package/dist/commonjs/compat/browser_version.d.ts.map +1 -1
- package/dist/commonjs/compat/browser_version.js +13 -0
- package/dist/commonjs/compat/disable_remote_playback_on_managed_media_source.d.ts.map +1 -1
- package/dist/commonjs/compat/disable_remote_playback_on_managed_media_source.js +1 -1
- package/dist/commonjs/compat/is_codec_supported.d.ts.map +1 -1
- package/dist/commonjs/compat/is_codec_supported.js +4 -3
- package/dist/commonjs/compat/should_patch_out_dolby_vision_config_data_from_mp4.d.ts +26 -0
- package/dist/commonjs/compat/should_patch_out_dolby_vision_config_data_from_mp4.d.ts.map +1 -0
- package/dist/commonjs/compat/should_patch_out_dolby_vision_config_data_from_mp4.js +45 -0
- package/dist/commonjs/core/entry/utils.js +3 -3
- package/dist/commonjs/core/fetchers/segment/segment_fetcher.d.ts.map +1 -1
- package/dist/commonjs/core/fetchers/segment/segment_fetcher.js +2 -1
- package/dist/commonjs/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.d.ts.map +1 -1
- package/dist/commonjs/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.js +2 -1
- package/dist/commonjs/experimental/tools/mediaCapabilitiesProber/probers/defaultCodecsFinder.d.ts.map +1 -1
- package/dist/commonjs/experimental/tools/mediaCapabilitiesProber/probers/defaultCodecsFinder.js +8 -6
- package/dist/commonjs/experimental/tools/mediaCapabilitiesProber/probers/mediaContentType.d.ts.map +1 -1
- package/dist/commonjs/experimental/tools/mediaCapabilitiesProber/probers/mediaContentType.js +4 -3
- package/dist/commonjs/initialize_worker.js +1 -1
- package/dist/commonjs/main_thread/api/debug/modules/segment_buffer_content.js +3 -3
- package/dist/commonjs/main_thread/api/public_api.js +2 -2
- package/dist/commonjs/main_thread/init/utils/update_manifest_codec_support.d.ts.map +1 -1
- package/dist/commonjs/main_thread/init/utils/update_manifest_codec_support.js +24 -12
- package/dist/commonjs/manifest/classes/adaptation.d.ts.map +1 -1
- package/dist/commonjs/manifest/classes/adaptation.js +3 -1
- package/dist/commonjs/manifest/classes/representation.d.ts +6 -2
- package/dist/commonjs/manifest/classes/representation.d.ts.map +1 -1
- package/dist/commonjs/manifest/classes/representation.js +45 -23
- package/dist/commonjs/manifest/types.d.ts +14 -6
- package/dist/commonjs/manifest/types.d.ts.map +1 -1
- package/dist/commonjs/manifest/utils.js +4 -4
- package/dist/commonjs/mse/main_media_source_interface.d.ts.map +1 -1
- package/dist/commonjs/mse/main_media_source_interface.js +3 -2
- package/dist/commonjs/mse/worker_media_source_interface.d.ts.map +1 -1
- package/dist/commonjs/parsers/containers/isobmff/get_box.d.ts +12 -1
- package/dist/commonjs/parsers/containers/isobmff/get_box.d.ts.map +1 -1
- package/dist/commonjs/parsers/containers/isobmff/get_box.js +16 -0
- package/dist/commonjs/parsers/containers/isobmff/index.d.ts +2 -1
- package/dist/commonjs/parsers/containers/isobmff/index.d.ts.map +1 -1
- package/dist/commonjs/parsers/containers/isobmff/index.js +3 -1
- package/dist/commonjs/parsers/containers/isobmff/remove_dolby_vision_config_data.d.ts +13 -0
- package/dist/commonjs/parsers/containers/isobmff/remove_dolby_vision_config_data.d.ts.map +1 -0
- package/dist/commonjs/parsers/containers/isobmff/remove_dolby_vision_config_data.js +180 -0
- package/dist/commonjs/parsers/manifest/metaplaylist/metaplaylist_parser.js +4 -4
- package/dist/commonjs/transports/dash/segment_parser.d.ts.map +1 -1
- package/dist/commonjs/transports/dash/segment_parser.js +6 -0
- package/dist/commonjs/transports/dash/text_parser.d.ts.map +1 -1
- package/dist/commonjs/transports/dash/text_parser.js +5 -1
- package/dist/commonjs/transports/local/text_parser.d.ts.map +1 -1
- package/dist/commonjs/transports/local/text_parser.js +5 -1
- package/dist/commonjs/transports/metaplaylist/pipelines.d.ts.map +1 -1
- package/dist/commonjs/transports/metaplaylist/pipelines.js +2 -1
- package/dist/commonjs/transports/smooth/pipelines.js +3 -3
- package/dist/commonjs/transports/types.d.ts +28 -2
- package/dist/commonjs/transports/types.d.ts.map +1 -1
- package/dist/commonjs/transports/utils/parse_text_track.d.ts +9 -2
- package/dist/commonjs/transports/utils/parse_text_track.d.ts.map +1 -1
- package/dist/commonjs/transports/utils/parse_text_track.js +1 -1
- package/dist/es2017/__GENERATED_CODE/embedded_worker.d.ts.map +1 -1
- package/dist/es2017/__GENERATED_CODE/embedded_worker.js +1 -1
- package/dist/es2017/compat/browser_compatibility_types.d.ts +16 -14
- package/dist/es2017/compat/browser_compatibility_types.d.ts.map +1 -1
- package/dist/es2017/compat/browser_compatibility_types.js +7 -1
- package/dist/es2017/compat/browser_version.d.ts +2 -1
- package/dist/es2017/compat/browser_version.d.ts.map +1 -1
- package/dist/es2017/compat/browser_version.js +13 -1
- package/dist/es2017/compat/disable_remote_playback_on_managed_media_source.d.ts.map +1 -1
- package/dist/es2017/compat/disable_remote_playback_on_managed_media_source.js +2 -2
- package/dist/es2017/compat/is_codec_supported.d.ts.map +1 -1
- package/dist/es2017/compat/is_codec_supported.js +2 -1
- package/dist/es2017/compat/should_patch_out_dolby_vision_config_data_from_mp4.d.ts +26 -0
- package/dist/es2017/compat/should_patch_out_dolby_vision_config_data_from_mp4.d.ts.map +1 -0
- package/dist/es2017/compat/should_patch_out_dolby_vision_config_data_from_mp4.js +42 -0
- package/dist/es2017/core/entry/utils.js +4 -4
- package/dist/es2017/core/fetchers/segment/segment_fetcher.d.ts.map +1 -1
- package/dist/es2017/core/fetchers/segment/segment_fetcher.js +2 -1
- package/dist/es2017/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.d.ts.map +1 -1
- package/dist/es2017/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.js +2 -1
- package/dist/es2017/experimental/tools/mediaCapabilitiesProber/probers/defaultCodecsFinder.d.ts.map +1 -1
- package/dist/es2017/experimental/tools/mediaCapabilitiesProber/probers/defaultCodecsFinder.js +3 -1
- package/dist/es2017/experimental/tools/mediaCapabilitiesProber/probers/mediaContentType.d.ts.map +1 -1
- package/dist/es2017/experimental/tools/mediaCapabilitiesProber/probers/mediaContentType.js +2 -1
- package/dist/es2017/initialize_worker.js +1 -1
- package/dist/es2017/main_thread/api/debug/modules/segment_buffer_content.js +3 -3
- package/dist/es2017/main_thread/api/public_api.js +2 -2
- package/dist/es2017/main_thread/init/utils/update_manifest_codec_support.d.ts.map +1 -1
- package/dist/es2017/main_thread/init/utils/update_manifest_codec_support.js +9 -7
- package/dist/es2017/manifest/classes/adaptation.d.ts.map +1 -1
- package/dist/es2017/manifest/classes/adaptation.js +3 -1
- package/dist/es2017/manifest/classes/representation.d.ts +6 -2
- package/dist/es2017/manifest/classes/representation.d.ts.map +1 -1
- package/dist/es2017/manifest/classes/representation.js +45 -23
- package/dist/es2017/manifest/types.d.ts +14 -6
- package/dist/es2017/manifest/types.d.ts.map +1 -1
- package/dist/es2017/manifest/utils.js +4 -4
- package/dist/es2017/mse/main_media_source_interface.d.ts.map +1 -1
- package/dist/es2017/mse/main_media_source_interface.js +2 -1
- package/dist/es2017/mse/worker_media_source_interface.d.ts.map +1 -1
- package/dist/es2017/parsers/containers/isobmff/get_box.d.ts +12 -1
- package/dist/es2017/parsers/containers/isobmff/get_box.d.ts.map +1 -1
- package/dist/es2017/parsers/containers/isobmff/get_box.js +16 -1
- package/dist/es2017/parsers/containers/isobmff/index.d.ts +2 -1
- package/dist/es2017/parsers/containers/isobmff/index.d.ts.map +1 -1
- package/dist/es2017/parsers/containers/isobmff/index.js +2 -1
- package/dist/es2017/parsers/containers/isobmff/remove_dolby_vision_config_data.d.ts +13 -0
- package/dist/es2017/parsers/containers/isobmff/remove_dolby_vision_config_data.d.ts.map +1 -0
- package/dist/es2017/parsers/containers/isobmff/remove_dolby_vision_config_data.js +155 -0
- package/dist/es2017/parsers/manifest/metaplaylist/metaplaylist_parser.js +4 -4
- package/dist/es2017/transports/dash/segment_parser.d.ts.map +1 -1
- package/dist/es2017/transports/dash/segment_parser.js +7 -1
- package/dist/es2017/transports/dash/text_parser.d.ts.map +1 -1
- package/dist/es2017/transports/dash/text_parser.js +5 -1
- package/dist/es2017/transports/local/text_parser.d.ts.map +1 -1
- package/dist/es2017/transports/local/text_parser.js +5 -1
- package/dist/es2017/transports/metaplaylist/pipelines.d.ts.map +1 -1
- package/dist/es2017/transports/metaplaylist/pipelines.js +2 -1
- package/dist/es2017/transports/smooth/pipelines.js +3 -3
- package/dist/es2017/transports/types.d.ts +28 -2
- package/dist/es2017/transports/types.d.ts.map +1 -1
- package/dist/es2017/transports/utils/parse_text_track.d.ts +9 -2
- package/dist/es2017/transports/utils/parse_text_track.d.ts.map +1 -1
- package/dist/es2017/transports/utils/parse_text_track.js +1 -1
- package/dist/worker.js +6 -6
- package/eslint.config.mjs +1 -14
- package/package.json +1 -1
- package/src/__GENERATED_CODE/embedded_worker.ts +1 -1
- package/src/compat/__tests__/browser_compatibility_types.test.ts +15 -26
- package/src/compat/__tests__/browser_version.test.ts +57 -18
- package/src/compat/__tests__/clear_element_src.test.ts +20 -40
- package/src/compat/__tests__/is_codec_supported.test.ts +39 -44
- package/src/compat/__tests__/is_vtt_cue.test.ts +5 -8
- package/src/compat/__tests__/make_vtt_cue.test.ts +20 -31
- package/src/compat/__tests__/remove_cue.test.ts +8 -20
- package/src/compat/__tests__/should_patch_out_dolby_vision_config_data_from_mp4.test.ts +78 -0
- package/src/compat/browser_compatibility_types.ts +8 -1
- package/src/compat/browser_version.ts +17 -1
- package/src/compat/disable_remote_playback_on_managed_media_source.ts +2 -2
- package/src/compat/is_codec_supported.ts +2 -1
- package/src/compat/should_patch_out_dolby_vision_config_data_from_mp4.ts +50 -0
- package/src/core/adaptive/__tests__/adaptive_representation_selector.test.ts +68 -28
- package/src/core/adaptive/__tests__/buffer_based_chooser.test.ts +26 -84
- package/src/core/entry/__tests__/utils.test.ts +7 -1
- package/src/core/entry/utils.ts +4 -4
- package/src/core/fetchers/segment/segment_fetcher.ts +2 -1
- package/src/errors/__tests__/format_error.test.ts +23 -24
- package/src/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.ts +2 -1
- package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/mediaDisplayInfos.test.ts +106 -0
- package/src/experimental/tools/mediaCapabilitiesProber/probers/__tests__/HDCPPolicy.test.ts +19 -42
- package/src/experimental/tools/mediaCapabilitiesProber/probers/__tests__/decodingInfo.test.ts +33 -40
- package/src/experimental/tools/mediaCapabilitiesProber/probers/__tests__/defaultCodecsFinder.test.ts +44 -68
- package/src/experimental/tools/mediaCapabilitiesProber/probers/__tests__/mediaContentType.test.ts +45 -80
- package/src/experimental/tools/mediaCapabilitiesProber/probers/defaultCodecsFinder.ts +3 -1
- package/src/experimental/tools/mediaCapabilitiesProber/probers/mediaContentType.ts +2 -1
- package/src/features/__tests__/add_features.test.ts +12 -27
- package/src/initialize_worker.ts +1 -1
- package/src/main_thread/api/__tests__/option_utils.test.ts +38 -67
- package/src/main_thread/api/__tests__/public_api.test.ts +56 -138
- package/src/main_thread/api/debug/modules/segment_buffer_content.ts +3 -3
- package/src/main_thread/api/public_api.ts +2 -2
- package/src/main_thread/decrypt/__tests__/__global__/find_key_system.test.ts +46 -28
- package/src/main_thread/decrypt/__tests__/__global__/get_license.test.ts +40 -10
- package/src/main_thread/decrypt/__tests__/__global__/init_data.test.ts +112 -129
- package/src/main_thread/decrypt/__tests__/__global__/media_key_system_access.test.ts +282 -377
- package/src/main_thread/decrypt/__tests__/__global__/media_keys.test.ts +70 -63
- package/src/main_thread/decrypt/__tests__/__global__/server_certificate.test.ts +73 -54
- package/src/main_thread/decrypt/__tests__/__global__/utils.ts +43 -83
- package/src/main_thread/decrypt/__tests__/find_key_system.test.ts +36 -17
- package/src/main_thread/decrypt/utils/__tests__/clean_old_stored_persistent_info.test.ts +44 -48
- package/src/main_thread/init/utils/__tests__/are_same_stream_events.test.ts +7 -22
- package/src/main_thread/init/utils/__tests__/refresh_scheduled_events_list.test.ts +3 -6
- package/src/main_thread/init/utils/__tests__/update_manifest_codec_support.test.ts +42 -19
- package/src/main_thread/init/utils/update_manifest_codec_support.ts +8 -6
- package/src/manifest/classes/__tests__/adaptation.test.ts +69 -125
- package/src/manifest/classes/__tests__/manifest.test.ts +88 -95
- package/src/manifest/classes/__tests__/period.test.ts +167 -117
- package/src/manifest/classes/__tests__/representation.test.ts +84 -25
- package/src/manifest/classes/__tests__/update_periods.test.ts +96 -225
- package/src/manifest/classes/adaptation.ts +4 -1
- package/src/manifest/classes/representation.ts +59 -27
- package/src/manifest/types.ts +14 -6
- package/src/manifest/utils.ts +4 -4
- package/src/mse/__tests__/main_media_source_interface.test.ts +3 -1
- package/src/mse/__tests__/worker_media_source_interface.test.ts +608 -0
- package/src/mse/main_media_source_interface.ts +2 -1
- package/src/mse/worker_media_source_interface.ts +2 -2
- package/src/parsers/containers/isobmff/__tests__/get_box.test.ts +449 -0
- package/src/parsers/containers/isobmff/__tests__/remove_dolby_vision_config_data.test.ts +282 -0
- package/src/parsers/containers/isobmff/get_box.ts +17 -0
- package/src/parsers/containers/isobmff/index.ts +8 -1
- package/src/parsers/containers/isobmff/remove_dolby_vision_config_data.ts +179 -0
- package/src/parsers/manifest/dash/common/__tests__/get_clock_offset.test.ts +19 -25
- package/src/parsers/manifest/dash/common/__tests__/get_http_utc-timing_url.test.ts +7 -19
- package/src/parsers/manifest/dash/js-parser/node_parsers/__tests__/ContentProtection.test.ts +26 -37
- package/src/parsers/manifest/dash/js-parser/node_parsers/__tests__/Initialization.test.ts +24 -53
- package/src/parsers/manifest/dash/js-parser/node_parsers/__tests__/SegmentURL.test.ts +31 -78
- package/src/parsers/manifest/metaplaylist/metaplaylist_parser.ts +6 -4
- package/src/parsers/manifest/utils/__tests__/update_segment_timeline.test.ts +79 -87
- package/src/parsers/texttracks/ttml/__tests__/resolve_styles_inheritance.test.ts +20 -26
- package/src/parsers/texttracks/ttml/html/__tests__/__global__/html_ttml_parser.test.ts +2 -7
- package/src/parsers/texttracks/webvtt/__tests__/parse_cue_block.test.ts +33 -30
- package/src/parsers/texttracks/webvtt/__tests__/parse_style_block.test.ts +33 -100
- package/src/parsers/texttracks/webvtt/html/__tests__/convert_payload_to_html.test.ts +16 -18
- package/src/parsers/texttracks/webvtt/html/__tests__/parse_webvtt_to_div.test.ts +73 -78
- package/src/parsers/texttracks/webvtt/html/__tests__/to_html.test.ts +36 -37
- package/src/transports/dash/segment_parser.ts +13 -0
- package/src/transports/dash/text_parser.ts +5 -1
- package/src/transports/local/text_parser.ts +5 -1
- package/src/transports/metaplaylist/pipelines.ts +2 -1
- package/src/transports/smooth/isobmff/__tests__/create_boxes.test.ts +150 -127
- package/src/transports/smooth/pipelines.ts +3 -3
- package/src/transports/types.ts +28 -2
- package/src/transports/utils/__tests__/check_isobmff_integrity.test.ts +49 -75
- package/src/transports/utils/parse_text_track.ts +10 -3
- package/src/utils/__tests__/object_assign.test.ts +2 -2
|
@@ -1,8 +1,9 @@
|
|
|
1
1
|
import { describe, beforeEach, afterEach, it, expect, vi } from "vitest";
|
|
2
2
|
import type { IMediaKeySystemAccess } from "../../../../compat/browser_compatibility_types";
|
|
3
|
+
import getEmeApiImplementation from "../../../../compat/eme";
|
|
3
4
|
import type { IKeySystemOption } from "../../../../public_types";
|
|
4
5
|
import assert from "../../../../utils/assert";
|
|
5
|
-
import
|
|
6
|
+
import ContentDecryptor from "../../content_decryptor";
|
|
6
7
|
import {
|
|
7
8
|
defaultKSConfig,
|
|
8
9
|
defaultPRRecommendationKSConfig,
|
|
@@ -11,6 +12,40 @@ import {
|
|
|
11
12
|
testContentDecryptorError,
|
|
12
13
|
} from "./utils";
|
|
13
14
|
|
|
15
|
+
const mocks = vi.hoisted(() => {
|
|
16
|
+
return {
|
|
17
|
+
// Used to implement every functions that should never be called.
|
|
18
|
+
neverCalled: vi.fn(),
|
|
19
|
+
shouldRenewMediaKeySystemAccess: vi.fn(() => false),
|
|
20
|
+
canReuseMediaKeys: vi.fn(() => true),
|
|
21
|
+
onEncrypted: vi.fn(),
|
|
22
|
+
requestMediaKeySystemAccess: vi.fn(),
|
|
23
|
+
setMediaKeys: vi.fn(),
|
|
24
|
+
getInitData: vi.fn(),
|
|
25
|
+
generateKeyRequest: vi.fn(),
|
|
26
|
+
};
|
|
27
|
+
});
|
|
28
|
+
vi.mock("../../../../compat/should_renew_media_key_system_access", () => ({
|
|
29
|
+
default: mocks.shouldRenewMediaKeySystemAccess,
|
|
30
|
+
}));
|
|
31
|
+
vi.mock("../../../../compat/can_reuse_media_keys", () => ({
|
|
32
|
+
default: mocks.canReuseMediaKeys,
|
|
33
|
+
}));
|
|
34
|
+
vi.mock("../../../../compat/eme", () => ({
|
|
35
|
+
default: () => ({
|
|
36
|
+
onEncrypted: mocks.onEncrypted,
|
|
37
|
+
requestMediaKeySystemAccess: mocks.requestMediaKeySystemAccess,
|
|
38
|
+
setMediaKeys: mocks.setMediaKeys,
|
|
39
|
+
}),
|
|
40
|
+
getInitData: mocks.getInitData,
|
|
41
|
+
generateKeyRequest: mocks.generateKeyRequest,
|
|
42
|
+
closeSession: vi.fn(),
|
|
43
|
+
loadSession: vi.fn(),
|
|
44
|
+
}));
|
|
45
|
+
vi.mock("../../set_server_certificate", () => ({
|
|
46
|
+
default: mocks.neverCalled,
|
|
47
|
+
}));
|
|
48
|
+
|
|
14
49
|
function requestMediaKeySystemAccessNoMediaKeys(
|
|
15
50
|
keySystem: string,
|
|
16
51
|
config: MediaKeySystemConfiguration[],
|
|
@@ -61,9 +96,6 @@ async function checkIncompatibleKeySystemsErrorMessage(
|
|
|
61
96
|
keySystemsConfigs: IKeySystemOption[],
|
|
62
97
|
): Promise<void> {
|
|
63
98
|
const mediaElement = document.createElement("video");
|
|
64
|
-
const ContentDecryptor = (await vi.importActual("../../content_decryptor"))
|
|
65
|
-
.default as typeof IContentDecryptor;
|
|
66
|
-
const getEmeApiImplementation = (await import("../../../../compat/eme")).default;
|
|
67
99
|
|
|
68
100
|
const eme = getEmeApiImplementation("auto");
|
|
69
101
|
assert(eme !== null, "Expected to have an EME implementation");
|
|
@@ -81,44 +113,41 @@ async function checkIncompatibleKeySystemsErrorMessage(
|
|
|
81
113
|
}
|
|
82
114
|
|
|
83
115
|
describe("decrypt - global tests - media key system access", () => {
|
|
84
|
-
// Used to implement every functions that should never be called.
|
|
85
|
-
const neverCalledFn = vi.fn();
|
|
86
|
-
|
|
87
116
|
beforeEach(() => {
|
|
88
117
|
vi.resetModules();
|
|
89
118
|
vi.restoreAllMocks();
|
|
90
|
-
vi.doMock("../../set_server_certificate", () => ({
|
|
91
|
-
default: neverCalledFn,
|
|
92
|
-
}));
|
|
93
119
|
});
|
|
94
120
|
|
|
95
121
|
afterEach(() => {
|
|
96
|
-
expect(
|
|
122
|
+
expect(mocks.neverCalled).not.toHaveBeenCalled();
|
|
123
|
+
mocks.shouldRenewMediaKeySystemAccess.mockReset();
|
|
124
|
+
mocks.canReuseMediaKeys.mockReset();
|
|
125
|
+
mocks.onEncrypted.mockReset();
|
|
126
|
+
mocks.requestMediaKeySystemAccess.mockReset();
|
|
127
|
+
mocks.setMediaKeys.mockReset();
|
|
128
|
+
mocks.getInitData.mockReset();
|
|
129
|
+
mocks.generateKeyRequest.mockReset();
|
|
97
130
|
});
|
|
98
131
|
|
|
99
132
|
it("should throw if an empty keySystemsConfigs is given", async () => {
|
|
100
|
-
mockCompat();
|
|
133
|
+
mockCompat(mocks);
|
|
101
134
|
await checkIncompatibleKeySystemsErrorMessage([]);
|
|
102
135
|
});
|
|
103
136
|
|
|
104
137
|
it("should throw if given a single incompatible keySystemsConfigs", async () => {
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
mockCompat({
|
|
109
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
110
|
-
});
|
|
111
|
-
const getLicenseFn = neverCalledFn;
|
|
138
|
+
mockCompat(mocks);
|
|
139
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
140
|
+
const getLicenseFn = mocks.neverCalled;
|
|
112
141
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
113
142
|
{ type: "foo", getLicense: getLicenseFn },
|
|
114
143
|
]);
|
|
115
|
-
expect(
|
|
116
|
-
expect(
|
|
144
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
145
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
117
146
|
1,
|
|
118
147
|
"foo",
|
|
119
148
|
defaultKSConfig,
|
|
120
149
|
);
|
|
121
|
-
expect(
|
|
150
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
122
151
|
2,
|
|
123
152
|
"foo",
|
|
124
153
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
@@ -126,45 +155,41 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
126
155
|
});
|
|
127
156
|
|
|
128
157
|
it("should throw if given multiple incompatible keySystemsConfigs", async () => {
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
132
|
-
mockCompat({
|
|
133
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
134
|
-
});
|
|
158
|
+
mockCompat(mocks);
|
|
159
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
135
160
|
const config = [
|
|
136
|
-
{ type: "foo", getLicense:
|
|
137
|
-
{ type: "bar", getLicense:
|
|
138
|
-
{ type: "baz", getLicense:
|
|
161
|
+
{ type: "foo", getLicense: mocks.neverCalled },
|
|
162
|
+
{ type: "bar", getLicense: mocks.neverCalled },
|
|
163
|
+
{ type: "baz", getLicense: mocks.neverCalled },
|
|
139
164
|
];
|
|
140
165
|
await checkIncompatibleKeySystemsErrorMessage(config);
|
|
141
|
-
expect(
|
|
142
|
-
expect(
|
|
166
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(6);
|
|
167
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
143
168
|
1,
|
|
144
169
|
"foo",
|
|
145
170
|
defaultKSConfig,
|
|
146
171
|
);
|
|
147
|
-
expect(
|
|
172
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
148
173
|
2,
|
|
149
174
|
"foo",
|
|
150
175
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
151
176
|
);
|
|
152
|
-
expect(
|
|
177
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
153
178
|
3,
|
|
154
179
|
"bar",
|
|
155
180
|
defaultKSConfig,
|
|
156
181
|
);
|
|
157
|
-
expect(
|
|
182
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
158
183
|
4,
|
|
159
184
|
"bar",
|
|
160
185
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
161
186
|
);
|
|
162
|
-
expect(
|
|
187
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
163
188
|
5,
|
|
164
189
|
"baz",
|
|
165
190
|
defaultKSConfig,
|
|
166
191
|
);
|
|
167
|
-
expect(
|
|
192
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
168
193
|
6,
|
|
169
194
|
"baz",
|
|
170
195
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
@@ -172,22 +197,18 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
172
197
|
});
|
|
173
198
|
|
|
174
199
|
it("should throw if given a single incompatible keySystemsConfigs", async () => {
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
178
|
-
mockCompat({
|
|
179
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
180
|
-
});
|
|
200
|
+
mockCompat(mocks);
|
|
201
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
181
202
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
182
|
-
{ type: "foo", getLicense:
|
|
203
|
+
{ type: "foo", getLicense: mocks.neverCalled },
|
|
183
204
|
]);
|
|
184
|
-
expect(
|
|
185
|
-
expect(
|
|
205
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
206
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
186
207
|
1,
|
|
187
208
|
"foo",
|
|
188
209
|
defaultKSConfig,
|
|
189
210
|
);
|
|
190
|
-
expect(
|
|
211
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
191
212
|
2,
|
|
192
213
|
"foo",
|
|
193
214
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
@@ -195,26 +216,22 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
195
216
|
});
|
|
196
217
|
|
|
197
218
|
it('should set persistentState value if persistentState is set to "required"', async () => {
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
201
|
-
mockCompat({
|
|
202
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
203
|
-
});
|
|
219
|
+
mockCompat(mocks);
|
|
220
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
204
221
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
205
|
-
{ type: "foo", getLicense:
|
|
222
|
+
{ type: "foo", getLicense: mocks.neverCalled, persistentState: "required" },
|
|
206
223
|
]);
|
|
207
|
-
expect(
|
|
224
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
208
225
|
|
|
209
226
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
210
227
|
return { ...conf, persistentState: "required" };
|
|
211
228
|
});
|
|
212
|
-
expect(
|
|
229
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
213
230
|
1,
|
|
214
231
|
"foo",
|
|
215
232
|
expectedConfig,
|
|
216
233
|
);
|
|
217
|
-
expect(
|
|
234
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
218
235
|
2,
|
|
219
236
|
"foo",
|
|
220
237
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -222,30 +239,26 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
222
239
|
});
|
|
223
240
|
|
|
224
241
|
it('should set persistentState value if persistentState is set to "not-allowed"', async () => {
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
228
|
-
mockCompat({
|
|
229
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
230
|
-
});
|
|
242
|
+
mockCompat(mocks);
|
|
243
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
231
244
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
232
245
|
{
|
|
233
246
|
type: "foo",
|
|
234
|
-
getLicense:
|
|
247
|
+
getLicense: mocks.neverCalled,
|
|
235
248
|
persistentState: "not-allowed",
|
|
236
249
|
},
|
|
237
250
|
]);
|
|
238
|
-
expect(
|
|
251
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
239
252
|
|
|
240
253
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
241
254
|
return { ...conf, persistentState: "not-allowed" };
|
|
242
255
|
});
|
|
243
|
-
expect(
|
|
256
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
244
257
|
1,
|
|
245
258
|
"foo",
|
|
246
259
|
expectedConfig,
|
|
247
260
|
);
|
|
248
|
-
expect(
|
|
261
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
249
262
|
2,
|
|
250
263
|
"foo",
|
|
251
264
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -253,26 +266,22 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
253
266
|
});
|
|
254
267
|
|
|
255
268
|
it('should set persistentState value if persistentState is set to "optional"', async () => {
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
259
|
-
mockCompat({
|
|
260
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
261
|
-
});
|
|
269
|
+
mockCompat(mocks);
|
|
270
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
262
271
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
263
|
-
{ type: "foo", getLicense:
|
|
272
|
+
{ type: "foo", getLicense: mocks.neverCalled, persistentState: "optional" },
|
|
264
273
|
]);
|
|
265
|
-
expect(
|
|
274
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
266
275
|
|
|
267
276
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
268
277
|
return { ...conf, persistentState: "optional" };
|
|
269
278
|
});
|
|
270
|
-
expect(
|
|
279
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
271
280
|
1,
|
|
272
281
|
"foo",
|
|
273
282
|
expectedConfig,
|
|
274
283
|
);
|
|
275
|
-
expect(
|
|
284
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
276
285
|
2,
|
|
277
286
|
"foo",
|
|
278
287
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -280,30 +289,26 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
280
289
|
});
|
|
281
290
|
|
|
282
291
|
it('should set distinctiveIdentifier value if distinctiveIdentifier is set to "required"', async () => {
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
286
|
-
mockCompat({
|
|
287
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
288
|
-
});
|
|
292
|
+
mockCompat(mocks);
|
|
293
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
289
294
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
290
295
|
{
|
|
291
296
|
type: "foo",
|
|
292
|
-
getLicense:
|
|
297
|
+
getLicense: mocks.neverCalled,
|
|
293
298
|
distinctiveIdentifier: "required",
|
|
294
299
|
},
|
|
295
300
|
]);
|
|
296
|
-
expect(
|
|
301
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
297
302
|
|
|
298
303
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
299
304
|
return { ...conf, distinctiveIdentifier: "required" };
|
|
300
305
|
});
|
|
301
|
-
expect(
|
|
306
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
302
307
|
1,
|
|
303
308
|
"foo",
|
|
304
309
|
expectedConfig,
|
|
305
310
|
);
|
|
306
|
-
expect(
|
|
311
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
307
312
|
2,
|
|
308
313
|
"foo",
|
|
309
314
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -311,30 +316,26 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
311
316
|
});
|
|
312
317
|
|
|
313
318
|
it('should set distinctiveIdentifier value if distinctiveIdentifier is set to "not-allowed"', async () => {
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
317
|
-
mockCompat({
|
|
318
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
319
|
-
});
|
|
319
|
+
mockCompat(mocks);
|
|
320
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
320
321
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
321
322
|
{
|
|
322
323
|
type: "foo",
|
|
323
|
-
getLicense:
|
|
324
|
+
getLicense: mocks.neverCalled,
|
|
324
325
|
distinctiveIdentifier: "not-allowed",
|
|
325
326
|
},
|
|
326
327
|
]);
|
|
327
|
-
expect(
|
|
328
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
328
329
|
|
|
329
330
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
330
331
|
return { ...conf, distinctiveIdentifier: "not-allowed" };
|
|
331
332
|
});
|
|
332
|
-
expect(
|
|
333
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
333
334
|
1,
|
|
334
335
|
"foo",
|
|
335
336
|
expectedConfig,
|
|
336
337
|
);
|
|
337
|
-
expect(
|
|
338
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
338
339
|
2,
|
|
339
340
|
"foo",
|
|
340
341
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -342,30 +343,26 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
342
343
|
});
|
|
343
344
|
|
|
344
345
|
it('should set distinctiveIdentifier value if distinctiveIdentifier is set to "optional"', async () => {
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
348
|
-
mockCompat({
|
|
349
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
350
|
-
});
|
|
346
|
+
mockCompat(mocks);
|
|
347
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
351
348
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
352
349
|
{
|
|
353
350
|
type: "foo",
|
|
354
|
-
getLicense:
|
|
351
|
+
getLicense: mocks.neverCalled,
|
|
355
352
|
distinctiveIdentifier: "optional",
|
|
356
353
|
},
|
|
357
354
|
]);
|
|
358
|
-
expect(
|
|
355
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
359
356
|
|
|
360
357
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
361
358
|
return { ...conf, distinctiveIdentifier: "optional" };
|
|
362
359
|
});
|
|
363
|
-
expect(
|
|
360
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
364
361
|
1,
|
|
365
362
|
"foo",
|
|
366
363
|
expectedConfig,
|
|
367
364
|
);
|
|
368
|
-
expect(
|
|
365
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
369
366
|
2,
|
|
370
367
|
"foo",
|
|
371
368
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -373,20 +370,16 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
373
370
|
});
|
|
374
371
|
|
|
375
372
|
it("should want only persistent sessions if wantedSessionTypes is set to `['persistent-license']`", async () => {
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
379
|
-
mockCompat({
|
|
380
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
381
|
-
});
|
|
373
|
+
mockCompat(mocks);
|
|
374
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
382
375
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
383
376
|
{
|
|
384
377
|
type: "foo",
|
|
385
|
-
getLicense:
|
|
378
|
+
getLicense: mocks.neverCalled,
|
|
386
379
|
wantedSessionTypes: ["persistent-license"],
|
|
387
380
|
},
|
|
388
381
|
]);
|
|
389
|
-
expect(
|
|
382
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
390
383
|
|
|
391
384
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
392
385
|
return {
|
|
@@ -394,12 +387,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
394
387
|
sessionTypes: ["persistent-license"],
|
|
395
388
|
};
|
|
396
389
|
});
|
|
397
|
-
expect(
|
|
390
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
398
391
|
1,
|
|
399
392
|
"foo",
|
|
400
393
|
expectedConfig,
|
|
401
394
|
);
|
|
402
|
-
expect(
|
|
395
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
403
396
|
2,
|
|
404
397
|
"foo",
|
|
405
398
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -407,20 +400,16 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
407
400
|
});
|
|
408
401
|
|
|
409
402
|
it("should want only temporary sessions if wantedSessionTypes is set to `['temporary']`", async () => {
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
413
|
-
mockCompat({
|
|
414
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
415
|
-
});
|
|
403
|
+
mockCompat(mocks);
|
|
404
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
416
405
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
417
406
|
{
|
|
418
407
|
type: "foo",
|
|
419
|
-
getLicense:
|
|
408
|
+
getLicense: mocks.neverCalled,
|
|
420
409
|
wantedSessionTypes: ["temporary"],
|
|
421
410
|
},
|
|
422
411
|
]);
|
|
423
|
-
expect(
|
|
412
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
424
413
|
|
|
425
414
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
426
415
|
return {
|
|
@@ -428,12 +417,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
428
417
|
sessionTypes: ["temporary"],
|
|
429
418
|
};
|
|
430
419
|
});
|
|
431
|
-
expect(
|
|
420
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
432
421
|
1,
|
|
433
422
|
"foo",
|
|
434
423
|
expectedConfig,
|
|
435
424
|
);
|
|
436
|
-
expect(
|
|
425
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
437
426
|
2,
|
|
438
427
|
"foo",
|
|
439
428
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -441,20 +430,16 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
441
430
|
});
|
|
442
431
|
|
|
443
432
|
it("should want both temporary and persistent sessions if wantedSessionTypes is set to `['persistent-license', 'temporary']`", async () => {
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
447
|
-
mockCompat({
|
|
448
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
449
|
-
});
|
|
433
|
+
mockCompat(mocks);
|
|
434
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
450
435
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
451
436
|
{
|
|
452
437
|
type: "foo",
|
|
453
|
-
getLicense:
|
|
438
|
+
getLicense: mocks.neverCalled,
|
|
454
439
|
wantedSessionTypes: ["persistent-license", "temporary"],
|
|
455
440
|
},
|
|
456
441
|
]);
|
|
457
|
-
expect(
|
|
442
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
458
443
|
|
|
459
444
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
460
445
|
return {
|
|
@@ -462,12 +447,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
462
447
|
sessionTypes: ["persistent-license", "temporary"],
|
|
463
448
|
};
|
|
464
449
|
});
|
|
465
|
-
expect(
|
|
450
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
466
451
|
1,
|
|
467
452
|
"foo",
|
|
468
453
|
expectedConfig,
|
|
469
454
|
);
|
|
470
|
-
expect(
|
|
455
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
471
456
|
2,
|
|
472
457
|
"foo",
|
|
473
458
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -475,12 +460,8 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
475
460
|
});
|
|
476
461
|
|
|
477
462
|
it("should want persistent sessions if persistentLicenseConfig is set", async () => {
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
481
|
-
mockCompat({
|
|
482
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
483
|
-
});
|
|
463
|
+
mockCompat(mocks);
|
|
464
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
484
465
|
const persistentLicenseConfig = {
|
|
485
466
|
save() {
|
|
486
467
|
throw new Error("Should not save.");
|
|
@@ -490,9 +471,9 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
490
471
|
},
|
|
491
472
|
};
|
|
492
473
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
493
|
-
{ type: "foo", getLicense:
|
|
474
|
+
{ type: "foo", getLicense: mocks.neverCalled, persistentLicenseConfig },
|
|
494
475
|
]);
|
|
495
|
-
expect(
|
|
476
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
496
477
|
|
|
497
478
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
498
479
|
return {
|
|
@@ -501,12 +482,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
501
482
|
sessionTypes: ["persistent-license"],
|
|
502
483
|
};
|
|
503
484
|
});
|
|
504
|
-
expect(
|
|
485
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
505
486
|
1,
|
|
506
487
|
"foo",
|
|
507
488
|
expectedConfig,
|
|
508
489
|
);
|
|
509
|
-
expect(
|
|
490
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
510
491
|
2,
|
|
511
492
|
"foo",
|
|
512
493
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -514,12 +495,8 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
514
495
|
});
|
|
515
496
|
|
|
516
497
|
it("should not want persistent sessions if persistentLicenseConfig is set but wantedSessionTypes only wants temporary licenses", async () => {
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
520
|
-
mockCompat({
|
|
521
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
522
|
-
});
|
|
498
|
+
mockCompat(mocks);
|
|
499
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
523
500
|
const persistentLicenseConfig = {
|
|
524
501
|
save() {
|
|
525
502
|
throw new Error("Should not save.");
|
|
@@ -531,12 +508,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
531
508
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
532
509
|
{
|
|
533
510
|
type: "foo",
|
|
534
|
-
getLicense:
|
|
511
|
+
getLicense: mocks.neverCalled,
|
|
535
512
|
wantedSessionTypes: ["temporary"],
|
|
536
513
|
persistentLicenseConfig,
|
|
537
514
|
},
|
|
538
515
|
]);
|
|
539
|
-
expect(
|
|
516
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
540
517
|
|
|
541
518
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
542
519
|
return {
|
|
@@ -544,12 +521,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
544
521
|
sessionTypes: ["temporary"],
|
|
545
522
|
};
|
|
546
523
|
});
|
|
547
|
-
expect(
|
|
524
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
548
525
|
1,
|
|
549
526
|
"foo",
|
|
550
527
|
expectedConfig,
|
|
551
528
|
);
|
|
552
|
-
expect(
|
|
529
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
553
530
|
2,
|
|
554
531
|
"foo",
|
|
555
532
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -557,12 +534,8 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
557
534
|
});
|
|
558
535
|
|
|
559
536
|
it("should properly handle persistentLicenseConfig and wantedSessionTypes set to persistent-license", async () => {
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
563
|
-
mockCompat({
|
|
564
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
565
|
-
});
|
|
537
|
+
mockCompat(mocks);
|
|
538
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
566
539
|
const persistentLicenseConfig = {
|
|
567
540
|
save() {
|
|
568
541
|
throw new Error("Should not save.");
|
|
@@ -574,12 +547,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
574
547
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
575
548
|
{
|
|
576
549
|
type: "foo",
|
|
577
|
-
getLicense:
|
|
550
|
+
getLicense: mocks.neverCalled,
|
|
578
551
|
wantedSessionTypes: ["persistent-license"],
|
|
579
552
|
persistentLicenseConfig,
|
|
580
553
|
},
|
|
581
554
|
]);
|
|
582
|
-
expect(
|
|
555
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
583
556
|
|
|
584
557
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
585
558
|
return {
|
|
@@ -588,12 +561,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
588
561
|
sessionTypes: ["persistent-license"],
|
|
589
562
|
};
|
|
590
563
|
});
|
|
591
|
-
expect(
|
|
564
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
592
565
|
1,
|
|
593
566
|
"foo",
|
|
594
567
|
expectedConfig,
|
|
595
568
|
);
|
|
596
|
-
expect(
|
|
569
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
597
570
|
2,
|
|
598
571
|
"foo",
|
|
599
572
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -601,12 +574,8 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
601
574
|
});
|
|
602
575
|
|
|
603
576
|
it("should properly handle persistentLicenseConfig and wantedSessionTypes set to both temporary and persistent-license", async () => {
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
607
|
-
mockCompat({
|
|
608
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
609
|
-
});
|
|
577
|
+
mockCompat(mocks);
|
|
578
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
610
579
|
const persistentLicenseConfig = {
|
|
611
580
|
save() {
|
|
612
581
|
throw new Error("Should not save.");
|
|
@@ -618,12 +587,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
618
587
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
619
588
|
{
|
|
620
589
|
type: "foo",
|
|
621
|
-
getLicense:
|
|
590
|
+
getLicense: mocks.neverCalled,
|
|
622
591
|
wantedSessionTypes: ["temporary", "persistent-license"],
|
|
623
592
|
persistentLicenseConfig,
|
|
624
593
|
},
|
|
625
594
|
]);
|
|
626
|
-
expect(
|
|
595
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
627
596
|
|
|
628
597
|
const expectedConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map((conf) => {
|
|
629
598
|
return {
|
|
@@ -632,12 +601,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
632
601
|
sessionTypes: ["temporary", "persistent-license"],
|
|
633
602
|
};
|
|
634
603
|
});
|
|
635
|
-
expect(
|
|
604
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
636
605
|
1,
|
|
637
606
|
"foo",
|
|
638
607
|
expectedConfig,
|
|
639
608
|
);
|
|
640
|
-
expect(
|
|
609
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
641
610
|
2,
|
|
642
611
|
"foo",
|
|
643
612
|
removeCapabiltiesFromConfig(expectedConfig),
|
|
@@ -645,22 +614,18 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
645
614
|
});
|
|
646
615
|
|
|
647
616
|
it("should do nothing if persistentLicenseConfig is set to null", async () => {
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
651
|
-
mockCompat({
|
|
652
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
653
|
-
});
|
|
617
|
+
mockCompat(mocks);
|
|
618
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
654
619
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
655
|
-
{ type: "foo", getLicense:
|
|
620
|
+
{ type: "foo", getLicense: mocks.neverCalled },
|
|
656
621
|
]);
|
|
657
|
-
expect(
|
|
658
|
-
expect(
|
|
622
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
623
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
659
624
|
1,
|
|
660
625
|
"foo",
|
|
661
626
|
defaultKSConfig,
|
|
662
627
|
);
|
|
663
|
-
expect(
|
|
628
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
664
629
|
2,
|
|
665
630
|
"foo",
|
|
666
631
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
@@ -668,25 +633,21 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
668
633
|
});
|
|
669
634
|
|
|
670
635
|
it("should do nothing if persistentLicenseConfig is set to undefined", async () => {
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
674
|
-
mockCompat({
|
|
675
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
676
|
-
});
|
|
636
|
+
mockCompat(mocks);
|
|
637
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
677
638
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
678
639
|
{
|
|
679
640
|
type: "foo",
|
|
680
|
-
getLicense:
|
|
641
|
+
getLicense: mocks.neverCalled,
|
|
681
642
|
},
|
|
682
643
|
]);
|
|
683
|
-
expect(
|
|
684
|
-
expect(
|
|
644
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
645
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
685
646
|
1,
|
|
686
647
|
"foo",
|
|
687
648
|
defaultKSConfig,
|
|
688
649
|
);
|
|
689
|
-
expect(
|
|
650
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
690
651
|
2,
|
|
691
652
|
"foo",
|
|
692
653
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
@@ -694,32 +655,28 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
694
655
|
});
|
|
695
656
|
|
|
696
657
|
it("should translate a `clearkey` keySystem", async () => {
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
700
|
-
mockCompat({
|
|
701
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
702
|
-
});
|
|
658
|
+
mockCompat(mocks);
|
|
659
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
703
660
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
704
|
-
{ type: "clearkey", getLicense:
|
|
661
|
+
{ type: "clearkey", getLicense: mocks.neverCalled },
|
|
705
662
|
]);
|
|
706
|
-
expect(
|
|
707
|
-
expect(
|
|
663
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(4);
|
|
664
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
708
665
|
1,
|
|
709
666
|
"webkit-org.w3.clearkey",
|
|
710
667
|
defaultKSConfig,
|
|
711
668
|
);
|
|
712
|
-
expect(
|
|
669
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
713
670
|
2,
|
|
714
671
|
"webkit-org.w3.clearkey",
|
|
715
672
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
716
673
|
);
|
|
717
|
-
expect(
|
|
674
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
718
675
|
3,
|
|
719
676
|
"org.w3.clearkey",
|
|
720
677
|
defaultKSConfig,
|
|
721
678
|
);
|
|
722
|
-
expect(
|
|
679
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
723
680
|
4,
|
|
724
681
|
"org.w3.clearkey",
|
|
725
682
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
@@ -727,22 +684,18 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
727
684
|
});
|
|
728
685
|
|
|
729
686
|
it("should translate a `widevine` keySystem", async () => {
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
733
|
-
mockCompat({
|
|
734
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
735
|
-
});
|
|
687
|
+
mockCompat(mocks);
|
|
688
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
736
689
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
737
|
-
{ type: "widevine", getLicense:
|
|
690
|
+
{ type: "widevine", getLicense: mocks.neverCalled },
|
|
738
691
|
]);
|
|
739
|
-
expect(
|
|
740
|
-
expect(
|
|
692
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
693
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
741
694
|
1,
|
|
742
695
|
"com.widevine.alpha",
|
|
743
696
|
defaultWidevineConfig,
|
|
744
697
|
);
|
|
745
|
-
expect(
|
|
698
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
746
699
|
2,
|
|
747
700
|
"com.widevine.alpha",
|
|
748
701
|
removeCapabiltiesFromConfig(defaultWidevineConfig),
|
|
@@ -750,52 +703,48 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
750
703
|
});
|
|
751
704
|
|
|
752
705
|
it("should translate a `playready` keySystem", async () => {
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
756
|
-
mockCompat({
|
|
757
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
758
|
-
});
|
|
706
|
+
mockCompat(mocks);
|
|
707
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
759
708
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
760
|
-
{ type: "playready", getLicense:
|
|
709
|
+
{ type: "playready", getLicense: mocks.neverCalled },
|
|
761
710
|
]);
|
|
762
|
-
expect(
|
|
763
|
-
expect(
|
|
711
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(8);
|
|
712
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
764
713
|
1,
|
|
765
714
|
"com.microsoft.playready.recommendation",
|
|
766
715
|
defaultPRRecommendationKSConfig,
|
|
767
716
|
);
|
|
768
|
-
expect(
|
|
717
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
769
718
|
2,
|
|
770
719
|
"com.microsoft.playready.recommendation",
|
|
771
720
|
removeCapabiltiesFromConfig(defaultPRRecommendationKSConfig),
|
|
772
721
|
);
|
|
773
|
-
expect(
|
|
722
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
774
723
|
3,
|
|
775
724
|
"com.microsoft.playready",
|
|
776
725
|
defaultKSConfig,
|
|
777
726
|
);
|
|
778
|
-
expect(
|
|
727
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
779
728
|
4,
|
|
780
729
|
"com.microsoft.playready",
|
|
781
730
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
782
731
|
);
|
|
783
|
-
expect(
|
|
732
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
784
733
|
5,
|
|
785
734
|
"com.chromecast.playready",
|
|
786
735
|
defaultKSConfig,
|
|
787
736
|
);
|
|
788
|
-
expect(
|
|
737
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
789
738
|
6,
|
|
790
739
|
"com.chromecast.playready",
|
|
791
740
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
792
741
|
);
|
|
793
|
-
expect(
|
|
742
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
794
743
|
7,
|
|
795
744
|
"com.youtube.playready",
|
|
796
745
|
defaultKSConfig,
|
|
797
746
|
);
|
|
798
|
-
expect(
|
|
747
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
799
748
|
8,
|
|
800
749
|
"com.youtube.playready",
|
|
801
750
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
@@ -803,84 +752,76 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
803
752
|
});
|
|
804
753
|
|
|
805
754
|
it("should translate a `fairplay` keySystem", async () => {
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
809
|
-
mockCompat({
|
|
810
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
811
|
-
});
|
|
755
|
+
mockCompat(mocks);
|
|
756
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
812
757
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
813
|
-
{ type: "fairplay", getLicense:
|
|
758
|
+
{ type: "fairplay", getLicense: mocks.neverCalled },
|
|
814
759
|
]);
|
|
815
|
-
expect(
|
|
816
|
-
expect(
|
|
760
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
761
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledWith(
|
|
817
762
|
"com.apple.fps.1_0",
|
|
818
763
|
defaultKSConfig,
|
|
819
764
|
);
|
|
820
|
-
expect(
|
|
765
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledWith(
|
|
821
766
|
"com.apple.fps.1_0",
|
|
822
767
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
823
768
|
);
|
|
824
769
|
});
|
|
825
770
|
|
|
826
771
|
it("should translate a multiple keySystems at the same time", async () => {
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
830
|
-
mockCompat({
|
|
831
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
832
|
-
});
|
|
772
|
+
mockCompat(mocks);
|
|
773
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
833
774
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
834
|
-
{ type: "playready", getLicense:
|
|
835
|
-
{ type: "clearkey", getLicense:
|
|
775
|
+
{ type: "playready", getLicense: mocks.neverCalled },
|
|
776
|
+
{ type: "clearkey", getLicense: mocks.neverCalled },
|
|
836
777
|
]);
|
|
837
|
-
expect(
|
|
838
|
-
expect(
|
|
778
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(12);
|
|
779
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
839
780
|
1,
|
|
840
781
|
"com.microsoft.playready.recommendation",
|
|
841
782
|
defaultPRRecommendationKSConfig,
|
|
842
783
|
);
|
|
843
|
-
expect(
|
|
784
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
844
785
|
2,
|
|
845
786
|
"com.microsoft.playready.recommendation",
|
|
846
787
|
removeCapabiltiesFromConfig(defaultPRRecommendationKSConfig),
|
|
847
788
|
);
|
|
848
|
-
expect(
|
|
789
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
849
790
|
3,
|
|
850
791
|
"com.microsoft.playready",
|
|
851
792
|
defaultKSConfig,
|
|
852
793
|
);
|
|
853
|
-
expect(
|
|
794
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
854
795
|
4,
|
|
855
796
|
"com.microsoft.playready",
|
|
856
797
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
857
798
|
);
|
|
858
|
-
expect(
|
|
799
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
859
800
|
5,
|
|
860
801
|
"com.chromecast.playready",
|
|
861
802
|
defaultKSConfig,
|
|
862
803
|
);
|
|
863
|
-
expect(
|
|
804
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
864
805
|
6,
|
|
865
806
|
"com.chromecast.playready",
|
|
866
807
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
867
808
|
);
|
|
868
|
-
expect(
|
|
809
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
869
810
|
9,
|
|
870
811
|
"webkit-org.w3.clearkey",
|
|
871
812
|
defaultKSConfig,
|
|
872
813
|
);
|
|
873
|
-
expect(
|
|
814
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
874
815
|
10,
|
|
875
816
|
"webkit-org.w3.clearkey",
|
|
876
817
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
877
818
|
);
|
|
878
|
-
expect(
|
|
819
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
879
820
|
11,
|
|
880
821
|
"org.w3.clearkey",
|
|
881
822
|
defaultKSConfig,
|
|
882
823
|
);
|
|
883
|
-
expect(
|
|
824
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
884
825
|
12,
|
|
885
826
|
"org.w3.clearkey",
|
|
886
827
|
removeCapabiltiesFromConfig(defaultKSConfig),
|
|
@@ -888,12 +829,8 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
888
829
|
});
|
|
889
830
|
|
|
890
831
|
it("should translate a multiple keySystems at the same time with different configs", async () => {
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
894
|
-
mockCompat({
|
|
895
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
896
|
-
});
|
|
832
|
+
mockCompat(mocks);
|
|
833
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
897
834
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
898
835
|
{
|
|
899
836
|
type: "playready",
|
|
@@ -905,12 +842,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
905
842
|
return [];
|
|
906
843
|
},
|
|
907
844
|
},
|
|
908
|
-
getLicense:
|
|
845
|
+
getLicense: mocks.neverCalled,
|
|
909
846
|
},
|
|
910
847
|
{
|
|
911
848
|
type: "clearkey",
|
|
912
849
|
distinctiveIdentifier: "required",
|
|
913
|
-
getLicense:
|
|
850
|
+
getLicense: mocks.neverCalled,
|
|
914
851
|
},
|
|
915
852
|
]);
|
|
916
853
|
const expectedPRRecommendationPersistentConfig: MediaKeySystemConfiguration[] =
|
|
@@ -935,63 +872,63 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
935
872
|
return { ...conf, distinctiveIdentifier: "required" };
|
|
936
873
|
},
|
|
937
874
|
);
|
|
938
|
-
expect(
|
|
939
|
-
expect(
|
|
875
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(12);
|
|
876
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
940
877
|
1,
|
|
941
878
|
"com.microsoft.playready.recommendation",
|
|
942
879
|
expectedPRRecommendationPersistentConfig,
|
|
943
880
|
);
|
|
944
|
-
expect(
|
|
881
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
945
882
|
2,
|
|
946
883
|
"com.microsoft.playready.recommendation",
|
|
947
884
|
removeCapabiltiesFromConfig(expectedPRRecommendationPersistentConfig),
|
|
948
885
|
);
|
|
949
|
-
expect(
|
|
886
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
950
887
|
3,
|
|
951
888
|
"com.microsoft.playready",
|
|
952
889
|
expectedPersistentConfig,
|
|
953
890
|
);
|
|
954
|
-
expect(
|
|
891
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
955
892
|
4,
|
|
956
893
|
"com.microsoft.playready",
|
|
957
894
|
removeCapabiltiesFromConfig(expectedPersistentConfig),
|
|
958
895
|
);
|
|
959
|
-
expect(
|
|
896
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
960
897
|
5,
|
|
961
898
|
"com.chromecast.playready",
|
|
962
899
|
expectedPersistentConfig,
|
|
963
900
|
);
|
|
964
|
-
expect(
|
|
901
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
965
902
|
6,
|
|
966
903
|
"com.chromecast.playready",
|
|
967
904
|
removeCapabiltiesFromConfig(expectedPersistentConfig),
|
|
968
905
|
);
|
|
969
|
-
expect(
|
|
906
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
970
907
|
7,
|
|
971
908
|
"com.youtube.playready",
|
|
972
909
|
expectedPersistentConfig,
|
|
973
910
|
);
|
|
974
|
-
expect(
|
|
911
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
975
912
|
8,
|
|
976
913
|
"com.youtube.playready",
|
|
977
914
|
removeCapabiltiesFromConfig(expectedPersistentConfig),
|
|
978
915
|
);
|
|
979
|
-
expect(
|
|
916
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
980
917
|
9,
|
|
981
918
|
"webkit-org.w3.clearkey",
|
|
982
919
|
expectedIdentifierConfig,
|
|
983
920
|
);
|
|
984
|
-
expect(
|
|
921
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
985
922
|
10,
|
|
986
923
|
"webkit-org.w3.clearkey",
|
|
987
924
|
removeCapabiltiesFromConfig(expectedIdentifierConfig),
|
|
988
925
|
);
|
|
989
|
-
expect(
|
|
926
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
990
927
|
11,
|
|
991
928
|
"org.w3.clearkey",
|
|
992
929
|
expectedIdentifierConfig,
|
|
993
930
|
);
|
|
994
|
-
expect(
|
|
931
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
995
932
|
12,
|
|
996
933
|
"org.w3.clearkey",
|
|
997
934
|
removeCapabiltiesFromConfig(expectedIdentifierConfig),
|
|
@@ -999,12 +936,8 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
999
936
|
});
|
|
1000
937
|
|
|
1001
938
|
it("should set widevine robustnesses for a `com.widevine.alpha` keySystem", async () => {
|
|
1002
|
-
|
|
1003
|
-
|
|
1004
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
1005
|
-
mockCompat({
|
|
1006
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
1007
|
-
});
|
|
939
|
+
mockCompat(mocks);
|
|
940
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
1008
941
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
1009
942
|
{
|
|
1010
943
|
type: "com.widevine.alpha",
|
|
@@ -1016,7 +949,7 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1016
949
|
return [];
|
|
1017
950
|
},
|
|
1018
951
|
},
|
|
1019
|
-
getLicense:
|
|
952
|
+
getLicense: mocks.neverCalled,
|
|
1020
953
|
},
|
|
1021
954
|
]);
|
|
1022
955
|
const expectedPersistentConfig: MediaKeySystemConfiguration[] =
|
|
@@ -1027,13 +960,13 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1027
960
|
sessionTypes: ["persistent-license"],
|
|
1028
961
|
};
|
|
1029
962
|
});
|
|
1030
|
-
expect(
|
|
1031
|
-
expect(
|
|
963
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
964
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1032
965
|
1,
|
|
1033
966
|
"com.widevine.alpha",
|
|
1034
967
|
expectedPersistentConfig,
|
|
1035
968
|
);
|
|
1036
|
-
expect(
|
|
969
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1037
970
|
2,
|
|
1038
971
|
"com.widevine.alpha",
|
|
1039
972
|
removeCapabiltiesFromConfig(expectedPersistentConfig),
|
|
@@ -1041,12 +974,8 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1041
974
|
});
|
|
1042
975
|
|
|
1043
976
|
it("should set playready robustnesses for a `playready` keySystem", async () => {
|
|
1044
|
-
|
|
1045
|
-
|
|
1046
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
1047
|
-
mockCompat({
|
|
1048
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
1049
|
-
});
|
|
977
|
+
mockCompat(mocks);
|
|
978
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
1050
979
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
1051
980
|
{
|
|
1052
981
|
type: "playready",
|
|
@@ -1058,12 +987,12 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1058
987
|
return [];
|
|
1059
988
|
},
|
|
1060
989
|
},
|
|
1061
|
-
getLicense:
|
|
990
|
+
getLicense: mocks.neverCalled,
|
|
1062
991
|
},
|
|
1063
992
|
{
|
|
1064
993
|
type: "clearkey",
|
|
1065
994
|
distinctiveIdentifier: "required",
|
|
1066
|
-
getLicense:
|
|
995
|
+
getLicense: mocks.neverCalled,
|
|
1067
996
|
},
|
|
1068
997
|
]);
|
|
1069
998
|
const expectedPersistentConfig: MediaKeySystemConfiguration[] = defaultKSConfig.map(
|
|
@@ -1088,63 +1017,63 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1088
1017
|
return { ...conf, distinctiveIdentifier: "required" };
|
|
1089
1018
|
},
|
|
1090
1019
|
);
|
|
1091
|
-
expect(
|
|
1092
|
-
expect(
|
|
1020
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(12);
|
|
1021
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1093
1022
|
1,
|
|
1094
1023
|
"com.microsoft.playready.recommendation",
|
|
1095
1024
|
expectedRecoPersistentConfig,
|
|
1096
1025
|
);
|
|
1097
|
-
expect(
|
|
1026
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1098
1027
|
2,
|
|
1099
1028
|
"com.microsoft.playready.recommendation",
|
|
1100
1029
|
removeCapabiltiesFromConfig(expectedRecoPersistentConfig),
|
|
1101
1030
|
);
|
|
1102
|
-
expect(
|
|
1031
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1103
1032
|
3,
|
|
1104
1033
|
"com.microsoft.playready",
|
|
1105
1034
|
expectedPersistentConfig,
|
|
1106
1035
|
);
|
|
1107
|
-
expect(
|
|
1036
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1108
1037
|
4,
|
|
1109
1038
|
"com.microsoft.playready",
|
|
1110
1039
|
removeCapabiltiesFromConfig(expectedPersistentConfig),
|
|
1111
1040
|
);
|
|
1112
|
-
expect(
|
|
1041
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1113
1042
|
5,
|
|
1114
1043
|
"com.chromecast.playready",
|
|
1115
1044
|
expectedPersistentConfig,
|
|
1116
1045
|
);
|
|
1117
|
-
expect(
|
|
1046
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1118
1047
|
6,
|
|
1119
1048
|
"com.chromecast.playready",
|
|
1120
1049
|
removeCapabiltiesFromConfig(expectedPersistentConfig),
|
|
1121
1050
|
);
|
|
1122
|
-
expect(
|
|
1051
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1123
1052
|
7,
|
|
1124
1053
|
"com.youtube.playready",
|
|
1125
1054
|
expectedPersistentConfig,
|
|
1126
1055
|
);
|
|
1127
|
-
expect(
|
|
1056
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1128
1057
|
8,
|
|
1129
1058
|
"com.youtube.playready",
|
|
1130
1059
|
removeCapabiltiesFromConfig(expectedPersistentConfig),
|
|
1131
1060
|
);
|
|
1132
|
-
expect(
|
|
1061
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1133
1062
|
9,
|
|
1134
1063
|
"webkit-org.w3.clearkey",
|
|
1135
1064
|
expectedIdentifierConfig,
|
|
1136
1065
|
);
|
|
1137
|
-
expect(
|
|
1066
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1138
1067
|
10,
|
|
1139
1068
|
"webkit-org.w3.clearkey",
|
|
1140
1069
|
removeCapabiltiesFromConfig(expectedIdentifierConfig),
|
|
1141
1070
|
);
|
|
1142
|
-
expect(
|
|
1071
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1143
1072
|
11,
|
|
1144
1073
|
"org.w3.clearkey",
|
|
1145
1074
|
expectedIdentifierConfig,
|
|
1146
1075
|
);
|
|
1147
|
-
expect(
|
|
1076
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1148
1077
|
12,
|
|
1149
1078
|
"org.w3.clearkey",
|
|
1150
1079
|
removeCapabiltiesFromConfig(expectedIdentifierConfig),
|
|
@@ -1152,12 +1081,8 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1152
1081
|
});
|
|
1153
1082
|
|
|
1154
1083
|
it("should set playready robustnesses for a `com.microsoft.playready.recommendation` keySystem", async () => {
|
|
1155
|
-
|
|
1156
|
-
|
|
1157
|
-
.mockImplementation(() => Promise.reject("nope"));
|
|
1158
|
-
mockCompat({
|
|
1159
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
1160
|
-
});
|
|
1084
|
+
mockCompat(mocks);
|
|
1085
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => Promise.reject("nope"));
|
|
1161
1086
|
await checkIncompatibleKeySystemsErrorMessage([
|
|
1162
1087
|
{
|
|
1163
1088
|
type: "com.microsoft.playready.recommendation",
|
|
@@ -1169,7 +1094,7 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1169
1094
|
return [];
|
|
1170
1095
|
},
|
|
1171
1096
|
},
|
|
1172
|
-
getLicense:
|
|
1097
|
+
getLicense: mocks.neverCalled,
|
|
1173
1098
|
},
|
|
1174
1099
|
]);
|
|
1175
1100
|
const expectedRecoPersistentConfig: MediaKeySystemConfiguration[] =
|
|
@@ -1180,13 +1105,13 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1180
1105
|
sessionTypes: ["persistent-license"],
|
|
1181
1106
|
};
|
|
1182
1107
|
});
|
|
1183
|
-
expect(
|
|
1184
|
-
expect(
|
|
1108
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(2);
|
|
1109
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1185
1110
|
1,
|
|
1186
1111
|
"com.microsoft.playready.recommendation",
|
|
1187
1112
|
expectedRecoPersistentConfig,
|
|
1188
1113
|
);
|
|
1189
|
-
expect(
|
|
1114
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1190
1115
|
2,
|
|
1191
1116
|
"com.microsoft.playready.recommendation",
|
|
1192
1117
|
removeCapabiltiesFromConfig(expectedRecoPersistentConfig),
|
|
@@ -1194,19 +1119,14 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1194
1119
|
});
|
|
1195
1120
|
|
|
1196
1121
|
it("should successfully create a MediaKeySystemAccess if given the right configuration", async () => {
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1122
|
+
mockCompat(mocks);
|
|
1123
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(
|
|
1124
|
+
(keyType: string, conf: MediaKeySystemConfiguration[]) => {
|
|
1200
1125
|
return requestMediaKeySystemAccessNoMediaKeys(keyType, conf);
|
|
1201
|
-
}
|
|
1202
|
-
|
|
1203
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
1204
|
-
});
|
|
1205
|
-
const ContentDecryptor = (await vi.importActual("../../content_decryptor"))
|
|
1206
|
-
.default as typeof IContentDecryptor;
|
|
1207
|
-
const getEmeApiImplementation = (await import("../../../../compat/eme")).default;
|
|
1126
|
+
},
|
|
1127
|
+
);
|
|
1208
1128
|
return new Promise<void>((res, rej) => {
|
|
1209
|
-
const config = [{ type: "com.widevine.alpha", getLicense:
|
|
1129
|
+
const config = [{ type: "com.widevine.alpha", getLicense: mocks.neverCalled }];
|
|
1210
1130
|
|
|
1211
1131
|
const mediaElement = document.createElement("video");
|
|
1212
1132
|
const eme = getEmeApiImplementation("auto");
|
|
@@ -1216,8 +1136,8 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1216
1136
|
rej(error);
|
|
1217
1137
|
});
|
|
1218
1138
|
setTimeout(() => {
|
|
1219
|
-
expect(
|
|
1220
|
-
expect(
|
|
1139
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
|
|
1140
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledWith(
|
|
1221
1141
|
"com.widevine.alpha",
|
|
1222
1142
|
defaultWidevineConfig,
|
|
1223
1143
|
);
|
|
@@ -1227,24 +1147,19 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1227
1147
|
});
|
|
1228
1148
|
|
|
1229
1149
|
it("should successfully create a MediaKeySystemAccess if given multiple configurations where one works", async () => {
|
|
1230
|
-
|
|
1231
|
-
|
|
1232
|
-
|
|
1150
|
+
mockCompat(mocks);
|
|
1151
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(
|
|
1152
|
+
(keyType: string, conf: MediaKeySystemConfiguration[]) => {
|
|
1233
1153
|
if (keyType === "some-other-working-key-system") {
|
|
1234
1154
|
return requestMediaKeySystemAccessNoMediaKeys(keyType, conf);
|
|
1235
1155
|
}
|
|
1236
1156
|
return Promise.reject("nope");
|
|
1237
|
-
}
|
|
1238
|
-
|
|
1239
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
1240
|
-
});
|
|
1241
|
-
const ContentDecryptor = (await vi.importActual("../../content_decryptor"))
|
|
1242
|
-
.default as typeof IContentDecryptor;
|
|
1243
|
-
const getEmeApiImplementation = (await import("../../../../compat/eme")).default;
|
|
1157
|
+
},
|
|
1158
|
+
);
|
|
1244
1159
|
return new Promise<void>((res, rej) => {
|
|
1245
1160
|
const config = [
|
|
1246
|
-
{ type: "com.widevine.alpha", getLicense:
|
|
1247
|
-
{ type: "some-other-working-key-system", getLicense:
|
|
1161
|
+
{ type: "com.widevine.alpha", getLicense: mocks.neverCalled },
|
|
1162
|
+
{ type: "some-other-working-key-system", getLicense: mocks.neverCalled },
|
|
1248
1163
|
];
|
|
1249
1164
|
|
|
1250
1165
|
const mediaElement = document.createElement("video");
|
|
@@ -1255,18 +1170,18 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1255
1170
|
rej(error);
|
|
1256
1171
|
});
|
|
1257
1172
|
setTimeout(() => {
|
|
1258
|
-
expect(
|
|
1259
|
-
expect(
|
|
1173
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(3);
|
|
1174
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1260
1175
|
1,
|
|
1261
1176
|
"com.widevine.alpha",
|
|
1262
1177
|
defaultWidevineConfig,
|
|
1263
1178
|
);
|
|
1264
|
-
expect(
|
|
1179
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1265
1180
|
2,
|
|
1266
1181
|
"com.widevine.alpha",
|
|
1267
1182
|
removeCapabiltiesFromConfig(defaultWidevineConfig),
|
|
1268
1183
|
);
|
|
1269
|
-
expect(
|
|
1184
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1270
1185
|
3,
|
|
1271
1186
|
"some-other-working-key-system",
|
|
1272
1187
|
defaultKSConfig,
|
|
@@ -1277,28 +1192,23 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1277
1192
|
});
|
|
1278
1193
|
|
|
1279
1194
|
it("should not continue to check if the ContentDecryptor is disposed from", async () => {
|
|
1280
|
-
|
|
1195
|
+
mockCompat(mocks);
|
|
1196
|
+
let contentDecryptor: ContentDecryptor | null = null;
|
|
1281
1197
|
let rmksHasBeenCalled = false;
|
|
1282
|
-
|
|
1198
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => {
|
|
1283
1199
|
return Promise.resolve().then(() => {
|
|
1284
1200
|
rmksHasBeenCalled = true;
|
|
1285
1201
|
contentDecryptor?.dispose(undefined);
|
|
1286
1202
|
return Promise.reject("nope");
|
|
1287
1203
|
});
|
|
1288
1204
|
});
|
|
1289
|
-
mockCompat({
|
|
1290
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
1291
|
-
});
|
|
1292
|
-
const ContentDecryptor = (await vi.importActual("../../content_decryptor"))
|
|
1293
|
-
.default as typeof IContentDecryptor;
|
|
1294
|
-
const getEmeApiImplementation = (await import("../../../../compat/eme")).default;
|
|
1295
1205
|
return new Promise<void>((res, rej) => {
|
|
1296
1206
|
const mediaElement = document.createElement("video");
|
|
1297
1207
|
|
|
1298
1208
|
const config = [
|
|
1299
|
-
{ type: "foo", getLicense:
|
|
1300
|
-
{ type: "bar", getLicense:
|
|
1301
|
-
{ type: "baz", getLicense:
|
|
1209
|
+
{ type: "foo", getLicense: mocks.neverCalled },
|
|
1210
|
+
{ type: "bar", getLicense: mocks.neverCalled },
|
|
1211
|
+
{ type: "baz", getLicense: mocks.neverCalled },
|
|
1302
1212
|
];
|
|
1303
1213
|
const eme = getEmeApiImplementation("auto");
|
|
1304
1214
|
assert(eme !== null, "Expected to have an EME implementation");
|
|
@@ -1308,8 +1218,8 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1308
1218
|
});
|
|
1309
1219
|
setTimeout(() => {
|
|
1310
1220
|
expect(rmksHasBeenCalled).toEqual(true);
|
|
1311
|
-
expect(
|
|
1312
|
-
expect(
|
|
1221
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenCalledTimes(1);
|
|
1222
|
+
expect(mocks.requestMediaKeySystemAccess).toHaveBeenNthCalledWith(
|
|
1313
1223
|
1,
|
|
1314
1224
|
"foo",
|
|
1315
1225
|
defaultKSConfig,
|
|
@@ -1320,21 +1230,16 @@ describe("decrypt - global tests - media key system access", () => {
|
|
|
1320
1230
|
});
|
|
1321
1231
|
|
|
1322
1232
|
it("should trigger error even if requestMediaKeySystemAccess throws", async () => {
|
|
1233
|
+
mockCompat(mocks);
|
|
1323
1234
|
let rmksHasBeenCalled = false;
|
|
1324
|
-
|
|
1235
|
+
mocks.requestMediaKeySystemAccess.mockImplementation(() => {
|
|
1325
1236
|
rmksHasBeenCalled = true;
|
|
1326
1237
|
throw new Error("nope");
|
|
1327
1238
|
});
|
|
1328
|
-
mockCompat({
|
|
1329
|
-
requestMediaKeySystemAccess: mockRequestMediaKeySystemAccess,
|
|
1330
|
-
});
|
|
1331
|
-
const ContentDecryptor = (await vi.importActual("../../content_decryptor"))
|
|
1332
|
-
.default as typeof IContentDecryptor;
|
|
1333
|
-
const getEmeApiImplementation = (await import("../../../../compat/eme")).default;
|
|
1334
1239
|
return new Promise<void>((res, rej) => {
|
|
1335
1240
|
const mediaElement = document.createElement("video");
|
|
1336
1241
|
|
|
1337
|
-
const config = [{ type: "foo", getLicense:
|
|
1242
|
+
const config = [{ type: "foo", getLicense: mocks.neverCalled }];
|
|
1338
1243
|
const eme = getEmeApiImplementation("auto");
|
|
1339
1244
|
assert(eme !== null, "Expected to have an EME implementation");
|
|
1340
1245
|
const contentDecryptor = new ContentDecryptor(eme, mediaElement, config);
|