1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
|
( function ( mw ) {
QUnit.module( 'mediawiki.api', QUnit.newMwEnvironment( {
setup: function () {
this.server = this.sandbox.useFakeServer();
}
} ) );
QUnit.test( 'Basic functionality', function ( assert ) {
QUnit.expect( 2 );
var api = new mw.Api();
api.get( {} )
.done( function ( data ) {
assert.deepEqual( data, [], 'If request succeeds without errors, resolve deferred' );
} );
api.post( {} )
.done( function ( data ) {
assert.deepEqual( data, [], 'Simple POST request' );
} );
this.server.respond( function ( request ) {
request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
} );
} );
QUnit.test( 'API error', function ( assert ) {
QUnit.expect( 1 );
var api = new mw.Api();
api.get( { action: 'doesntexist' } )
.fail( function ( errorCode ) {
assert.equal( errorCode, 'unknown_action', 'API error should reject the deferred' );
} );
this.server.respond( function ( request ) {
request.respond( 200, { 'Content-Type': 'application/json' },
'{ "error": { "code": "unknown_action" } }'
);
} );
} );
QUnit.test( 'FormData support', function ( assert ) {
QUnit.expect( 2 );
var api = new mw.Api();
api.post( { action: 'test' }, { contentType: 'multipart/form-data' } );
this.server.respond( function ( request ) {
if ( window.FormData ) {
assert.ok( !request.url.match( /action=/ ), 'Request has no query string' );
assert.ok( request.requestBody instanceof FormData, 'Request uses FormData body' );
} else {
assert.ok( !request.url.match( /action=test/ ), 'Request has no query string' );
assert.equal( request.requestBody, 'action=test&format=json', 'Request uses query string body' );
}
request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
} );
} );
QUnit.test( 'Converting arrays to pipe-separated', function ( assert ) {
QUnit.expect( 1 );
var api = new mw.Api();
api.get( { test: [ 'foo', 'bar', 'baz' ] } );
this.server.respond( function ( request ) {
assert.ok( request.url.match( /test=foo%7Cbar%7Cbaz/ ), 'Pipe-separated value was submitted' );
request.respond( 200, { 'Content-Type': 'application/json' }, '[]' );
} );
} );
QUnit.test( 'getToken( pre-populated )', function ( assert ) {
QUnit.expect( 2 );
var api = new mw.Api();
// Get editToken for local wiki, this should not make
// a request as it should be retrieved from user.tokens.
api.getToken( 'edit' )
.done( function ( token ) {
assert.ok( token.length, 'Got a token' );
} )
.fail( function ( err ) {
assert.equal( '', err, 'API error' );
} );
assert.equal( this.server.requests.length, 0, 'Requests made' );
} );
QUnit.test( 'getToken()', function ( assert ) {
QUnit.expect( 5 );
var test = this,
api = new mw.Api();
// Get a token of a type that isn't prepopulated by user.tokens.
// Could use "block" or "delete" here, but those could in theory
// be added to user.tokens, use a fake one instead.
api.getToken( 'testaction' )
.done( function ( token ) {
assert.ok( token.length, 'Got testaction token' );
} )
.fail( function ( err ) {
assert.equal( err, '', 'API error' );
} );
api.getToken( 'testaction' )
.done( function ( token ) {
assert.ok( token.length, 'Got testaction token (cached)' );
} )
.fail( function ( err ) {
assert.equal( err, '', 'API error' );
} );
// Don't cache error (bug 65268)
api.getToken( 'testaction2' )
.fail( function ( err ) {
assert.equal( err, 'bite-me', 'Expected error' );
} )
.always( function () {
// Make this request after the first one has finished.
// If we make it simultaneously we still want it to share
// the cache, but as soon as it is fulfilled as error we
// reject it so that the next one tries fresh.
api.getToken( 'testaction2' )
.done( function ( token ) {
assert.ok( token.length, 'Got testaction2 token (error was not be cached)' );
} )
.fail( function ( err ) {
assert.equal( err, '', 'API error' );
} );
assert.equal( test.server.requests.length, 3, 'Requests made' );
test.server.requests[2].respond( 200, { 'Content-Type': 'application/json' },
'{ "tokens": { "testaction2token": "0123abc" } }'
);
} );
this.server.requests[0].respond( 200, { 'Content-Type': 'application/json' },
'{ "tokens": { "testactiontoken": "0123abc" } }'
);
this.server.requests[1].respond( 200, { 'Content-Type': 'application/json' },
'{ "error": { "code": "bite-me", "info": "Smite me, O Mighty Smiter" } }'
);
} );
QUnit.test( 'postWithToken( tokenType, params )', function ( assert ) {
QUnit.expect( 1 );
var api = new mw.Api( { ajax: { url: '/postWithToken/api.php' } } );
// - Requests token
// - Performs action=example
api.postWithToken( 'testsimpletoken', { action: 'example', key: 'foo' } )
.done( function ( data ) {
assert.deepEqual( data, { example: { foo: 'quux' } } );
} );
this.server.requests[0].respond( 200, { 'Content-Type': 'application/json' },
'{ "tokens": { "testsimpletokentoken": "a-bad-token" } }'
);
this.server.requests[1].respond( 200, { 'Content-Type': 'application/json' },
'{ "example": { "foo": "quux" } }'
);
} );
QUnit.test( 'postWithToken( tokenType, params with assert )', function ( assert ) {
QUnit.expect( 2 );
var api = new mw.Api( { ajax: { url: '/postWithToken/api.php' } } );
api.postWithToken( 'testasserttoken', { action: 'example', key: 'foo', assert: 'user' } )
.fail( function ( errorCode ) {
assert.equal( errorCode, 'assertuserfailed', 'getToken fails assert' );
} );
assert.equal( this.server.requests.length, 1, 'Request for token made' );
this.server.respondWith( /assert=user/, function ( request ) {
request.respond(
200,
{ 'Content-Type': 'application/json' },
'{ "error": { "code": "assertuserfailed", "info": "Assertion failed" } }'
);
} );
this.server.respond();
} );
QUnit.test( 'postWithToken( tokenType, params, ajaxOptions )', function ( assert ) {
QUnit.expect( 3 );
var api = new mw.Api();
api.postWithToken(
'edit',
{
action: 'example'
},
{
headers: {
'X-Foo': 'Bar'
}
}
);
api.postWithToken(
'edit',
{
action: 'example'
},
function () {
assert.ok( false, 'This parameter cannot be a callback' );
}
)
.always( function ( data ) {
assert.equal( data.example, 'quux' );
} );
assert.equal( this.server.requests.length, 2, 'Request made' );
assert.equal( this.server.requests[0].requestHeaders['X-Foo'], 'Bar', 'Header sent' );
this.server.respond( function ( request ) {
request.respond( 200, { 'Content-Type': 'application/json' }, '{ "example": "quux" }' );
} );
} );
QUnit.test( 'postWithToken() - badtoken', function ( assert ) {
QUnit.expect( 1 );
var api = new mw.Api();
// - Request: token
// - Request: action=example -> badtoken error
// - Request: new token
// - Request: action=example
api.postWithToken( 'testbadtoken', { action: 'example', key: 'foo' } )
.done( function ( data ) {
assert.deepEqual( data, { example: { foo: 'quux' } } );
} );
this.server.requests[0].respond( 200, { 'Content-Type': 'application/json' },
'{ "tokens": { "testbadtokentoken": "a-bad-token" } }'
);
this.server.requests[1].respond( 200, { 'Content-Type': 'application/json' },
'{ "error": { "code": "badtoken" } }'
);
this.server.requests[2].respond( 200, { 'Content-Type': 'application/json' },
'{ "tokens": { "testbadtokentoken": "a-good-token" } }'
);
this.server.requests[3].respond( 200, { 'Content-Type': 'application/json' },
'{ "example": { "foo": "quux" } }'
);
} );
QUnit.test( 'postWithToken() - badtoken-cached', function ( assert ) {
QUnit.expect( 2 );
var api = new mw.Api();
// - Request: token
// - Request: action=example
api.postWithToken( 'testbadtokencache', { action: 'example', key: 'foo' } )
.done( function ( data ) {
assert.deepEqual( data, { example: { foo: 'quux' } } );
} );
// - Cache: Try previously cached token
// - Request: action=example -> badtoken error
// - Request: new token
// - Request: action=example
api.postWithToken( 'testbadtokencache', { action: 'example', key: 'bar' } )
.done( function ( data ) {
assert.deepEqual( data, { example: { bar: 'quux' } } );
} );
this.server.requests[0].respond( 200, { 'Content-Type': 'application/json' },
'{ "tokens": { "testbadtokencachetoken": "a-good-token-once" } }'
);
this.server.requests[1].respond( 200, { 'Content-Type': 'application/json' },
'{ "example": { "foo": "quux" } }'
);
this.server.requests[2].respond( 200, { 'Content-Type': 'application/json' },
'{ "error": { "code": "badtoken" } }'
);
this.server.requests[3].respond( 200, { 'Content-Type': 'application/json' },
'{ "tokens": { "testbadtokencachetoken": "a-good-new-token" } }'
);
this.server.requests[4].respond( 200, { 'Content-Type': 'application/json' },
'{ "example": { "bar": "quux" } }'
);
} );
}( mediaWiki ) );
|
