fix($resource): to work with $http, $httpBackend services

Breaks Disabling $resource caching for the moment.

1 files changed, 124 insertions, 129 deletions

diff --git a/test/ResourceSpec.js b/test/ResourceSpec.js
index 46616799..5d91bf3e 100644
--- a/test/ResourceSpec.js
+++ b/test/ResourceSpec.js
@@ -1,19 +1,14 @@
 'use strict';
 
-xdescribe("resource", function() {
+describe("resource", function() {
   var resource, CreditCard, callback;
 
   function nakedExpect(obj) {
     return expect(angular.fromJson(angular.toJson(obj)));
   }
 
-  beforeEach(inject(
-    function($provide) {
-      $provide.value('$xhr.error', jasmine.createSpy('xhr.error'));
-      $provide.factory('$xhrError', ['$xhr.error', identity]);
-    },
-    function($xhr) {
-      resource = new ResourceFactory($xhr);
+  beforeEach(inject(function($http) {
+      resource = new ResourceFactory($http);
       CreditCard = resource.route('/CreditCard/:id:verb', {id:'@id.key'}, {
         charge:{
           method:'POST',
@@ -24,6 +19,10 @@ xdescribe("resource", function() {
     })
   );
 
+  afterEach(inject(function($httpBackend) {
+    $httpBackend.verifyExpectations();
+  }));
+
   it("should build resource", function() {
     expect(typeof CreditCard).toBe('function');
     expect(typeof CreditCard.get).toBe('function');
@@ -33,162 +32,183 @@ xdescribe("resource", function() {
     expect(typeof CreditCard.query).toBe('function');
   });
 
-  it('should default to empty parameters', inject(function($browser) {
-    $browser.xhr.expectGET('URL').respond({});
+  it('should default to empty parameters', inject(function($httpBackend) {
+    $httpBackend.expect('GET', 'URL').respond({});
     resource.route('URL').query();
   }));
 
-  it('should ignore slashes of undefinend parameters', inject(function($browser) {
+  it('should ignore slashes of undefinend parameters', inject(function($httpBackend) {
     var R = resource.route('/Path/:a/:b/:c');
-    $browser.xhr.expectGET('/Path').respond({});
-    $browser.xhr.expectGET('/Path/1').respond({});
-    $browser.xhr.expectGET('/Path/2/3').respond({});
-    $browser.xhr.expectGET('/Path/4/5/6').respond({});
+
+    $httpBackend.when('GET').then('{}');
+    $httpBackend.expect('GET', '/Path');
+    $httpBackend.expect('GET', '/Path/1');
+    $httpBackend.expect('GET', '/Path/2/3');
+    $httpBackend.expect('GET', '/Path/4/5/6');
+
     R.get({});
     R.get({a:1});
     R.get({a:2, b:3});
     R.get({a:4, b:5, c:6});
   }));
 
-  it('should correctly encode url params', inject(function($browser) {
+  it('should correctly encode url params', inject(function($httpBackend) {
     var R = resource.route('/Path/:a');
-    $browser.xhr.expectGET('/Path/foo%231').respond({});
-    $browser.xhr.expectGET('/Path/doh!@foo?bar=baz%231').respond({});
+
+    $httpBackend.expect('GET', '/Path/foo%231').respond('{}');
+    $httpBackend.expect('GET', '/Path/doh!@foo?bar=baz%231').respond('{}');
+
     R.get({a: 'foo#1'});
     R.get({a: 'doh!@foo', bar: 'baz#1'});
   }));
 
-  it('should not encode @ in url params', inject(function($browser) {
+  it('should not encode @ in url params', inject(function($httpBackend) {
     //encodeURIComponent is too agressive and doesn't follow http://www.ietf.org/rfc/rfc3986.txt
     //with regards to the character set (pchar) allowed in path segments
     //so we need this test to make sure that we don't over-encode the params and break stuff like
     //buzz api which uses @self
 
     var R = resource.route('/Path/:a');
-    $browser.xhr.expectGET('/Path/doh@fo%20o?!do%26h=g%3Da+h&:bar=$baz@1').respond({});
+    $httpBackend.expect('GET', '/Path/doh@fo%20o?!do%26h=g%3Da+h&:bar=$baz@1').respond('{}');
     R.get({a: 'doh@fo o', ':bar': '$baz@1', '!do&h': 'g=a h'});
   }));
 
-  it('should encode & in url params', inject(function($browser) {
+  it('should encode & in url params', inject(function($httpBackend) {
     var R = resource.route('/Path/:a');
-    $browser.xhr.expectGET('/Path/doh&foo?bar=baz%261').respond({});
+    $httpBackend.expect('GET', '/Path/doh&foo?bar=baz%261').respond('{}');
     R.get({a: 'doh&foo', bar: 'baz&1'});
   }));
 
-  it("should build resource with default param", inject(function($browser) {
-    $browser.xhr.expectGET('/Order/123/Line/456.visa?minimum=0.05').respond({id:'abc'});
-    var LineItem = resource.route('/Order/:orderId/Line/:id:verb', {orderId: '123', id: '@id.key', verb:'.visa', minimum:0.05});
-    var item = LineItem.get({id:456});
-    $browser.xhr.flush();
+  it('should build resource with default param', inject(function($httpBackend) {
+    $httpBackend.expect('GET', '/Order/123/Line/456.visa?minimum=0.05').respond({id: 'abc'});
+    var LineItem = resource.route('/Order/:orderId/Line/:id:verb',
+                                  {orderId: '123', id: '@id.key', verb:'.visa', minimum: 0.05});
+    var item = LineItem.get({id: 456});
+    $httpBackend.flush();
     nakedExpect(item).toEqual({id:'abc'});
   }));
 
-  it("should build resource with action default param overriding default param", inject(function($browser) {
-    $browser.xhr.expectGET('/Customer/123').respond({id:'abc'});
+  it("should build resource with action default param overriding default param", inject(function($httpBackend) {
+    $httpBackend.expect('GET', '/Customer/123').respond({id: 'abc'});
     var TypeItem = resource.route('/:type/:typeId', {type: 'Order'},
                                   {get: {method: 'GET', params: {type: 'Customer'}}});
-    var item = TypeItem.get({typeId:123});
-    $browser.xhr.flush();
-    nakedExpect(item).toEqual({id:'abc'});
+    var item = TypeItem.get({typeId: 123});
+
+    $httpBackend.flush();
+    nakedExpect(item).toEqual({id: 'abc'});
   }));
 
-  it("should create resource", inject(function($browser) {
-    $browser.xhr.expectPOST('/CreditCard', {name:'misko'}).respond({id:123, name:'misko'});
+  it("should create resource", inject(function($httpBackend) {
+    $httpBackend.expect('POST', '/CreditCard', '{"name":"misko"}').respond({id: 123, name: 'misko'});
 
-    var cc = CreditCard.save({name:'misko'}, callback);
-    nakedExpect(cc).toEqual({name:'misko'});
+    var cc = CreditCard.save({name: 'misko'}, callback);
+    nakedExpect(cc).toEqual({name: 'misko'});
     expect(callback).not.toHaveBeenCalled();
-    $browser.xhr.flush();
-    nakedExpect(cc).toEqual({id:123, name:'misko'});
+
+    $httpBackend.flush();
+    nakedExpect(cc).toEqual({id: 123, name: 'misko'});
     expect(callback).toHaveBeenCalledWith(cc);
   }));
 
-  it("should read resource", inject(function($browser) {
-    $browser.xhr.expectGET("/CreditCard/123").respond({id:123, number:'9876'});
-    var cc = CreditCard.get({id:123}, callback);
+  it("should read resource", inject(function($httpBackend) {
+    $httpBackend.expect('GET', '/CreditCard/123').respond({id: 123, number: '9876'});
+    var cc = CreditCard.get({id: 123}, callback);
+
     expect(cc instanceof CreditCard).toBeTruthy();
     nakedExpect(cc).toEqual({});
     expect(callback).not.toHaveBeenCalled();
-    $browser.xhr.flush();
-    nakedExpect(cc).toEqual({id:123, number:'9876'});
+
+    $httpBackend.flush();
+    nakedExpect(cc).toEqual({id: 123, number: '9876'});
     expect(callback).toHaveBeenCalledWith(cc);
   }));
 
-  it("should read partial resource", inject(function($browser) {
-    $browser.xhr.expectGET("/CreditCard").respond([{id:{key:123}}]);
-    $browser.xhr.expectGET("/CreditCard/123").respond({id:{key:123}, number:'9876'});
+  it("should read partial resource", inject(function($httpBackend) {
+    $httpBackend.expect('GET', '/CreditCard').respond([{id:{key:123}}]);
+    $httpBackend.expect('GET', '/CreditCard/123').respond({id: {key: 123}, number: '9876'});
+
     var ccs = CreditCard.query();
-    $browser.xhr.flush();
+
+    $httpBackend.flush();
     expect(ccs.length).toEqual(1);
+
     var cc = ccs[0];
-    expect(cc instanceof CreditCard).toBeTruthy();
-    expect(cc.number).not.toBeDefined();
+    expect(cc instanceof CreditCard).toBe(true);
+    expect(cc.number).toBeUndefined();
+
     cc.$get(callback);
-    $browser.xhr.flush();
+    $httpBackend.flush();
     expect(callback).toHaveBeenCalledWith(cc);
     expect(cc.number).toEqual('9876');
   }));
 
-  it("should update resource", inject(function($browser) {
-    $browser.xhr.expectPOST('/CreditCard/123', {id:{key:123}, name:'misko'}).respond({id:{key:123}, name:'rama'});
+  it("should update resource", inject(function($httpBackend) {
+    $httpBackend.expect('POST', '/CreditCard/123', '{"id":{"key":123},"name":"misko"}').
+                 respond({id: {key: 123}, name: 'rama'});
 
-    var cc = CreditCard.save({id:{key:123}, name:'misko'}, callback);
+    var cc = CreditCard.save({id: {key: 123}, name: 'misko'}, callback);
     nakedExpect(cc).toEqual({id:{key:123}, name:'misko'});
     expect(callback).not.toHaveBeenCalled();
-    $browser.xhr.flush();
+    $httpBackend.flush();
   }));
 
-  it("should query resource", inject(function($browser) {
-    $browser.xhr.expectGET("/CreditCard?key=value").respond([{id:1}, {id:2}]);
+  it("should query resource", inject(function($httpBackend) {
+    $httpBackend.expect('GET', '/CreditCard?key=value').respond([{id: 1}, {id: 2}]);
 
-    var ccs = CreditCard.query({key:'value'}, callback);
+    var ccs = CreditCard.query({key: 'value'}, callback);
     expect(ccs).toEqual([]);
     expect(callback).not.toHaveBeenCalled();
-    $browser.xhr.flush();
+
+    $httpBackend.flush();
     nakedExpect(ccs).toEqual([{id:1}, {id:2}]);
     expect(callback).toHaveBeenCalledWith(ccs);
   }));
 
-  it("should have all arguments optional", inject(function($browser) {
-    $browser.xhr.expectGET('/CreditCard').respond([{id:1}]);
+  it("should have all arguments optional", inject(function($httpBackend) {
+    $httpBackend.expect('GET', '/CreditCard').respond([{id:1}]);
+
     var log = '';
     var ccs = CreditCard.query(function() { log += 'cb;'; });
-    $browser.xhr.flush();
+
+    $httpBackend.flush();
     nakedExpect(ccs).toEqual([{id:1}]);
     expect(log).toEqual('cb;');
   }));
 
-  it('should delete resource and call callback', inject(function($browser) {
-    $browser.xhr.expectDELETE("/CreditCard/123").respond(200, {});
+  it('should delete resource and call callback', inject(function($httpBackend) {
+    $httpBackend.expect('DELETE', '/CreditCard/123').respond({});
+    $httpBackend.expect('DELETE', '/CreditCard/333').respond(204, null);
 
     CreditCard.remove({id:123}, callback);
     expect(callback).not.toHaveBeenCalled();
-    $browser.xhr.flush();
+
+    $httpBackend.flush();
     nakedExpect(callback.mostRecentCall.args).toEqual([{}]);
 
     callback.reset();
-    $browser.xhr.expectDELETE("/CreditCard/333").respond(204, null);
     CreditCard.remove({id:333}, callback);
     expect(callback).not.toHaveBeenCalled();
-    $browser.xhr.flush();
+
+    $httpBackend.flush();
     nakedExpect(callback.mostRecentCall.args).toEqual([{}]);
   }));
 
-  it('should post charge verb', inject(function($browser) {
-    $browser.xhr.expectPOST('/CreditCard/123!charge?amount=10', {auth:'abc'}).respond({success:'ok'});
-
-    CreditCard.charge({id:123, amount:10},{auth:'abc'}, callback);
+  it('should post charge verb', inject(function($httpBackend) {
+    $httpBackend.expect('POST', '/CreditCard/123!charge?amount=10', '{"auth":"abc"}').respond({success: 'ok'});
+    CreditCard.charge({id:123, amount:10}, {auth:'abc'}, callback);
   }));
 
-  it('should post charge verb on instance', inject(function($browser) {
-    $browser.xhr.expectPOST('/CreditCard/123!charge?amount=10', {id:{key:123}, name:'misko'}).respond({success:'ok'});
+  it('should post charge verb on instance', inject(function($httpBackend) {
+    $httpBackend.expect('POST', '/CreditCard/123!charge?amount=10',
+        '{"id":{"key":123},"name":"misko"}').respond({success: 'ok'});
 
     var card = new CreditCard({id:{key:123}, name:'misko'});
     card.$charge({amount:10}, callback);
   }));
 
-  it('should create on save', inject(function($browser) {
-    $browser.xhr.expectPOST('/CreditCard', {name:'misko'}).respond({id:123});
+  it('should create on save', inject(function($httpBackend) {
+    $httpBackend.expect('POST', '/CreditCard', '{"name":"misko"}').respond({id: 123});
+
     var cc = new CreditCard();
     expect(cc.$get).toBeDefined();
     expect(cc.$query).toBeDefined();
@@ -198,97 +218,72 @@ xdescribe("resource", function() {
     cc.name = 'misko';
     cc.$save(callback);
     nakedExpect(cc).toEqual({name:'misko'});
-    $browser.xhr.flush();
+
+    $httpBackend.flush();
     nakedExpect(cc).toEqual({id:123});
     expect(callback).toHaveBeenCalledWith(cc);
   }));
 
-  it('should not mutate the resource object if response contains no body', inject(function($browser) {
+  it('should not mutate the resource object if response contains no body', inject(function($httpBackend) {
     var data = {id:{key:123}, number:'9876'};
-    $browser.xhr.expectGET("/CreditCard/123").respond(data);
+    $httpBackend.expect('GET', '/CreditCard/123').respond(data);
+    $httpBackend.expect('POST', '/CreditCard/123', toJson(data)).respond('');
+
     var cc = CreditCard.get({id:123});
-    $browser.xhr.flush();
-    expect(cc instanceof CreditCard).toBeTruthy();
-    var idBefore = cc.id;
+    $httpBackend.flush();
+    expect(cc instanceof CreditCard).toBe(true);
 
-    $browser.xhr.expectPOST("/CreditCard/123", data).respond('');
+    var idBefore = cc.id;
     cc.$save();
-    $browser.xhr.flush();
+    $httpBackend.flush();
     expect(idBefore).toEqual(cc.id);
   }));
 
-  it('should bind default parameters', inject(function($browser) {
-    $browser.xhr.expectGET('/CreditCard/123.visa?minimum=0.05').respond({id:123});
+  it('should bind default parameters', inject(function($httpBackend) {
+    $httpBackend.expect('GET', '/CreditCard/123.visa?minimum=0.05').respond({id: 123});
     var Visa = CreditCard.bind({verb:'.visa', minimum:0.05});
     var visa = Visa.get({id:123});
-    $browser.xhr.flush();
+    $httpBackend.flush();
     nakedExpect(visa).toEqual({id:123});
   }));
 
-  it('should excersize full stack', inject(function($rootScope, $browser, $resource, $compile) {
-    $compile('<div></div>')($rootScope);
+  it('should excersize full stack', inject(function($httpBackend, $resource) {
     var Person = $resource('/Person/:id');
-    $browser.xhr.expectGET('/Person/123').respond('\n{\n"name":\n"misko"\n}\n');
+
+    $httpBackend.expect('GET', '/Person/123').respond('\n{\n"name":\n"misko"\n}\n');
     var person = Person.get({id:123});
-    $browser.xhr.flush();
+    $httpBackend.flush();
     expect(person.name).toEqual('misko');
   }));
 
-  it('should return the same object when verifying the cache',
-      inject(function($rootScope, $compile, $browser, $resource) {
-    $compile('<div></div>')($rootScope);
-    var Person = $resource('/Person/:id', null, {query: {method:'GET', isArray: true, verifyCache: true}});
-    $browser.xhr.expectGET('/Person/123').respond('[\n{\n"name":\n"misko"\n}\n]');
-    var person = Person.query({id:123});
-    $browser.xhr.flush();
-    expect(person[0].name).toEqual('misko');
-
-    $browser.xhr.expectGET('/Person/123').respond('[\n{\n"name":\n"rob"\n}\n]');
-    var person2 = Person.query({id:123});
-    $browser.defer.flush();
-
-    expect(person2[0].name).toEqual('misko');
-    var person2Cache = person2;
-    $browser.xhr.flush();
-    expect(person2Cache).toEqual(person2);
-    expect(person2[0].name).toEqual('rob');
-  }));
-
   describe('failure mode', function() {
     var ERROR_CODE = 500,
         ERROR_RESPONSE = 'Server Error',
         errorCB;
 
     beforeEach(function() {
-      errorCB = jasmine.createSpy();
+      errorCB = jasmine.createSpy('error').andCallFake(function(response, status) {
+        expect(response).toBe(ERROR_RESPONSE);
+        expect(status).toBe(ERROR_CODE);
+      });
     });
 
-    it('should report error when non 2xx if error callback is not provided',
-        inject(function($browser, $xhrError) {
-      $browser.xhr.expectGET('/CreditCard/123').respond(ERROR_CODE, ERROR_RESPONSE);
-      CreditCard.get({id:123});
-      $browser.xhr.flush();
-      expect($xhrError).toHaveBeenCalled();
-    }));
+    it('should call the error callback if provided on non 2xx response', inject(function($httpBackend) {
+      $httpBackend.expect('GET', '/CreditCard/123').respond(ERROR_CODE, ERROR_RESPONSE);
 
-    it('should call the error callback if provided on non 2xx response',
-        inject(function($browser, $xhrError) {
-      $browser.xhr.expectGET('/CreditCard/123').respond(ERROR_CODE, ERROR_RESPONSE);
       CreditCard.get({id:123}, callback, errorCB);
-      $browser.xhr.flush();
-      expect(errorCB).toHaveBeenCalledWith(500, ERROR_RESPONSE);
+      $httpBackend.flush();
+      expect(errorCB).toHaveBeenCalledOnce();
       expect(callback).not.toHaveBeenCalled();
-      expect($xhrError).not.toHaveBeenCalled();
     }));
 
-    it('should call the error callback if provided on non 2xx response',
-        inject(function($browser, $xhrError) {
-      $browser.xhr.expectGET('/CreditCard').respond(ERROR_CODE, ERROR_RESPONSE);
+    it('should call the error callback if provided on non 2xx response', inject(function($httpBackend) {
+      $httpBackend.expect('GET', '/CreditCard').respond(ERROR_CODE, ERROR_RESPONSE);
+
       CreditCard.get(callback, errorCB);
-      $browser.xhr.flush();
-      expect(errorCB).toHaveBeenCalledWith(500, ERROR_RESPONSE);
+      $httpBackend.flush();
+      expect(errorCB).toHaveBeenCalledOnce();
       expect(callback).not.toHaveBeenCalled();
-      expect($xhrError).not.toHaveBeenCalled();
     }));
   });
 });