2 QUnit
.module( 'mediawiki.api', QUnit
.newMwEnvironment( {
4 this.server
= this.sandbox
.useFakeServer();
8 QUnit
.test( 'Basic functionality', function ( assert
) {
11 var api
= new mw
.Api();
14 .done( function ( data
) {
15 assert
.deepEqual( data
, [], 'If request succeeds without errors, resolve deferred' );
19 .done( function ( data
) {
20 assert
.deepEqual( data
, [], 'Simple POST request' );
23 this.server
.respond( function ( request
) {
24 request
.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
28 QUnit
.test( 'API error', function ( assert
) {
31 var api
= new mw
.Api();
33 api
.get( { action
: 'doesntexist' } )
34 .fail( function ( errorCode
) {
35 assert
.equal( errorCode
, 'unknown_action', 'API error should reject the deferred' );
38 this.server
.respond( function ( request
) {
39 request
.respond( 200, { 'Content-Type': 'application/json' },
40 '{ "error": { "code": "unknown_action" } }'
45 QUnit
.test( 'FormData support', function ( assert
) {
48 var api
= new mw
.Api();
50 api
.post( { action
: 'test' }, { contentType
: 'multipart/form-data' } );
52 this.server
.respond( function ( request
) {
53 if ( window
.FormData
) {
54 assert
.ok( !request
.url
.match( /action=/), 'Request has no query string' );
55 assert
.ok( request
.requestBody
instanceof FormData
, 'Request uses FormData body' );
57 assert
.ok( !request
.url
.match( /action=test/), 'Request has no query string' );
58 assert
.equal( request
.requestBody
, 'action=test&format=json', 'Request uses query string body' );
60 request
.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
64 QUnit
.test( 'getToken( pre-populated )', function ( assert
) {
67 var api
= new mw
.Api();
69 // Get editToken for local wiki, this should not make
70 // a request as it should be retrieved from user.tokens.
71 api
.getToken( 'edit' )
72 .done( function ( token
) {
73 assert
.ok( token
.length
, 'Got a token' );
75 .fail( function ( err
) {
76 assert
.equal( '', err
, 'API error' );
79 assert
.equal( this.server
.requests
.length
, 0, 'Requests made' );
82 QUnit
.test( 'getToken()', function ( assert
) {
88 // Get a token of a type that isn't prepopulated by user.tokens.
89 // Could use "block" or "delete" here, but those could in theory
90 // be added to user.tokens, use a fake one instead.
91 api
.getToken( 'testaction' )
92 .done( function ( token
) {
93 assert
.ok( token
.length
, 'Got testaction token' );
95 .fail( function ( err
) {
96 assert
.equal( err
, '', 'API error' );
98 api
.getToken( 'testaction' )
99 .done( function ( token
) {
100 assert
.ok( token
.length
, 'Got testaction token (cached)' );
102 .fail( function ( err
) {
103 assert
.equal( err
, '', 'API error' );
106 // Don't cache error (bug 65268)
107 api
.getToken( 'testaction2' )
108 .fail( function ( err
) {
109 assert
.equal( err
, 'bite-me', 'Expected error' );
111 .always( function () {
112 // Make this request after the first one has finished.
113 // If we make it simultaneously we still want it to share
114 // the cache, but as soon as it is fulfilled as error we
115 // reject it so that the next one tries fresh.
116 api
.getToken( 'testaction2' )
117 .done( function ( token
) {
118 assert
.ok( token
.length
, 'Got testaction2 token (error was not be cached)' );
120 .fail( function ( err
) {
121 assert
.equal( err
, '', 'API error' );
124 assert
.equal( test
.server
.requests
.length
, 3, 'Requests made' );
126 test
.server
.requests
[2].respond( 200, { 'Content-Type': 'application/json' },
127 '{ "tokens": { "testaction2token": "0123abc" } }'
131 this.server
.requests
[0].respond( 200, { 'Content-Type': 'application/json' },
132 '{ "tokens": { "testactiontoken": "0123abc" } }'
135 this.server
.requests
[1].respond( 200, { 'Content-Type': 'application/json' },
136 '{ "error": { "code": "bite-me", "info": "Smite me, O Mighty Smiter" } }'
140 QUnit
.test( 'postWithToken( tokenType, params )', function ( assert
) {
143 var api
= new mw
.Api( { ajax
: { url
: '/postWithToken/api.php' } } );
146 // - Performs action=example
147 api
.postWithToken( 'testsimpletoken', { action
: 'example', key
: 'foo' } )
148 .done( function ( data
) {
149 assert
.deepEqual( data
, { example
: { foo
: 'quux' } } );
152 this.server
.requests
[0].respond( 200, { 'Content-Type': 'application/json' },
153 '{ "tokens": { "testsimpletokentoken": "a-bad-token" } }'
156 this.server
.requests
[1].respond( 200, { 'Content-Type': 'application/json' },
157 '{ "example": { "foo": "quux" } }'
161 QUnit
.test( 'postWithToken( tokenType, params with assert )', function ( assert
) {
164 var api
= new mw
.Api( { ajax
: { url
: '/postWithToken/api.php' } } );
166 api
.postWithToken( 'testasserttoken', { action
: 'example', key
: 'foo', assert
: 'user' } )
167 .fail( function ( errorCode
) {
168 assert
.equal( errorCode
, 'assertuserfailed', 'getToken fails assert' );
171 assert
.equal( this.server
.requests
.length
, 1, 'Request for token made' );
172 this.server
.respondWith( /assert=user/, function ( request
) {
175 { 'Content-Type': 'application/json' },
176 '{ "error": { "code": "assertuserfailed", "info": "Assertion failed" } }'
180 this.server
.respond();
183 QUnit
.test( 'postWithToken( tokenType, params, ajaxOptions )', function ( assert
) {
186 var api
= new mw
.Api();
206 assert
.ok( false, 'This parameter cannot be a callback' );
209 .always( function ( data
) {
210 assert
.equal( data
.example
, 'quux' );
213 assert
.equal( this.server
.requests
.length
, 2, 'Request made' );
214 assert
.equal( this.server
.requests
[0].requestHeaders
['X-Foo'], 'Bar', 'Header sent' );
216 this.server
.respond( function ( request
) {
217 request
.respond( 200, { 'Content-Type': 'application/json' }, '{ "example": "quux" }' );
221 QUnit
.test( 'postWithToken() - badtoken', function ( assert
) {
224 var api
= new mw
.Api();
227 // - Request: action=example -> badtoken error
228 // - Request: new token
229 // - Request: action=example
230 api
.postWithToken( 'testbadtoken', { action
: 'example', key
: 'foo' } )
231 .done( function ( data
) {
232 assert
.deepEqual( data
, { example
: { foo
: 'quux' } } );
235 this.server
.requests
[0].respond( 200, { 'Content-Type': 'application/json' },
236 '{ "tokens": { "testbadtokentoken": "a-bad-token" } }'
239 this.server
.requests
[1].respond( 200, { 'Content-Type': 'application/json' },
240 '{ "error": { "code": "badtoken" } }'
243 this.server
.requests
[2].respond( 200, { 'Content-Type': 'application/json' },
244 '{ "tokens": { "testbadtokentoken": "a-good-token" } }'
247 this.server
.requests
[3].respond( 200, { 'Content-Type': 'application/json' },
248 '{ "example": { "foo": "quux" } }'
253 QUnit
.test( 'postWithToken() - badtoken-cached', function ( assert
) {
256 var api
= new mw
.Api();
259 // - Request: action=example
260 api
.postWithToken( 'testbadtokencache', { action
: 'example', key
: 'foo' } )
261 .done( function ( data
) {
262 assert
.deepEqual( data
, { example
: { foo
: 'quux' } } );
265 // - Cache: Try previously cached token
266 // - Request: action=example -> badtoken error
267 // - Request: new token
268 // - Request: action=example
269 api
.postWithToken( 'testbadtokencache', { action
: 'example', key
: 'bar' } )
270 .done( function ( data
) {
271 assert
.deepEqual( data
, { example
: { bar
: 'quux' } } );
274 this.server
.requests
[0].respond( 200, { 'Content-Type': 'application/json' },
275 '{ "tokens": { "testbadtokencachetoken": "a-good-token-once" } }'
278 this.server
.requests
[1].respond( 200, { 'Content-Type': 'application/json' },
279 '{ "example": { "foo": "quux" } }'
282 this.server
.requests
[2].respond( 200, { 'Content-Type': 'application/json' },
283 '{ "error": { "code": "badtoken" } }'
286 this.server
.requests
[3].respond( 200, { 'Content-Type': 'application/json' },
287 '{ "tokens": { "testbadtokencachetoken": "a-good-new-token" } }'
290 this.server
.requests
[4].respond( 200, { 'Content-Type': 'application/json' },
291 '{ "example": { "bar": "quux" } }'