angularjs-rails-resource 1.0.0.pre.3 → 1.0.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7ce09b68d048977e8091b90cd120e0f7836f183
-  data.tar.gz: 2c0eb42c1684eb64a5fd58e80a7adc8fed7e4e2f
+  metadata.gz: 20771e48c443e10d5168fbd655ef6612531ce5fd
+  data.tar.gz: 0f47dfc805d46e310170964e062ca7b343bbbabc
 SHA512:
-  metadata.gz: 6eb139ae046e2756eba924f354fbc386d752994ce43bbb67f5696f5c8567cc5ac49a125c7b687079c4766bce508dbd67dbc9c86097647e502daaf00952b01677
-  data.tar.gz: 56415e2fc32de4a5bd82db9cf0ece3ab680aa583bbb61a5df39bd2f8d14c95a2e74b3028c877da15f6fe648a86f6977937d1be9188d3971a4437d0ba295d3bf3
+  metadata.gz: 6fcbd686a622b259875e64033a564ed2291678a7ef439cd83c898fc494b62a81bf7c0a3402f60222d507b51108fe9dfc830b18a9bae7994df3a16eaac3e80c4b
+  data.tar.gz: d1508be43ab85c0b47870a55413187d81a4bad5960156cd602c037847dd64b2bd47193f8e8a526b1062109b5146ec1d4a7978ee1dd9eab55178e0fd452900d5f

data/CHANGELOG.md

@@ -1,11 +1,22 @@
 <a name="1.0.0"></a>
 # 1.0.0
+## Deprecations
+- <code>requestTransformers</code>, <code>responseInterceptors</code>, <code>afterResponseInterceptors</code> have been replaced with
+ a single <code>interceptors</code> chain.
+- <code>beforeRequest</code> - Use <code>interceptBeforeRequestWrapping</code>
+- <code>beforeResponse</code> - Use <code>interceptResponse</code>
+- <code>afterResponse</code> - Use <code>interceptAfterResponse</code>
+
 ## Bug Fixes
 
 ## Features
 - Added <code>configure</code> function to allow changing configuration options after the resource has been initially configured.
 - Separated out RailsResource into separate service to allow subclassing without using the factories.
-- Added snapshot and rollback extension, be sure to check the [README](README.md#serializers) for details.
+- Added mixin capability, see [README](README.md#mixins) for details
+- Added snapshot and rollback extension, see [README](README.md#serializers) for details.
+- Added <code>underscoreParams</code> configuration option to allow turning off parameter underscore renaming.
+- Added <code>fullResponse</code> configuration option to allow returning the full $http response for promise resolution.
+- Added optional query params to class and instance $delete methods
 
 ## Breaking Changes
 - <code>railsResourceFactoryProvider</code> settings have been moved to <code>RailsResourceProvider</code>
@@ -15,8 +26,28 @@
     - <code>enableRootWrapping</code> was renamed <code>rootWrapping</code>
     - <code>rootName</code> was renamed <code>name</code>
     - <code>rootPluralName</code> was renamed <code>pluralName</code>
-- Query parameters were not underscored previously.  We are now underscoring parameters by default.
-The configuration option <code>underscoreParams</code> can be set to false to disable the renaming.
+- Query parameters were not underscored previously.  We are now underscoring parameters by default. The configuration option <code>underscoreParams</code> can be set to false to disable the renaming.
+- Replaced <code>railsRootWrappingTransformer</code> and <code>railsRootWrappingInterceptor</code> with <code>railsRootWrapper</code> that has wrap & unwrap methods.  This eliminates the need for using promises during resource construction to handle unwrapping data passed into the constructor.
+- Resource constructor no longer executes response interceptors.  If you need to customize the constructor you should look at using subclassing instead.
+- <code>processResponse</code>, <code>transformData</code>, <code>callInterceptors</code> have all been removed as part of rewriting the request / response handling.
+
+<a name="1.0.0-pre.4"></a>
+# 1.0.0-pre.4
+## Deprecations
+- <code>requestTransformers</code>, <code>responseInterceptors</code>, <code>afterResponseInterceptors</code> have been replaced with
+ a single <code>interceptors</code> chain.
+- <code>beforeRequest</code> - Use <code>interceptBeforeRequestWrapping</code>
+- <code>beforeResponse</code> - Use <code>interceptResponse</code>
+- <code>afterResponse</code> - Use <code>interceptAfterResponse</code>
+
+## Features
+- Added <code>fullResponse</code> configuration option to allow returning the full $http response for promise resolution.
+- Added optional query params to class and instance $delete methods
+
+## Breaking Changes
+- Replaced <code>railsRootWrappingTransformer</code> and <code>railsRootWrappingInterceptor</code> with <code>railsRootWrapper</code> that has wrap & unwrap methods.  This eliminates the need for using promises during resource construction to handle unwrapping data passed into the constructor.
+- Resource constructor no longer executes response interceptors.  If you need to customize the constructor you should look at using subclassing instead.
+- <code>processResponse</code>, <code>transformData</code>, <code>callInterceptors</code> have all been removed as part of rewriting the request / response handling.
 
 <a name="1.0.0-pre.3"></a>
 # 1.0.0-pre.3

data/README.md

@@ -4,7 +4,7 @@
 A resource factory inspired by $resource from AngularJS and [Misko's recommendation](http://stackoverflow.com/questions/11850025/recommended-way-of-getting-data-from-the-server).
 
 ## Differences from $resource
-This library is not a drop in replacement for $resource.  There are significant differences that you should be aware of and
+This library is not a drop in replacement for $resource.  There are significant differences that you should be aware of:
 
 1.  <code>get</code> and <code>query</code> return [$q promises](http://docs.angularjs.org/api/ng.$q), not an instance or array that will be populated.  To gain access to the results you
 should use the promise <code>then</code> function.
@@ -205,7 +205,12 @@ defined on the resource can be called multiple times to adjust properties as nee
  * **underscoreParams** *(optional)* - Controls whether or not query parameters are converted from camel case to underscore.
  * **updateMethod** *(optional)* - Allows overriding the default HTTP method (PUT) used for update.  Valid values are "post", "put", or "patch".
  * **serializer** *(optional)* - Allows specifying a custom [serializer](#serializers) to configure custom serialization options.
- * **requestTransformers** *(optional) - See [Transformers / Interceptors](#transformers--interceptors)
+ * **fullResponse** *(optional)* - When set to true promises will return full $http responses instead of just the response data.
+ * **interceptors** *(optional)* - See [Interceptors](#interceptors)
+ * **extensions** *(optional)* - See [Extensions](#extensions)
+
+**Deprecated:**
+ * **requestTransformers** *(optional)* - See [Transformers / Interceptors](#transformers--interceptors)
  * **responseInterceptors** *(optional)* - See [Transformers / Interceptors](#transformers--interceptors)
  * **afterResponseInterceptors** *(optional)* - See [Transformers / Interceptors](#transformers--interceptors)
 
@@ -222,6 +227,8 @@ Each configuration option listed is exposed as a method on the provider that tak
 * defaultParams - {function(object):RailsResourceProvider}
 * underscoreParams - {function(boolean):RailsResourceProvider}
 * updateMethod - {function(boolean):RailsResourceProvider}
+* fullResponse - {function(boolean):RailsResourceProvider}
+* extensions - {function(...string):RailsResourceProvider}
 
 For example, to turn off the root wrapping application-wide and set the update method to PATCH:
 
@@ -295,18 +302,39 @@ RailsResources have the following class methods available.
     * **data** {object} - The data to serialize and POST / PUT / PATCH
     * **returns** {promise} A promise that will be resolved with a new Resource instance (or instances in the case of an array response).
 
-* $delete(customUrl) - Executes a DELETE to a custom URL.  The main difference between this and $http.delete is that a server response that contains a body will be deserialized using the normal Resource deserialization process.
+* $delete(customUrl, queryParams) - Executes a DELETE to a custom URL.  The main difference between this and $http.delete is that a server response that contains a body will be deserialized using the normal Resource deserialization process.
     * **customUrl** {string} - The url to DELETE to
+    * **queryParams** {object} (optional) - The set of query parameters to include in the DELETE request
     * **returns** {promise} A promise that will be resolved with a new Resource instance (or instances in the case of an array response) if the server includes a response body.
 
-* beforeRequest(fn(data, resource)) - See [Transformers](#transformers) for more information.  The function is called prior to the serialization process so the data
+* $http(httpConfig, context, resourceConfigOverrides) - Executes an HTTP operation specified by the config.  The request data is serialized and root wrapped (if configured).  The response data is unwrapped (if configured) and deserialized and copied to the context object if specified.
+  * **httpConfig** {object} - Standard $http config object.
+  * **context** {object} - The instance that the operation is being run against.
+  * **resourceConfigOverrides** {object} - An optional set of RailsResource configuration option overrides to use for this request.
+
+* addInterceptor(interceptor) - Adds an interceptor to the resource class.
+  * **interceptor** {object | string} - See [Interceptors](#interceptors) for details of object format.
+
+* intercept(phase, callback) - Creates an interceptor for the specified phase and adds it to the resource's interceptor list.  The callback function will be executed when the interceptor phase is run.  If the callback function returns a value that will take the place of the value going forward in the promise chain.
+  * **phase** {string} - The interceptor phase, see [Interceptors](#interceptors) for a list of phases.
+  * **callback** {function(value, resourceConstructor, context)} - The callback function to execute.  The value parameter varies based on the phase.  See [Interceptors](#interceptors) for details.  The resourceConstructor is the resource's constructor function.  The context is the resource instance that operation is running against which may be undefined.
+* interceptBeforeRequest(callback) - Shortcut for intercept('beforeRequest', callback)
+* interceptBeforeRequestWrapping(callback) - Shortcut for intercept('beforeRequestWrapping', callback)
+* interceptRequest(callback) - Shortcut for intercept('request', callback)
+* interceptBeforeResponse(callback) - Shortcut for intercept('beforeResponse', callback)
+* interceptBeforeResponseDeserialize(callback) - Shortcut for intercept('beforeResponseDeserialize', callback)
+* interceptResponse - Shortcut for intercept('response', callback)
+* interceptAfterResponse - Shortcut for intercept('afterResponse', callback)
+
+**Deprecated** 
+* beforeRequest(fn(data, resource)) - See [Interceptors](#interceptors) for more information.  The function is called prior to the serialization process so the data
 passed to the function is still a Resource instance as long as another transformation function has not returned a new object to serialize.
     * fn(data, resource) {function} - The function to add as a transformer.
         * **data** {object} - The data being serialized
         * **resource** {Resource class} - The Resource class that is calling the function
         * **returns** {object | undefined} - If the function returns a new object that object will instead be used for serialization.
 
-* beforeResponse(fn(data, resource, context)) - See [Interceptors](#interceptors) for more information.  The function is called after the response data has been deserialized.
+* beforeResponse(fn(data, resource, context)) - See [Interceptors](#interceptors) for more information.  The function is called after the response data has been unwrapped and deserialized.
     * fn(data, resource, context) {function} - The function to add as an interceptor
         * **data** {object} - The data received from the server
         * **resource** {Resource function} - The Resource constructor that is calling the function
@@ -335,12 +363,15 @@ All of the instance methods will update the instance in-place on response and wi
 * remove(), delete() - Executes an HTTP DELETE against the resource's URL (e.g. /books/1234)
     * **returns** {promise} - A promise that will be resolved with the instance itself
 
+* $http(httpConfig, resourceConfigOverrides) - Executes class method $http with the resource instance as the operation context.
+
 * $post(customUrl), $put(customUrl), $patch(customUrl) - Serializes and submits the instance using an HTTP POST/PUT/PATCH to the given URL.
     * **customUrl** {string} - The url to POST / PUT / PATCH to
     * **returns** {promise} - A promise that will be resolved with the instance itself
 
-* $delete(customUrl) - Executes a DELETE to a custom URL.  The main difference between this and $http.delete is that a server response that contains a body will be deserialized using the normal Resource deserialization process.
+* $delete(customUrl, queryParams) - Executes a DELETE to a custom URL.  The main difference between this and $http.delete is that a server response that contains a body will be deserialized using the normal Resource deserialization process.
     * **customUrl** {string} - The url to DELETE to
+    * **queryParams** {object} (optional) - The set of query parameters to include in the DELETE request
     * **returns** {promise} - A promise that will be resolved with the instance itself
 
 
@@ -417,8 +448,68 @@ The customizer function passed to the railsSerializer has available to it the fo
 The serializers are defined using mostly instance prototype methods.  For information on those methods please see the inline documentation.  There are however a couple of class methods that
 are also defined to expose underscore, camelize, and pluralize.  Those functions are set to the value specified by the configuration options sent to the serializer.
 
+## Interceptors
+The entire request / response processing is configured as a [$q promise chain](http://docs.angularjs.org/api/ng.$q).  Interceptors allow inserting additional synchronous or asynchronous processing at various phases in the request / response cycle.  The flexibility of the synchronous or asynchronous promise resolution allows any number of customizations to be built.  For instance, on response you could load additional data before returning that the current response is complete.  Or, you could listen to multiple phases and set a flag that a save operation is in progress in <code>beforeRequest</code> and then in <code>afterResponse</code> and <code>afterResponseError</code> you could clear the flag.
+
+Interceptors are similar in design to the $http interceptors.  You can add interceptors via the <code>RailsResource.addInterceptors</code> method or by explicitly adding them to the <code>interceptors</code> array on the on the resource <code>config</code> object.  When you add the interceptor, you can add it using either the interceptor service factory name or the object reference.  An interceptor should contain a set of keys representing one of the valid phases and the callback function for the phase.
+
+There are several phases for both request and response to give users and mixins more flexibility for exactly where they want to insert a customization.  Each phase also has a corresponding error phase which is the phase name appended with Error (e.g. beforeResponse and beforeResponseError).  The error phases receive the current rejection value which in most cases would be the error returned from $http.  Since these are $q promises, your interceptor can decide whether or not to propagate the error or recover from it.  If you want to propagate the error, you must return a <code>$q.reject(reason)</code> result.  Otherwise any value you return will be treated as a successful value to use for the rest of the chain.  For instance, in the <code>beforeResponseError</code> phase you could attempt to recover by using an alternate URL for the request data and return the new promise as the result.
+
+Each request phase interceptor is called with the $http config object, the resource constructor, and if applicable the resource instance.  The interceptor is free to modify the config or create a new one.  The interceptor function must return a valid $http config or a promise that will eventually resolve to a config object.  
+
+The valid request phases are:
+
+ * beforeRequest: Interceptors are called prior to any data serialization or root wrapping.
+ * beforeRequestError: Interceptors get called when a previous interceptor threw an error or resolved with a rejection.
+ * beforeRequestWrapping: Interceptors are called after data serialization but before root wrapping.
+ * beforeRequestWrappingError: Interceptors get called when a previous interceptor threw an error or resolved with a rejection.
+ * request:  Interceptors are called after any data serialization and root wrapping have been performed.
+ * requestError: Interceptors get called when a previous interceptor threw an error or resolved with a rejection.
 
-## Transformers / Interceptors
+The beforeResponse and response interceptors are called with the $http response object, the resource constructor, and if applicable the resource instance.  The afterResponse interceptors are typically called with the response data instead of the full response object unless the config option fullResponse has been set to true.  Like the request interceptor callbacks the response callbacks can manipulate the data or return new data.  The interceptor function must return
+
+ The valid response phases are:
+
+ * beforeResponse: Interceptors are called prior to any data processing.
+ * beforeResponseError: Interceptors get called when a previous interceptor threw an error or resolved with a rejection.
+ * beforeResponseDeserialize: Interceptors are called after root unwrapping but prior to data deserializing.
+ * beforeResponseDeserializeError: Interceptors get called when a previous interceptor threw an error or resolved with a rejection.
+ * response:  Interceptors are called after the data has been deserialized and root unwrapped but prior to the data being copied to the resource instance if applicable.
+ * responseError: Interceptors get called when a previous interceptor threw an error or resolved with a rejection.
+ * afterResponse:  Interceptors are called at the very end of the response chain after all processing
+      has been completed.  The value of the first parameter is one of the following:
+       - resource instance: When fullResponse is false and the operation was called on a resource instance.
+       - response data: When fullResponse is false and the operation was called on the resource class.
+       - $http response: When fullResponse is true
+ * afterResponseError: Interceptors get called when a previous interceptor threw an error or resolved with a rejection.
+
+### Example Interceptor
+```javascript
+angular.module('rails').factory('saveIndicatorInterceptor', function () {
+    return {
+        'beforeRequest': function (httpConfig, resourceConstructor, context) {
+            if (context && (httpConfig.method === 'post' || httpConfig.method === 'put')) {
+                context.savePending = true;
+            }
+            return httpConfig;
+        },
+        'afterResponse': function (result, resourceConstructor, context) {
+            if (context) {
+                context.savePending = false;
+            }
+            return result;                    
+        },
+        'afterResponseError': function (rejection, resourceConstructor, context) {
+            if (context) {
+                context.savePending = false;
+            }
+            return $q.reject(rejection);
+        }
+    };
+});
+```
+  
+## Transformers / Interceptors (**DEPRECATED**)
 The transformers and interceptors can be specified using an array containing transformer/interceptor functions or strings
 that can be resolved using Angular's DI.  The transformers / interceptors concept was prior to the [serializers](#serializers) but
 we kept the API available because there may be use cases that can be accomplished with these but not the serializers.

data/bower.json

@@ -1,6 +1,6 @@
 {
   "name": "angularjs-rails-resource",
-  "version": "1.0.0-pre.3",
+  "version": "1.0.0-pre.4",
   "main": "angularjs-rails-resource.js",
   "description": "A resource factory inspired by $resource from AngularJS",
   "repository": {

data/changelog.js

@@ -142,7 +142,7 @@ var writeChangelog = function(stream, commits, version) {
         fix: {},
         feat: {},
         perf: {},
-        deprecate: {},
+        deprecates: {},
         breaks: {}
     };
 
@@ -157,6 +157,15 @@ var writeChangelog = function(stream, commits, version) {
             section[component].push(commit);
         }
 
+        if (commit.deprecates) {
+            sections.deprecates[component] = sections.deprecates[component] || [];
+            commit.deprecates.forEach(function (deprecation) {
+                sections.deprecates[component].push({
+                    subject: deprecation
+                });
+            });
+        }
+
         if (commit.breaking) {
             sections.breaks[component] = sections.breaks[component] || [];
             sections.breaks[component].push({

data/lib/angularjs-rails-resource/version.rb

@@ -1,7 +1,7 @@
 module Angularjs
   module Rails
     module Resource
-      VERSION = '1.0.0.pre.3'
+      VERSION = '1.0.0.pre.4'
     end
   end
 end

data/package.json

@@ -1,7 +1,7 @@
 {
   "name": "angularjs-rails-resource",
   "description" : "A resource factory inspired by $resource from AngularJS",
-  "version": "1.0.0-pre.3",
+  "version": "1.0.0-pre.4",
   "main" : "dist/angularjs-rails-resource.min.js",
   "homepage" : "https://github.com/FineLinePrototyping/angularjs-rails-resource.git",
   "author" : "",

data/test/unit/angularjs/rails/extensions/snapshotsSpec.js

@@ -175,8 +175,6 @@ describe('RailsResource.snapshots', function () {
         book.rollback();
 
         expect(book.$key).toBe('1235');
-        expect(book.$snapshots).toBeDefined();
-        expect(book.$snapshots.length).toBe(0);
     });
 
     it('should roll back to the first snapshot for -1', function () {

data/test/unit/angularjs/rails/interceptorsSpec.js

@@ -1,6 +1,7 @@
-describe('transformers', function () {
+describe('interceptors', function () {
     'use strict';
-    var $httpBackend, $rootScope, factory, Test, testInterceptor, testAfterInterceptor,
+    var $q, $http, $httpBackend, $rootScope, factory, Test, testInterceptor, testAfterInterceptor, testRequestTransformer,
+        deprecatedTestInterceptor, deprecatedTestAfterInterceptor,
         config = {
             url: '/test',
             name: 'test'
@@ -9,7 +10,7 @@ describe('transformers', function () {
     beforeEach(function () {
         module('rails');
 
-        angular.module('rails').factory('railsTestInterceptor', function () {
+        angular.module('rails').factory('deprecatedRailsTestInterceptor', function () {
             return function (promise) {
                 return promise.then(function (response) {
                     response.data.interceptorAdded = 'x';
@@ -18,7 +19,7 @@ describe('transformers', function () {
             }
         });
 
-        angular.module('rails').factory('railsTestAfterInterceptor', function () {
+        angular.module('rails').factory('deprecatedRailsTestAfterInterceptor', function () {
             return function (promise) {
                 return promise.then(function (resource) {
                     resource.interceptorAdded = 'x';
@@ -26,15 +27,88 @@ describe('transformers', function () {
                 });
             }
         });
+
+        angular.module('rails').factory('railsTestInterceptor', function () {
+            return {
+                'response': function (response) {
+                    response.data.interceptorAdded = 'x';
+                    return response;
+                },
+                'responseError': function (rejection) {
+                    rejection.interceptorCalled = true;
+                    return $q.reject(rejection);
+                }
+            };
+        });
+
+        angular.module('rails').factory('asyncInterceptor', function () {
+            return {
+                'response': function (response) {
+                    return $http.get('/async').then(function (asyncResponse) {
+                        response.data.async = asyncResponse.data;
+                        return response;
+                    });
+                }
+            };
+        });
+
+        angular.module('rails').factory('saveIndicatorInterceptor', function () {
+            return {
+                'beforeRequest': function (httpConfig, resourceConstructor, context) {
+                    if (context && (httpConfig.method === 'put' || httpConfig.method === 'post')) {
+                        context.$savePending = true;
+                    }
+                    return httpConfig;
+                },
+                'afterResponse': function (result, resourceConstructor, context) {
+                    if (context) {
+                        context.$savePending = false;
+                    }
+                    return result;
+                },
+                'afterResponseError': function (rejection, resourceConstructor, context) {
+                    if (context) {
+                        context.$savePending = false;
+                    }
+                    return $q.reject(rejection);
+                }
+            };
+        });
+
+        angular.module('rails').factory('railsTestAfterInterceptor', function () {
+            return {
+                'afterResponse': function (response) {
+                    response.interceptorAdded = 'x';
+                    return response;
+                }
+            };
+        });
+
+        angular.module('rails').factory('railsTestRequestTransformer', function () {
+            return {
+                'beforeRequest': function (httpConfig, resource) {
+                    httpConfig.data.transformer_called = true;
+                    return httpConfig;
+                }
+            };
+        });
+
     });
 
-    beforeEach(inject(function (_$httpBackend_, _$rootScope_, railsResourceFactory, railsTestInterceptor, railsTestAfterInterceptor) {
+    beforeEach(inject(function (_$q_, _$http_, _$httpBackend_, _$rootScope_, railsResourceFactory,
+                                railsTestInterceptor, railsTestAfterInterceptor, railsTestRequestTransformer,
+                                deprecatedRailsTestInterceptor, deprecatedRailsTestAfterInterceptor) {
+        $q = _$q_;
+        $http = _$http_;
         $httpBackend = _$httpBackend_;
         $rootScope = _$rootScope_;
         factory = railsResourceFactory;
         Test = railsResourceFactory(config);
         testInterceptor = railsTestInterceptor;
         testAfterInterceptor = railsTestAfterInterceptor;
+        deprecatedTestInterceptor = deprecatedRailsTestInterceptor;
+        deprecatedTestAfterInterceptor = deprecatedRailsTestAfterInterceptor;
+        testRequestTransformer = railsTestRequestTransformer;
     }));
 
     afterEach(function () {
@@ -42,14 +116,14 @@ describe('transformers', function () {
         $httpBackend.verifyNoOutstandingRequest();
     });
 
-    describe('before response', function () {
+    describe('deprecated before response', function () {
         it('should be able to reference interceptor using name', function () {
             var promise, result, Resource, testConfig = {};
 
             $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
 
             angular.copy(config, testConfig);
-            testConfig.responseInterceptors = ['railsTestInterceptor'];
+            testConfig.responseInterceptors = ['deprecatedRailsTestInterceptor'];
             Resource = factory(testConfig);
 
             expect(promise = Resource.get(123)).toBeDefined();
@@ -71,7 +145,7 @@ describe('transformers', function () {
 
 
             angular.copy(config, testConfig);
-            testConfig.responseInterceptors = [testInterceptor];
+            testConfig.responseInterceptors = [deprecatedTestInterceptor];
             Resource = factory(testConfig);
 
             expect(promise = Resource.get(123)).toBeDefined();
@@ -138,15 +212,15 @@ describe('transformers', function () {
         });
     });
 
-    describe('after response', function () {
+    describe('response', function () {
         it('should be able to reference interceptor using name', function () {
             var promise, result, Resource, testConfig = {};
 
             $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
 
             angular.copy(config, testConfig);
-            testConfig.afterResponseInterceptors = ['railsTestAfterInterceptor'];
             Resource = factory(testConfig);
+            Resource.addInterceptor('railsTestInterceptor');
 
             expect(promise = Resource.get(123)).toBeDefined();
 
@@ -165,9 +239,130 @@ describe('transformers', function () {
 
             $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
 
+            angular.copy(config, testConfig);
+            Resource = factory(testConfig);
+            Resource.addInterceptor(testInterceptor);
+
+            expect(promise = Resource.get(123)).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({interceptorAdded: 'x', id: 123, abcDef: 'xyz'});
+        });
+
+        it('should execute error interceptors on HTTP error', function () {
+            var promise, result, rejection, Resource, testConfig = {};
+
+            $httpBackend.expectGET('/test/123').respond(500);
 
             angular.copy(config, testConfig);
-            testConfig.afterResponseInterceptors = [testAfterInterceptor];
+            Resource = factory(testConfig);
+            Resource.addInterceptor(testInterceptor);
+
+            expect(promise = Resource.get(123)).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            }, function (error) {
+                rejection = error;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).not.toBeDefined();
+            expect(rejection).toBeDefined();
+            expect(rejection.interceptorCalled).toBeTruthy();
+        });
+
+        it('should be able to add interceptor using interceptResponse', function () {
+            var promise, result, Resource, interceptorCalled = false;
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+
+            Resource = factory(config);
+
+            Resource.interceptResponse(function (response, constructor, context) {
+                expect(response.data).toEqualData({id: 123, abcDef: 'xyz'});
+                expect(constructor).toEqual(Resource);
+                expect(context).toBeUndefined();
+                interceptorCalled = true;
+                return response;
+            });
+
+            expect(promise = Resource.get(123)).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({id: 123, abcDef: 'xyz'});
+            expect(interceptorCalled).toBeTruthy();
+        });
+
+        it('should set context to resource instance', function () {
+            var instance, Resource, interceptorCalled = false;
+
+            $httpBackend.expectPOST('/test').respond(200, {id: 123, abc_def: 'xyz'});
+
+            Resource = factory(config);
+
+            instance = new Resource({abcDef: 'xyz'});
+
+            Resource.interceptResponse(function (response, constructor, context) {
+                expect(response.data).toEqualData({id: 123, abcDef: 'xyz'});
+                expect(constructor).toEqual(Resource);
+                expect(context).toBeInstanceOf(Resource);
+                expect(context).toEqualData(instance);
+                interceptorCalled = true;
+                return response;
+            });
+
+            instance.save();
+
+            $httpBackend.flush();
+
+            expect(interceptorCalled).toBeTruthy();
+        });
+    });
+
+    describe('deprecated after response', function () {
+        it('should be able to reference interceptor using name', function () {
+            var promise, result, Resource, testConfig = {};
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+
+            angular.copy(config, testConfig);
+            testConfig.afterResponseInterceptors = ['deprecatedRailsTestAfterInterceptor'];
+            Resource = factory(testConfig);
+
+            expect(promise = Resource.get(123)).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({interceptorAdded: 'x', id: 123, abcDef: 'xyz'});
+        });
+
+        it('should be able to add interceptor using reference', function () {
+            var promise, result, Resource, testConfig = {};
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+
+
+            angular.copy(config, testConfig);
+            testConfig.afterResponseInterceptors = [deprecatedTestAfterInterceptor];
             Resource = factory(testConfig);
 
             expect(promise = Resource.get(123)).toBeDefined();
@@ -231,5 +426,212 @@ describe('transformers', function () {
         });
     });
 
+    describe('after response', function () {
+        it('should be able to reference interceptor using name', function () {
+            var promise, result, Resource, testConfig = {};
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+
+            angular.copy(config, testConfig);
+            testConfig.interceptors = ['railsTestAfterInterceptor'];
+            Resource = factory(testConfig);
+
+            expect(promise = Resource.get(123)).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({interceptorAdded: 'x', id: 123, abcDef: 'xyz'});
+        });
+
+        it('should be able to add interceptor using reference', function () {
+            var promise, result, Resource, testConfig = {};
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+
+            angular.copy(config, testConfig);
+            testConfig.interceptors = [testAfterInterceptor];
+            Resource = factory(testConfig);
+
+            expect(promise = Resource.get(123)).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({interceptorAdded: 'x', id: 123, abcDef: 'xyz'});
+        });
+
+        it('should be able to add interceptor using afterResponse', function () {
+            var promise, result, Resource, interceptorCalled = false;
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+
+            Resource = factory(config);
+
+            Resource.interceptAfterResponse(function (resource, constructor, context) {
+                expect(resource).toEqualData({id: 123, abcDef: 'xyz'});
+                expect(constructor).toEqual(Resource);
+                interceptorCalled = true;
+            });
+
+            expect(promise = Resource.get(123)).toBeDefined();
+
+            promise.then(function (response) {
+                result = response;
+            });
+
+            $httpBackend.flush();
+
+            expect(result).toBeInstanceOf(Resource);
+            expect(result).toEqualData({id: 123, abcDef: 'xyz'});
+            expect(interceptorCalled).toBeTruthy();
+        });
+
+        it('should set context to resource instance', function () {
+            var instance, Resource, interceptorCalled = false;
+
+            $httpBackend.expectPOST('/test').respond(200, {id: 123, abc_def: 'xyz'});
+
+            Resource = factory(config);
+
+            instance = new Resource({abcDef: 'xyz'});
+
+            Resource.interceptAfterResponse(function (resource, constructor, context) {
+                expect(resource).toEqualData({id: 123, abcDef: 'xyz'});
+                expect(constructor).toEqual(Resource);
+                interceptorCalled = true;
+            });
+
+            instance.save();
+
+            $httpBackend.flush();
+
+            expect(interceptorCalled).toBeTruthy();
+        });
+    });
+
+    describe('before request wrapping', function () {
+        it('should be able to add transformer using name', function() {
+            var Resource, testConfig = {};
+
+            $httpBackend.expectPOST('/test/123', {test: {id: 123, transformer_called: true}}).respond(200, {id: 123, abc_def: 'xyz'});
+
+            angular.copy(config, testConfig);
+            testConfig.interceptors = ['railsTestRequestTransformer'];
+            Resource = factory(testConfig);
+            new Resource({id: 123}).create();
+
+            $httpBackend.flush();
+        });
+
+        it('should be able to add transformer using reference', function() {
+            var Resource, testConfig = {};
+
+            $httpBackend.expectPOST('/test/123', {test: {id: 123, transformer_called: true}}).respond(200, {id: 123, abc_def: 'xyz'});
+
+            angular.copy(config, testConfig);
+            testConfig.interceptors = [testRequestTransformer];
+            Resource = factory(testConfig);
+            new Resource({id: 123}).create();
+
+            $httpBackend.flush();
+        });
+
+        it('should call transformer function with beforeRequest', function () {
+            var Resource, transformerCalled = false;
+
+            $httpBackend.expectPOST('/test/123', {test: {id: 123}}).respond(200, {id: 123, abc_def: 'xyz'});
+
+            Resource = factory(config);
+            Resource.interceptBeforeRequest(function (httpConfig, constructor) {
+                expect(httpConfig.data).toEqualData({id: 123});
+                expect(constructor).toEqual(Resource);
+                transformerCalled = true;
+                return httpConfig;
+            });
+
+            new Resource({id: 123}).create();
+
+            $httpBackend.flush();
+            expect(transformerCalled).toBeTruthy();
+        });
+
+        it('should be able to return new data from beforeRequest function', function () {
+            var Resource, transformerCalled = false;
+
+            $httpBackend.expectPOST('/test/123', {test: {id: 1}}).respond(200, {id: 123, abc_def: 'xyz'});
+
+            Resource = factory(config);
+            Resource.interceptBeforeRequest(function (httpConfig, resource) {
+                expect(httpConfig.data).toEqualData({id: 123});
+                expect(resource).toEqual(Resource);
+                transformerCalled = true;
+                httpConfig.data = {id: 1};
+                return httpConfig;
+            });
+
+            new Resource({id: 123}).create();
+
+            $httpBackend.flush();
+            expect(transformerCalled).toBeTruthy();
+        });
+    });
+
+    describe('async interceptor', function () {
+        it('should execute both requests', function () {
+            var testResult;
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+            $httpBackend.expectGET('/async').respond(200, {id: 1, value: true});
+
+            Test.addInterceptor('asyncInterceptor');
+            Test.get(123).then(function (result) {
+                testResult = result;
+            });
 
+            $httpBackend.flush();
+            expect(testResult).toEqualData({id: 123, abcDef: 'xyz', async: {id: 1, value: true}});
+        });
+
+        it('should fail if async operation fails', function () {
+            var testResult, testError;
+
+            $httpBackend.expectGET('/test/123').respond(200, {id: 123, abc_def: 'xyz'});
+            $httpBackend.expectGET('/async').respond(500);
+
+            Test.addInterceptor('asyncInterceptor');
+            Test.get(123).then(function (result) {
+                testResult = result;
+            }, function (error) {
+                testError = error;
+            });
+
+            $httpBackend.flush();
+            expect(testResult).not.toBeDefined();
+            expect(testError).toBeDefined();
+        });
+    });
+
+    describe('multi-phase interceptor', function () {
+        it('should execute multiple success phases', function () {
+            var test = new Test({abcDef: 'xyz'});
+
+            Test.addInterceptor('saveIndicatorInterceptor');
+            $httpBackend.expectPOST('/test', {test: {abc_def: 'xyz'}}).respond(200, {id: 123, abc_def: 'xyz'});
+            $rootScope.$apply(function () {
+                test.save();
+            });
+            expect(test.$savePending).toEqual(true);
+            $httpBackend.flush();
+            expect(test.$savePending).toEqual(false);
+        });
+    });
 });