summaryrefslogtreecommitdiffstats
path: root/testing/web-platform/tests/encrypted-media/scripts/syntax-mediakeysession.js
diff options
context:
space:
mode:
Diffstat (limited to 'testing/web-platform/tests/encrypted-media/scripts/syntax-mediakeysession.js')
-rw-r--r--testing/web-platform/tests/encrypted-media/scripts/syntax-mediakeysession.js445
1 files changed, 445 insertions, 0 deletions
diff --git a/testing/web-platform/tests/encrypted-media/scripts/syntax-mediakeysession.js b/testing/web-platform/tests/encrypted-media/scripts/syntax-mediakeysession.js
new file mode 100644
index 000000000..3663a7b93
--- /dev/null
+++ b/testing/web-platform/tests/encrypted-media/scripts/syntax-mediakeysession.js
@@ -0,0 +1,445 @@
+function runTest(config) {
+ var keysystem = config.keysystem;
+ var testname = testnamePrefix(null, config.keysystem);
+ var initDataType = config.initDataType;
+ var initData = config.initData;
+ var configuration = {
+ initDataTypes: [config.initDataType],
+ audioCapabilities: [{contentType: config.audioType}],
+ videoCapabilities: [{contentType: config.videoType}],
+ sessionTypes: ['temporary']
+ };
+
+ var kTypeSpecificGenerateRequestExceptionsTestCases = [
+ // Tests in this set use a shortened parameter name due to
+ // format_value() only returning the first 60 characters as the
+ // result. With a longer name the first 60 characters is not
+ // enough to determine which test failed. Even with the
+ // shortened name, the error message for the last couple of
+ // tests is the same.
+
+ // Too few parameters.
+ {
+ exception: 'TypeError',
+ func: function (mk1, type) {
+ return mk1.createSession().generateRequest(type);
+ }
+ },
+ // Invalid parameters.
+ {
+ exception: 'TypeError',
+ func: function (mk2, type) {
+ return mk2.createSession().generateRequest(type, '');
+ }
+ },
+ {
+ exception: 'TypeError',
+ func: function (mk3, type) {
+ return mk3.createSession().generateRequest(type, null);
+ }
+ },
+ {
+ exception: 'TypeError',
+ func: function (mk4, type) {
+ return mk4.createSession().generateRequest(type, undefined);
+ }
+ },
+ {
+ exception: 'TypeError',
+ func: function (mk5, type) {
+ return mk5.createSession().generateRequest(type, 1);
+ }
+ },
+ // (new Uint8Array(0)) returns empty array. So 'TypeError' should
+ // be returned.
+ {
+ exception: 'TypeError',
+ func: function (mk6, type) {
+ return mk6.createSession().generateRequest(type, new Uint8Array(0));
+ }
+ }
+ ];
+ function generateRequestTestExceptions(){
+ return new Promise(function(resolve, reject){
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) {
+ assert_true(isTypeSupported, "initDataType not supported");
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]);
+ }).then(function (access) {
+ return access.createMediaKeys();
+ }).then(function (mediaKeys) {
+ var mp4SessionPromises = kTypeSpecificGenerateRequestExceptionsTestCases.map(function (testCase) {
+ return test_exception(testCase, mediaKeys, initDataType, initData);
+ });
+ assert_not_equals(mp4SessionPromises.length, 0);
+ return Promise.all(mp4SessionPromises);
+ }).then(function (result) {
+ resolve();
+ }).catch(function (error) {
+ reject(error);
+ });
+ })
+ }
+ promise_test(function() {
+ return generateRequestTestExceptions();
+ }, testname + ' test MediaKeySession generateRequest() exceptions.');
+
+ var kLoadExceptionsTestCases = [
+ // Too few parameters.
+ {
+ exception: 'TypeError',
+ func: function (mk1) {
+ return mk1.createSession('temporary').load();
+ }
+ },
+ {
+ exception: 'TypeError',
+ func: function (mk3) {
+ return mk3.createSession('temporary').load('');
+ }
+ },
+ {
+ exception: 'TypeError',
+ func: function (mk4) {
+ return mk4.createSession('temporary').load(1);
+ }
+ },
+ {
+ exception: 'TypeError',
+ func: function (mk5) {
+ return mk5.createSession('temporary').load('!@#$%^&*()');
+ }
+ },
+ {
+ exception: 'TypeError',
+ func: function (mk6) {
+ return mk6.createSession('temporary').load('1234');
+ }
+ }
+ ];
+ function loadTestExceptions(){
+ return new Promise(function(resolve, reject){
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) {
+ assert_true(isTypeSupported, "initDataType not supported");
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]);
+ }).then(function (access) {
+ return access.createMediaKeys();
+ }).then(function (mediaKeys) {
+ var sessionPromises = kLoadExceptionsTestCases.map(function (testCase) {
+ return test_exception(testCase, mediaKeys);
+ });
+ assert_not_equals(sessionPromises.length, 0);
+ return Promise.all(sessionPromises);
+ }).then(function () {
+ resolve();
+ }).catch(function (error) {
+ reject(error);
+ });
+ })
+ }
+ promise_test(function() {
+ return loadTestExceptions();
+ }, testname + ' test MediaKeySession load() exceptions.');
+
+ // All calls to |func| in this group are supposed to succeed.
+ // However, the spec notes that some things are optional for
+ // Clear Key. In particular, support for persistent sessions
+ // is optional. Since some implementations won't support some
+ // features, a NotSupportedError is treated as a success
+ // if |isNotSupportedAllowed| is true.
+ var kCreateSessionTestCases = [
+ // Use the default sessionType.
+ {
+ func: function(mk) { return mk.createSession(); },
+ isNotSupportedAllowed: false
+ },
+ // Try variations of sessionType.
+ {
+ func: function(mk) { return mk.createSession('temporary'); },
+ isNotSupportedAllowed: false
+ },
+ {
+ func: function(mk) { return mk.createSession(undefined); },
+ isNotSupportedAllowed: false
+ },
+ {
+ // Since this is optional, some Clear Key implementations
+ // will succeed, others will return a "NotSupportedError".
+ // Both are allowed results.
+ func: function(mk) { return mk.createSession('persistent-license'); },
+ isNotSupportedAllowed: true
+ },
+ // Try additional parameter, which should be ignored.
+ {
+ func: function(mk) { return mk.createSession('temporary', 'extra'); },
+ isNotSupportedAllowed: false
+ }
+ ];
+ // This function checks that calling generateRequest() works for
+ // various sessions. |testCase.func| creates a MediaKeySession
+ // object, and then generateRequest() is called on that object. It
+ // allows for an NotSupportedError to be generated and treated as a
+ // success, if allowed. See comment above kCreateSessionTestCases.
+ function test_generateRequest(testCase, mediaKeys, type, initData) {
+ var mediaKeySession;
+ try {
+ mediaKeySession = testCase.func.call(null, mediaKeys);
+ } catch (e) {
+ assert_true(testCase.isNotSupportedAllowed);
+ assert_equals(e.name, 'NotSupportedError');
+ return Promise.resolve('not supported');
+ }
+ return mediaKeySession.generateRequest(type, initData);
+ }
+ function generateRequestForVariousSessions(){
+ return new Promise(function(resolve, reject){
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) {
+ assert_true(isTypeSupported, "initDataType should be supported");
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]);
+ }).then(function (access) {
+ return access.createMediaKeys();
+ }).then(function (mediaKeys) {
+ var mp4SessionPromises = kCreateSessionTestCases.map(function (testCase) {
+ return test_generateRequest(testCase, mediaKeys, initDataType, initData);
+ });
+ assert_not_equals(mp4SessionPromises.length, 0);
+ return Promise.all(mp4SessionPromises);
+ }).then(function () {
+ resolve();
+ }).catch(function (error) {
+ reject(error);
+ });
+ })
+ }
+ promise_test(function() {
+ return generateRequestForVariousSessions();
+ }, testname + ' test if MediaKeySession generateRequest() resolves for various sessions');
+
+ var kUpdateSessionExceptionsTestCases = [
+ // Tests in this set use a shortened parameter name due to
+ // format_value() only returning the first 60 characters as the
+ // result. With a longer name (mediaKeySession) the first 60
+ // characters is not enough to determine which test failed.
+
+ // Too few parameters.
+ {
+ exception: 'TypeError',
+ func: function (s) {
+ return s.update();
+ }
+ },
+ // Invalid parameters.
+ {
+ exception: 'TypeError',
+ func: function (s) {
+ return s.update('');
+ }
+ },
+ {
+ exception: 'TypeError',
+ func: function (s) {
+ return s.update(null);
+ }
+ },
+ {
+ exception: 'TypeError',
+ func: function (s) {
+ return s.update(undefined);
+ }
+ },
+ {
+ exception: 'TypeError',
+ func: function (s) {
+ return s.update(1);
+ }
+ },
+ // (new Uint8Array(0)) returns empty array. So 'TypeError' should
+ // be returned.
+ {
+ exception: 'TypeError',
+ func: function (s) {
+ return s.update(new Uint8Array(0));
+ }
+ }
+ ];
+
+ function updateTestExceptions(){
+ return new Promise(function(resolve, reject){
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) {
+ assert_true(isTypeSupported, "initDataType not supported");
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]);
+ }).then(function (access) {
+ return access.createMediaKeys();
+ }).then(function (mediaKeys) {
+ var mp4SessionPromises = kUpdateSessionExceptionsTestCases.map(function (testCase) {
+ var mediaKeySession = mediaKeys.createSession();
+ return mediaKeySession.generateRequest(initDataType, initData).then(function (result) {
+ return test_exception(testCase, mediaKeySession);
+ });
+ });
+ assert_not_equals(mp4SessionPromises.length, 0);
+ return Promise.all(mp4SessionPromises);
+ }).then(function () {
+ resolve();
+ }).catch(function (error) {
+ reject(error);
+ });
+ })
+ }
+ promise_test(function() {
+ return updateTestExceptions();
+ }, testname + ' test MediaKeySession update() exceptions.');
+
+ function create_close_exception_test(mediaKeys) {
+ var mediaKeySession = mediaKeys.createSession();
+ return mediaKeySession.close().then(function (result) {
+ assert_unreached('close() should not succeed if session uninitialized');
+ }).catch(function (error) {
+ assert_equals(error.name, 'InvalidStateError');
+ // Return something so the promise resolves.
+ return Promise.resolve();
+ });
+ }
+ function closeTestExceptions(){
+ return new Promise(function(resolve, reject){
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) {
+ assert_true(isTypeSupported, "initDataType not supported");
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]);
+ }).then(function (access) {
+ return access.createMediaKeys();
+ }).then(function (mediaKeys) {
+ return create_close_exception_test(mediaKeys);
+ }).then(function () {
+ resolve();
+ }).catch(function (error) {
+ reject(error);
+ });
+ });
+ }
+ promise_test(function() {
+ return closeTestExceptions();
+ }, testname + ' test MediaKeySession close() exceptions.');
+
+ function create_remove_exception_test(mediaKeys, type, initData) {
+ // remove() on an uninitialized session should fail.
+ var mediaKeySession = mediaKeys.createSession('temporary');
+ return mediaKeySession.remove().then(function (result) {
+ assert_unreached('remove() should not succeed if session uninitialized');
+ }, function (error) {
+ assert_equals(error.name, 'InvalidStateError');
+ });
+ }
+ function removeTestException(){
+ return new Promise(function(resolve, reject){
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) {
+ assert_true(isTypeSupported, "initDataType not supported");
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]);
+ }).then(function (access) {
+ return access.createMediaKeys();
+ }).then(function (mediaKeys) {
+ return create_remove_exception_test(mediaKeys, initDataType, initData);
+ }).then(function () {
+ resolve();
+ }).catch(function (error) {
+ reject(error);
+ });
+ });
+ }
+ promise_test(function() {
+ return removeTestException();
+ }, testname + ' test MediaKeySession remove() exceptions.');
+
+ // All calls to |func| in this group are supposed to succeed.
+ // However, the spec notes that some things are optional for
+ // Clear Key. In particular, support for persistent sessions
+ // is optional. Since some implementations won't support some
+ // features, a NotSupportedError is treated as a success
+ // if |isNotSupportedAllowed| is true.
+ var kCreateSessionTestCases = [
+ // Use the default sessionType.
+ {
+ func: function (mk) {
+ return mk.createSession();
+ },
+ isNotSupportedAllowed: false
+ },
+ // Try variations of sessionType.
+ {
+ func: function (mk) {
+ return mk.createSession('temporary');
+ },
+ isNotSupportedAllowed: false
+ },
+ {
+ func: function (mk) {
+ return mk.createSession(undefined);
+ },
+ isNotSupportedAllowed: false
+ },
+ {
+ // Since this is optional, some Clear Key implementations
+ // will succeed, others will return a "NotSupportedError".
+ // Both are allowed results.
+ func: function (mk) {
+ return mk.createSession('persistent-license');
+ },
+ isNotSupportedAllowed: true
+ },
+ // Try additional parameter, which should be ignored.
+ {
+ func: function (mk) {
+ return mk.createSession('temporary', 'extra');
+ },
+ isNotSupportedAllowed: false
+ }
+ ];
+
+ // This function checks that calling |testCase.func| creates a
+ // MediaKeySession object with some default values. It also
+ // allows for an NotSupportedError to be generated and treated as a
+ // success, if allowed. See comment above kCreateSessionTestCases.
+ function test_createSession(testCase, mediaKeys) {
+ var mediaKeySession;
+ try {
+ mediaKeySession = testCase.func.call(null, mediaKeys);
+ } catch (e) {
+ assert_true(testCase.isNotSupportedAllowed);
+ return;
+ }
+ assert_equals(typeof mediaKeySession, 'object');
+ assert_equals(typeof mediaKeySession.addEventListener, 'function');
+ assert_equals(typeof mediaKeySession.sessionId, 'string');
+ assert_equals(typeof mediaKeySession.expiration, 'number');
+ assert_equals(typeof mediaKeySession.closed, 'object');
+ assert_equals(typeof mediaKeySession.keyStatuses, 'object');
+ assert_equals(typeof mediaKeySession.onkeystatuseschange, 'object');
+ assert_equals(typeof mediaKeySession.onmessage, 'object');
+ assert_equals(typeof mediaKeySession.generateRequest, 'function');
+ assert_equals(typeof mediaKeySession.load, 'function');
+ assert_equals(typeof mediaKeySession.update, 'function');
+ assert_equals(typeof mediaKeySession.close, 'function');
+ assert_equals(typeof mediaKeySession.remove, 'function');
+ assert_equals(mediaKeySession.sessionId, '');
+ }
+ function createSessionTest(){
+ return new Promise(function(resolve, reject){
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) {
+ assert_true(isTypeSupported, "initDataType not supported");
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]);
+ }).then(function (access) {
+ return access.createMediaKeys();
+ }).then(function (mediaKeys) {
+ kCreateSessionTestCases.map(function (testCase) {
+ test_createSession(testCase, mediaKeys);
+ });
+ resolve();
+ }).catch(function (error) {
+ reject(error);
+ });
+ })
+ }
+ promise_test(function() {
+ return createSessionTest();
+ }, testname + ' test MediaKeySession attribute syntax.');
+
+
+}