tests/qunit/suites/resources/mediawiki.api/mediawiki.api.test.js

   1 ( function ( mw, $ ) {
   2         QUnit.module( 'mediawiki.api', QUnit.newMwEnvironment( {
   3                 setup: function () {
   4                         this.server = this.sandbox.useFakeServer();
   5                         this.server.respondImmediately = true;
   6                 }
   7         } ) );
   8
   9         function sequence( responses ) {
  10                 var i = 0;
  11                 return function ( request ) {
  12                         var response = responses[ i ];
  13                         if ( response ) {
  14                                 i++;
  15                                 request.respond.apply( request, response );
  16                         }
  17                 };
  18         }
  19
  20         function sequenceBodies( status, headers, bodies ) {
  21                 jQuery.each( bodies, function ( i, body ) {
  22                         bodies[ i ] = [ status, headers, body ];
  23                 } );
  24                 return sequence( bodies );
  25         }
  26
  27         QUnit.test( 'get()', function ( assert ) {
  28                 var api = new mw.Api();
  29
  30                 this.server.respond( [ 200, { 'Content-Type': 'application/json' }, '[]' ] );
  31
  32                 return api.get( {} ).then( function ( data ) {
  33                         assert.deepEqual( data, [], 'If request succeeds without errors, resolve deferred' );
  34                 } );
  35         } );
  36
  37         QUnit.test( 'post()', function ( assert ) {
  38                 var api = new mw.Api();
  39
  40                 this.server.respond( [ 200, { 'Content-Type': 'application/json' }, '[]' ] );
  41
  42                 return api.post( {} ).then( function ( data ) {
  43                         assert.deepEqual( data, [], 'Simple POST request' );
  44                 } );
  45         } );
  46
  47         QUnit.test( 'API error errorformat=bc', function ( assert ) {
  48                 var api = new mw.Api();
  49
  50                 this.server.respond( [ 200, { 'Content-Type': 'application/json' },
  51                         '{ "error": { "code": "unknown_action" } }'
  52                 ] );
  53
  54                 api.get( { action: 'doesntexist' } )
  55                         .fail( function ( errorCode ) {
  56                                 assert.equal( errorCode, 'unknown_action', 'API error should reject the deferred' );
  57                         } )
  58                         .always( assert.async() );
  59         } );
  60
  61         QUnit.test( 'API error errorformat!=bc', function ( assert ) {
  62                 var api = new mw.Api();
  63
  64                 this.server.respond( [ 200, { 'Content-Type': 'application/json' },
  65                         '{ "errors": [ { "code": "unknown_action", "key": "unknown-error", "params": [] } ] }'
  66                 ] );
  67
  68                 api.get( { action: 'doesntexist' } )
  69                         .fail( function ( errorCode ) {
  70                                 assert.equal( errorCode, 'unknown_action', 'API error should reject the deferred' );
  71                         } )
  72                         .always( assert.async() );
  73         } );
  74
  75         QUnit.test( 'FormData support', function ( assert ) {
  76                 var api = new mw.Api();
  77
  78                 this.server.respond( function ( request ) {
  79                         if ( window.FormData ) {
  80                                 assert.ok( !request.url.match( /action=/ ), 'Request has no query string' );
  81                                 assert.ok( request.requestBody instanceof FormData, 'Request uses FormData body' );
  82                         } else {
  83                                 assert.ok( !request.url.match( /action=test/ ), 'Request has no query string' );
  84                                 assert.equal( request.requestBody, 'action=test&format=json', 'Request uses query string body' );
  85                         }
  86                         request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
  87                 } );
  88
  89                 return api.post( { action: 'test' }, { contentType: 'multipart/form-data' } );
  90         } );
  91
  92         QUnit.test( 'Converting arrays to pipe-separated (string)', function ( assert ) {
  93                 var api = new mw.Api();
  94
  95                 this.server.respond( function ( request ) {
  96                         assert.ok( request.url.match( /test=foo%7Cbar%7Cbaz/ ), 'Pipe-separated value was submitted' );
  97                         request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
  98                 } );
  99
 100                 return api.get( { test: [ 'foo', 'bar', 'baz' ] } );
 101         } );
 102
 103         QUnit.test( 'Converting arrays to pipe-separated (mw.Title)', function ( assert ) {
 104                 var api = new mw.Api();
 105
 106                 this.server.respond( function ( request ) {
 107                         assert.ok( request.url.match( /test=Foo%7CBar/ ), 'Pipe-separated value was submitted' );
 108                         request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
 109                 } );
 110
 111                 return api.get( { test: [ new mw.Title( 'Foo' ), new mw.Title( 'Bar' ) ] } );
 112         } );
 113
 114         QUnit.test( 'Converting arrays to pipe-separated (misc primitives)', function ( assert ) {
 115                 var api = new mw.Api();
 116
 117                 this.server.respond( function ( request ) {
 118                         assert.ok( request.url.match( /test=true%7Cfalse%7C%7C%7C0%7C1%2E2/ ), 'Pipe-separated value was submitted: ' + request.url );
 119                         request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
 120                 } );
 121
 122                 // undefined/null will become empty string
 123                 return api.get( { test: [ true, false, undefined, null, 0, 1.2 ] } );
 124         } );
 125
 126         QUnit.test( 'Omitting false booleans', function ( assert ) {
 127                 var api = new mw.Api();
 128
 129                 this.server.respond( function ( request ) {
 130                         assert.ok( !request.url.match( /foo/ ), 'foo query parameter is not present' );
 131                         assert.ok( request.url.match( /bar=true/ ), 'bar query parameter is present with value true' );
 132                         request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
 133                 } );
 134
 135                 return api.get( { foo: false, bar: true } );
 136         } );
 137
 138         QUnit.test( 'getToken() - cached', function ( assert ) {
 139                 var api = new mw.Api(),
 140                         test = this;
 141
 142                 // Get csrfToken for local wiki, this should not make
 143                 // a request as it should be retrieved from mw.user.tokens.
 144                 return api.getToken( 'csrf' )
 145                         .then( function ( token ) {
 146                                 assert.ok( token.length, 'Got a token' );
 147                         }, function ( err ) {
 148                                 assert.equal( '', err, 'API error' );
 149                         } )
 150                         .then( function () {
 151                                 assert.equal( test.server.requests.length, 0, 'Requests made' );
 152                         } );
 153         } );
 154
 155         QUnit.test( 'getToken() - uncached', function ( assert ) {
 156                 var api = new mw.Api(),
 157                         firstDone = assert.async(),
 158                         secondDone = assert.async();
 159
 160                 this.server.respondWith( /type=testuncached/, [ 200, { 'Content-Type': 'application/json' },
 161                         '{ "query": { "tokens": { "testuncachedtoken": "good" } } }'
 162                 ] );
 163
 164                 // Get a token of a type that isn't prepopulated by user.tokens.
 165                 // Could use "block" or "delete" here, but those could in theory
 166                 // be added to user.tokens, use a fake one instead.
 167                 api.getToken( 'testuncached' )
 168                         .done( function ( token ) {
 169                                 assert.equal( token, 'good', 'The token' );
 170                         } )
 171                         .fail( function ( err ) {
 172                                 assert.equal( err, '', 'API error' );
 173                         } )
 174                         .always( firstDone );
 175
 176                 api.getToken( 'testuncached' )
 177                         .done( function ( token ) {
 178                                 assert.equal( token, 'good', 'The cached token' );
 179                         } )
 180                         .fail( function ( err ) {
 181                                 assert.equal( err, '', 'API error' );
 182                         } )
 183                         .always( secondDone );
 184
 185                 assert.equal( this.server.requests.length, 1, 'Requests made' );
 186         } );
 187
 188         QUnit.test( 'getToken() - error', function ( assert ) {
 189                 var api = new mw.Api();
 190
 191                 this.server.respondWith( /type=testerror/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
 192                         [
 193                                 '{ "error": { "code": "bite-me", "info": "Smite me, O Mighty Smiter" } }',
 194                                 '{ "query": { "tokens": { "testerrortoken": "good" } } }'
 195                         ]
 196                 ) );
 197
 198                 // Don't cache error (bug 65268)
 199                 return api.getToken( 'testerror' )
 200                         .then( null, function ( err ) {
 201                                 assert.equal( err, 'bite-me', 'Expected error' );
 202
 203                                 return api.getToken( 'testerror' );
 204                         } )
 205                         .then( function ( token ) {
 206                                 assert.equal( token, 'good', 'The token' );
 207                         } );
 208         } );
 209
 210         QUnit.test( 'getToken() - deprecated', function ( assert ) {
 211                 // Cache API endpoint from default to avoid cachehit in mw.user.tokens
 212                 var api = new mw.Api( { ajax: { url: '/postWithToken/api.php' } } ),
 213                         test = this;
 214
 215                 this.server.respondWith( /type=csrf/, [ 200, { 'Content-Type': 'application/json' },
 216                         '{ "query": { "tokens": { "csrftoken": "csrfgood" } } }'
 217                 ] );
 218
 219                 // Get a token of a type that is in the legacy map.
 220                 return api.getToken( 'email' )
 221                         .done( function ( token ) {
 222                                 assert.equal( token, 'csrfgood', 'Token' );
 223                         } )
 224                         .fail( function ( err ) {
 225                                 assert.equal( err, '', 'API error' );
 226                         } )
 227                         .always( function () {
 228                                 assert.equal( test.server.requests.length, 1, 'Requests made' );
 229                         } );
 230         } );
 231
 232         QUnit.test( 'badToken()', function ( assert ) {
 233                 var api = new mw.Api(),
 234                         test = this;
 235
 236                 this.server.respondWith( /type=testbad/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
 237                         [
 238                                 '{ "query": { "tokens": { "testbadtoken": "bad" } } }',
 239                                 '{ "query": { "tokens": { "testbadtoken": "good" } } }'
 240                         ]
 241                 ) );
 242
 243                 return api.getToken( 'testbad' )
 244                         .then( function () {
 245                                 api.badToken( 'testbad' );
 246                                 return api.getToken( 'testbad' );
 247                         } )
 248                         .then( function ( token ) {
 249                                 assert.equal( token, 'good', 'The token' );
 250                                 assert.equal( test.server.requests.length, 2, 'Requests made' );
 251                         } );
 252
 253         } );
 254
 255         QUnit.test( 'badToken( legacy )', function ( assert ) {
 256                 var api = new mw.Api( { ajax: { url: '/badTokenLegacy/api.php' } } ),
 257                         test = this;
 258
 259                 this.server.respondWith( /type=csrf/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
 260                         [
 261                                 '{ "query": { "tokens": { "csrftoken": "badlegacy" } } }',
 262                                 '{ "query": { "tokens": { "csrftoken": "goodlegacy" } } }'
 263                         ]
 264                 ) );
 265
 266                 return api.getToken( 'options' )
 267                         .then( function () {
 268                                 api.badToken( 'options' );
 269                                 return api.getToken( 'options' );
 270                         } )
 271                         .then( function ( token ) {
 272                                 assert.equal( token, 'goodlegacy', 'The token' );
 273                                 assert.equal( test.server.requests.length, 2, 'Request made' );
 274                         } );
 275
 276         } );
 277
 278         QUnit.test( 'postWithToken( tokenType, params )', function ( assert ) {
 279                 var api = new mw.Api( { ajax: { url: '/postWithToken/api.php' } } );
 280
 281                 this.server.respondWith( 'GET', /type=testpost/, [ 200, { 'Content-Type': 'application/json' },
 282                         '{ "query": { "tokens": { "testposttoken": "good" } } }'
 283                 ] );
 284                 this.server.respondWith( 'POST', /api/, function ( request ) {
 285                         if ( request.requestBody.match( /token=good/ ) ) {
 286                                 request.respond( 200, { 'Content-Type': 'application/json' },
 287                                         '{ "example": { "foo": "quux" } }'
 288                                 );
 289                         }
 290                 } );
 291
 292                 return api.postWithToken( 'testpost', { action: 'example', key: 'foo' } )
 293                         .then( function ( data ) {
 294                                 assert.deepEqual( data, { example: { foo: 'quux' } } );
 295                         } );
 296         } );
 297
 298         QUnit.test( 'postWithToken( tokenType, params with assert )', function ( assert ) {
 299                 var api = new mw.Api( { ajax: { url: '/postWithToken/api.php' } } ),
 300                         test = this;
 301
 302                 this.server.respondWith( /assert=user/, [ 200, { 'Content-Type': 'application/json' },
 303                         '{ "error": { "code": "assertuserfailed", "info": "Assertion failed" } }'
 304                 ] );
 305
 306                 return api.postWithToken( 'testassertpost', { action: 'example', key: 'foo', assert: 'user' } )
 307                         // Cast error to success and vice versa
 308                         .then( function ( ) {
 309                                 return $.Deferred().reject( 'Unexpected success' );
 310                         }, function ( errorCode ) {
 311                                 assert.equal( errorCode, 'assertuserfailed', 'getToken fails assert' );
 312                                 return $.Deferred().resolve();
 313                         } )
 314                         .then( function () {
 315                                 assert.equal( test.server.requests.length, 1, 'Requests made' );
 316                         } );
 317         } );
 318
 319         QUnit.test( 'postWithToken( tokenType, params, ajaxOptions )', function ( assert ) {
 320                 var api = new mw.Api(),
 321                         test = this;
 322
 323                 this.server.respond( [ 200, { 'Content-Type': 'application/json' }, '{ "example": "quux" }' ] );
 324
 325                 return api.postWithToken( 'csrf',
 326                                 { action: 'example' },
 327                                 {
 328                                         headers: {
 329                                                 'X-Foo': 'Bar'
 330                                         }
 331                                 }
 332                         )
 333                         .then( function () {
 334                                 assert.equal( test.server.requests[ 0 ].requestHeaders[ 'X-Foo' ], 'Bar', 'Header sent' );
 335
 336                                 return api.postWithToken( 'csrf',
 337                                         { action: 'example' },
 338                                         function () {
 339                                                 assert.ok( false, 'This parameter cannot be a callback' );
 340                                         }
 341                                 );
 342                         } )
 343                         .then( function ( data ) {
 344                                 assert.equal( data.example, 'quux' );
 345
 346                                 assert.equal( test.server.requests.length, 2, 'Request made' );
 347                         } );
 348         } );
 349
 350         QUnit.test( 'postWithToken() - badtoken', function ( assert ) {
 351                 var api = new mw.Api();
 352
 353                 this.server.respondWith( /type=testbadtoken/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
 354                         [
 355                                 '{ "query": { "tokens": { "testbadtokentoken": "bad" } } }',
 356                                 '{ "query": { "tokens": { "testbadtokentoken": "good" } } }'
 357                         ]
 358                 ) );
 359                 this.server.respondWith( 'POST', /api/, function ( request ) {
 360                         if ( request.requestBody.match( /token=bad/ ) ) {
 361                                 request.respond( 200, { 'Content-Type': 'application/json' },
 362                                         '{ "error": { "code": "badtoken" } }'
 363                                 );
 364                         }
 365                         if ( request.requestBody.match( /token=good/ ) ) {
 366                                 request.respond( 200, { 'Content-Type': 'application/json' },
 367                                         '{ "example": { "foo": "quux" } }'
 368                                 );
 369                         }
 370                 } );
 371
 372                 // - Request: new token -> bad
 373                 // - Request: action=example -> badtoken error
 374                 // - Request: new token -> good
 375                 // - Request: action=example -> success
 376                 return api.postWithToken( 'testbadtoken', { action: 'example', key: 'foo' } )
 377                         .then( function ( data ) {
 378                                 assert.deepEqual( data, { example: { foo: 'quux' } } );
 379                         } );
 380         } );
 381
 382         QUnit.test( 'postWithToken() - badtoken-cached', function ( assert ) {
 383                 var sequenceA,
 384                         api = new mw.Api();
 385
 386                 this.server.respondWith( /type=testonce/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
 387                         [
 388                                 '{ "query": { "tokens": { "testoncetoken": "good-A" } } }',
 389                                 '{ "query": { "tokens": { "testoncetoken": "good-B" } } }'
 390                         ]
 391                 ) );
 392                 sequenceA = sequenceBodies( 200, { 'Content-Type': 'application/json' },
 393                         [
 394                                 '{ "example": { "value": "A" } }',
 395                                 '{ "error": { "code": "badtoken" } }'
 396                         ]
 397                 );
 398                 this.server.respondWith( 'POST', /api/, function ( request ) {
 399                         if ( request.requestBody.match( /token=good-A/ ) ) {
 400                                 sequenceA( request );
 401                         } else if ( request.requestBody.match( /token=good-B/ ) ) {
 402                                 request.respond( 200, { 'Content-Type': 'application/json' },
 403                                         '{ "example": { "value": "B" } }'
 404                                 );
 405                         }
 406                 } );
 407
 408                 // - Request: new token -> A
 409                 // - Request: action=example
 410                 return api.postWithToken( 'testonce', { action: 'example', key: 'foo' } )
 411                         .then( function ( data ) {
 412                                 assert.deepEqual( data, { example: { value: 'A' } } );
 413
 414                                 // - Request: action=example w/ token A -> badtoken error
 415                                 // - Request: new token -> B
 416                                 // - Request: action=example w/ token B -> success
 417                                 return api.postWithToken( 'testonce', { action: 'example', key: 'bar' } );
 418                         } )
 419                         .then( function ( data ) {
 420                                 assert.deepEqual( data, { example: { value: 'B' } } );
 421                         } );
 422         } );
 423
 424         QUnit.module( 'mediawiki.api (2)', {
 425                 setup: function () {
 426                         var self = this,
 427                                 requests = this.requests = [];
 428                         this.api = new mw.Api();
 429                         this.sandbox.stub( jQuery, 'ajax', function () {
 430                                 var request = $.extend( {
 431                                         abort: self.sandbox.spy()
 432                                 }, $.Deferred() );
 433                                 requests.push( request );
 434                                 return request;
 435                         } );
 436                 }
 437         } );
 438
 439         QUnit.test( '#abort', 3, function ( assert ) {
 440                 this.api.get( {
 441                         a: 1
 442                 } );
 443                 this.api.post( {
 444                         b: 2
 445                 } );
 446                 this.api.abort();
 447                 assert.ok( this.requests.length === 2, 'Check both requests triggered' );
 448                 $.each( this.requests, function ( i, request ) {
 449                         assert.ok( request.abort.calledOnce, 'abort request number ' + i );
 450                 } );
 451         } );
 452 }( mediaWiki, jQuery ) );