2d0bf42151
- Some libraries are relying on it existing, even though the specs doesn't say it should. Fix #91
672 lines
22 KiB
JavaScript
672 lines
22 KiB
JavaScript
describe('FakeRequest', function() {
|
|
beforeEach(function() {
|
|
this.requestTracker = { track: jasmine.createSpy('trackRequest') };
|
|
this.stubTracker = { findStub: function() {} };
|
|
var parserInstance = this.parserInstance = jasmine.createSpy('parse');
|
|
this.paramParser = { findParser: function() { return { parse: parserInstance }; } };
|
|
this.fakeGlobal = {
|
|
XMLHttpRequest: function() {
|
|
this.extraAttribute = 'my cool attribute';
|
|
},
|
|
DOMParser: window.DOMParser,
|
|
ActiveXObject: window.ActiveXObject
|
|
};
|
|
this.FakeRequest = getJasmineRequireObj().AjaxFakeRequest()(this.fakeGlobal, this.requestTracker, this.stubTracker, this.paramParser);
|
|
});
|
|
|
|
it('extends from the global XMLHttpRequest', function() {
|
|
var request = new this.FakeRequest();
|
|
|
|
expect(request.extraAttribute).toEqual('my cool attribute');
|
|
});
|
|
|
|
it('skips XMLHttpRequest attributes that IE does not want copied', function() {
|
|
// use real window here so it will correctly go red on IE if it breaks
|
|
var FakeRequest = getJasmineRequireObj().AjaxFakeRequest()(window, this.requestTracker, this.stubTracker, this.paramParser);
|
|
var request = new FakeRequest();
|
|
|
|
expect(request.responseBody).toBeUndefined();
|
|
expect(request.responseXML).toBeUndefined();
|
|
expect(request.statusText).toBeUndefined();
|
|
});
|
|
|
|
it('tracks the request', function() {
|
|
var request = new this.FakeRequest();
|
|
|
|
expect(this.requestTracker.track).toHaveBeenCalledWith(request);
|
|
});
|
|
|
|
it('has default request headers and override mime type', function() {
|
|
var request = new this.FakeRequest();
|
|
|
|
expect(request.requestHeaders).toEqual({});
|
|
expect(request.overriddenMimeType).toBeNull();
|
|
});
|
|
|
|
it('saves request information when opened', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open('METHOD', 'URL', 'ignore_async', 'USERNAME', 'PASSWORD');
|
|
|
|
expect(request.method).toEqual('METHOD');
|
|
expect(request.url).toEqual('URL');
|
|
expect(request.username).toEqual('USERNAME');
|
|
expect(request.password).toEqual('PASSWORD');
|
|
});
|
|
|
|
it('saves an override mime type', function() {
|
|
var request = new this.FakeRequest();
|
|
|
|
request.overrideMimeType('application/text; charset: utf-8');
|
|
|
|
expect(request.overriddenMimeType).toBe('application/text; charset: utf-8');
|
|
});
|
|
|
|
it('saves request headers', function() {
|
|
var request = new this.FakeRequest();
|
|
|
|
request.setRequestHeader('X-Header-1', 'value1');
|
|
request.setRequestHeader('X-Header-2', 'value2');
|
|
|
|
expect(request.requestHeaders).toEqual({
|
|
'X-Header-1': 'value1',
|
|
'X-Header-2': 'value2'
|
|
});
|
|
});
|
|
|
|
it('combines request headers with the same header name', function() {
|
|
var request = new this.FakeRequest();
|
|
|
|
request.setRequestHeader('X-Header', 'value1');
|
|
request.setRequestHeader('X-Header', 'value2');
|
|
|
|
expect(request.requestHeaders['X-Header']).toEqual('value1, value2');
|
|
});
|
|
|
|
it('finds the content-type request header', function() {
|
|
var request = new this.FakeRequest();
|
|
|
|
request.setRequestHeader('ContEnt-tYPe', 'application/text+xml');
|
|
|
|
expect(request.contentType()).toEqual('application/text+xml');
|
|
});
|
|
|
|
describe('managing readyState', function() {
|
|
beforeEach(function() {
|
|
this.request = new this.FakeRequest();
|
|
this.request.onreadystatechange = jasmine.createSpy('onreadystatechange');
|
|
});
|
|
|
|
it('has an initial ready state of 0 (uninitialized)', function() {
|
|
expect(this.request.readyState).toBe(0);
|
|
expect(this.request.onreadystatechange).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('has a ready state of 1 (open) when opened', function() {
|
|
this.request.open();
|
|
|
|
expect(this.request.readyState).toBe(1);
|
|
expect(this.request.onreadystatechange).toHaveBeenCalled();
|
|
});
|
|
|
|
it('has a ready state of 0 (uninitialized) when aborted', function() {
|
|
this.request.open();
|
|
this.request.onreadystatechange.calls.reset();
|
|
|
|
this.request.abort();
|
|
|
|
expect(this.request.readyState).toBe(0);
|
|
expect(this.request.onreadystatechange).toHaveBeenCalled();
|
|
});
|
|
|
|
it('has a ready state of 2 (sent) when sent', function() {
|
|
this.request.open();
|
|
this.request.onreadystatechange.calls.reset();
|
|
|
|
this.request.send();
|
|
|
|
expect(this.request.readyState).toBe(2);
|
|
expect(this.request.onreadystatechange).toHaveBeenCalled();
|
|
});
|
|
|
|
it('has a ready state of 4 (loaded) when timed out', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
this.request.onreadystatechange.calls.reset();
|
|
|
|
jasmine.clock().install();
|
|
this.request.responseTimeout();
|
|
jasmine.clock().uninstall();
|
|
|
|
expect(this.request.readyState).toBe(4);
|
|
expect(this.request.onreadystatechange).toHaveBeenCalledWith('timeout');
|
|
});
|
|
|
|
it('has a ready state of 4 (loaded) when network erroring', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
this.request.onreadystatechange.calls.reset();
|
|
|
|
this.request.responseError();
|
|
|
|
expect(this.request.readyState).toBe(4);
|
|
expect(this.request.onreadystatechange).toHaveBeenCalled();
|
|
});
|
|
|
|
it('has a ready state of 4 (loaded) when responding', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
this.request.onreadystatechange.calls.reset();
|
|
|
|
this.request.respondWith({});
|
|
|
|
expect(this.request.readyState).toBe(4);
|
|
expect(this.request.onreadystatechange).toHaveBeenCalled();
|
|
});
|
|
|
|
it('throws an error when timing out a request that has completed', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
this.request.respondWith({});
|
|
var request = this.request;
|
|
|
|
expect(function() {
|
|
request.responseTimeout();
|
|
}).toThrowError('FakeXMLHttpRequest already completed');
|
|
});
|
|
|
|
it('throws an error when responding to a request that has completed', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
this.request.respondWith({});
|
|
var request = this.request;
|
|
|
|
expect(function() {
|
|
request.respondWith({});
|
|
}).toThrowError('FakeXMLHttpRequest already completed');
|
|
});
|
|
|
|
it('throws an error when erroring a request that has completed', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
this.request.respondWith({});
|
|
var request = this.request;
|
|
|
|
expect(function() {
|
|
request.responseError({});
|
|
}).toThrowError('FakeXMLHttpRequest already completed');
|
|
});
|
|
});
|
|
|
|
describe('triggering progress events', function() {
|
|
beforeEach(function() {
|
|
this.request = new this.FakeRequest();
|
|
|
|
spyOn(this.request, 'onloadstart');
|
|
spyOn(this.request, 'onprogress');
|
|
spyOn(this.request, 'onabort');
|
|
spyOn(this.request, 'onerror');
|
|
spyOn(this.request, 'onload');
|
|
spyOn(this.request, 'ontimeout');
|
|
spyOn(this.request, 'onloadend');
|
|
|
|
var spies = {};
|
|
|
|
spies.loadstart1 = jasmine.createSpy('loadstart1');
|
|
spies.loadstart2 = jasmine.createSpy('loadstart2');
|
|
this.request.addEventListener('loadstart', spies.loadstart1);
|
|
this.request.addEventListener('loadstart', spies.loadstart2);
|
|
|
|
spies.progress1 = jasmine.createSpy('progress1');
|
|
spies.progress2 = jasmine.createSpy('progress2');
|
|
this.request.addEventListener('progress', spies.progress1);
|
|
this.request.addEventListener('progress', spies.progress2);
|
|
|
|
spies.abort1 = jasmine.createSpy('abort1');
|
|
spies.abort2 = jasmine.createSpy('abort2');
|
|
this.request.addEventListener('abort', spies.abort1);
|
|
this.request.addEventListener('abort', spies.abort2);
|
|
|
|
spies.error1 = jasmine.createSpy('error1');
|
|
spies.error2 = jasmine.createSpy('error2');
|
|
this.request.addEventListener('error', spies.error1);
|
|
this.request.addEventListener('error', spies.error2);
|
|
|
|
spies.load1 = jasmine.createSpy('load1');
|
|
spies.load2 = jasmine.createSpy('load2');
|
|
this.request.addEventListener('load', spies.load1);
|
|
this.request.addEventListener('load', spies.load2);
|
|
|
|
spies.timeout1 = jasmine.createSpy('timeout1');
|
|
spies.timeout2 = jasmine.createSpy('timeout2');
|
|
this.request.addEventListener('timeout', spies.timeout1);
|
|
this.request.addEventListener('timeout', spies.timeout2);
|
|
|
|
spies.loadend1 = jasmine.createSpy('loadend1');
|
|
spies.loadend2 = jasmine.createSpy('loadend2');
|
|
this.request.addEventListener('loadend', spies.loadend1);
|
|
this.request.addEventListener('loadend', spies.loadend2);
|
|
|
|
this.resetEvents = function() {
|
|
var request = this.request;
|
|
var events = ['loadstart', 'progress', 'abort', 'error', 'load', 'timeout', 'loadend'];
|
|
for (var index in events) {
|
|
var event = events[index];
|
|
request['on' + event].calls.reset();
|
|
spies[event + '1'].calls.reset();
|
|
spies[event + '2'].calls.reset();
|
|
}
|
|
};
|
|
|
|
jasmine.addMatchers({
|
|
toHaveTriggeredEvent: function(util) {
|
|
return {
|
|
compare: function(actual, expected) {
|
|
var direct = actual['on' + expected].calls.any();
|
|
var event1 = spies[expected + '1'].calls.any();
|
|
var event2 = spies[expected + '2'].calls.any();
|
|
var pass = direct && event1 && event2;
|
|
|
|
var missed = [], triggered = [];
|
|
|
|
(direct ? triggered : missed).push('direct');
|
|
(event1 ? triggered : missed).push(expected + '1');
|
|
(event2 ? triggered : missed).push(expected + '2');
|
|
|
|
return {
|
|
pass: pass,
|
|
message: pass ?
|
|
'Expected XHR not to have triggered ' + expected + ' but ' + triggered.join(', ') + ' triggered' :
|
|
'Expected XHR to have triggered ' + expected + ' but ' + missed.join(', ') + " didn't trigger"
|
|
};
|
|
}
|
|
};
|
|
}
|
|
});
|
|
});
|
|
|
|
it('should not trigger any events to start', function() {
|
|
this.request.open();
|
|
|
|
expect(this.request).not.toHaveTriggeredEvent('loadstart');
|
|
expect(this.request).not.toHaveTriggeredEvent('progress');
|
|
expect(this.request).not.toHaveTriggeredEvent('abort');
|
|
expect(this.request).not.toHaveTriggeredEvent('error');
|
|
expect(this.request).not.toHaveTriggeredEvent('load');
|
|
expect(this.request).not.toHaveTriggeredEvent('timeout');
|
|
expect(this.request).not.toHaveTriggeredEvent('loadend');
|
|
});
|
|
|
|
it('should trigger loadstart when sent', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
|
|
expect(this.request).toHaveTriggeredEvent('loadstart');
|
|
expect(this.request).not.toHaveTriggeredEvent('progress');
|
|
expect(this.request).not.toHaveTriggeredEvent('abort');
|
|
expect(this.request).not.toHaveTriggeredEvent('error');
|
|
expect(this.request).not.toHaveTriggeredEvent('load');
|
|
expect(this.request).not.toHaveTriggeredEvent('timeout');
|
|
expect(this.request).not.toHaveTriggeredEvent('loadend');
|
|
});
|
|
|
|
it('should trigger abort, progress, loadend when aborted', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
|
|
this.resetEvents();
|
|
|
|
this.request.abort();
|
|
|
|
expect(this.request).not.toHaveTriggeredEvent('loadstart');
|
|
expect(this.request).toHaveTriggeredEvent('progress');
|
|
expect(this.request).toHaveTriggeredEvent('abort');
|
|
expect(this.request).not.toHaveTriggeredEvent('error');
|
|
expect(this.request).not.toHaveTriggeredEvent('load');
|
|
expect(this.request).not.toHaveTriggeredEvent('timeout');
|
|
expect(this.request).toHaveTriggeredEvent('loadend');
|
|
});
|
|
|
|
it('should trigger error, progress, loadend when network error', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
|
|
this.resetEvents();
|
|
|
|
this.request.responseError();
|
|
|
|
expect(this.request).not.toHaveTriggeredEvent('loadstart');
|
|
expect(this.request).toHaveTriggeredEvent('progress');
|
|
expect(this.request).not.toHaveTriggeredEvent('abort');
|
|
expect(this.request).toHaveTriggeredEvent('error');
|
|
expect(this.request).not.toHaveTriggeredEvent('load');
|
|
expect(this.request).not.toHaveTriggeredEvent('timeout');
|
|
expect(this.request).toHaveTriggeredEvent('loadend');
|
|
});
|
|
|
|
it('should trigger timeout, progress, loadend when timing out', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
|
|
this.resetEvents();
|
|
|
|
jasmine.clock().install();
|
|
this.request.responseTimeout();
|
|
jasmine.clock().uninstall();
|
|
|
|
expect(this.request).not.toHaveTriggeredEvent('loadstart');
|
|
expect(this.request).toHaveTriggeredEvent('progress');
|
|
expect(this.request).not.toHaveTriggeredEvent('abort');
|
|
expect(this.request).not.toHaveTriggeredEvent('error');
|
|
expect(this.request).not.toHaveTriggeredEvent('load');
|
|
expect(this.request).toHaveTriggeredEvent('timeout');
|
|
expect(this.request).toHaveTriggeredEvent('loadend');
|
|
});
|
|
|
|
it('should trigger load, progress, loadend when responding', function() {
|
|
this.request.open();
|
|
this.request.send();
|
|
|
|
this.resetEvents();
|
|
|
|
this.request.respondWith({ status: 200 });
|
|
|
|
expect(this.request).not.toHaveTriggeredEvent('loadstart');
|
|
expect(this.request).toHaveTriggeredEvent('progress');
|
|
expect(this.request).not.toHaveTriggeredEvent('abort');
|
|
expect(this.request).not.toHaveTriggeredEvent('error');
|
|
expect(this.request).toHaveTriggeredEvent('load');
|
|
expect(this.request).not.toHaveTriggeredEvent('timeout');
|
|
expect(this.request).toHaveTriggeredEvent('loadend');
|
|
});
|
|
});
|
|
|
|
it('ticks the jasmine clock on timeout', function() {
|
|
var clock = { tick: jasmine.createSpy('tick') };
|
|
spyOn(jasmine, 'clock').and.returnValue(clock);
|
|
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.responseTimeout();
|
|
|
|
expect(clock.tick).toHaveBeenCalledWith(30000);
|
|
});
|
|
|
|
it('has an initial status of null', function() {
|
|
var request = new this.FakeRequest();
|
|
|
|
expect(request.status).toBeNull();
|
|
});
|
|
|
|
it('has an aborted status', function() {
|
|
var request = new this.FakeRequest();
|
|
|
|
request.abort();
|
|
|
|
expect(request.status).toBe(0);
|
|
expect(request.statusText).toBe('abort');
|
|
});
|
|
|
|
it('has a status from the response', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200 });
|
|
|
|
expect(request.status).toBe(200);
|
|
expect(request.statusText).toBe('');
|
|
});
|
|
|
|
it('has a statusText from the response', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200, statusText: 'OK' });
|
|
|
|
expect(request.status).toBe(200);
|
|
expect(request.statusText).toBe('OK');
|
|
});
|
|
|
|
it('saves off any data sent to the server', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send('foo=bar&baz=quux');
|
|
|
|
expect(request.params).toBe('foo=bar&baz=quux');
|
|
});
|
|
|
|
it('parses data sent to the server', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send('foo=bar&baz=quux');
|
|
|
|
this.parserInstance.and.returnValue('parsed');
|
|
|
|
expect(request.data()).toBe('parsed');
|
|
});
|
|
|
|
it('skips parsing if no data was sent', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
expect(request.data()).toEqual({});
|
|
expect(this.parserInstance).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('saves responseText', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200, responseText: 'foobar' });
|
|
|
|
expect(request.responseText).toBe('foobar');
|
|
});
|
|
|
|
it('defaults responseText if none is given', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200 });
|
|
|
|
expect(request.responseText).toBe('');
|
|
});
|
|
|
|
it('retrieves individual response headers', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({
|
|
status: 200,
|
|
responseHeaders: {
|
|
'X-Header': 'foo'
|
|
}
|
|
});
|
|
|
|
expect(request.getResponseHeader('X-Header')).toBe('foo');
|
|
});
|
|
|
|
it('retrieves individual response headers case-insensitively', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({
|
|
status: 200,
|
|
responseHeaders: {
|
|
'X-Header': 'foo'
|
|
}
|
|
});
|
|
|
|
expect(request.getResponseHeader('x-header')).toBe('foo');
|
|
});
|
|
|
|
it('retrieves a combined response header', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({
|
|
status: 200,
|
|
responseHeaders: [
|
|
{ name: 'X-Header', value: 'foo' },
|
|
{ name: 'X-Header', value: 'bar' }
|
|
]
|
|
});
|
|
|
|
expect(request.getResponseHeader('x-header')).toBe('foo, bar');
|
|
});
|
|
|
|
it("doesn't pollute the response headers of other XHRs", function() {
|
|
var request1 = new this.FakeRequest();
|
|
request1.open();
|
|
request1.send();
|
|
|
|
var request2 = new this.FakeRequest();
|
|
request2.open();
|
|
request2.send();
|
|
|
|
request1.respondWith({ status: 200, responseHeaders: { 'X-Foo': 'bar' } });
|
|
request2.respondWith({ status: 200, responseHeaders: { 'X-Baz': 'quux' } });
|
|
|
|
expect(request1.getAllResponseHeaders()).toBe("X-Foo: bar\r\n");
|
|
expect(request2.getAllResponseHeaders()).toBe("X-Baz: quux\r\n");
|
|
});
|
|
|
|
it('retrieves all response headers', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({
|
|
status: 200,
|
|
responseHeaders: [
|
|
{ name: 'X-Header-1', value: 'foo' },
|
|
{ name: 'X-Header-2', value: 'bar' },
|
|
{ name: 'X-Header-1', value: 'baz' }
|
|
]
|
|
});
|
|
|
|
expect(request.getAllResponseHeaders()).toBe("X-Header-1: foo\r\nX-Header-2: bar\r\nX-Header-1: baz\r\n");
|
|
});
|
|
|
|
it('sets the content-type header to the specified contentType when no other headers are supplied', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200, contentType: 'text/plain' });
|
|
|
|
expect(request.getResponseHeader('content-type')).toBe('text/plain');
|
|
expect(request.getAllResponseHeaders()).toBe("Content-Type: text/plain\r\n");
|
|
});
|
|
|
|
it('sets a default content-type header if no contentType and headers are supplied', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200 });
|
|
|
|
expect(request.getResponseHeader('content-type')).toBe('application/json');
|
|
expect(request.getAllResponseHeaders()).toBe("Content-Type: application/json\r\n");
|
|
});
|
|
|
|
it('has no responseXML by default', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200 });
|
|
|
|
expect(request.responseXML).toBeNull();
|
|
});
|
|
|
|
it('parses a text/xml document into responseXML', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200, contentType: 'text/xml', responseText: '<dom><stuff/></dom>' });
|
|
|
|
if (typeof window.Document !== 'undefined') {
|
|
expect(request.responseXML instanceof window.Document).toBe(true);
|
|
expect(request.response instanceof window.Document).toBe(true);
|
|
} else {
|
|
// IE 8
|
|
expect(request.responseXML instanceof window.ActiveXObject).toBe(true);
|
|
expect(request.response instanceof window.ActiveXObject).toBe(true);
|
|
}
|
|
});
|
|
|
|
it('parses an application/xml document into responseXML', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200, contentType: 'application/xml', responseText: '<dom><stuff/></dom>' });
|
|
|
|
if (typeof window.Document !== 'undefined') {
|
|
expect(request.responseXML instanceof window.Document).toBe(true);
|
|
expect(request.response instanceof window.Document).toBe(true);
|
|
} else {
|
|
// IE 8
|
|
expect(request.responseXML instanceof window.ActiveXObject).toBe(true);
|
|
expect(request.response instanceof window.ActiveXObject).toBe(true);
|
|
}
|
|
});
|
|
|
|
it('parses a custom blah+xml document into responseXML', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200, contentType: 'application/text+xml', responseText: '<dom><stuff/></dom>' });
|
|
|
|
if (typeof window.Document !== 'undefined') {
|
|
expect(request.responseXML instanceof window.Document).toBe(true);
|
|
expect(request.response instanceof window.Document).toBe(true);
|
|
} else {
|
|
// IE 8
|
|
expect(request.responseXML instanceof window.ActiveXObject).toBe(true);
|
|
expect(request.response instanceof window.ActiveXObject).toBe(true);
|
|
}
|
|
});
|
|
|
|
it('defaults the response attribute to the responseText', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200, responseText: 'foo' });
|
|
|
|
expect(request.response).toEqual('foo');
|
|
});
|
|
|
|
it('has a text response when the responseType is blank', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200, responseText: 'foo', responseType: '' });
|
|
|
|
expect(request.response).toEqual('foo');
|
|
});
|
|
|
|
it('has a text response when the responseType is text', function() {
|
|
var request = new this.FakeRequest();
|
|
request.open();
|
|
request.send();
|
|
|
|
request.respondWith({ status: 200, responseText: 'foo', responseType: 'text' });
|
|
|
|
expect(request.response).toEqual('foo');
|
|
});
|
|
});
|