LayoutTests/media/encrypted-media/mock-navigator-requestMediaKeySystemAccess.html - WebKit - Git at Google

 <!DOCTYPE html>
 <html>
 <head>
     <script src=../video-test.js></script>
     <script type="text/javascript">
     var mock;
     var promise;
     var capabilities = {};

     function doTest ()
     {
         if (!window.internals) {
             // failTest("Internals is required for this test.")
             // return;
         }

         run('internals.initializeMockMediaSource()');
         run('mock = internals.registerMockCDM()');
         run('mock.supportedDataTypes = ["mock"]');

         next();
     }

     function next() {
         if (!tests.length) {
             mock.unregister();
             endTest()
             return;
         }

         var nextTest = tests.shift();
         consoleWrite('');
         nextTest();
     }

     function passingTestWithCapabilities(capabilities, success) {
         shouldResolve(testWithCapabilities(capabilities)).then(success).then(next, next);
     }

     function failingTestWithCapabilities(capabilities, failure) {
         shouldReject(testWithCapabilities(capabilities)).then(failure).then(next, next);
     }

     function testWithCapabilities(capabilities) {
         window.capabilities = capabilities;
         consoleWrite(`SET capabilities = '${ JSON.stringify(capabilities, null, 1) }'`);
         run('promise  = navigator.requestMediaKeySystemAccess("org.webkit.mock", capabilities)');
         return promise;
     }

     tests = [
         function() {
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.keySystem', 'org.webkit.mock');
                     testExpected('access.getConfiguration().initDataTypes.length', '1');
                     testExpected('access.getConfiguration().initDataTypes[0]', 'mock');
                     testExpected('access.getConfiguration().sessionTypes.length', '1');
                     testExpected('access.getConfiguration().sessionTypes[0]', 'temporary');
                     testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
                     testExpected('access.getConfiguration().persistentState', 'not-allowed');
                 });
         },

         function() {
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'unknown/mime; codecs="unknown"' }]
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             failingTestWithCapabilities([{
                     initDataTypes: ['unknownType'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             run('mock.supportedRobustness = ["high"]');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', robustness: "high" }],
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().videoCapabilities.length', '1');
                     testExpected('access.getConfiguration().videoCapabilities[0].robustness', 'high');
                 });
         },

         function() {
             run('mock.supportedRobustness = ["high"]');
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', robustness: "low" }],
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             run('mock.distinctiveIdentifierRequirement = "not-allowed"');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     distinctiveIdentifier: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
                 });
         },

         function() {
             run('mock.distinctiveIdentifiersRequirement = "required"');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     distinctiveIdentifier: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().distinctiveIdentifier', 'required');
                 });
         },

         function() {
             run('mock.distinctiveIdentifiersRequirement = "not-allowed"');
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     distinctiveIdentifier: 'required'
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             run('mock.distinctiveIdentifiersRequirement = "not-allowed"');
             passingTestWithCapabilities([{
                     label: 'distinctive-identifiers-required',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     distinctiveIdentifier: 'required'
                 }, {
                     label: 'distinctive-identifiers-not-required',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     distinctiveIdentifier: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().label', 'distinctive-identifiers-not-required');
                     testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
                 });
         },

         function() {
             run('mock.persistentStateRequirement = "required"');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     persistentState: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().persistentState', 'required');
                 });
         },

         function() {
             run('mock.persistentStateRequirement = "not-allowed"');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     persistentState: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().persistentState', 'not-allowed');
                 });
         },

         function() {
             run('mock.persistentStateRequirement = "not-allowed"');
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     persistentState: 'required'
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             run('mock.persistentStateRequirement = "not-allowed"');
             passingTestWithCapabilities([{
                     label: 'persistent-state-required',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     persistentState: 'required'
                 }, {
                     label: 'persistent-state-not-required',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     persistentState: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().label', 'persistent-state-not-required');
                     testExpected('access.getConfiguration().persistentState', 'not-allowed');
                 });
         },

         function() {
             run('mock.supportedEncryptionSchemes = ["cenc"]');
             passingTestWithCapabilities([{
                     label: 'encryption-scheme-cenc',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cenc'}],
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().label', 'encryption-scheme-cenc');
                     testExpected('access.getConfiguration().videoCapabilities[0].encryptionScheme', 'cenc');
                 });
         },

         function() {
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cbcs'}],
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             run('mock.supportedEncryptionSchemes = ["cenc", "cbcs"]');
             passingTestWithCapabilities([{
                     label: 'encryption-scheme-cbcs',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cbcs'}],
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().label', 'encryption-scheme-cbcs');
                     testExpected('access.getConfiguration().videoCapabilities[0].encryptionScheme', 'cbcs');
                 });
         },
     ];
     </script>
 </head>
 <body onload="doTest()">
 </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<script src=../video-test.js></script>
	<script type="text/javascript">
	var mock;
	var promise;
	var capabilities = {};

	function doTest ()
	{
	if (!window.internals) {
	// failTest("Internals is required for this test.")
	// return;
	}

	run('internals.initializeMockMediaSource()');
	run('mock = internals.registerMockCDM()');
	run('mock.supportedDataTypes = ["mock"]');

	next();
	}

	function next() {
	if (!tests.length) {
	mock.unregister();
	endTest()
	return;
	}

	var nextTest = tests.shift();
	consoleWrite('');
	nextTest();
	}

	function passingTestWithCapabilities(capabilities, success) {
	shouldResolve(testWithCapabilities(capabilities)).then(success).then(next, next);
	}

	function failingTestWithCapabilities(capabilities, failure) {
	shouldReject(testWithCapabilities(capabilities)).then(failure).then(next, next);
	}

	function testWithCapabilities(capabilities) {
	window.capabilities = capabilities;
	consoleWrite(`SET capabilities = '${ JSON.stringify(capabilities, null, 1) }'`);
	run('promise = navigator.requestMediaKeySystemAccess("org.webkit.mock", capabilities)');
	return promise;
	}

	tests = [
	function() {
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.keySystem', 'org.webkit.mock');
	testExpected('access.getConfiguration().initDataTypes.length', '1');
	testExpected('access.getConfiguration().initDataTypes[0]', 'mock');
	testExpected('access.getConfiguration().sessionTypes.length', '1');
	testExpected('access.getConfiguration().sessionTypes[0]', 'temporary');
	testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
	testExpected('access.getConfiguration().persistentState', 'not-allowed');
	});
	},

	function() {
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'unknown/mime; codecs="unknown"' }]
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	failingTestWithCapabilities([{
	initDataTypes: ['unknownType'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	run('mock.supportedRobustness = ["high"]');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', robustness: "high" }],
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().videoCapabilities.length', '1');
	testExpected('access.getConfiguration().videoCapabilities[0].robustness', 'high');
	});
	},

	function() {
	run('mock.supportedRobustness = ["high"]');
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', robustness: "low" }],
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	run('mock.distinctiveIdentifierRequirement = "not-allowed"');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	distinctiveIdentifier: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
	});
	},

	function() {
	run('mock.distinctiveIdentifiersRequirement = "required"');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	distinctiveIdentifier: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().distinctiveIdentifier', 'required');
	});
	},

	function() {
	run('mock.distinctiveIdentifiersRequirement = "not-allowed"');
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	distinctiveIdentifier: 'required'
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	run('mock.distinctiveIdentifiersRequirement = "not-allowed"');
	passingTestWithCapabilities([{
	label: 'distinctive-identifiers-required',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	distinctiveIdentifier: 'required'
	}, {
	label: 'distinctive-identifiers-not-required',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	distinctiveIdentifier: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().label', 'distinctive-identifiers-not-required');
	testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
	});
	},

	function() {
	run('mock.persistentStateRequirement = "required"');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	persistentState: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().persistentState', 'required');
	});
	},

	function() {
	run('mock.persistentStateRequirement = "not-allowed"');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	persistentState: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().persistentState', 'not-allowed');
	});
	},

	function() {
	run('mock.persistentStateRequirement = "not-allowed"');
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	persistentState: 'required'
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	run('mock.persistentStateRequirement = "not-allowed"');
	passingTestWithCapabilities([{
	label: 'persistent-state-required',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	persistentState: 'required'
	}, {
	label: 'persistent-state-not-required',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	persistentState: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().label', 'persistent-state-not-required');
	testExpected('access.getConfiguration().persistentState', 'not-allowed');
	});
	},

	function() {
	run('mock.supportedEncryptionSchemes = ["cenc"]');
	passingTestWithCapabilities([{
	label: 'encryption-scheme-cenc',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cenc'}],
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().label', 'encryption-scheme-cenc');
	testExpected('access.getConfiguration().videoCapabilities[0].encryptionScheme', 'cenc');
	});
	},

	function() {
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cbcs'}],
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	run('mock.supportedEncryptionSchemes = ["cenc", "cbcs"]');
	passingTestWithCapabilities([{
	label: 'encryption-scheme-cbcs',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cbcs'}],
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().label', 'encryption-scheme-cbcs');
	testExpected('access.getConfiguration().videoCapabilities[0].encryptionScheme', 'cbcs');
	});
	},
	];
	</script>
	</head>
	<body onload="doTest()">
	</body>
	</html>