refactor(xhr): move render's xhr implementation to render/

The existence of this module in the services/ folder led some to believe xhr
is meant to be a general-purpose http library.

Fixes #2305

modules/angular2/test/render/dom/compiler/template_loader_spec.ts

@@ -16,7 +16,7 @@ import {UrlResolver} from 'angular2/src/services/url_resolver';
 
 import {ViewDefinition} from 'angular2/src/render/api';
 import {PromiseWrapper} from 'angular2/src/facade/async';
-import {MockXHR} from 'angular2/src/mock/xhr_mock';
+import {MockXHR} from 'angular2/src/render/xhr_mock';
 
 export function main() {
   describe('TemplateLoader', () => {

modules/angular2/test/render/dom/shadow_dom/emulated_scoped_shadow_dom_strategy_spec.ts

@@ -18,7 +18,7 @@ import {DOM} from 'angular2/src/dom/dom_adapter';
 import {Map, MapWrapper} from 'angular2/src/facade/collection';
 import {PromiseWrapper, Promise} from 'angular2/src/facade/async';
 
-import {XHR} from 'angular2/src/services/xhr';
+import {XHR} from 'angular2/src/render/xhr';
 
 import {
   EmulatedScopedShadowDomStrategy,

modules/angular2/test/render/dom/shadow_dom/style_inliner_spec.ts

@@ -17,7 +17,7 @@ import {isBlank} from 'angular2/src/facade/lang';
 import {Promise, PromiseWrapper} from 'angular2/src/facade/async';
 import {Map, MapWrapper} from 'angular2/src/facade/collection';
 
-import {XHR} from 'angular2/src/services/xhr';
+import {XHR} from 'angular2/src/render/xhr';
 
 import {bind} from 'angular2/di';
 

modules/angular2/test/render/xhr_impl_spec.ts

@@ -0,0 +1,39 @@
+import {
+  AsyncTestCompleter,
+  beforeEach,
+  ddescribe,
+  describe,
+  expect,
+  iit,
+  inject,
+  it,
+  xit
+} from 'angular2/test_lib';
+
+import {XHRImpl} from 'angular2/src/render/xhr_impl';
+import {PromiseWrapper} from 'angular2/src/facade/async';
+
+export function main() {
+  describe('XHRImpl', () => {
+    var xhr;
+    var url200 = '/base/modules/angular2/test/services/static_assets/200.html';
+    var url404 = '/base/modules/angular2/test/services/static_assets/404.html';
+
+    beforeEach(() => { xhr = new XHRImpl(); });
+
+    it('should resolve the Promise with the file content on success',
+       inject([AsyncTestCompleter], (async) => {
+         xhr.get(url200).then((text) => {
+           expect(text.trim()).toEqual('<p>hey</p>');
+           async.done();
+         });
+       }));
+
+    it('should reject the Promise on failure', inject([AsyncTestCompleter], (async) => {
+         PromiseWrapper.catchError(xhr.get(url404), (e) => {
+           expect(e).toEqual(`Failed to load ${url404}`);
+           async.done();
+         });
+       }));
+  });
+}

modules/angular2/test/render/xhr_mock_spec.ts

@@ -0,0 +1,112 @@
+import {
+  AsyncTestCompleter,
+  beforeEach,
+  ddescribe,
+  describe,
+  el,
+  expect,
+  iit,
+  inject,
+  IS_DARTIUM,
+  it,
+} from 'angular2/test_lib';
+import {MockXHR} from 'angular2/src/render/xhr_mock';
+import {PromiseWrapper, Promise} from 'angular2/src/facade/async';
+import {isPresent} from 'angular2/src/facade/lang';
+
+export function main() {
+  describe('MockXHR', () => {
+    var xhr;
+
+    beforeEach(() => { xhr = new MockXHR(); });
+
+    function expectResponse(request: Promise<string>, url: string, response: string, done = null) {
+      function onResponse(text: string): string {
+        if (response === null) {
+          throw `Unexpected response ${url} -> ${text}`;
+        } else {
+          expect(text).toEqual(response);
+          if (isPresent(done)) done();
+        }
+        return text;
+      }
+
+      function onError(error: string): string {
+        if (response !== null) {
+          throw `Unexpected error ${url}`;
+        } else {
+          expect(error).toEqual(`Failed to load ${url}`);
+          if (isPresent(done)) done();
+        }
+        return error;
+      }
+
+      PromiseWrapper.then(request, onResponse, onError);
+    }
+
+    it('should return a response from the definitions', inject([AsyncTestCompleter], (async) => {
+         var url = '/foo';
+         var response = 'bar';
+         xhr.when(url, response);
+         expectResponse(xhr.get(url), url, response, () => async.done());
+         xhr.flush();
+       }));
+
+    it('should return an error from the definitions', inject([AsyncTestCompleter], (async) => {
+         var url = '/foo';
+         var response = null;
+         xhr.when(url, response);
+         expectResponse(xhr.get(url), url, response, () => async.done());
+         xhr.flush();
+       }));
+
+    it('should return a response from the expectations', inject([AsyncTestCompleter], (async) => {
+         var url = '/foo';
+         var response = 'bar';
+         xhr.expect(url, response);
+         expectResponse(xhr.get(url), url, response, () => async.done());
+         xhr.flush();
+       }));
+
+    it('should return an error from the expectations', inject([AsyncTestCompleter], (async) => {
+         var url = '/foo';
+         var response = null;
+         xhr.expect(url, response);
+         expectResponse(xhr.get(url), url, response, () => async.done());
+         xhr.flush();
+       }));
+
+    it('should not reuse expectations', () => {
+      var url = '/foo';
+      var response = 'bar';
+      xhr.expect(url, response);
+      xhr.get(url);
+      xhr.get(url);
+      expect(() => { xhr.flush(); }).toThrowError('Unexpected request /foo');
+    });
+
+    it('should return expectations before definitions', inject([AsyncTestCompleter], (async) => {
+         var url = '/foo';
+         xhr.when(url, 'when');
+         xhr.expect(url, 'expect');
+         expectResponse(xhr.get(url), url, 'expect');
+         expectResponse(xhr.get(url), url, 'when', () => async.done());
+         xhr.flush();
+       }));
+
+    it('should throw when there is no definitions or expectations', () => {
+      xhr.get('/foo');
+      expect(() => { xhr.flush(); }).toThrowError('Unexpected request /foo');
+    });
+
+    it('should throw when flush is called without any pending requests',
+       () => { expect(() => { xhr.flush(); }).toThrowError('No pending requests to flush'); });
+
+    it('should throw on unstatisfied expectations', () => {
+      xhr.expect('/foo', 'bar');
+      xhr.when('/bar', 'foo');
+      xhr.get('/bar');
+      expect(() => { xhr.flush(); }).toThrowError('Unsatisfied requests: /foo');
+    });
+  });
+}