refactor(http): move http files to top-level module
Closes #2680 Closes #3417
This commit is contained in:
Jeff Cross
@ -1,179 +0,0 @@
|
||||
import {
|
||||
AsyncTestCompleter,
|
||||
afterEach,
|
||||
beforeEach,
|
||||
ddescribe,
|
||||
describe,
|
||||
expect,
|
||||
iit,
|
||||
inject,
|
||||
it,
|
||||
xit,
|
||||
SpyObject
|
||||
} from 'angular2/test_lib';
|
||||
import {ObservableWrapper} from 'angular2/src/facade/async';
|
||||
import {BrowserJsonp} from 'angular2/src/http/backends/browser_jsonp';
|
||||
import {JSONPConnection, JSONPBackend} from 'angular2/src/http/backends/jsonp_backend';
|
||||
import {bind, Injector} from 'angular2/di';
|
||||
import {isPresent, StringWrapper} from 'angular2/src/facade/lang';
|
||||
import {TimerWrapper} from 'angular2/src/facade/async';
|
||||
import {Request} from 'angular2/src/http/static_request';
|
||||
import {Response} from 'angular2/src/http/static_response';
|
||||
import {Map} from 'angular2/src/facade/collection';
|
||||
import {RequestOptions, BaseRequestOptions} from 'angular2/src/http/base_request_options';
|
||||
import {BaseResponseOptions, ResponseOptions} from 'angular2/src/http/base_response_options';
|
||||
import {ResponseTypes, ReadyStates, RequestMethods} from 'angular2/src/http/enums';
|
||||
|
||||
var addEventListenerSpy;
|
||||
var existingScripts = [];
|
||||
var unused: Response;
|
||||
|
||||
class MockBrowserJsonp extends BrowserJsonp {
|
||||
src: string;
|
||||
callbacks: Map<string, (data: any) => any>;
|
||||
constructor() {
|
||||
super();
|
||||
this.callbacks = new Map();
|
||||
}
|
||||
|
||||
addEventListener(type: string, cb: (data: any) => any) { this.callbacks.set(type, cb); }
|
||||
|
||||
dispatchEvent(type: string, argument?: any) {
|
||||
if (!isPresent(argument)) {
|
||||
argument = {};
|
||||
}
|
||||
this.callbacks.get(type)(argument);
|
||||
}
|
||||
|
||||
build(url: string) {
|
||||
var script = new MockBrowserJsonp();
|
||||
script.src = url;
|
||||
existingScripts.push(script);
|
||||
return script;
|
||||
}
|
||||
|
||||
send(node: any) { /* noop */
|
||||
}
|
||||
cleanup(node: any) { /* noop */
|
||||
}
|
||||
}
|
||||
|
||||
export function main() {
|
||||
describe('JSONPBackend', () => {
|
||||
let backend;
|
||||
let sampleRequest;
|
||||
|
||||
beforeEach(() => {
|
||||
let injector = Injector.resolveAndCreate([
|
||||
bind(ResponseOptions)
|
||||
.toClass(BaseResponseOptions),
|
||||
bind(BrowserJsonp).toClass(MockBrowserJsonp),
|
||||
JSONPBackend
|
||||
]);
|
||||
backend = injector.get(JSONPBackend);
|
||||
let base = new BaseRequestOptions();
|
||||
sampleRequest = new Request(base.merge(new RequestOptions({url: 'https://google.com'})));
|
||||
});
|
||||
|
||||
afterEach(() => { existingScripts = []; });
|
||||
|
||||
it('should create a connection', () => {
|
||||
var instance;
|
||||
expect(() => instance = backend.createConnection(sampleRequest)).not.toThrow();
|
||||
expect(instance).toBeAnInstanceOf(JSONPConnection);
|
||||
});
|
||||
|
||||
|
||||
describe('JSONPConnection', () => {
|
||||
it('should use the injected BaseResponseOptions to create the response',
|
||||
inject([AsyncTestCompleter], async => {
|
||||
let connection = new JSONPConnection(sampleRequest, new MockBrowserJsonp(),
|
||||
new ResponseOptions({type: ResponseTypes.Error}));
|
||||
ObservableWrapper.subscribe<Response>(connection.response, res => {
|
||||
expect(res.type).toBe(ResponseTypes.Error);
|
||||
async.done();
|
||||
});
|
||||
connection.finished();
|
||||
existingScripts[0].dispatchEvent('load');
|
||||
}));
|
||||
|
||||
it('should ignore load/callback when disposed', inject([AsyncTestCompleter], async => {
|
||||
var connection = new JSONPConnection(sampleRequest, new MockBrowserJsonp());
|
||||
let spy = new SpyObject();
|
||||
let loadSpy = spy.spy('load');
|
||||
let errorSpy = spy.spy('error');
|
||||
let returnSpy = spy.spy('cancelled');
|
||||
|
||||
ObservableWrapper.subscribe(connection.response, loadSpy, errorSpy, returnSpy);
|
||||
connection.dispose();
|
||||
expect(connection.readyState).toBe(ReadyStates.CANCELLED);
|
||||
|
||||
connection.finished('Fake data');
|
||||
existingScripts[0].dispatchEvent('load');
|
||||
|
||||
TimerWrapper.setTimeout(() => {
|
||||
expect(loadSpy).not.toHaveBeenCalled();
|
||||
expect(errorSpy).not.toHaveBeenCalled();
|
||||
expect(returnSpy).toHaveBeenCalled();
|
||||
async.done();
|
||||
}, 10);
|
||||
}));
|
||||
|
||||
it('should report error if loaded without invoking callback',
|
||||
inject([AsyncTestCompleter], async => {
|
||||
let connection = new JSONPConnection(sampleRequest, new MockBrowserJsonp());
|
||||
ObservableWrapper.subscribe(
|
||||
connection.response,
|
||||
res => {
|
||||
expect("response listener called").toBe(false);
|
||||
async.done();
|
||||
},
|
||||
err => {
|
||||
expect(StringWrapper.contains(err.message, 'did not invoke callback')).toBe(true);
|
||||
async.done();
|
||||
});
|
||||
|
||||
existingScripts[0].dispatchEvent('load');
|
||||
}));
|
||||
|
||||
it('should report error if script contains error', inject([AsyncTestCompleter], async => {
|
||||
let connection = new JSONPConnection(sampleRequest, new MockBrowserJsonp());
|
||||
|
||||
ObservableWrapper.subscribe(connection.response,
|
||||
res => {
|
||||
expect("response listener called").toBe(false);
|
||||
async.done();
|
||||
},
|
||||
err => {
|
||||
expect(err['message']).toBe('Oops!');
|
||||
async.done();
|
||||
});
|
||||
|
||||
existingScripts[0].dispatchEvent('error', ({message: "Oops!"}));
|
||||
}));
|
||||
|
||||
it('should throw if request method is not GET', () => {
|
||||
[RequestMethods.POST, RequestMethods.PUT, RequestMethods.DELETE, RequestMethods.OPTIONS,
|
||||
RequestMethods.HEAD, RequestMethods.PATCH]
|
||||
.forEach(method => {
|
||||
let base = new BaseRequestOptions();
|
||||
let req = new Request(
|
||||
base.merge(new RequestOptions({url: 'https://google.com', method: method})));
|
||||
expect(() => new JSONPConnection(req, new MockBrowserJsonp())).toThrowError();
|
||||
});
|
||||
});
|
||||
|
||||
it('should respond with data passed to callback', inject([AsyncTestCompleter], async => {
|
||||
let connection = new JSONPConnection(sampleRequest, new MockBrowserJsonp());
|
||||
|
||||
ObservableWrapper.subscribe<Response>(connection.response, res => {
|
||||
expect(res.json()).toEqual(({fake_payload: true, blob_id: 12345}));
|
||||
async.done();
|
||||
});
|
||||
|
||||
connection.finished(({fake_payload: true, blob_id: 12345}));
|
||||
existingScripts[0].dispatchEvent('load');
|
||||
}));
|
||||
});
|
||||
});
|
||||
}
|
||||
@ -1,202 +0,0 @@
|
||||
import {
|
||||
AsyncTestCompleter,
|
||||
afterEach,
|
||||
beforeEach,
|
||||
ddescribe,
|
||||
describe,
|
||||
expect,
|
||||
iit,
|
||||
inject,
|
||||
it,
|
||||
xit,
|
||||
SpyObject
|
||||
} from 'angular2/test_lib';
|
||||
import {ObservableWrapper} from 'angular2/src/facade/async';
|
||||
import {BrowserXhr} from 'angular2/src/http/backends/browser_xhr';
|
||||
import {XHRConnection, XHRBackend} from 'angular2/src/http/backends/xhr_backend';
|
||||
import {bind, Injector} from 'angular2/di';
|
||||
import {Request} from 'angular2/src/http/static_request';
|
||||
import {Response} from 'angular2/src/http/static_response';
|
||||
import {Headers} from 'angular2/src/http/headers';
|
||||
import {Map} from 'angular2/src/facade/collection';
|
||||
import {RequestOptions, BaseRequestOptions} from 'angular2/src/http/base_request_options';
|
||||
import {BaseResponseOptions, ResponseOptions} from 'angular2/src/http/base_response_options';
|
||||
import {ResponseTypes} from 'angular2/src/http/enums';
|
||||
|
||||
var abortSpy;
|
||||
var sendSpy;
|
||||
var openSpy;
|
||||
var setRequestHeaderSpy;
|
||||
var addEventListenerSpy;
|
||||
var existingXHRs = [];
|
||||
var unused: Response;
|
||||
|
||||
class MockBrowserXHR extends BrowserXhr {
|
||||
abort: any;
|
||||
send: any;
|
||||
open: any;
|
||||
response: any;
|
||||
responseText: string;
|
||||
setRequestHeader: any;
|
||||
callbacks: Map<string, Function>;
|
||||
status: number;
|
||||
constructor() {
|
||||
super();
|
||||
var spy = new SpyObject();
|
||||
this.abort = abortSpy = spy.spy('abort');
|
||||
this.send = sendSpy = spy.spy('send');
|
||||
this.open = openSpy = spy.spy('open');
|
||||
this.setRequestHeader = setRequestHeaderSpy = spy.spy('setRequestHeader');
|
||||
this.callbacks = new Map();
|
||||
}
|
||||
|
||||
setStatusCode(status) { this.status = status; }
|
||||
|
||||
setResponse(value) { this.response = value; }
|
||||
|
||||
setResponseText(value) { this.responseText = value; }
|
||||
|
||||
addEventListener(type: string, cb: Function) { this.callbacks.set(type, cb); }
|
||||
|
||||
dispatchEvent(type: string) { this.callbacks.get(type)({}); }
|
||||
|
||||
build() {
|
||||
var xhr = new MockBrowserXHR();
|
||||
existingXHRs.push(xhr);
|
||||
return xhr;
|
||||
}
|
||||
}
|
||||
|
||||
export function main() {
|
||||
describe('XHRBackend', () => {
|
||||
var backend;
|
||||
var sampleRequest;
|
||||
|
||||
beforeEach(() => {
|
||||
var injector = Injector.resolveAndCreate([
|
||||
bind(ResponseOptions)
|
||||
.toClass(BaseResponseOptions),
|
||||
bind(BrowserXhr).toClass(MockBrowserXHR),
|
||||
XHRBackend
|
||||
]);
|
||||
backend = injector.get(XHRBackend);
|
||||
var base = new BaseRequestOptions();
|
||||
sampleRequest = new Request(base.merge(new RequestOptions({url: 'https://google.com'})));
|
||||
});
|
||||
|
||||
afterEach(() => { existingXHRs = []; });
|
||||
|
||||
it('should create a connection',
|
||||
() => { expect(() => backend.createConnection(sampleRequest)).not.toThrow(); });
|
||||
|
||||
|
||||
describe('XHRConnection', () => {
|
||||
it('should use the injected BaseResponseOptions to create the response',
|
||||
inject([AsyncTestCompleter], async => {
|
||||
var connection = new XHRConnection(sampleRequest, new MockBrowserXHR(),
|
||||
new ResponseOptions({type: ResponseTypes.Error}));
|
||||
ObservableWrapper.subscribe<Response>(connection.response, res => {
|
||||
expect(res.type).toBe(ResponseTypes.Error);
|
||||
async.done();
|
||||
});
|
||||
existingXHRs[0].dispatchEvent('load');
|
||||
}));
|
||||
|
||||
it('should complete a request', inject([AsyncTestCompleter], async => {
|
||||
var connection = new XHRConnection(sampleRequest, new MockBrowserXHR(),
|
||||
new ResponseOptions({type: ResponseTypes.Error}));
|
||||
ObservableWrapper.subscribe<Response>(connection.response, res => {
|
||||
expect(res.type).toBe(ResponseTypes.Error);
|
||||
}, null, () => { async.done(); });
|
||||
|
||||
existingXHRs[0].dispatchEvent('load');
|
||||
}));
|
||||
|
||||
it('should call abort when disposed', () => {
|
||||
var connection = new XHRConnection(sampleRequest, new MockBrowserXHR());
|
||||
connection.dispose();
|
||||
expect(abortSpy).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
|
||||
it('should automatically call open with method and url', () => {
|
||||
new XHRConnection(sampleRequest, new MockBrowserXHR());
|
||||
expect(openSpy).toHaveBeenCalledWith('GET', sampleRequest.url);
|
||||
});
|
||||
|
||||
|
||||
it('should automatically call send on the backend with request body', () => {
|
||||
var body = 'Some body to love';
|
||||
var base = new BaseRequestOptions();
|
||||
new XHRConnection(new Request(base.merge(new RequestOptions({body: body}))),
|
||||
new MockBrowserXHR());
|
||||
expect(sendSpy).toHaveBeenCalledWith(body);
|
||||
});
|
||||
|
||||
it('should attach headers to the request', () => {
|
||||
var headers = new Headers({'Content-Type': 'text/xml', 'Breaking-Bad': '<3'});
|
||||
|
||||
var base = new BaseRequestOptions();
|
||||
new XHRConnection(new Request(base.merge(new RequestOptions({headers: headers}))),
|
||||
new MockBrowserXHR());
|
||||
expect(setRequestHeaderSpy).toHaveBeenCalledWith('Content-Type', ['text/xml']);
|
||||
expect(setRequestHeaderSpy).toHaveBeenCalledWith('Breaking-Bad', ['<3']);
|
||||
});
|
||||
|
||||
it('should return the correct status code', inject([AsyncTestCompleter], async => {
|
||||
var statusCode = 418;
|
||||
var connection = new XHRConnection(sampleRequest, new MockBrowserXHR(),
|
||||
new ResponseOptions({status: statusCode}));
|
||||
|
||||
ObservableWrapper.subscribe<Response>(connection.response, res => {
|
||||
expect(res.status).toBe(statusCode);
|
||||
async.done();
|
||||
});
|
||||
|
||||
existingXHRs[0].setStatusCode(statusCode);
|
||||
existingXHRs[0].dispatchEvent('load');
|
||||
}));
|
||||
|
||||
it('should normalize IE\'s 1223 status code into 204', inject([AsyncTestCompleter], async => {
|
||||
var statusCode = 1223;
|
||||
var normalizedCode = 204;
|
||||
var connection = new XHRConnection(sampleRequest, new MockBrowserXHR(),
|
||||
new ResponseOptions({status: statusCode}));
|
||||
|
||||
ObservableWrapper.subscribe<Response>(connection.response, res => {
|
||||
expect(res.status).toBe(normalizedCode);
|
||||
async.done();
|
||||
});
|
||||
|
||||
existingXHRs[0].setStatusCode(statusCode);
|
||||
existingXHRs[0].dispatchEvent('load');
|
||||
}));
|
||||
|
||||
it('should normalize responseText and response', inject([AsyncTestCompleter], async => {
|
||||
var responseBody = 'Doge';
|
||||
|
||||
var connection1 =
|
||||
new XHRConnection(sampleRequest, new MockBrowserXHR(), new ResponseOptions());
|
||||
|
||||
var connection2 =
|
||||
new XHRConnection(sampleRequest, new MockBrowserXHR(), new ResponseOptions());
|
||||
|
||||
ObservableWrapper.subscribe<Response>(connection1.response, res => {
|
||||
expect(res.text()).toBe(responseBody);
|
||||
|
||||
ObservableWrapper.subscribe<Response>(connection2.response, ress => {
|
||||
expect(ress.text()).toBe(responseBody);
|
||||
async.done();
|
||||
});
|
||||
existingXHRs[1].dispatchEvent('load');
|
||||
});
|
||||
|
||||
existingXHRs[0].setResponseText(responseBody);
|
||||
existingXHRs[1].setResponse(responseBody);
|
||||
|
||||
existingXHRs[0].dispatchEvent('load');
|
||||
}));
|
||||
|
||||
});
|
||||
});
|
||||
}
|
||||
@ -1,32 +0,0 @@
|
||||
import {
|
||||
AsyncTestCompleter,
|
||||
beforeEach,
|
||||
ddescribe,
|
||||
describe,
|
||||
expect,
|
||||
iit,
|
||||
inject,
|
||||
it,
|
||||
xit
|
||||
} from 'angular2/test_lib';
|
||||
import {BaseRequestOptions, RequestOptions} from 'angular2/src/http/base_request_options';
|
||||
import {RequestMethods, RequestModesOpts} from 'angular2/src/http/enums';
|
||||
|
||||
export function main() {
|
||||
describe('BaseRequestOptions', () => {
|
||||
it('should create a new object when calling merge', () => {
|
||||
var options1 = new BaseRequestOptions();
|
||||
var options2 = options1.merge(new RequestOptions({method: RequestMethods.DELETE}));
|
||||
expect(options2).not.toBe(options1);
|
||||
expect(options2.method).toBe(RequestMethods.DELETE);
|
||||
});
|
||||
|
||||
it('should retain previously merged values when merging again', () => {
|
||||
var options1 = new BaseRequestOptions();
|
||||
var options2 = options1.merge(new RequestOptions({method: RequestMethods.DELETE}));
|
||||
var options3 = options2.merge(new RequestOptions({mode: RequestModesOpts.NoCors}));
|
||||
expect(options3.mode).toBe(RequestModesOpts.NoCors);
|
||||
expect(options3.method).toBe(RequestMethods.DELETE);
|
||||
});
|
||||
});
|
||||
}
|
||||
@ -1,66 +0,0 @@
|
||||
import {Headers} from 'angular2/src/http/headers';
|
||||
import {Map, StringMapWrapper} from 'angular2/src/facade/collection';
|
||||
import {
|
||||
AsyncTestCompleter,
|
||||
beforeEach,
|
||||
ddescribe,
|
||||
describe,
|
||||
expect,
|
||||
iit,
|
||||
inject,
|
||||
it,
|
||||
xit
|
||||
} from 'angular2/test_lib';
|
||||
|
||||
export function main() {
|
||||
describe('Headers', () => {
|
||||
it('should conform to spec', () => {
|
||||
// Examples borrowed from https://developer.mozilla.org/en-US/docs/Web/API/Headers/Headers
|
||||
// Spec at https://fetch.spec.whatwg.org/#dom-headers
|
||||
var firstHeaders = new Headers(); // Currently empty
|
||||
firstHeaders.append('Content-Type', 'image/jpeg');
|
||||
expect(firstHeaders.get('Content-Type')).toBe('image/jpeg');
|
||||
var httpHeaders = StringMapWrapper.create();
|
||||
StringMapWrapper.set(httpHeaders, 'Content-Type', 'image/jpeg');
|
||||
StringMapWrapper.set(httpHeaders, 'Accept-Charset', 'utf-8');
|
||||
StringMapWrapper.set(httpHeaders, 'X-My-Custom-Header', 'Zeke are cool');
|
||||
var secondHeaders = new Headers(httpHeaders);
|
||||
var secondHeadersObj = new Headers(secondHeaders);
|
||||
expect(secondHeadersObj.get('Content-Type')).toBe('image/jpeg');
|
||||
});
|
||||
|
||||
|
||||
describe('initialization', () => {
|
||||
it('should merge values in provided dictionary', () => {
|
||||
var map = StringMapWrapper.create();
|
||||
StringMapWrapper.set(map, 'foo', 'bar');
|
||||
var headers = new Headers(map);
|
||||
expect(headers.get('foo')).toBe('bar');
|
||||
expect(headers.getAll('foo')).toEqual(['bar']);
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
describe('.set()', () => {
|
||||
it('should clear all values and re-set for the provided key', () => {
|
||||
var map = StringMapWrapper.create();
|
||||
StringMapWrapper.set(map, 'foo', 'bar');
|
||||
var headers = new Headers(map);
|
||||
expect(headers.get('foo')).toBe('bar');
|
||||
expect(headers.getAll('foo')).toEqual(['bar']);
|
||||
headers.set('foo', 'baz');
|
||||
expect(headers.get('foo')).toBe('baz');
|
||||
expect(headers.getAll('foo')).toEqual(['baz']);
|
||||
});
|
||||
|
||||
|
||||
it('should convert input array to string', () => {
|
||||
var headers = new Headers();
|
||||
var inputArr = ['bar', 'baz'];
|
||||
headers.set('foo', inputArr);
|
||||
expect(/bar, ?baz/g.test(headers.get('foo'))).toBe(true);
|
||||
expect(/bar, ?baz/g.test(headers.getAll('foo')[0])).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
@ -1,249 +0,0 @@
|
||||
import {
|
||||
AsyncTestCompleter,
|
||||
afterEach,
|
||||
beforeEach,
|
||||
ddescribe,
|
||||
describe,
|
||||
expect,
|
||||
iit,
|
||||
inject,
|
||||
it,
|
||||
xit,
|
||||
SpyObject
|
||||
} from 'angular2/test_lib';
|
||||
import {Http} from 'angular2/src/http/http';
|
||||
import {Injector, bind} from 'angular2/di';
|
||||
import {MockBackend, MockConnection} from 'angular2/src/http/backends/mock_backend';
|
||||
import {Response} from 'angular2/src/http/static_response';
|
||||
import {RequestMethods} from 'angular2/src/http/enums';
|
||||
import {BaseRequestOptions, RequestOptions} from 'angular2/src/http/base_request_options';
|
||||
import {ResponseOptions} from 'angular2/src/http/base_response_options';
|
||||
import {Request} from 'angular2/src/http/static_request';
|
||||
import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
|
||||
import {ConnectionBackend} from 'angular2/src/http/interfaces';
|
||||
import {URLSearchParams} from 'angular2/src/http/url_search_params';
|
||||
|
||||
class SpyObserver extends SpyObject {
|
||||
onNext: Function;
|
||||
onError: Function;
|
||||
onCompleted: Function;
|
||||
constructor() {
|
||||
super();
|
||||
this.onNext = this.spy('onNext');
|
||||
this.onError = this.spy('onError');
|
||||
this.onCompleted = this.spy('onCompleted');
|
||||
}
|
||||
}
|
||||
|
||||
export function main() {
|
||||
describe('http', () => {
|
||||
var url = 'http://foo.bar';
|
||||
var http: Http;
|
||||
var injector: Injector;
|
||||
var backend: MockBackend;
|
||||
var baseResponse;
|
||||
beforeEach(() => {
|
||||
injector = Injector.resolveAndCreate([
|
||||
BaseRequestOptions,
|
||||
MockBackend,
|
||||
bind(Http).toFactory(
|
||||
function(backend: ConnectionBackend, defaultOptions: BaseRequestOptions) {
|
||||
return new Http(backend, defaultOptions);
|
||||
},
|
||||
[MockBackend, BaseRequestOptions])
|
||||
]);
|
||||
http = injector.get(Http);
|
||||
backend = injector.get(MockBackend);
|
||||
baseResponse = new Response(new ResponseOptions({body: 'base response'}));
|
||||
});
|
||||
|
||||
afterEach(() => backend.verifyNoPendingRequests());
|
||||
|
||||
describe('Http', () => {
|
||||
describe('.request()', () => {
|
||||
it('should return an Observable',
|
||||
() => { expect(ObservableWrapper.isObservable(http.request(url))).toBe(true); });
|
||||
|
||||
|
||||
it('should accept a fully-qualified request as its only parameter',
|
||||
inject([AsyncTestCompleter], (async) => {
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.url).toBe('https://google.com');
|
||||
c.mockRespond(new Response(new ResponseOptions({body: 'Thank you'})));
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(
|
||||
http.request(new Request(new RequestOptions({url: 'https://google.com'}))),
|
||||
(res) => {});
|
||||
}));
|
||||
|
||||
|
||||
it('should perform a get request for given url if only passed a string',
|
||||
inject([AsyncTestCompleter], (async) => {
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections,
|
||||
c => c.mockRespond(baseResponse));
|
||||
ObservableWrapper.subscribe<Response>(http.request('http://basic.connection'), res => {
|
||||
expect(res.text()).toBe('base response');
|
||||
async.done();
|
||||
});
|
||||
}));
|
||||
|
||||
// TODO: make dart not complain about "argument type 'Map' cannot be assigned to the
|
||||
// parameter type 'IRequestOptions'"
|
||||
// xit('should perform a get request for given url if passed a dictionary',
|
||||
// inject([AsyncTestCompleter], async => {
|
||||
// ObservableWrapper.subscribe(backend.connections, c => c.mockRespond(baseResponse));
|
||||
// ObservableWrapper.subscribe(http.request(url, {method: RequestMethods.GET}), res =>
|
||||
// {
|
||||
// expect(res.text()).toBe('base response');
|
||||
// async.done();
|
||||
// });
|
||||
// }));
|
||||
});
|
||||
|
||||
|
||||
describe('.get()', () => {
|
||||
it('should perform a get request for given url', inject([AsyncTestCompleter], async => {
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.method).toBe(RequestMethods.GET);
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(http.get(url), res => {});
|
||||
}));
|
||||
});
|
||||
|
||||
|
||||
describe('.post()', () => {
|
||||
it('should perform a post request for given url', inject([AsyncTestCompleter], async => {
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.method).toBe(RequestMethods.POST);
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(http.post(url, 'post me'), res => {});
|
||||
}));
|
||||
|
||||
|
||||
it('should attach the provided body to the request', inject([AsyncTestCompleter], async => {
|
||||
var body = 'this is my post body';
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.text()).toBe(body);
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(http.post(url, body), res => {});
|
||||
}));
|
||||
});
|
||||
|
||||
|
||||
describe('.put()', () => {
|
||||
it('should perform a put request for given url', inject([AsyncTestCompleter], async => {
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.method).toBe(RequestMethods.PUT);
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(http.put(url, 'put me'), res => {});
|
||||
}));
|
||||
|
||||
it('should attach the provided body to the request', inject([AsyncTestCompleter], async => {
|
||||
var body = 'this is my put body';
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.text()).toBe(body);
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(http.put(url, body), res => {});
|
||||
}));
|
||||
});
|
||||
|
||||
|
||||
describe('.delete()', () => {
|
||||
it('should perform a delete request for given url', inject([AsyncTestCompleter], async => {
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.method).toBe(RequestMethods.DELETE);
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(http.delete(url), res => {});
|
||||
}));
|
||||
});
|
||||
|
||||
|
||||
describe('.patch()', () => {
|
||||
it('should perform a patch request for given url', inject([AsyncTestCompleter], async => {
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.method).toBe(RequestMethods.PATCH);
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(http.patch(url, 'this is my patch body'), res => {});
|
||||
}));
|
||||
|
||||
it('should attach the provided body to the request', inject([AsyncTestCompleter], async => {
|
||||
var body = 'this is my patch body';
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.text()).toBe(body);
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(http.patch(url, body), res => {});
|
||||
}));
|
||||
});
|
||||
|
||||
|
||||
describe('.head()', () => {
|
||||
it('should perform a head request for given url', inject([AsyncTestCompleter], async => {
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.method).toBe(RequestMethods.HEAD);
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(http.head(url), res => {});
|
||||
}));
|
||||
});
|
||||
|
||||
|
||||
describe('searchParams', () => {
|
||||
it('should append search params to url', inject([AsyncTestCompleter], async => {
|
||||
var params = new URLSearchParams();
|
||||
params.append('q', 'puppies');
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.url).toEqual('https://www.google.com?q=puppies');
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(
|
||||
http.get('https://www.google.com', new RequestOptions({search: params})),
|
||||
res => {});
|
||||
}));
|
||||
|
||||
|
||||
it('should append string search params to url', inject([AsyncTestCompleter], async => {
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.url).toEqual('https://www.google.com?q=piggies');
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(
|
||||
http.get('https://www.google.com', new RequestOptions({search: 'q=piggies'})),
|
||||
res => {});
|
||||
}));
|
||||
|
||||
|
||||
it('should produce valid url when url already contains a query',
|
||||
inject([AsyncTestCompleter], async => {
|
||||
ObservableWrapper.subscribe<MockConnection>(backend.connections, c => {
|
||||
expect(c.request.url).toEqual('https://www.google.com?q=angular&as_eq=1.x');
|
||||
backend.resolveAllConnections();
|
||||
async.done();
|
||||
});
|
||||
ObservableWrapper.subscribe(http.get('https://www.google.com?q=angular',
|
||||
new RequestOptions({search: 'as_eq=1.x'})),
|
||||
res => {});
|
||||
}));
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
@ -1,80 +0,0 @@
|
||||
import {
|
||||
AsyncTestCompleter,
|
||||
beforeEach,
|
||||
ddescribe,
|
||||
describe,
|
||||
expect,
|
||||
iit,
|
||||
inject,
|
||||
it,
|
||||
xit
|
||||
} from 'angular2/test_lib';
|
||||
import {URLSearchParams} from 'angular2/src/http/url_search_params';
|
||||
|
||||
export function main() {
|
||||
describe('URLSearchParams', () => {
|
||||
it('should conform to spec', () => {
|
||||
var paramsString = "q=URLUtils.searchParams&topic=api";
|
||||
var searchParams = new URLSearchParams(paramsString);
|
||||
|
||||
// Tests borrowed from example at
|
||||
// https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams
|
||||
// Compliant with spec described at https://url.spec.whatwg.org/#urlsearchparams
|
||||
expect(searchParams.has("topic")).toBe(true);
|
||||
expect(searchParams.has("foo")).toBe(false);
|
||||
expect(searchParams.get("topic")).toEqual("api");
|
||||
expect(searchParams.getAll("topic")).toEqual(["api"]);
|
||||
expect(searchParams.get("foo")).toBe(null);
|
||||
searchParams.append("topic", "webdev");
|
||||
expect(searchParams.getAll("topic")).toEqual(["api", "webdev"]);
|
||||
expect(searchParams.toString()).toEqual("q=URLUtils.searchParams&topic=api&topic=webdev");
|
||||
searchParams.delete("topic");
|
||||
expect(searchParams.toString()).toEqual("q=URLUtils.searchParams");
|
||||
|
||||
// Test default constructor
|
||||
expect(new URLSearchParams().toString()).toBe("");
|
||||
});
|
||||
|
||||
|
||||
it('should support map-like merging operation via setAll()', () => {
|
||||
var mapA = new URLSearchParams('a=1&a=2&a=3&c=8');
|
||||
var mapB = new URLSearchParams('a=4&a=5&a=6&b=7');
|
||||
mapA.setAll(mapB);
|
||||
expect(mapA.has('a')).toBe(true);
|
||||
expect(mapA.has('b')).toBe(true);
|
||||
expect(mapA.has('c')).toBe(true);
|
||||
expect(mapA.getAll('a')).toEqual(['4']);
|
||||
expect(mapA.getAll('b')).toEqual(['7']);
|
||||
expect(mapA.getAll('c')).toEqual(['8']);
|
||||
expect(mapA.toString()).toEqual('a=4&c=8&b=7');
|
||||
});
|
||||
|
||||
|
||||
it('should support multimap-like merging operation via appendAll()', () => {
|
||||
var mapA = new URLSearchParams('a=1&a=2&a=3&c=8');
|
||||
var mapB = new URLSearchParams('a=4&a=5&a=6&b=7');
|
||||
mapA.appendAll(mapB);
|
||||
expect(mapA.has('a')).toBe(true);
|
||||
expect(mapA.has('b')).toBe(true);
|
||||
expect(mapA.has('c')).toBe(true);
|
||||
expect(mapA.getAll('a')).toEqual(['1', '2', '3', '4', '5', '6']);
|
||||
expect(mapA.getAll('b')).toEqual(['7']);
|
||||
expect(mapA.getAll('c')).toEqual(['8']);
|
||||
expect(mapA.toString()).toEqual('a=1&a=2&a=3&a=4&a=5&a=6&c=8&b=7');
|
||||
});
|
||||
|
||||
|
||||
it('should support multimap-like merging operation via replaceAll()', () => {
|
||||
var mapA = new URLSearchParams('a=1&a=2&a=3&c=8');
|
||||
var mapB = new URLSearchParams('a=4&a=5&a=6&b=7');
|
||||
mapA.replaceAll(mapB);
|
||||
expect(mapA.has('a')).toBe(true);
|
||||
expect(mapA.has('b')).toBe(true);
|
||||
expect(mapA.has('c')).toBe(true);
|
||||
expect(mapA.getAll('a')).toEqual(['4', '5', '6']);
|
||||
expect(mapA.getAll('b')).toEqual(['7']);
|
||||
expect(mapA.getAll('c')).toEqual(['8']);
|
||||
expect(mapA.toString()).toEqual('a=4&a=5&a=6&c=8&b=7');
|
||||
});
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user