668 lines
16 KiB
JavaScript
668 lines
16 KiB
JavaScript
(function(qunit, $) {
|
|
'use strict';
|
|
|
|
var t = qunit.test;
|
|
|
|
/* ----------------- */
|
|
qunit.module( 'Core' );
|
|
/* ----------------- */
|
|
|
|
t('Return XMLHttpRequest object from $.ajax', function(assert) {
|
|
$.mockjax({
|
|
url: '/xmlhttprequest',
|
|
responseText: 'Hello Word'
|
|
});
|
|
|
|
var xhr = $.ajax({
|
|
url: '/xmlhttprequest',
|
|
complete: function() { }
|
|
});
|
|
if (xhr && xhr.abort) {
|
|
xhr.abort();
|
|
}
|
|
|
|
assert.ok(xhr, 'XHR object is not null or undefined');
|
|
assert.ok(xhr.done && xhr.fail, 'Got Promise methods');
|
|
});
|
|
|
|
t('Intercept synchronized proxy calls and return synchronously', function(assert) {
|
|
$.mockjax({
|
|
url: '/proxy',
|
|
proxy: 'test_proxy.json'
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/proxy',
|
|
dataType: 'json',
|
|
async: false,
|
|
success: function(json) {
|
|
assert.ok(json && json.proxy, 'Proxy callback request succeeded');
|
|
},
|
|
error: qunit.noErrorCallbackExpected
|
|
});
|
|
});
|
|
|
|
t('Intercept asynchronized proxy calls', function(assert) {
|
|
var done = assert.async();
|
|
$.mockjax({
|
|
url: '/proxy',
|
|
proxy: 'test_proxy.json'
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/proxy',
|
|
dataType: 'json',
|
|
success: function(json) {
|
|
assert.ok(json && json.proxy, 'Proxy callback request succeeded');
|
|
},
|
|
error: qunit.noErrorCallbackExpected,
|
|
complete: done
|
|
});
|
|
});
|
|
|
|
t('Intercept proxy calls for XML', function(assert) {
|
|
$.mockjax({
|
|
url: '/proxy',
|
|
proxy: 'test_proxy.xml'
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/proxy',
|
|
dataType: 'xml',
|
|
async: false,
|
|
success: function(doc) {
|
|
assert.ok(doc, 'Proxy callback request succeeded');
|
|
assert.strictEqual($(doc).find('foo').length, 1, 'Foo element exists in XML');
|
|
assert.strictEqual($(doc).find('foo').text(), 'bar', 'XML content is correct');
|
|
},
|
|
error: qunit.noErrorCallbackExpected
|
|
});
|
|
});
|
|
|
|
t('Intercept and proxy (sub-ajax request)', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/proxy',
|
|
proxy: 'test_proxy.json'
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/proxy',
|
|
dataType: 'json',
|
|
success: function(json) {
|
|
assert.ok(json && json.proxy, 'Proxy request succeeded');
|
|
},
|
|
error: qunit.noErrorCallbackExpected,
|
|
complete: done
|
|
});
|
|
});
|
|
|
|
t('Proxy type specification', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/proxy',
|
|
proxy: 'test_proxy.json',
|
|
proxyType: 'GET'
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/proxy',
|
|
error: qunit.noErrorCallbackExpected,
|
|
dataType: 'json',
|
|
success: function(json) {
|
|
assert.ok(json && json.proxy, 'Proxy request succeeded');
|
|
},
|
|
complete: done
|
|
});
|
|
});
|
|
|
|
t('Support 1.5 $.ajax(url, settings) signature.', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/resource',
|
|
responseText: 'Hello World'
|
|
});
|
|
|
|
$.ajax('/resource', {
|
|
success: function(response) {
|
|
assert.equal(response, 'Hello World');
|
|
},
|
|
error: qunit.noErrorCallbackExpected,
|
|
complete: done
|
|
});
|
|
});
|
|
|
|
t('Dynamic response callback', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/response-callback',
|
|
response: function(settings) {
|
|
this.responseText = settings.data.response + ' 2';
|
|
}
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
dataType: 'text',
|
|
data: {
|
|
response: 'Hello world'
|
|
},
|
|
error: qunit.noErrorCallbackExpected,
|
|
complete: function(xhr) {
|
|
assert.equal(xhr.responseText, 'Hello world 2', 'Response Text matches');
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
t('Dynamic asynchronous response callback', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/response-callback',
|
|
responseText: 'original response',
|
|
response: function(settings, resDone) {
|
|
var that = this;
|
|
setTimeout(function() {
|
|
that.responseText = settings.data.response + ' 3';
|
|
resDone();
|
|
}, 30);
|
|
}
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
dataType: 'text',
|
|
data: {
|
|
response: 'Hello world'
|
|
},
|
|
error: qunit.noErrorCallbackExpected,
|
|
complete: function(xhr) {
|
|
assert.equal(xhr.responseText, 'Hello world 3', 'Response Text matches');
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
if (qunit.compareSemver($().jquery, '1.4', '>=')) {
|
|
// The $.ajax() API changed in version 1.4 to include the third argument: xhr
|
|
t('Success callback should have access to xhr object', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/response'
|
|
});
|
|
|
|
$.ajax({
|
|
type: 'GET',
|
|
url: '/response',
|
|
success: function() {
|
|
assert.ok(arguments[2], 'there is a third argument to the success callback');
|
|
assert.ok(arguments[2] && arguments[2].status === 200, 'third argument has proper status code');
|
|
done();
|
|
},
|
|
error: function() {
|
|
assert.ok(false, 'should not result in error');
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
t('Dynamic response status callback', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/response-callback',
|
|
response: function() {
|
|
this.status = 500;
|
|
this.statusText = 'Internal Server Error';
|
|
}
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
dataType: 'text',
|
|
data: {
|
|
response: 'Hello world'
|
|
},
|
|
error: function() {
|
|
assert.ok(true, 'error callback was called');
|
|
},
|
|
complete: function(xhr) {
|
|
assert.equal(xhr.status, 500, 'Dynamically set response status matches');
|
|
|
|
if( $.fn.jquery !== '1.5.2') {
|
|
// This assertion fails in 1.5.2 due to this bug: http://bugs.jquery.com/ticket/9854
|
|
// The statusText is being modified internally by jQuery in 1.5.2
|
|
assert.equal(xhr.statusText, 'Internal Server Error', 'Dynamically set response statusText matches');
|
|
}
|
|
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
t('Dynamic response status callback - list of statuses as an array (mix of successes and failures)', function(assert) {
|
|
var done = assert.async();
|
|
var possibleStatuses = [200,201,204,400,404,500];
|
|
var returnedStatuses = [];
|
|
var maxNumLoops = possibleStatuses.length * 50;
|
|
var numLoopsComplete = 0;
|
|
|
|
$.mockjax({
|
|
url: '/response-callback',
|
|
response: function() {
|
|
this.status = possibleStatuses;
|
|
this.statusText = 'Internal Server Error';
|
|
}
|
|
});
|
|
|
|
var completeCallback = function(xhr) {
|
|
assert.notEqual($.inArray(xhr.status, possibleStatuses), -1, 'Dynamically set random response status found');
|
|
|
|
// add this to our array of returned statuses (if it isn't there already)
|
|
if($.inArray(xhr.status, returnedStatuses) === -1) {
|
|
returnedStatuses.push(xhr.status);
|
|
}
|
|
|
|
// increment counter
|
|
numLoopsComplete++;
|
|
|
|
// if we made it this far without matching all possible statuses, fail!
|
|
if (numLoopsComplete >= maxNumLoops) {
|
|
assert.equal(
|
|
returnedStatuses.length,
|
|
possibleStatuses.length,
|
|
'Did not randomly return all possible statuses (only returned: ' + returnedStatuses.toString() + ')'
|
|
);
|
|
|
|
done();
|
|
}
|
|
|
|
// we short-circuited early, so we can be done
|
|
if (returnedStatuses.length === possibleStatuses.length) {
|
|
done();
|
|
}
|
|
};
|
|
|
|
do {
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
dataType: 'text',
|
|
async: false,
|
|
data: {
|
|
response: 'Hello world'
|
|
},
|
|
complete: completeCallback
|
|
});
|
|
} while ((numLoopsComplete < maxNumLoops) && (possibleStatuses.length !== returnedStatuses.length));
|
|
});
|
|
|
|
t('Default Response Settings', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/response-callback'
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
dataType: 'text',
|
|
data: {
|
|
response: ''
|
|
},
|
|
complete: function(xhr) {
|
|
assert.equal(xhr.status, 200, 'Response status matches default');
|
|
|
|
if( $.fn.jquery !== '1.5.2') {
|
|
// This assertion fails in 1.5.2 due to this bug: http://bugs.jquery.com/ticket/9854
|
|
// The statusText is being modified internally by jQuery in 1.5.2
|
|
assert.equal(xhr.statusText, 'OK', 'Response statusText matches default');
|
|
}
|
|
|
|
assert.equal(xhr.responseText.length, 0, 'responseText length should be 0');
|
|
assert.equal(xhr.responseXml === undefined, true, 'responseXml should be undefined');
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
t('Throw new error when throwUnmocked is set to true and unmocked ajax calls are fired', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjaxSettings.throwUnmocked = true;
|
|
|
|
try {
|
|
$.ajax({
|
|
async: true,
|
|
type: 'GET',
|
|
url: '/api/example/1',
|
|
complete: function() {
|
|
assert.ok(false, 'Unmocked ajax request completed successfully and should have thrown an error.');
|
|
done();
|
|
}
|
|
});
|
|
}
|
|
catch (e) {
|
|
assert.ok(e instanceof Error, 'Error was not thrown with "throwUnmocked" set to true and existing unmocked ajax request');
|
|
done();
|
|
}
|
|
});
|
|
|
|
t('Get unfired handlers', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/api/example/1'
|
|
});
|
|
$.mockjax({
|
|
url: '/api/example/2'
|
|
});
|
|
|
|
$.ajax({
|
|
async: false,
|
|
type: 'GET',
|
|
url: '/api/example/1',
|
|
complete: function() {
|
|
var handlersNotFired = $.mockjax.unfiredHandlers();
|
|
assert.equal(handlersNotFired.length, 1, 'all mocks were fired');
|
|
assert.equal(handlersNotFired[0].url, '/api/example/2', 'mockjax call has unexpected url');
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
t('Get unfired handlers after calling mockjax.clear', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/api/example/1'
|
|
});
|
|
$.mockjax({
|
|
url: '/api/example/2'
|
|
});
|
|
$.mockjax({
|
|
url: '/api/example/3'
|
|
});
|
|
|
|
$.ajax({
|
|
async: false,
|
|
type: 'GET',
|
|
url: '/api/example/1',
|
|
complete: function() {
|
|
$.mockjax.clear(2);
|
|
var handlersNotFired = $.mockjax.unfiredHandlers();
|
|
assert.equal(handlersNotFired.length, 1, 'all mocks were fired');
|
|
assert.equal(handlersNotFired[0].url, '/api/example/2', 'mockjax call has unexpected url');
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
t('Response settings correct using PUT method', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/put-request',
|
|
type: 'PUT',
|
|
responseText: 'this was a PUT'
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/put-request',
|
|
type: 'PUT',
|
|
dataType: 'text',
|
|
complete: function(xhr) {
|
|
assert.equal(xhr.status, 200, 'Response status matches default');
|
|
|
|
assert.equal(xhr.responseText, 'this was a PUT', 'responseText is correct');
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
t('Preserve context when set in jsonp ajax requet', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/jsonp*',
|
|
contentType: 'text/json',
|
|
proxy: 'test_jsonp.js'
|
|
});
|
|
|
|
window.abcdef123456 = function() {};
|
|
var cxt = {context: 'context'};
|
|
|
|
$.ajax({
|
|
url: '/jsonp?callback=?',
|
|
jsonpCallback: 'abcdef123456',
|
|
dataType: 'jsonp',
|
|
error: qunit.noErrorCallbackExpected,
|
|
context: cxt})
|
|
.done(function() {
|
|
assert.deepEqual(this, cxt, 'this is equal to context object');
|
|
window.abcdef123456 = null;
|
|
done();
|
|
});
|
|
});
|
|
|
|
t('Validate this is the $.ajax object if context is not set', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/jsonp*',
|
|
contentType: 'text/json',
|
|
proxy: 'test_jsonp.js'
|
|
});
|
|
|
|
window.abcdef123456 = function() {};
|
|
|
|
$.ajax({
|
|
url: '/jsonp?callback=?',
|
|
jsonpCallback: 'abcdef123456',
|
|
dataType: 'jsonp',
|
|
error: qunit.noErrorCallbackExpected
|
|
})
|
|
.done(function() {
|
|
assert.ok(this.jsonp, '\'this\' is the $.ajax object for this request.');
|
|
window.abcdef123456 = null;
|
|
done();
|
|
});
|
|
});
|
|
|
|
t('Dynamic mock definition', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax( function( settings ) {
|
|
var service = settings.url.match(/\/users\/(.*)$/);
|
|
if (service) {
|
|
return {
|
|
proxy: 'test_proxy.json'
|
|
};
|
|
}
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/users/test',
|
|
dataType: 'json',
|
|
error: qunit.noErrorCallbackExpected,
|
|
success: function(json) {
|
|
assert.ok(json && json.proxy, 'Proxy request succeeded');
|
|
},
|
|
complete: done
|
|
});
|
|
});
|
|
|
|
t('Dynamic mock response generation', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/response-callback',
|
|
response: function() {
|
|
this.responseText = { currentTime: 'now: ' + new Date() };
|
|
}
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
dataType: 'json',
|
|
error: qunit.noErrorCallbackExpected,
|
|
success: function(json) {
|
|
assert.equal(typeof json.currentTime, 'string', 'Dynamic response succeeded');
|
|
},
|
|
complete: done
|
|
});
|
|
});
|
|
|
|
t('Case-insensitive matching for request types', function(assert) {
|
|
var done = assert.async();
|
|
|
|
$.mockjax({
|
|
url: '/case_insensitive_match',
|
|
type: 'GET',
|
|
responseText: 'uppercase type response'
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/case_insensitive_match',
|
|
type: 'get',
|
|
error: qunit.noErrorCallbackExpected,
|
|
complete: function(xhr) {
|
|
assert.equal(xhr.responseText, 'uppercase type response', 'Request matched regardless of case');
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
t('Inspecting $.mockjax.handler(id) after request has fired', function(assert) {
|
|
var ID = $.mockjax({
|
|
url: '/mockjax_properties',
|
|
responseText: 'Hello Word'
|
|
});
|
|
|
|
$.ajax({
|
|
url: '/mockjax_properties',
|
|
complete: function() {}
|
|
});
|
|
|
|
assert.ok($.mockjax.handler(ID).fired, 'Sets the mock\'s fired property to true');
|
|
});
|
|
|
|
t('Inspecting $.mockjax.handlers() for type and length', function(assert) {
|
|
assert.ok(Array.isArray($.mockjax.handlers()), 'The list of handlers is an array before any mocks');
|
|
assert.strictEqual($.mockjax.handlers().length, 0, 'The list of handlers is empty before any mocks');
|
|
|
|
$.mockjax({ url: '/foo', responseText: 'Hello Word' });
|
|
|
|
assert.ok(Array.isArray($.mockjax.handlers()), 'The list of handlers is an array after adding a mock');
|
|
assert.strictEqual($.mockjax.handlers().length, 1, 'The length of the list of handlers is correct after adding a mock');
|
|
|
|
$.mockjax({ url: '/bar', responseText: 'Hello Word' });
|
|
$.mockjax({ url: '/bat', responseText: 'Hello Word' });
|
|
$.mockjax({ url: '/baz', responseText: 'Hello Word' });
|
|
|
|
assert.ok(Array.isArray($.mockjax.handlers()), 'The list of handlers is an array after adding many mocks');
|
|
assert.strictEqual($.mockjax.handlers().length, 4, 'The length of the list of handlers is correct after adding many mocks');
|
|
});
|
|
|
|
t('Testing $.mockjax.handlers() after clearing', function(assert) {
|
|
$.mockjax({ url: '/foo', responseText: 'Hello Word' });
|
|
$.mockjax({ url: '/bar', responseText: 'Hello Word' });
|
|
$.mockjax({ url: '/bat', responseText: 'Hello Word' });
|
|
$.mockjax({ url: '/baz', responseText: 'Hello Word' });
|
|
|
|
assert.ok(Array.isArray($.mockjax.handlers()), 'The list of handlers is an array after adding mocks');
|
|
assert.strictEqual($.mockjax.handlers().length, 4, 'The length of the list of handlers is correct after adding mocks');
|
|
|
|
$.mockjax.clear(1);
|
|
|
|
assert.ok(Array.isArray($.mockjax.handlers()), 'The list of handlers is an array after clearing mock');
|
|
assert.strictEqual($.mockjax.handlers().length, 4, 'The length of the list of handlers is correct after clearing mock');
|
|
assert.strictEqual($.mockjax.handlers()[0].url, '/foo', 'The first handler is correct after clearing');
|
|
assert.strictEqual($.mockjax.handlers()[1], null, 'The cleared handler is correct after clearing');
|
|
assert.strictEqual($.mockjax.handlers()[3].url, '/baz', 'The last handler is correct after clearing');
|
|
});
|
|
|
|
|
|
t('Inspecting $.mockjax() with multiple mocks argument', function(assert) {
|
|
var done = assert.async();
|
|
var handlers = $.mockjax([
|
|
{ url: '/response-callback', responseText: 'First' },
|
|
{ url: '/response-callback', responseText: 'Second' }
|
|
]);
|
|
|
|
assert.equal(handlers.length, 2, 'Not enough mocks');
|
|
|
|
var callCount = 2;
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
complete: function() {
|
|
callCount--;
|
|
if (callCount === 0) {
|
|
done();
|
|
}
|
|
}
|
|
});
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
complete: function() {
|
|
callCount--;
|
|
if (callCount === 0) {
|
|
done();
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
t('Inspecting $.mockjax() with empty multiple mocks argument', function(assert) {
|
|
var done = assert.async();
|
|
var handlers = $.mockjax([]);
|
|
|
|
assert.equal(handlers.length, 0);
|
|
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
error: function() {
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
t('Inspecting $.mockjax() with null in multiple mocks argument', function(assert) {
|
|
var done = assert.async();
|
|
var handlers = $.mockjax([ null ]);
|
|
|
|
assert.equal(handlers.length, 1);
|
|
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
error: function() {
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
t('Inspecting $.mockjax() with multiple mocks argument and reset handler', function(assert) {
|
|
var done = assert.async();
|
|
var handlers = $.mockjax([
|
|
{ url: '/rest', responseText: 'will be reset' }
|
|
]);
|
|
|
|
assert.equal(handlers.length, 1);
|
|
$.mockjax.clear(handlers[0]);
|
|
|
|
$.ajax({
|
|
url: '/response-callback',
|
|
error: function() {
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
|
|
})(window.QUnit, window.jQuery);
|