root / snf-app / synnefo / ui / static / snf / js / tests / jquery.mockjax.js @ 483c9197
History | View | Annotate | Download (11.7 kB)
1 |
/*!
|
---|---|
2 |
* MockJax - jQuery Plugin to Mock Ajax requests
|
3 |
*
|
4 |
* Version: 1.4.0
|
5 |
* Released: 2011-02-04
|
6 |
* Source: http://github.com/appendto/jquery-mockjax
|
7 |
* Docs: http://enterprisejquery.com/2010/07/mock-your-ajax-requests-with-mockjax-for-rapid-development
|
8 |
* Plugin: mockjax
|
9 |
* Author: Jonathan Sharp (http://jdsharp.com)
|
10 |
* License: MIT,GPL
|
11 |
*
|
12 |
* Copyright (c) 2010 appendTo LLC.
|
13 |
* Dual licensed under the MIT or GPL licenses.
|
14 |
* http://appendto.com/open-source-licenses
|
15 |
*/
|
16 |
(function($) { |
17 |
var _ajax = $.ajax, |
18 |
mockHandlers = []; |
19 |
|
20 |
function parseXML(xml) { |
21 |
if ( window['DOMParser'] == undefined && window.ActiveXObject ) { |
22 |
DOMParser = function() { }; |
23 |
DOMParser.prototype.parseFromString = function( xmlString ) { |
24 |
var doc = new ActiveXObject('Microsoft.XMLDOM'); |
25 |
doc.async = 'false';
|
26 |
doc.loadXML( xmlString ); |
27 |
return doc;
|
28 |
}; |
29 |
} |
30 |
|
31 |
try {
|
32 |
var xmlDoc = ( new DOMParser() ).parseFromString( xml, 'text/xml' ); |
33 |
if ( $.isXMLDoc( xmlDoc ) ) { |
34 |
var err = $('parsererror', xmlDoc); |
35 |
if ( err.length == 1 ) { |
36 |
throw('Error: ' + $(xmlDoc).text() ); |
37 |
} |
38 |
} else {
|
39 |
throw('Unable to parse XML'); |
40 |
} |
41 |
} catch( e ) {
|
42 |
var msg = ( e.name == undefined ? e : e.name + ': ' + e.message ); |
43 |
$(document).trigger('xmlParseError', [ msg ]); |
44 |
return undefined; |
45 |
} |
46 |
return xmlDoc;
|
47 |
} |
48 |
|
49 |
$.extend({
|
50 |
ajax: function(origSettings) { |
51 |
var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings), |
52 |
mock = false;
|
53 |
// Iterate over our mock handlers (in registration order) until we find
|
54 |
// one that is willing to intercept the request
|
55 |
$.each(mockHandlers, function(k, v) { |
56 |
if ( !mockHandlers[k] ) {
|
57 |
return;
|
58 |
} |
59 |
var m = null; |
60 |
// If the mock was registered with a function, let the function decide if we
|
61 |
// want to mock this request
|
62 |
if ( $.isFunction(mockHandlers[k]) ) { |
63 |
m = mockHandlers[k](s); |
64 |
} else {
|
65 |
m = mockHandlers[k]; |
66 |
// Inspect the URL of the request and check if the mock handler's url
|
67 |
// matches the url for this ajax request
|
68 |
if ( $.isFunction(m.url.test) ) { |
69 |
// The user provided a regex for the url, test it
|
70 |
if ( !m.url.test( s.url ) ) {
|
71 |
m = null;
|
72 |
} |
73 |
} else {
|
74 |
// Look for a simple wildcard '*' or a direct URL match
|
75 |
var star = m.url.indexOf('*'); |
76 |
if ( ( m.url != '*' && m.url != s.url && star == -1 ) || |
77 |
( star > -1 && m.url.substr(0, star) != s.url.substr(0, star) ) ) { |
78 |
// The url we tested did not match the wildcard *
|
79 |
m = null;
|
80 |
} |
81 |
} |
82 |
if ( m ) {
|
83 |
// Inspect the data submitted in the request (either POST body or GET query string)
|
84 |
if ( m.data && s.data ) {
|
85 |
var identical = false; |
86 |
// Deep inspect the identity of the objects
|
87 |
(function ident(mock, live) { |
88 |
// Test for situations where the data is a querystring (not an object)
|
89 |
if (typeof live === 'string') { |
90 |
// Querystring may be a regex
|
91 |
identical = $.isFunction( mock.test ) ? mock.test(live) : mock == live;
|
92 |
return identical;
|
93 |
} |
94 |
$.each(mock, function(k, v) { |
95 |
if ( live[k] === undefined ) { |
96 |
identical = false;
|
97 |
return false; |
98 |
} else {
|
99 |
identical = true;
|
100 |
if ( typeof live[k] == 'object' ) { |
101 |
return ident(mock[k], live[k]);
|
102 |
} else {
|
103 |
if ( $.isFunction( mock[k].test ) ) { |
104 |
identical = mock[k].test(live[k]); |
105 |
} else {
|
106 |
identical = ( mock[k] == live[k] ); |
107 |
} |
108 |
return identical;
|
109 |
} |
110 |
} |
111 |
}); |
112 |
})(m.data, s.data); |
113 |
// They're not identical, do not mock this request
|
114 |
if ( identical == false ) { |
115 |
m = null;
|
116 |
} |
117 |
} |
118 |
// Inspect the request type
|
119 |
if ( m && m.type && m.type != s.type ) {
|
120 |
// The request type doesn't match (GET vs. POST)
|
121 |
m = null;
|
122 |
} |
123 |
} |
124 |
} |
125 |
if ( m ) {
|
126 |
mock = true;
|
127 |
|
128 |
// Handle console logging
|
129 |
var c = $.extend({}, $.mockjaxSettings, m); |
130 |
if ( c.log && $.isFunction(c.log) ) { |
131 |
c.log('MOCK ' + s.type.toUpperCase() + ': ' + s.url, $.extend({}, s)); |
132 |
} |
133 |
|
134 |
var jsre = /=\?(&|$)/, jsc = (new Date()).getTime(); |
135 |
|
136 |
// Handle JSONP Parameter Callbacks, we need to replicate some of the jQuery core here
|
137 |
// because there isn't an easy hook for the cross domain script tag of jsonp
|
138 |
if ( s.dataType === "jsonp" ) { |
139 |
if ( s.type.toUpperCase() === "GET" ) { |
140 |
if ( !jsre.test( s.url ) ) {
|
141 |
s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?"; |
142 |
} |
143 |
} else if ( !s.data || !jsre.test(s.data) ) { |
144 |
s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?"; |
145 |
} |
146 |
s.dataType = "json";
|
147 |
} |
148 |
|
149 |
// Build temporary JSONP function
|
150 |
if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) { |
151 |
jsonp = s.jsonpCallback || ("jsonp" + jsc++);
|
152 |
|
153 |
// Replace the =? sequence both in the query string and the data
|
154 |
if ( s.data ) {
|
155 |
s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1"); |
156 |
} |
157 |
|
158 |
s.url = s.url.replace(jsre, "=" + jsonp + "$1"); |
159 |
|
160 |
// We need to make sure
|
161 |
// that a JSONP style response is executed properly
|
162 |
s.dataType = "script";
|
163 |
|
164 |
// Handle JSONP-style loading
|
165 |
window[ jsonp ] = window[ jsonp ] || function( tmp ) {
|
166 |
data = tmp; |
167 |
success(); |
168 |
complete(); |
169 |
// Garbage collect
|
170 |
window[ jsonp ] = undefined;
|
171 |
|
172 |
try {
|
173 |
delete window[ jsonp ];
|
174 |
} catch(e) {}
|
175 |
|
176 |
if ( head ) {
|
177 |
head.removeChild( script ); |
178 |
} |
179 |
}; |
180 |
} |
181 |
|
182 |
var rurl = /^(\w+:)?\/\/([^\/?#]+)/, |
183 |
parts = rurl.exec( s.url ), |
184 |
remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host); |
185 |
|
186 |
// Test if we are going to create a script tag (if so, intercept & mock)
|
187 |
if ( s.dataType === "script" && s.type.toUpperCase() === "GET" && remote ) { |
188 |
// Synthesize the mock request for adding a script tag
|
189 |
var callbackContext = origSettings && origSettings.context || s;
|
190 |
|
191 |
function success() { |
192 |
// If a local callback was specified, fire it and pass it the data
|
193 |
if ( s.success ) {
|
194 |
s.success.call( callbackContext, ( m.response ? m.response.toString() : m.responseText || ''), status, {} );
|
195 |
} |
196 |
|
197 |
// Fire the global callback
|
198 |
if ( s.global ) {
|
199 |
trigger( "ajaxSuccess", [{}, s] );
|
200 |
} |
201 |
} |
202 |
|
203 |
function complete() { |
204 |
// Process result
|
205 |
if ( s.complete ) {
|
206 |
s.complete.call( callbackContext, {} , status ); |
207 |
} |
208 |
|
209 |
// The request was completed
|
210 |
if ( s.global ) {
|
211 |
trigger( "ajaxComplete", [{}, s] );
|
212 |
} |
213 |
|
214 |
// Handle the global AJAX counter
|
215 |
if ( s.global && ! --jQuery.active ) {
|
216 |
jQuery.event.trigger( "ajaxStop" );
|
217 |
} |
218 |
} |
219 |
|
220 |
function trigger(type, args) { |
221 |
(s.context ? jQuery(s.context) : jQuery.event).trigger(type, args); |
222 |
} |
223 |
|
224 |
if ( m.response && $.isFunction(m.response) ) { |
225 |
m.response(origSettings); |
226 |
} else {
|
227 |
$.globalEval(m.responseText);
|
228 |
} |
229 |
success(); |
230 |
complete(); |
231 |
return false; |
232 |
} |
233 |
mock = _ajax.call($, $.extend(true, {}, origSettings, { |
234 |
// Mock the XHR object
|
235 |
xhr: function() { |
236 |
// Extend with our default mockjax settings
|
237 |
m = $.extend({}, $.mockjaxSettings, m); |
238 |
|
239 |
if ( m.contentType ) {
|
240 |
m.headers['content-type'] = m.contentType;
|
241 |
} |
242 |
|
243 |
// Return our mock xhr object
|
244 |
return {
|
245 |
status: m.status,
|
246 |
readyState: 1, |
247 |
open: function() { }, |
248 |
send: function() { |
249 |
// This is a substitute for < 1.4 which lacks $.proxy
|
250 |
var process = (function(that) { |
251 |
return function() { |
252 |
return (function() { |
253 |
// The request has returned
|
254 |
this.status = m.status;
|
255 |
this.readyState = 4; |
256 |
|
257 |
// We have an executable function, call it to give
|
258 |
// the mock handler a chance to update it's data
|
259 |
if ( $.isFunction(m.response) ) { |
260 |
m.response(origSettings); |
261 |
} |
262 |
// Copy over our mock to our xhr object before passing control back to
|
263 |
// jQuery's onreadystatechange callback
|
264 |
if ( s.dataType == 'json' && ( typeof m.responseText == 'object' ) ) { |
265 |
this.responseText = JSON.stringify(m.responseText);
|
266 |
} else if ( s.dataType == 'xml' ) { |
267 |
if ( typeof m.responseXML == 'string' ) { |
268 |
this.responseXML = parseXML(m.responseXML);
|
269 |
} else {
|
270 |
this.responseXML = m.responseXML;
|
271 |
} |
272 |
} else {
|
273 |
this.responseText = m.responseText;
|
274 |
} |
275 |
// jQuery < 1.4 doesn't have onreadystate change for xhr
|
276 |
if ( $.isFunction(this.onreadystatechange) ) { |
277 |
this.onreadystatechange( m.isTimeout ? 'timeout' : undefined ); |
278 |
} |
279 |
}).apply(that); |
280 |
}; |
281 |
})(this);
|
282 |
|
283 |
if ( m.proxy ) {
|
284 |
// We're proxying this request and loading in an external file instead
|
285 |
_ajax({ |
286 |
global: false, |
287 |
url: m.proxy,
|
288 |
type: m.proxyType,
|
289 |
data: m.data,
|
290 |
dataType: s.dataType,
|
291 |
complete: function(xhr, txt) { |
292 |
m.responseXML = xhr.responseXML; |
293 |
m.responseText = xhr.responseText; |
294 |
this.responseTimer = setTimeout(process, m.responseTime || 0); |
295 |
} |
296 |
}); |
297 |
} else {
|
298 |
// type == 'POST' || 'GET' || 'DELETE'
|
299 |
if ( s.async === false ) { |
300 |
// TODO: Blocking delay
|
301 |
process(); |
302 |
} else {
|
303 |
this.responseTimer = setTimeout(process, m.responseTime || 50); |
304 |
} |
305 |
} |
306 |
}, |
307 |
abort: function() { |
308 |
clearTimeout(this.responseTimer);
|
309 |
}, |
310 |
setRequestHeader: function() { }, |
311 |
getResponseHeader: function(header) { |
312 |
// 'Last-modified', 'Etag', 'content-type' are all checked by jQuery
|
313 |
if ( m.headers && m.headers[header] ) {
|
314 |
// Return arbitrary headers
|
315 |
return m.headers[header];
|
316 |
} else if ( header.toLowerCase() == 'last-modified' ) { |
317 |
return m.lastModified || (new Date()).toString(); |
318 |
} else if ( header.toLowerCase() == 'etag' ) { |
319 |
return m.etag || ''; |
320 |
} else if ( header.toLowerCase() == 'content-type' ) { |
321 |
return m.contentType || 'text/plain'; |
322 |
} |
323 |
}, |
324 |
getAllResponseHeaders: function() { |
325 |
var headers = ''; |
326 |
$.each(m.headers, function(k, v) { |
327 |
headers += k + ': ' + v + "\n"; |
328 |
}); |
329 |
return headers;
|
330 |
} |
331 |
}; |
332 |
} |
333 |
})); |
334 |
return false; |
335 |
} |
336 |
}); |
337 |
// We don't have a mock request, trigger a normal request
|
338 |
if ( !mock ) {
|
339 |
return _ajax.apply($, arguments); |
340 |
} else {
|
341 |
return mock;
|
342 |
} |
343 |
} |
344 |
}); |
345 |
|
346 |
$.mockjaxSettings = {
|
347 |
//url: null,
|
348 |
//type: 'GET',
|
349 |
log: function(msg) { |
350 |
window['console'] && window.console.log && window.console.log(msg);
|
351 |
}, |
352 |
status: 200, |
353 |
responseTime: 500, |
354 |
isTimeout: false, |
355 |
contentType: 'text/plain', |
356 |
response: '', |
357 |
responseText: '', |
358 |
responseXML: '', |
359 |
proxy: '', |
360 |
proxyType: 'GET', |
361 |
|
362 |
lastModified: null, |
363 |
etag: '', |
364 |
headers: {
|
365 |
etag: 'IJF@H#@923uf8023hFO@I#H#', |
366 |
'content-type' : 'text/plain' |
367 |
} |
368 |
}; |
369 |
|
370 |
$.mockjax = function(settings) { |
371 |
var i = mockHandlers.length;
|
372 |
mockHandlers[i] = settings; |
373 |
return i;
|
374 |
}; |
375 |
$.mockjaxClear = function(i) { |
376 |
if ( arguments.length == 1 ) { |
377 |
mockHandlers[i] = null;
|
378 |
} else {
|
379 |
mockHandlers = []; |
380 |
} |
381 |
}; |
382 |
})(jQuery); |