2 QUnit
.module( 'mediawiki.api', QUnit
.newMwEnvironment( {
4 this.server
= this.sandbox
.useFakeServer();
5 this.server
.respondImmediately
= true;
9 function sequence( responses
) {
11 return function ( request
) {
12 var response
= responses
[ i
];
15 request
.respond
.apply( request
, response
);
20 function sequenceBodies( status
, headers
, bodies
) {
21 jQuery
.each( bodies
, function ( i
, body
) {
22 bodies
[ i
] = [ status
, headers
, body
];
24 return sequence( bodies
);
27 QUnit
.test( 'get()', function ( assert
) {
28 var api
= new mw
.Api();
30 this.server
.respond( [ 200, { 'Content-Type': 'application/json' }, '[]' ] );
32 return api
.get( {} ).then( function ( data
) {
33 assert
.deepEqual( data
, [], 'If request succeeds without errors, resolve deferred' );
37 QUnit
.test( 'post()', function ( assert
) {
38 var api
= new mw
.Api();
40 this.server
.respond( [ 200, { 'Content-Type': 'application/json' }, '[]' ] );
42 return api
.post( {} ).then( function ( data
) {
43 assert
.deepEqual( data
, [], 'Simple POST request' );
47 QUnit
.test( 'API error errorformat=bc', function ( assert
) {
48 var api
= new mw
.Api();
50 this.server
.respond( [ 200, { 'Content-Type': 'application/json' },
51 '{ "error": { "code": "unknown_action" } }'
54 api
.get( { action
: 'doesntexist' } )
55 .fail( function ( errorCode
) {
56 assert
.equal( errorCode
, 'unknown_action', 'API error should reject the deferred' );
58 .always( assert
.async() );
61 QUnit
.test( 'API error errorformat!=bc', function ( assert
) {
62 var api
= new mw
.Api();
64 this.server
.respond( [ 200, { 'Content-Type': 'application/json' },
65 '{ "errors": [ { "code": "unknown_action", "key": "unknown-error", "params": [] } ] }'
68 api
.get( { action
: 'doesntexist' } )
69 .fail( function ( errorCode
) {
70 assert
.equal( errorCode
, 'unknown_action', 'API error should reject the deferred' );
72 .always( assert
.async() );
75 QUnit
.test( 'FormData support', function ( assert
) {
76 var api
= new mw
.Api();
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' );
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' );
86 request
.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
89 return api
.post( { action
: 'test' }, { contentType
: 'multipart/form-data' } );
92 QUnit
.test( 'Converting arrays to pipe-separated (string)', function ( assert
) {
93 var api
= new mw
.Api();
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' }, '[]' );
100 return api
.get( { test
: [ 'foo', 'bar', 'baz' ] } );
103 QUnit
.test( 'Converting arrays to pipe-separated (mw.Title)', function ( assert
) {
104 var api
= new mw
.Api();
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' }, '[]' );
111 return api
.get( { test
: [ new mw
.Title( 'Foo' ), new mw
.Title( 'Bar' ) ] } );
114 QUnit
.test( 'Converting arrays to pipe-separated (misc primitives)', function ( assert
) {
115 var api
= new mw
.Api();
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' }, '[]' );
122 // undefined/null will become empty string
123 return api
.get( { test
: [ true, false, undefined, null, 0, 1.2 ] } );
126 QUnit
.test( 'Omitting false booleans', function ( assert
) {
127 var api
= new mw
.Api();
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' }, '[]' );
135 return api
.get( { foo
: false, bar
: true } );
138 QUnit
.test( 'getToken() - cached', function ( assert
) {
139 var api
= new mw
.Api(),
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' );
151 assert
.equal( test
.server
.requests
.length
, 0, 'Requests made' );
155 QUnit
.test( 'getToken() - uncached', function ( assert
) {
156 var api
= new mw
.Api(),
157 firstDone
= assert
.async(),
158 secondDone
= assert
.async();
160 this.server
.respondWith( /type=testuncached/, [ 200, { 'Content-Type': 'application/json' },
161 '{ "query": { "tokens": { "testuncachedtoken": "good" } } }'
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' );
171 .fail( function ( err
) {
172 assert
.equal( err
, '', 'API error' );
174 .always( firstDone
);
176 api
.getToken( 'testuncached' )
177 .done( function ( token
) {
178 assert
.equal( token
, 'good', 'The cached token' );
180 .fail( function ( err
) {
181 assert
.equal( err
, '', 'API error' );
183 .always( secondDone
);
185 assert
.equal( this.server
.requests
.length
, 1, 'Requests made' );
188 QUnit
.test( 'getToken() - error', function ( assert
) {
189 var api
= new mw
.Api();
191 this.server
.respondWith( /type=testerror/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
193 '{ "error": { "code": "bite-me", "info": "Smite me, O Mighty Smiter" } }',
194 '{ "query": { "tokens": { "testerrortoken": "good" } } }'
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' );
203 return api
.getToken( 'testerror' );
205 .then( function ( token
) {
206 assert
.equal( token
, 'good', 'The token' );
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' } } ),
215 this.server
.respondWith( /type=csrf/, [ 200, { 'Content-Type': 'application/json' },
216 '{ "query": { "tokens": { "csrftoken": "csrfgood" } } }'
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' );
224 .fail( function ( err
) {
225 assert
.equal( err
, '', 'API error' );
227 .always( function () {
228 assert
.equal( test
.server
.requests
.length
, 1, 'Requests made' );
232 QUnit
.test( 'badToken()', function ( assert
) {
233 var api
= new mw
.Api(),
236 this.server
.respondWith( /type=testbad/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
238 '{ "query": { "tokens": { "testbadtoken": "bad" } } }',
239 '{ "query": { "tokens": { "testbadtoken": "good" } } }'
243 return api
.getToken( 'testbad' )
245 api
.badToken( 'testbad' );
246 return api
.getToken( 'testbad' );
248 .then( function ( token
) {
249 assert
.equal( token
, 'good', 'The token' );
250 assert
.equal( test
.server
.requests
.length
, 2, 'Requests made' );
255 QUnit
.test( 'badToken( legacy )', function ( assert
) {
256 var api
= new mw
.Api( { ajax
: { url
: '/badTokenLegacy/api.php' } } ),
259 this.server
.respondWith( /type=csrf/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
261 '{ "query": { "tokens": { "csrftoken": "badlegacy" } } }',
262 '{ "query": { "tokens": { "csrftoken": "goodlegacy" } } }'
266 return api
.getToken( 'options' )
268 api
.badToken( 'options' );
269 return api
.getToken( 'options' );
271 .then( function ( token
) {
272 assert
.equal( token
, 'goodlegacy', 'The token' );
273 assert
.equal( test
.server
.requests
.length
, 2, 'Request made' );
278 QUnit
.test( 'postWithToken( tokenType, params )', function ( assert
) {
279 var api
= new mw
.Api( { ajax
: { url
: '/postWithToken/api.php' } } );
281 this.server
.respondWith( 'GET', /type=testpost/, [ 200, { 'Content-Type': 'application/json' },
282 '{ "query": { "tokens": { "testposttoken": "good" } } }'
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" } }'
292 return api
.postWithToken( 'testpost', { action
: 'example', key
: 'foo' } )
293 .then( function ( data
) {
294 assert
.deepEqual( data
, { example
: { foo
: 'quux' } } );
298 QUnit
.test( 'postWithToken( tokenType, params with assert )', function ( assert
) {
299 var api
= new mw
.Api( { ajax
: { url
: '/postWithToken/api.php' } } ),
302 this.server
.respondWith( /assert=user/, [ 200, { 'Content-Type': 'application/json' },
303 '{ "error": { "code": "assertuserfailed", "info": "Assertion failed" } }'
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();
315 assert
.equal( test
.server
.requests
.length
, 1, 'Requests made' );
319 QUnit
.test( 'postWithToken( tokenType, params, ajaxOptions )', function ( assert
) {
320 var api
= new mw
.Api(),
323 this.server
.respond( [ 200, { 'Content-Type': 'application/json' }, '{ "example": "quux" }' ] );
325 return api
.postWithToken( 'csrf',
326 { action
: 'example' },
334 assert
.equal( test
.server
.requests
[ 0 ].requestHeaders
[ 'X-Foo' ], 'Bar', 'Header sent' );
336 return api
.postWithToken( 'csrf',
337 { action
: 'example' },
339 assert
.ok( false, 'This parameter cannot be a callback' );
343 .then( function ( data
) {
344 assert
.equal( data
.example
, 'quux' );
346 assert
.equal( test
.server
.requests
.length
, 2, 'Request made' );
350 QUnit
.test( 'postWithToken() - badtoken', function ( assert
) {
351 var api
= new mw
.Api();
353 this.server
.respondWith( /type=testbadtoken/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
355 '{ "query": { "tokens": { "testbadtokentoken": "bad" } } }',
356 '{ "query": { "tokens": { "testbadtokentoken": "good" } } }'
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" } }'
365 if ( request
.requestBody
.match( /token=good/ ) ) {
366 request
.respond( 200, { 'Content-Type': 'application/json' },
367 '{ "example": { "foo": "quux" } }'
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' } } );
382 QUnit
.test( 'postWithToken() - badtoken-cached', function ( assert
) {
386 this.server
.respondWith( /type=testonce/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
388 '{ "query": { "tokens": { "testoncetoken": "good-A" } } }',
389 '{ "query": { "tokens": { "testoncetoken": "good-B" } } }'
392 sequenceA
= sequenceBodies( 200, { 'Content-Type': 'application/json' },
394 '{ "example": { "value": "A" } }',
395 '{ "error": { "code": "badtoken" } }'
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" } }'
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' } } );
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' } );
419 .then( function ( data
) {
420 assert
.deepEqual( data
, { example
: { value
: 'B' } } );
424 QUnit
.module( 'mediawiki.api (2)', {
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()
433 requests
.push( request
);
439 QUnit
.test( '#abort', 3, function ( assert
) {
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
);
452 }( mediaWiki
, jQuery
) );