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

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