2 QUnit
.module( 'mediawiki.api', QUnit
.newMwEnvironment( {
4 this.server
= this.sandbox
.useFakeServer();
5 this.server
.respondImmediately
= true;
6 this.clock
= this.sandbox
.useFakeTimers();
8 teardown: function () {
9 // https://github.com/jquery/jquery/issues/2453
14 function sequence( responses
) {
16 return function ( request
) {
17 var response
= responses
[i
];
20 request
.respond
.apply( request
, response
);
25 function sequenceBodies( status
, headers
, bodies
) {
26 jQuery
.each( bodies
, function ( i
, body
) {
27 bodies
[i
] = [ status
, headers
, body
];
29 return sequence( bodies
);
32 QUnit
.test( 'Basic functionality', function ( assert
) {
34 var api
= new mw
.Api();
36 this.server
.respond( [ 200, { 'Content-Type': 'application/json' }, '[]' ] );
39 .done( function ( data
) {
40 assert
.deepEqual( data
, [], 'If request succeeds without errors, resolve deferred' );
44 .done( function ( data
) {
45 assert
.deepEqual( data
, [], 'Simple POST request' );
49 QUnit
.test( 'API error', function ( assert
) {
51 var api
= new mw
.Api();
53 this.server
.respond( [ 200, { 'Content-Type': 'application/json' },
54 '{ "error": { "code": "unknown_action" } }'
57 api
.get( { action
: 'doesntexist' } )
58 .fail( function ( errorCode
) {
59 assert
.equal( errorCode
, 'unknown_action', 'API error should reject the deferred' );
63 QUnit
.test( 'FormData support', function ( assert
) {
65 var api
= new mw
.Api();
67 this.server
.respond( function ( request
) {
68 if ( window
.FormData
) {
69 assert
.ok( !request
.url
.match( /action=/ ), 'Request has no query string' );
70 assert
.ok( request
.requestBody
instanceof FormData
, 'Request uses FormData body' );
72 assert
.ok( !request
.url
.match( /action=test/ ), 'Request has no query string' );
73 assert
.equal( request
.requestBody
, 'action=test&format=json', 'Request uses query string body' );
75 request
.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
78 api
.post( { action
: 'test' }, { contentType
: 'multipart/form-data' } );
81 QUnit
.test( 'Converting arrays to pipe-separated', function ( assert
) {
83 var api
= new mw
.Api();
85 this.server
.respond( function ( request
) {
86 assert
.ok( request
.url
.match( /test=foo%7Cbar%7Cbaz/ ), 'Pipe-separated value was submitted' );
87 request
.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
90 api
.get( { test
: [ 'foo', 'bar', 'baz' ] } );
93 QUnit
.test( 'Omitting false booleans', function ( assert
) {
95 var api
= new mw
.Api();
97 this.server
.respond( function ( request
) {
98 assert
.ok( !request
.url
.match( /foo/ ), 'foo query parameter is not present' );
99 assert
.ok( request
.url
.match( /bar=true/ ), 'bar query parameter is present with value true' );
100 request
.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
103 api
.get( { foo
: false, bar
: true } );
106 QUnit
.test( 'getToken() - cached', function ( assert
) {
108 var api
= new mw
.Api();
110 // Get editToken for local wiki, this should not make
111 // a request as it should be retrieved from mw.user.tokens.
112 api
.getToken( 'edit' )
113 .done( function ( token
) {
114 assert
.ok( token
.length
, 'Got a token' );
116 .fail( function ( err
) {
117 assert
.equal( '', err
, 'API error' );
120 assert
.equal( this.server
.requests
.length
, 0, 'Requests made' );
123 QUnit
.test( 'getToken() - uncached', function ( assert
) {
125 var api
= new mw
.Api();
127 this.server
.respondWith( /type=testuncached/, [ 200, { 'Content-Type': 'application/json' },
128 '{ "tokens": { "testuncachedtoken": "good" } }'
131 // Get a token of a type that isn't prepopulated by user.tokens.
132 // Could use "block" or "delete" here, but those could in theory
133 // be added to user.tokens, use a fake one instead.
134 api
.getToken( 'testuncached' )
135 .done( function ( token
) {
136 assert
.equal( token
, 'good', 'The token' );
138 .fail( function ( err
) {
139 assert
.equal( err
, '', 'API error' );
142 api
.getToken( 'testuncached' )
143 .done( function ( token
) {
144 assert
.equal( token
, 'good', 'The cached token' );
146 .fail( function ( err
) {
147 assert
.equal( err
, '', 'API error' );
150 assert
.equal( this.server
.requests
.length
, 1, 'Requests made' );
153 QUnit
.test( 'getToken() - error', function ( assert
) {
155 var api
= new mw
.Api();
157 this.server
.respondWith( /type=testerror/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
159 '{ "error": { "code": "bite-me", "info": "Smite me, O Mighty Smiter" } }',
160 '{ "tokens": { "testerrortoken": "good" } }'
164 // Don't cache error (bug 65268)
165 api
.getToken( 'testerror' ).fail( function ( err
) {
166 assert
.equal( err
, 'bite-me', 'Expected error' );
168 // Make this request after the first one has finished.
169 // If we make it simultaneously we still want it to share
170 // the cache, but as soon as it is fulfilled as error we
171 // reject it so that the next one tries fresh.
172 api
.getToken( 'testerror' ).done( function ( token
) {
173 assert
.equal( token
, 'good', 'The token' );
178 QUnit
.test( 'badToken()', function ( assert
) {
180 var api
= new mw
.Api(),
183 this.server
.respondWith( /type=testbad/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
185 '{ "tokens": { "testbadtoken": "bad" } }',
186 '{ "tokens": { "testbadtoken": "good" } }'
190 api
.getToken( 'testbad' )
192 api
.badToken( 'testbad' );
193 return api
.getToken( 'testbad' );
195 .then( function ( token
) {
196 assert
.equal( token
, 'good', 'The token' );
197 assert
.equal( test
.server
.requests
.length
, 2, 'Requests made' );
202 QUnit
.test( 'postWithToken( tokenType, params )', function ( assert
) {
204 var api
= new mw
.Api( { ajax
: { url
: '/postWithToken/api.php' } } );
206 this.server
.respondWith( 'GET', /type=testpost/, [ 200, { 'Content-Type': 'application/json' },
207 '{ "tokens": { "testposttoken": "good" } }'
209 this.server
.respondWith( 'POST', /api/, function ( request
) {
210 if ( request
.requestBody
.match( /token=good/ ) ) {
211 request
.respond( 200, { 'Content-Type': 'application/json' },
212 '{ "example": { "foo": "quux" } }'
217 api
.postWithToken( 'testpost', { action
: 'example', key
: 'foo' } )
218 .done( function ( data
) {
219 assert
.deepEqual( data
, { example
: { foo
: 'quux' } } );
223 QUnit
.test( 'postWithToken( tokenType, params with assert )', function ( assert
) {
225 var api
= new mw
.Api( { ajax
: { url
: '/postWithToken/api.php' } } );
227 this.server
.respondWith( /assert=user/, [ 200, { 'Content-Type': 'application/json' },
228 '{ "error": { "code": "assertuserfailed", "info": "Assertion failed" } }'
231 api
.postWithToken( 'testassertpost', { action
: 'example', key
: 'foo', assert
: 'user' } )
232 .fail( function ( errorCode
) {
233 assert
.equal( errorCode
, 'assertuserfailed', 'getToken fails assert' );
236 assert
.equal( this.server
.requests
.length
, 1, 'Requests made' );
239 QUnit
.test( 'postWithToken( tokenType, params, ajaxOptions )', function ( assert
) {
241 var api
= new mw
.Api();
243 this.server
.respond( [ 200, { 'Content-Type': 'application/json' }, '{ "example": "quux" }' ] );
263 assert
.ok( false, 'This parameter cannot be a callback' );
266 .always( function ( data
) {
267 assert
.equal( data
.example
, 'quux' );
270 assert
.equal( this.server
.requests
.length
, 2, 'Request made' );
271 assert
.equal( this.server
.requests
[0].requestHeaders
['X-Foo'], 'Bar', 'Header sent' );
274 QUnit
.test( 'postWithToken() - badtoken', function ( assert
) {
276 var api
= new mw
.Api();
278 this.server
.respondWith( /type=testbadtoken/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
280 '{ "tokens": { "testbadtokentoken": "bad" } }',
281 '{ "tokens": { "testbadtokentoken": "good" } }'
284 this.server
.respondWith( 'POST', /api/, function ( request
) {
285 if ( request
.requestBody
.match( /token=bad/ ) ) {
286 request
.respond( 200, { 'Content-Type': 'application/json' },
287 '{ "error": { "code": "badtoken" } }'
290 if ( request
.requestBody
.match( /token=good/ ) ) {
291 request
.respond( 200, { 'Content-Type': 'application/json' },
292 '{ "example": { "foo": "quux" } }'
297 // - Request: new token -> bad
298 // - Request: action=example -> badtoken error
299 // - Request: new token -> good
300 // - Request: action=example -> success
301 api
.postWithToken( 'testbadtoken', { action
: 'example', key
: 'foo' } )
302 .done( function ( data
) {
303 assert
.deepEqual( data
, { example
: { foo
: 'quux' } } );
307 QUnit
.test( 'postWithToken() - badtoken-cached', function ( assert
) {
312 this.server
.respondWith( /type=testonce/, sequenceBodies( 200, { 'Content-Type': 'application/json' },
314 '{ "tokens": { "testoncetoken": "good-A" } }',
315 '{ "tokens": { "testoncetoken": "good-B" } }'
318 sequenceA
= sequenceBodies( 200, { 'Content-Type': 'application/json' },
320 '{ "example": { "value": "A" } }',
321 '{ "error": { "code": "badtoken" } }'
324 this.server
.respondWith( 'POST', /api/, function ( request
) {
325 if ( request
.requestBody
.match( /token=good-A/ ) ) {
326 sequenceA( request
);
327 } else if ( request
.requestBody
.match( /token=good-B/ ) ) {
328 request
.respond( 200, { 'Content-Type': 'application/json' },
329 '{ "example": { "value": "B" } }'
334 // - Request: new token -> A
335 // - Request: action=example
336 api
.postWithToken( 'testonce', { action
: 'example', key
: 'foo' } )
337 .done( function ( data
) {
338 assert
.deepEqual( data
, { example
: { value
: 'A' } } );
341 // - Request: action=example w/ token A -> badtoken error
342 // - Request: new token -> B
343 // - Request: action=example w/ token B -> success
344 api
.postWithToken( 'testonce', { action
: 'example', key
: 'bar' } )
345 .done( function ( data
) {
346 assert
.deepEqual( data
, { example
: { value
: 'B' } } );