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 bodies
.forEach( function ( body
, i
) {
22 bodies
[ i
] = [ status
, headers
, body
];
24 return sequence( bodies
);
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;
33 QUnit
.test( 'get()', function ( assert
) {
34 var api
= new mw
.Api();
36 this.server
.respond( [ 200, { 'Content-Type': 'application/json' }, '[]' ] );
38 return api
.get( {} ).then( function ( data
) {
39 assert
.deepEqual( data
, [], 'If request succeeds without errors, resolve deferred' );
43 QUnit
.test( 'post()', function ( assert
) {
44 var api
= new mw
.Api();
46 this.server
.respond( [ 200, { 'Content-Type': 'application/json' }, '[]' ] );
48 return api
.post( {} ).then( function ( data
) {
49 assert
.deepEqual( data
, [], 'Simple POST request' );
53 QUnit
.test( 'API error errorformat=bc', function ( assert
) {
54 var api
= new mw
.Api();
56 this.server
.respond( [ 200, { 'Content-Type': 'application/json' },
57 '{ "error": { "code": "unknown_action" } }'
60 api
.get( { action
: 'doesntexist' } )
61 .fail( function ( errorCode
) {
62 assert
.strictEqual( errorCode
, 'unknown_action', 'API error should reject the deferred' );
64 .always( assert
.async() );
67 QUnit
.test( 'API error errorformat!=bc', function ( assert
) {
68 var api
= new mw
.Api();
70 this.server
.respond( [ 200, { 'Content-Type': 'application/json' },
71 '{ "errors": [ { "code": "unknown_action", "key": "unknown-error", "params": [] } ] }'
74 api
.get( { action
: 'doesntexist' } )
75 .fail( function ( errorCode
) {
76 assert
.strictEqual( errorCode
, 'unknown_action', 'API error should reject the deferred' );
78 .always( assert
.async() );
81 QUnit
.test( 'FormData support', function ( assert
) {
82 var api
= new mw
.Api();
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' );
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' );
92 request
.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
95 return api
.post( { action
: 'test' }, { contentType
: 'multipart/form-data' } );
98 QUnit
.test( 'Converting arrays to pipe-separated (string)', function ( assert
) {
99 var api
= new mw
.Api();
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' }, '[]' );
106 return api
.get( { test
: [ 'foo', 'bar', 'baz' ] } );
109 QUnit
.test( 'Converting arrays to pipe-separated (mw.Title)', function ( assert
) {
110 var api
= new mw
.Api();
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' }, '[]' );
117 return api
.get( { test
: [ new mw
.Title( 'Foo' ), new mw
.Title( 'Bar' ) ] } );
120 QUnit
.test( 'Converting arrays to pipe-separated (misc primitives)', function ( assert
) {
121 var api
= new mw
.Api();
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' }, '[]' );
128 // undefined/null will become empty string
129 return api
.get( { test
: [ true, false, undefined, null, 0, 1.2 ] } );
132 QUnit
.test( 'Omitting false booleans', function ( assert
) {
133 var api
= new mw
.Api();
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' }, '[]' );
141 return api
.get( { foo
: false, bar
: true } );
144 QUnit
.test( 'getToken() - cached', function ( assert
) {
145 var api
= new mw
.Api(),
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' );
157 assert
.strictEqual( test
.server
.requests
.length
, 0, 'Requests made' );
161 QUnit
.test( 'getToken() - uncached', function ( assert
) {
162 var api
= new mw
.Api(),
163 firstDone
= assert
.async(),
164 secondDone
= assert
.async();
166 this.server
.respondWith( /type=testuncached/, [ 200, { 'Content-Type': 'application/json' },
167 '{ "query": { "tokens": { "testuncachedtoken": "good" } } }'
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' );
177 .fail( function ( err
) {
178 assert
.strictEqual( err
, '', 'API error' );
180 .always( firstDone
);
182 api
.getToken( 'testuncached' )
183 .done( function ( token
) {
184 assert
.strictEqual( token
, 'good', 'The cached token' );
186 .fail( function ( err
) {
187 assert
.strictEqual( err
, '', 'API error' );
189 .always( secondDone
);
191 assert
.strictEqual( this.server
.requests
.length
, 1, 'Requests made' );
194 QUnit
.test( 'getToken() - error', function ( assert
) {
195 var api
= new mw
.Api();
197 this.server
.respondWith( /type=testerror/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
199 '{ "error": { "code": "bite-me", "info": "Smite me, O Mighty Smiter" } }',
200 '{ "query": { "tokens": { "testerrortoken": "good" } } }'
204 // Don't cache error (T67268)
205 return api
.getToken( 'testerror' )
206 .catch( function ( err
) {
207 assert
.strictEqual( err
, 'bite-me', 'Expected error' );
209 return api
.getToken( 'testerror' );
211 .then( function ( token
) {
212 assert
.strictEqual( token
, 'good', 'The token' );
216 QUnit
.test( 'getToken() - no query', function ( assert
) {
217 var api
= new mw
.Api(),
218 // Same-origin warning and missing query in response.
222 '*': 'Tokens may not be obtained when the same-origin policy is not applied.'
227 this.server
.respondWith( /type=testnoquery/, [ 200, { 'Content-Type': 'application/json' },
228 JSON
.stringify( serverRsp
)
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
);
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' } } ),
244 this.server
.respondWith( /type=csrf/, [ 200, { 'Content-Type': 'application/json' },
245 '{ "query": { "tokens": { "csrftoken": "csrfgood" } } }'
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' );
253 .fail( function ( err
) {
254 assert
.strictEqual( err
, '', 'API error' );
256 .always( function () {
257 assert
.strictEqual( test
.server
.requests
.length
, 1, 'Requests made' );
261 QUnit
.test( 'badToken()', function ( assert
) {
262 var api
= new mw
.Api(),
265 this.server
.respondWith( /type=testbad/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
267 '{ "query": { "tokens": { "testbadtoken": "bad" } } }',
268 '{ "query": { "tokens": { "testbadtoken": "good" } } }'
272 return api
.getToken( 'testbad' )
274 api
.badToken( 'testbad' );
275 return api
.getToken( 'testbad' );
277 .then( function ( token
) {
278 assert
.strictEqual( token
, 'good', 'The token' );
279 assert
.strictEqual( test
.server
.requests
.length
, 2, 'Requests made' );
284 QUnit
.test( 'badToken( legacy )', function ( assert
) {
285 var api
= new mw
.Api( { ajax
: { url
: '/badTokenLegacy/api.php' } } ),
288 this.server
.respondWith( /type=csrf/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
290 '{ "query": { "tokens": { "csrftoken": "badlegacy" } } }',
291 '{ "query": { "tokens": { "csrftoken": "goodlegacy" } } }'
295 return api
.getToken( 'options' )
297 api
.badToken( 'options' );
298 return api
.getToken( 'options' );
300 .then( function ( token
) {
301 assert
.strictEqual( token
, 'goodlegacy', 'The token' );
302 assert
.strictEqual( test
.server
.requests
.length
, 2, 'Request made' );
307 QUnit
.test( 'postWithToken( tokenType, params )', function ( assert
) {
308 var api
= new mw
.Api( { ajax
: { url
: '/postWithToken/api.php' } } );
310 this.server
.respondWith( 'GET', /type=testpost/, [ 200, { 'Content-Type': 'application/json' },
311 '{ "query": { "tokens": { "testposttoken": "good" } } }'
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" } }'
321 return api
.postWithToken( 'testpost', { action
: 'example', key
: 'foo' } )
322 .then( function ( data
) {
323 assert
.deepEqual( data
, { example
: { foo
: 'quux' } } );
327 QUnit
.test( 'postWithToken( tokenType, params with assert )', function ( assert
) {
328 var api
= new mw
.Api( { ajax
: { url
: '/postWithToken/api.php' } } ),
331 this.server
.respondWith( /assert=user/, [ 200, { 'Content-Type': 'application/json' },
332 '{ "error": { "code": "assertuserfailed", "info": "Assertion failed" } }'
335 return api
.postWithToken( 'testassertpost', { action
: 'example', key
: 'foo', assert
: 'user' } )
336 // Cast error to success and vice versa
338 return $.Deferred().reject( 'Unexpected success' );
339 }, function ( errorCode
) {
340 assert
.strictEqual( errorCode
, 'assertuserfailed', 'getToken fails assert' );
341 return $.Deferred().resolve();
344 assert
.strictEqual( test
.server
.requests
.length
, 1, 'Requests made' );
348 QUnit
.test( 'postWithToken( tokenType, params, ajaxOptions )', function ( assert
) {
349 var api
= new mw
.Api(),
352 this.server
.respond( [ 200, { 'Content-Type': 'application/json' }, '{ "example": "quux" }' ] );
354 return api
.postWithToken( 'csrf',
355 { action
: 'example' },
361 ).then( function () {
362 assert
.strictEqual( test
.server
.requests
[ 0 ].requestHeaders
[ 'X-Foo' ], 'Bar', 'Header sent' );
364 return api
.postWithToken( 'csrf',
365 { action
: 'example' },
367 assert
.ok( false, 'This parameter cannot be a callback' );
370 } ).then( function ( data
) {
371 assert
.strictEqual( data
.example
, 'quux' );
373 assert
.strictEqual( test
.server
.requests
.length
, 2, 'Request made' );
377 QUnit
.test( 'postWithToken() - badtoken', function ( assert
) {
378 var api
= new mw
.Api();
380 this.server
.respondWith( /type=testbadtoken/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
382 '{ "query": { "tokens": { "testbadtokentoken": "bad" } } }',
383 '{ "query": { "tokens": { "testbadtokentoken": "good" } } }'
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" } }'
392 if ( request
.requestBody
.match( /token=good/ ) ) {
393 request
.respond( 200, { 'Content-Type': 'application/json' },
394 '{ "example": { "foo": "quux" } }'
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' } } );
409 QUnit
.test( 'postWithToken() - badtoken-cached', function ( assert
) {
413 this.server
.respondWith( /type=testonce/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
415 '{ "query": { "tokens": { "testoncetoken": "good-A" } } }',
416 '{ "query": { "tokens": { "testoncetoken": "good-B" } } }'
419 sequenceA
= sequenceBodies( 200, { 'Content-Type': 'application/json' },
421 '{ "example": { "value": "A" } }',
422 '{ "error": { "code": "badtoken" } }'
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" } }'
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' } } );
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' } );
446 .then( function ( data
) {
447 assert
.deepEqual( data
, { example
: { value
: 'B' } } );
451 QUnit
.module( 'mediawiki.api (2)', {
452 beforeEach: function () {
454 requests
= this.requests
= [];
455 this.api
= new mw
.Api();
456 this.sandbox
.stub( jQuery
, 'ajax', function () {
457 var request
= $.extend( {
458 abort
: self
.sandbox
.spy()
460 requests
.push( request
);
466 QUnit
.test( '#abort', function ( assert
) {
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
);
479 }( mediaWiki
, jQuery
) );