mediawiki.api: fix badtoken handling with legacy token types

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

diff --git a/tests/qunit/suites/resources/mediawiki.api/mediawiki.api.test.js b/tests/qunit/suites/resources/mediawiki.api/mediawiki.api.test.js
index de79198..394f3bd 100644 (file)
--- a/tests/qunit/suites/resources/mediawiki.api/mediawiki.api.test.js
+++ b/tests/qunit/suites/resources/mediawiki.api/mediawiki.api.test.js
@@ -1,4 +1,4 @@
-( function ( mw ) {
+( function ( mw, $ ) {
        QUnit.module( 'mediawiki.api', QUnit.newMwEnvironment( {
                setup: function () {
                        this.server = this.sandbox.useFakeServer();
@@ -14,7 +14,7 @@
        function sequence( responses ) {
                var i = 0;
                return function ( request ) {
-                       var response = responses[i];
+                       var response = responses[ i ];
                        if ( response ) {
                                i++;
                                request.respond.apply( request, response );
@@ -24,7 +24,7 @@
 
        function sequenceBodies( status, headers, bodies ) {
                jQuery.each( bodies, function ( i, body ) {
-                       bodies[i] = [ status, headers, body ];
+                       bodies[ i ] = [ status, headers, body ];
                } );
                return sequence( bodies );
        }
@@ -90,6 +90,19 @@
                api.get( { test: [ 'foo', 'bar', 'baz' ] } );
        } );
 
+       QUnit.test( 'Omitting false booleans', function ( assert ) {
+               QUnit.expect( 2 );
+               var api = new mw.Api();
+
+               this.server.respond( function ( request ) {
+                       assert.ok( !request.url.match( /foo/ ), 'foo query parameter is not present' );
+                       assert.ok( request.url.match( /bar=true/ ), 'bar query parameter is present with value true' );
+                       request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
+               } );
+
+               api.get( { foo: false, bar: true } );
+       } );
+
        QUnit.test( 'getToken() - cached', function ( assert ) {
                QUnit.expect( 2 );
                var api = new mw.Api();
@@ -112,7 +125,7 @@
                var api = new mw.Api();
 
                this.server.respondWith( /type=testuncached/, [ 200, { 'Content-Type': 'application/json' },
-                       '{ "tokens": { "testuncachedtoken": "good" } }'
+                       '{ "query": { "tokens": { "testuncachedtoken": "good" } } }'
                ] );
 
                // Get a token of a type that isn't prepopulated by user.tokens.
@@ -144,7 +157,7 @@
                this.server.respondWith( /type=testerror/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
                        [
                                '{ "error": { "code": "bite-me", "info": "Smite me, O Mighty Smiter" } }',
-                               '{ "tokens": { "testerrortoken": "good" } }'
+                               '{ "query": { "tokens": { "testerrortoken": "good" } } }'
                        ]
                ) );
 
@@ -162,6 +175,27 @@
                } );
        } );
 
+       QUnit.test( 'getToken() - deprecated', function ( assert ) {
+               QUnit.expect( 2 );
+               // Cache API endpoint from default to avoid cachehit in mw.user.tokens
+               var api = new mw.Api( { ajax: { url: '/postWithToken/api.php' } } );
+
+               this.server.respondWith( /type=csrf/, [ 200, { 'Content-Type': 'application/json' },
+                       '{ "query": { "tokens": { "csrftoken": "csrfgood" } } }'
+               ] );
+
+               // Get a token of a type that is in the legacy map.
+               api.getToken( 'email' )
+                       .done( function ( token ) {
+                               assert.equal( token, 'csrfgood', 'Token' );
+                       } )
+                       .fail( function ( err ) {
+                               assert.equal( err, '', 'API error' );
+                       } );
+
+               assert.equal( this.server.requests.length, 1, 'Requests made' );
+       } );
+
        QUnit.test( 'badToken()', function ( assert ) {
                QUnit.expect( 2 );
                var api = new mw.Api(),
@@ -169,8 +203,8 @@
 
                this.server.respondWith( /type=testbad/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
                        [
-                               '{ "tokens": { "testbadtoken": "bad" } }',
-                               '{ "tokens": { "testbadtoken": "good" } }'
+                               '{ "query": { "tokens": { "testbadtoken": "bad" } } }',
+                               '{ "query": { "tokens": { "testbadtoken": "good" } } }'
                        ]
                ) );
 
@@ -186,12 +220,36 @@
 
        } );
 
+       QUnit.test( 'badToken( legacy )', function ( assert ) {
+               QUnit.expect( 2 );
+               var api = new mw.Api( { ajax: { url: '/badTokenLegacy/api.php' } } ),
+                       test = this;
+
+               this.server.respondWith( /type=csrf/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
+                       [
+                               '{ "query": { "tokens": { "csrftoken": "badlegacy" } } }',
+                               '{ "query": { "tokens": { "csrftoken": "goodlegacy" } } }'
+                       ]
+               ) );
+
+               api.getToken( 'options' )
+                       .then( function () {
+                               api.badToken( 'options' );
+                               return api.getToken( 'options' );
+                       } )
+                       .then( function ( token ) {
+                               assert.equal( token, 'goodlegacy', 'The token' );
+                               assert.equal( test.server.requests.length, 2, 'Request made' );
+                       } );
+
+       } );
+
        QUnit.test( 'postWithToken( tokenType, params )', function ( assert ) {
                QUnit.expect( 1 );
                var api = new mw.Api( { ajax: { url: '/postWithToken/api.php' } } );
 
                this.server.respondWith( 'GET', /type=testpost/, [ 200, { 'Content-Type': 'application/json' },
-                       '{ "tokens": { "testposttoken": "good" } }'
+                       '{ "query": { "tokens": { "testposttoken": "good" } } }'
                ] );
                this.server.respondWith( 'POST', /api/, function ( request ) {
                        if ( request.requestBody.match( /token=good/ ) ) {
@@ -255,7 +313,7 @@
                } );
 
                assert.equal( this.server.requests.length, 2, 'Request made' );
-               assert.equal( this.server.requests[0].requestHeaders['X-Foo'], 'Bar', 'Header sent' );
+               assert.equal( this.server.requests[ 0 ].requestHeaders[ 'X-Foo' ], 'Bar', 'Header sent' );
        } );
 
        QUnit.test( 'postWithToken() - badtoken', function ( assert ) {
@@ -264,8 +322,8 @@
 
                this.server.respondWith( /type=testbadtoken/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
                        [
-                               '{ "tokens": { "testbadtokentoken": "bad" } }',
-                               '{ "tokens": { "testbadtokentoken": "good" } }'
+                               '{ "query": { "tokens": { "testbadtokentoken": "bad" } } }',
+                               '{ "query": { "tokens": { "testbadtokentoken": "good" } } }'
                        ]
                ) );
                this.server.respondWith( 'POST', /api/, function ( request ) {
@@ -298,8 +356,8 @@
 
                this.server.respondWith( /type=testonce/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
                        [
-                               '{ "tokens": { "testoncetoken": "good-A" } }',
-                               '{ "tokens": { "testoncetoken": "good-B" } }'
+                               '{ "query": { "tokens": { "testoncetoken": "good-A" } } }',
+                               '{ "query": { "tokens": { "testoncetoken": "good-B" } } }'
                        ]
                ) );
                sequenceA = sequenceBodies( 200, { 'Content-Type': 'application/json' },
@@ -333,4 +391,33 @@
                                assert.deepEqual( data, { example: { value: 'B' } } );
                        } );
        } );
-}( mediaWiki ) );
+
+       QUnit.module( 'mediawiki.api (2)', {
+               setup: function () {
+                       var self = this,
+                               requests = this.requests = [];
+                       this.api = new mw.Api();
+                       this.sandbox.stub( jQuery, 'ajax', function () {
+                               var request = $.extend( {
+                                       abort: self.sandbox.spy()
+                               }, $.Deferred() );
+                               requests.push( request );
+                               return request;
+                       } );
+               }
+       } );
+
+       QUnit.test( '#abort', 3, function ( assert ) {
+               this.api.get( {
+                       a: 1
+               } );
+               this.api.post( {
+                       b: 2
+               } );
+               this.api.abort();
+               assert.ok( this.requests.length === 2, 'Check both requests triggered' );
+               $.each( this.requests, function ( i, request ) {
+                       assert.ok( request.abort.calledOnce, 'abort request number ' + i );
+               } );
+       } );
+}( mediaWiki, jQuery ) );