Hopiu/angular.js
1
0
Fork 0
mirror of https://github.com/Hopiu/angular.js.git synced 2026-03-19 08:00:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source 
Breaks Disabling $resource caching for the moment.
This commit is contained in:
Vojta Jina 2011-10-19 10:47:17 -07:00 committed by Igor Minar
parent fe633dd0cf
commit feacf608ee
3 changed files with 142 additions and 147 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
src/Resource.js
View file

@ -36,8 +36,8 @@ Route.prototype = {
}
};
function ResourceFactory(xhr) {
this.xhr = xhr;
function ResourceFactory($http) {
this.$http = $http;
}
ResourceFactory.DEFAULT_ACTIONS = {
@ -107,11 +107,11 @@ ResourceFactory.prototype = {
}
var value = this instanceof Resource ? this : (action.isArray ? [] : new Resource(data));
self.xhr(
action.method,
route.url(extend({}, extractParams(data), action.params || {}, params)),
data,
function(status, response) {
var future = self.$http({
method: action.method,
url: route.url(extend({}, extractParams(data), action.params || {}, params)),
data: data
}).on('success', function(response, status) {
if (response) {
if (action.isArray) {
value.length = 0;
@ -123,9 +123,10 @@ ResourceFactory.prototype = {
}
}
(success||noop)(value);
},
error || action.verifyCache,
action.verifyCache);
});
if (error) future.on('error', error);
return value;
};

13
src/service/resource.js
View file

@ -3,15 +3,14 @@
/**
* @ngdoc object
* @name angular.module.ng.$resource
* @requires $xhr.cache
* @requires $http
*
* @description
* A factory which creates a resource object that lets you interact with
* [RESTful](http://en.wikipedia.org/wiki/Representational_State_Transfer) server-side data sources.
*
* The returned resource object has action methods which provide high-level behaviors without
* the need to interact with the low level {@link angular.module.ng.$xhr $xhr} service or
* raw XMLHttpRequest.
* the need to interact with the low level {@link angular.module.ng.$http $http} service.
*
* @param {string} url A parameterized URL template with parameters prefixed by `:` as in
* `/user/:username`.
@ -57,7 +56,7 @@
* 'remove': {method:'DELETE'},
* 'delete': {method:'DELETE'} };
*
* Calling these methods invoke an {@link angular.module.ng.$xhr} with the specified http method,
* Calling these methods invoke an {@link angular.module.ng.$http} with the specified http method,
* destination and parameters. When the data is returned from the server then the object is an
* instance of the resource class `save`, `remove` and `delete` actions are available on it as
* methods with the `$` prefix. This allows you to easily perform CRUD operations (create, read,
@ -128,7 +127,7 @@
* The object returned from this function execution is a resource "class" which has "static" method
* for each action in the definition.
*
* Calling these methods invoke `$xhr` on the `url` template with the given `method` and `params`.
* Calling these methods invoke `$http` on the `url` template with the given `method` and `params`.
* When the data is returned from the server then the object is an instance of the resource type and
* all of the non-GET methods are available with `$` prefix. This allows you to easily support CRUD
* operations (create, read, update, delete) on server-side data.
@ -201,8 +200,8 @@
</doc:example>
*/
function $ResourceProvider() {
this.$get = ['$xhr.cache', function($xhr){
var resource = new ResourceFactory($xhr);
this.$get = ['$http', function($http) {
var resource = new ResourceFactory($http);
return bind(resource, resource.route);
}];
}

255
test/ResourceSpec.js
View file

@ -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);
var cc = CreditCard.get({id:123});
$browser.xhr.flush();
expect(cc instanceof CreditCard).toBeTruthy();
var idBefore = cc.id;
$httpBackend.expect('GET', '/CreditCard/123').respond(data);
$httpBackend.expect('POST', '/CreditCard/123', toJson(data)).respond('');
$browser.xhr.expectPOST("/CreditCard/123", data).respond('');
var cc = CreditCard.get({id:123});
$httpBackend.flush();
expect(cc instanceof CreditCard).toBe(true);
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();
}));
});
});