Merge "Use OO.ui.MultilineTextInputWidget"

[lhc/web/wiklou.git] / tests / qunit / suites / resources / mediawiki / mediawiki.loader.test.js

diff --git a/tests/qunit/suites/resources/mediawiki/mediawiki.loader.test.js b/tests/qunit/suites/resources/mediawiki/mediawiki.loader.test.js
index 6f9af76..a00b3cb 100644 (file)
--- a/tests/qunit/suites/resources/mediawiki/mediawiki.loader.test.js
+++ b/tests/qunit/suites/resources/mediawiki/mediawiki.loader.test.js
@@ -5,6 +5,11 @@
                },
                teardown: function () {
                        mw.loader.store.enabled = false;
+                       // Teardown for StringSet shim test
+                       if ( this.nativeSet ) {
+                               window.Set = this.nativeSet;
+                               mw.redefineFallbacksForTest();
+                       }
                }
        } ) );
 
@@ -33,8 +38,10 @@
                function isCssImportApplied() {
                        // Trigger reflow, repaint, redraw, whatever (cross-browser)
                        $element.css( 'height' );
+                       // eslint-disable-next-line no-unused-expressions
                        el.innerHTML;
                        el.className = el.className;
+                       // eslint-disable-next-line no-unused-expressions
                        document.documentElement.clientHeight;
 
                        return $element.css( prop ) === val;
@@ -133,7 +140,8 @@
                } );
        } );
 
-       QUnit.test( '.using() Error: Circular dependency', function ( assert ) {
+       // Covers mw.loader#sortDependencies (with native Set if available)
+       QUnit.test( '.using() Error: Circular dependency [StringSet default]', function ( assert ) {
                var done = assert.async();
 
                mw.loader.register( [
@@ -152,15 +160,61 @@
                .always( done );
        } );
 
+       // @covers mw.loader#sortDependencies (with fallback shim)
+       QUnit.test( '.using() Error: Circular dependency [StringSet shim]', function ( assert ) {
+               var done = assert.async();
+
+               if ( !window.Set ) {
+                       assert.expect( 0 );
+                       done();
+                       return;
+               }
+
+               this.nativeSet = window.Set;
+               window.Set = undefined;
+               mw.redefineFallbacksForTest();
+
+               mw.loader.register( [
+                       [ 'test.shim.circle1', '0', [ 'test.shim.circle2' ] ],
+                       [ 'test.shim.circle2', '0', [ 'test.shim.circle3' ] ],
+                       [ 'test.shim.circle3', '0', [ 'test.shim.circle1' ] ]
+               ] );
+               mw.loader.using( 'test.shim.circle3' ).then(
+                       function done() {
+                               assert.ok( false, 'Unexpected resolution, expected error.' );
+                       },
+                       function fail( e ) {
+                               assert.ok( /Circular/.test( String( e ) ), 'Detect circular dependency' );
+                       }
+               )
+               .always( done );
+       } );
+
        QUnit.test( '.load() - Error: Circular dependency', function ( assert ) {
+               var capture = [];
                mw.loader.register( [
                        [ 'test.circleA', '0', [ 'test.circleB' ] ],
                        [ 'test.circleB', '0', [ 'test.circleC' ] ],
                        [ 'test.circleC', '0', [ 'test.circleA' ] ]
                ] );
-               assert.throws( function () {
-                       mw.loader.load( 'test.circleC' );
-               }, /Circular/, 'Detect circular dependency' );
+               this.sandbox.stub( mw, 'track', function ( topic, data ) {
+                       capture.push( {
+                               topic: topic,
+                               error: data.exception && data.exception.message,
+                               source: data.source
+                       } );
+               } );
+
+               mw.loader.load( 'test.circleC' );
+               assert.deepEqual(
+                       [ {
+                               topic: 'resourceloader.exception',
+                               error: 'Circular reference detected: test.circleB -> test.circleC',
+                               source: 'resolve'
+                       } ],
+                       capture,
+                       'Detect circular dependency'
+               );
        } );
 
        QUnit.test( '.using() - Error: Unregistered', function ( assert ) {
@@ -176,9 +230,51 @@
                ).always( done );
        } );
 
-       QUnit.test( '.load() - Error: Unregistered (ignored)', function ( assert ) {
-               assert.expect( 0 );
-               mw.loader.load( 'test.using.unreg2' );
+       QUnit.test( '.load() - Error: Unregistered', function ( assert ) {
+               var capture = [];
+               this.sandbox.stub( mw, 'track', function ( topic, data ) {
+                       capture.push( {
+                               topic: topic,
+                               error: data.exception && data.exception.message,
+                               source: data.source
+                       } );
+               } );
+
+               mw.loader.load( 'test.load.unreg' );
+               assert.deepEqual(
+                       [ {
+                               topic: 'resourceloader.exception',
+                               error: 'Unknown dependency: test.load.unreg',
+                               source: 'resolve'
+                       } ],
+                       capture
+               );
+       } );
+
+       // Regression test for T36853
+       QUnit.test( '.load() - Error: Missing dependency', function ( assert ) {
+               var capture = [];
+               this.sandbox.stub( mw, 'track', function ( topic, data ) {
+                       capture.push( {
+                               topic: topic,
+                               error: data.exception && data.exception.message,
+                               source: data.source
+                       } );
+               } );
+
+               mw.loader.register( [
+                       [ 'test.load.missingdep1', '0', [ 'test.load.missingdep2' ] ],
+                       [ 'test.load.missingdep', '0', [ 'test.load.missingdep1' ] ]
+               ] );
+               mw.loader.load( 'test.load.missingdep' );
+               assert.deepEqual(
+                       [ {
+                               topic: 'resourceloader.exception',
+                               error: 'Unknown dependency: test.load.missingdep2',
+                               source: 'resolve'
+                       } ],
+                       capture
+               );
        } );
 
        QUnit.test( '.implement( styles={ "css": [text, ..] } )', function ( assert ) {
@@ -510,7 +606,7 @@
                                assert.ok( true, 'QUnit expected() count dummy' );
                        },
                        function ( e, dependencies ) {
-                               assert.strictEqual( $.isArray( dependencies ), true, 'Expected array of dependencies' );
+                               assert.strictEqual( Array.isArray( dependencies ), true, 'Expected array of dependencies' );
                                assert.deepEqual( dependencies, [ 'test.module7' ], 'Error callback called with module test.module7' );
                        }
                );
@@ -521,7 +617,7 @@
                                assert.ok( true, 'QUnit expected() count dummy' );
                        },
                        function ( e, dependencies ) {
-                               assert.strictEqual( $.isArray( dependencies ), true, 'Expected array of dependencies' );
+                               assert.strictEqual( Array.isArray( dependencies ), true, 'Expected array of dependencies' );
                                dependencies.sort();
                                assert.deepEqual(
                                        dependencies,