Fix #3756: Test that persistent licenses cannot be ingested into temp… (

#3774)
web-platform-tests · Sep 26, 2016 · 72bbf87 · 72bbf87
1 parent 6926df6
commit 72bbf87
Show file tree

Hide file tree

Showing 2 changed files with 134 additions and 0 deletions.
diff --git a/encrypted-media/drm-temporary-license-type.html b/encrypted-media/drm-temporary-license-type.html
@@ -0,0 +1,71 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset=utf-8>
+    <title>Encrypted Media Extensions: Test that persistent license cannot be ingested into temporary session</title>
+    <link rel="help" href="https://w3c.github.io/encrypted-media/">
+
+    <!-- Web Platform Test Harness scripts -->
+    <script src=/resources/testharness.js></script>
+    <script src=/resources/testharnessreport.js></script>
+
+    <!-- Helper scripts for Encrypted Media Extensions tests  -->
+    <script src=/encrypted-media/util/utils.js></script>
+    <script src=/encrypted-media/util/utf8.js></script>
+    <script src=/encrypted-media/util/fetch.js></script>
+    <script src=/encrypted-media/util/testmediasource.js></script>
+
+    <!-- Content metadata -->
+    <script src=/encrypted-media/content/content-metadata.js></script>
+
+    <!-- Message handler for DRM servers -->
+    <script src=/encrypted-media/util/drm-messagehandler.js></script>
+
+    <!-- The script for this specific test -->
+    <script src=/encrypted-media/scripts/temporary-license-type.js></script>
+
+  </head>
+  <body>
+    <div id='log'></div>
+
+    <script>
+        var keysystem = getSupportedKeySystem();
+
+        getSupportedContentAndInitDataTypes( keysystem )
+        .then( function( supported )
+        {
+            // This test requires initData for supported content.
+            // We prefer explicit initData configured for the content, but
+            // otherwise we will generate initData for a supported initDataType
+            // FIXME: Move me to a utility function
+            var content,
+                initDataType,
+                initData;
+
+            var contentWithExplicitInitData = supported.filter( function( s ) { return s.content.initDataType; } );
+            if ( contentWithExplicitInitData.length > 0 )
+            {
+                content = contentWithExplicitInitData[ 0 ].content;
+                initDataType = content.keys[ 0 ].initDataType;
+                initData = base64DecodeToUnit8Array( content.keys[ 0 ].initData );
+            }
+            else
+            {
+                content = supported[ 0 ].content;
+                initDataType = supported[ 0 ].initDataTypes[ 0 ];
+                initData = getInitData( content, initDataType );
+            }
+
+            var handler = new MessageHandler( keysystem, content, 'persistent-license' );
+
+            runTest( {  keysystem:          keysystem,
+                        content:            content,
+                        messagehandler:     handler.messagehandler,
+                        initDataType:       initDataType,
+                        initData:           initData
+                    } );
+        } );
+
+    </script>
+  </body>
+</html>
diff --git a/encrypted-media/scripts/temporary-license-type.js b/encrypted-media/scripts/temporary-license-type.js
@@ -0,0 +1,63 @@
+function runTest(config,qualifier) {
+
+    var testname = testnamePrefix( qualifier, config.keysystem ) + ', cannot load persistent license into temporary session';
+
+    var configuration = getSimpleConfigurationForContent( config.content );
+
+    if ( config.initDataType && config.initData ) configuration.initDataTypes = [ config.initDataType ]
+
+    async_test(function(test)
+    {
+        var initDataType;
+        var initData;
+        var mediaKeySession;
+
+        function onFailure( error ) {
+            forceTestFailureFromPromise(test, error);
+        }
+
+        function processMessage(event)
+        {
+            assert_true(event instanceof window.MediaKeyMessageEvent);
+            assert_equals(event.target, mediaKeySession);
+            assert_equals(event.type, 'message');
+            assert_any( assert_equals,
+                        event.messageType,
+                        [ 'license-request', 'individualization-request' ] );
+
+            config.messagehandler( event.messageType, event.message ).then( function( response ) {
+                mediaKeySession.update( response ).then( test.step_func( function() {
+                    if ( event.messageType !== 'license-request' ) {
+                        return;
+                    }
+                    assert_unreached( "Update with incorrect license type should fail" )
+                } ) ).catch( test.step_func( function( error ) {
+                    if ( event.messageType !== 'license-request' ) {
+                        forceTestFailureFromPromise(test, error);
+                        return;
+                    }
+
+                    assert_equals(error.name, 'TypeError' );
+                    test.done();
+                } ) );
+            });
+        }
+
+        navigator.requestMediaKeySystemAccess( config.keysystem, [ configuration ] ).then(function(access) {
+            initDataType = access.getConfiguration().initDataTypes[0];
+
+            if ( config.initDataType && config.initData ) {
+                initData = config.initData;
+            } else {
+                initData = getInitData(config.content, initDataType);
+            }
+
+            return access.createMediaKeys();
+        }).then(test.step_func(function(mediaKeys) {
+            mediaKeySession = mediaKeys.createSession( 'temporary' );
+            waitForEventAndRunStep('message', mediaKeySession, test.step_func(processMessage), test);
+            return mediaKeySession.generateRequest(initDataType, initData);
+        })).catch(onFailure);
+    }, testname );
+
+}