angularjs-rails-resource 0.1.4 → 0.1.5

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

@@ -1,140 +1,9 @@
-describe("js.rails", function () {
+describe("railsResourceFactory", function () {
     'use strict';
 
     beforeEach(module('rails'));
 
-    describe('railsRootWrapping', function() {
-        var q, rootScope,
-            transformer, interceptor,
-            config = {rootName: 'test', rootPluralName: 'tests'};
-
-
-        function testTransform(wrappedData, unwrappedData) {
-            var result, resultPromise,
-                deferred = q.defer();
-
-            expect(transformer(unwrappedData, config)).toEqualData(wrappedData);
-            deferred.promise.resource = config;
-            expect(resultPromise = interceptor(deferred.promise)).toBeDefined();
-
-            resultPromise.then(function (response) {
-                result = response;
-            });
-
-            deferred.resolve({data: wrappedData});
-            rootScope.$digest(); // needed for $q to actually run callbacks
-            expect(result).toEqualData({data: unwrappedData});
-        }
-
-        beforeEach(inject(function ($rootScope, $q, railsRootWrappingTransformer, railsRootWrappingInterceptor) {
-            q = $q;
-            rootScope = $rootScope;
-            transformer = railsRootWrappingTransformer;
-            interceptor = railsRootWrappingInterceptor;
-        }));
-
-        it('should handle null root', function() {
-            testTransform({test: null}, null);
-        });
-
-        it('should transform arrays', function() {
-            testTransform({tests: [1, 2, 3]}, [1, 2, 3]);
-        });
-
-        it('should transform object', function() {
-            testTransform({test: {abc: 'xyz', def: 'abc'}}, {abc: 'xyz', def: 'abc'});
-        });
-    });
-
-    describe('railsFieldRenaming', function() {
-        var q, rootScope,
-            transformer, interceptor;
-
-        function testTransform(underscoreData, camelizeData) {
-            var result, resultPromise,
-                deferred = q.defer();
-
-            expect(transformer(angular.copy(camelizeData, {}))).toEqualData(underscoreData);
-            expect(resultPromise = interceptor(deferred.promise)).toBeDefined();
-
-            resultPromise.then(function (response) {
-                result = response;
-            });
-
-            deferred.resolve(angular.copy(underscoreData, {}));
-            rootScope.$digest(); // needed for $q to actually run callbacks
-            expect(result).toEqualData(camelizeData);
-        }
-
-        beforeEach(inject(function ($rootScope, $q, railsFieldRenamingTransformer, railsFieldRenamingInterceptor) {
-            q = $q;
-            rootScope = $rootScope;
-            transformer = railsFieldRenamingTransformer;
-            interceptor = railsFieldRenamingInterceptor;
-        }));
-
-        it('should ignore empty response', function() {
-            testTransform({}, {});
-        });
-
-        it('should ignore null response data', function() {
-            testTransform({data: null}, {data: null});
-        });
-
-        it('should leave non-data response fields untouched', function() {
-            testTransform({data: null, test_value: 'xyz'}, {data: null, test_value: 'xyz'});
-        });
-
-        it('should transform abc_def <-> abcDef', function() {
-            testTransform({data: {abc_def: 'xyz'}}, {data: {abcDef: 'xyz'}});
-        });
-
-        it('should transform abc_def, ghi_jkl <-> abcDef, ghiJkl', function() {
-            testTransform({data: {abc_def: 'xyz', ghi_jkl: 'abc'}}, {data: {abcDef: 'xyz', ghiJkl: 'abc'}});
-        });
-
-        it('should transform abc <-> abc', function() {
-            testTransform({data: {abc: 'xyz'}}, {data: {abc: 'xyz'}});
-        });
-
-        it('should transform _abc <-> _abc', function() {
-            testTransform({data: {_abc: 'xyz'}}, {data: {_abc: 'xyz'}});
-        });
-
-        it('should transform abc_ <-> abc_', function() {
-            testTransform({data: {abc_: 'xyz'}}, {data: {abc_: 'xyz'}});
-        });
-
-        it('should transform nested abc_def.abc_def <-> abcDef.abcDef', function() {
-            testTransform({data: {abc_def: {abc_def: 'xyz'}}}, {data: {abcDef: {abcDef: 'xyz'}}});
-        });
-
-        it('should transform nested abc_def.abc_def, abc_def.ghi_jkl <-> abcDef.abcDef, abcDef.ghiJkl', function() {
-            testTransform({data: {abc_def: {abc_def: 'xyz', ghi_jkl: 'abc'}}}, {data: {abcDef: {abcDef: 'xyz', ghiJkl: 'abc'}}});
-        });
-
-        it('should transform nested abc.abc_def <-> abc.abcDef', function() {
-            testTransform({data: {abc: {abc_def: 'xyz'}}}, {data: {abc: {abcDef: 'xyz'}}});
-        });
-
-        it('should handle empty root array', function() {
-            testTransform({data: []}, {data: []});
-        });
-
-        it('should camelize array of objects', function() {
-            testTransform({data: [{abc_def: 'xyz'}, {ghi_jkl: 'abc'}]}, {data: [{abcDef: 'xyz'}, {ghiJkl: 'abc'}]});
-        });
-
-        it('should handle array of strings', function() {
-            testTransform({data: ['abc', 'def']}, {data: ['abc', 'def']});
-        });
-
-        it('should handle array of numbers', function() {
-            testTransform({data: [1, 2, 3]}, {data: [1, 2, 3]});
-        });
-    });
-
-    describe('singular railsResourceFactory', function() {
+    describe('singular', function() {
         var $httpBackend, $rootScope, factory, Test,
             config = {
                 url: '/test',
@@ -453,9 +322,43 @@ describe("js.rails", function () {
 
             $httpBackend.flush();
         }));
+
+        it('should transform attributes on build', function() {
+            var test = new Test({id: 123, abc_def: "T"});
+            expect(test).toEqualData({id: 123, abcDef: "T"});
+        });
+
+        angular.forEach(['post', 'put', 'patch'], function (method) {
+            it('should be able to ' + method + ' to arbitrary url', inject(function($httpBackend) {
+                var promise, result = {};
+
+                promise = Test['$' + method]('/xyz', {id: 123, abc: 'xyz', xyz: 'abc'});
+                $httpBackend['expect' + angular.uppercase(method)]('/xyz', {test: {id: 123, abc: 'xyz', xyz: 'abc'}}).respond(200, {test: {id: 123, abc: 'xyz', xyz: 'abc', extra: 'test'}});
+
+                promise.then(function (response) {
+                    result = response;
+                });
+
+                $httpBackend.flush();
+
+                // abc was originally set on the object so it should still be there after the update
+                expect(result).toEqualData({id: 123, abc: 'xyz', xyz: 'abc', extra: 'test'});
+            }));
+
+            it('should be able to ' + method + ' instance to arbitrary url', inject(function($httpBackend) {
+                var test = new Test({id: 123, abc: 'xyz', xyz: 'abc'});
+                $httpBackend['expect' + angular.uppercase(method)]('/xyz', {test: {id: 123, abc: 'xyz', xyz: 'abc'}}).respond(200, {test: {id: 123, abc: 'xyz', xyz: 'abc', extra: 'test'}});
+                test['$' + method]('/xyz');
+                $httpBackend.flush();
+
+                // abc was originally set on the object so it should still be there after the update
+                expect(test).toEqualData({id: 123, abc: 'xyz', xyz: 'abc', extra: 'test'});
+            }));
+        });
+
     });
 
-    describe('plural railsResourceFactory', function() {
+    describe('plural', function() {
         var $httpBackend, $rootScope, factory, PluralTest,
             pluralConfig = {
                 url: '/pluralTest',
@@ -514,532 +417,4 @@ describe("js.rails", function () {
             expect(result.length).toBe(0);
         }));
     });
-
-    describe('nested railsResourceFactory', function() {
-        var $httpBackend, $rootScope, factory, NestedTest,
-            nestedConfig = {
-                url: '/nested/{{nestedId}}/test/{{id}}',
-                name: 'nestedTest'
-            };
-
-        beforeEach(inject(function (_$httpBackend_, _$rootScope_, railsResourceFactory) {
-            $httpBackend = _$httpBackend_;
-            $rootScope = _$rootScope_;
-            factory = railsResourceFactory;
-            NestedTest = railsResourceFactory(nestedConfig);
-        }));
-
-        afterEach(function() {
-            $httpBackend.verifyNoOutstandingExpectation();
-            $httpBackend.verifyNoOutstandingRequest();
-        });
-
-        it('query should return resource object when response is single object', inject(function($httpBackend) {
-            var promise, result;
-
-            $httpBackend.expectGET('/nested/1234/test').respond(200, {nested_test: {abc: 'xyz'}});
-
-            expect(promise = NestedTest.query(null, {nestedId: 1234})).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-
-            expect(result).toBeInstanceOf(NestedTest);
-            expect(result).toEqualData({abc: 'xyz'});
-        }));
-
-        it('query should return no data on 204', inject(function($httpBackend) {
-            var promise, result;
-
-            $httpBackend.expectGET('/nested/1234/test').respond(204);
-            expect(promise = NestedTest.query(null, {nestedId: 1234})).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-
-            expect(result).toBeUndefined();
-        }));
-
-        it('query should add parameter abc=1', inject(function($httpBackend) {
-            var promise;
-
-            $httpBackend.expectGET('/nested/1234/test?abc=1').respond(200, {nested_test: {abc: 'xyz'}});
-
-            expect(promise = NestedTest.query({abc: '1'}, {nestedId: 1234})).toBeDefined();
-            $httpBackend.flush();
-        }));
-
-        it('query should add parameters abc=1 & xyz=2', inject(function($httpBackend) {
-            var promise;
-
-            $httpBackend.expectGET('/nested/1234/test?abc=1&xyz=2').respond(200, {nested_test: {abc: 'xyz'}});
-
-            expect(promise = NestedTest.query({abc: '1', xyz: 2}, {nestedId: 1234})).toBeDefined();
-            $httpBackend.flush();
-        }));
-
-        it('query with default params should add parameter abc=1', inject(function($httpBackend) {
-            var promise, resource, defaultParamsConfig = {};
-
-            $httpBackend.expectGET('/nested/1234/test?abc=1').respond(200, {nested_test: {abc: 'xyz'}});
-
-            angular.copy(nestedConfig, defaultParamsConfig);
-            defaultParamsConfig.defaultParams = {abc: '1'};
-
-            resource = factory(defaultParamsConfig);
-            expect(promise = resource.query(null, {nestedId: 1234})).toBeDefined();
-
-            $httpBackend.flush();
-        }));
-
-        it('get should return resource object when response is 200', inject(function($httpBackend) {
-            var promise, result;
-
-            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {nested_test: {id: 123, abc: 'xyz'}});
-
-            expect(promise = NestedTest.get({nestedId: 1234, id: 123})).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-
-            expect(result).toBeInstanceOf(NestedTest);
-            expect(result).toEqualData({id: 123, abc: 'xyz'});
-        }));
-
-        it('get should call failure callback when 404', inject(function($httpBackend) {
-            var promise, success = false, failure = false;
-
-            $httpBackend.expectGET('/nested/1234/test/123').respond(404);
-
-            expect(promise = NestedTest.get({nestedId: 1234, id: 123})).toBeDefined();
-
-            promise.then(function () {
-                success = true;
-            }, function () {
-                failure = true;
-            });
-
-            $httpBackend.flush();
-
-            expect(success).toBe(false);
-            expect(failure).toBe(true);
-        }));
-
-        it('get with default params should add parameter abc=1', inject(function($httpBackend) {
-            var promise, resource, defaultParamsConfig = {};
-
-            $httpBackend.expectGET('/nested/1234/test/123?abc=1').respond(200, {nested_test: {abc: 'xyz'}});
-
-            angular.copy(nestedConfig, defaultParamsConfig);
-            defaultParamsConfig.defaultParams = {abc: '1'};
-
-            resource = factory(defaultParamsConfig);
-            expect(promise = resource.get({nestedId: 1234, id: 123})).toBeDefined();
-
-            $httpBackend.flush();
-        }));
-
-        it('should be able to turn off root mapping and field renaming', inject(function($httpBackend) {
-            var promise, result, resource;
-
-            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {id: 123, nested_id: 1234, abc_def: 'xyz'});
-
-            resource = factory(nestedConfig);
-            resource.responseInterceptors = [];
-            resource.requestTransformers = [];
-            expect(promise = resource.get({nestedId: 1234, id: 123})).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-
-            expect(result).toBeInstanceOf(resource);
-            expect(result).toEqualData({id: 123, nested_id: 1234, abc_def: 'xyz'});
-        }));
-
-        it('should be able to turn off root mapping but keep field renaming', inject(function($httpBackend) {
-            var promise, result, resource, testConfig = {};
-
-            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {id: 123, nested_id: 1234, abc_def: 'xyz'});
-
-            angular.copy(nestedConfig, testConfig);
-            testConfig.requestTransformers = [];
-            testConfig.responseInterceptors = ['railsFieldRenamingInterceptor'];
-            resource = factory(testConfig);
-
-            expect(promise = resource.get({nestedId: 1234, id: 123})).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-
-            expect(result).toBeInstanceOf(resource);
-            expect(result).toEqualData({id: 123, nestedId: 1234, abcDef: 'xyz'});
-        }));
-
-        it('should be able to create new instance and save it', inject(function($httpBackend) {
-            var data = new NestedTest({nestedId: 1234, abcDef: 'xyz'});
-
-            $httpBackend.expectPOST('/nested/1234/test', {nested_test: {nested_id: 1234, abc_def: 'xyz'}}).respond(200, {nested_test: {id: 123, nested_id: 1234, abc_def: 'xyz'}});
-            data.nestedId = 1234;
-            data.create();
-            $httpBackend.flush();
-
-            expect(data).toEqualData({id: 123, nestedId: 1234, abcDef: 'xyz'});
-        }));
-
-        it('should be able to create new instance and update it', inject(function($httpBackend) {
-            var data = new NestedTest({abcDef: 'xyz'});
-
-            $httpBackend.expectPOST('/nested/1234/test', {nested_test: {abc_def: 'xyz', nested_id: 1234}}).respond(200, {nested_test: {id: 123, nested_id: 1234, abc_def: 'xyz'}});
-            data.nestedId = 1234;
-            data.create();
-            $httpBackend.flush(1);
-
-            expect(data).toEqualData({id: 123, nestedId: 1234, abcDef: 'xyz'});
-
-            $httpBackend.expectPUT('/nested/1234/test/123', {nested_test: {id: 123, xyz: 'abc', abc_def: 'xyz', nested_id: 1234}}).respond(200, {nested_test: {id: 123, nested_id: 1234, abc_def: 'xyz', xyz: 'abc', extra: 'test'}});
-            data.xyz = 'abc';
-            data.update();
-            $httpBackend.flush();
-
-            expect(data).toEqualData({id: 123, nestedId: 1234, abcDef: 'xyz', xyz: 'abc', extra: 'test'});
-        }));
-
-        it('create with default params should add parameter abc=1', inject(function($httpBackend) {
-            var promise, Resource, data, defaultParamsConfig = {};
-
-            $httpBackend.expectPOST('/nested/1234/test?abc=1', {nested_test: {nested_id: 1234}}).respond(200, {nested_test: {id: 123, nested_id: 1234}});
-
-            angular.copy(nestedConfig, defaultParamsConfig);
-            defaultParamsConfig.defaultParams = {abc: '1'};
-
-            Resource = factory(defaultParamsConfig);
-            data = new Resource();
-            data.nestedId = 1234;
-            data.create();
-
-            $httpBackend.flush();
-        }));
-
-        it('should be able to get resource and update it', inject(function($httpBackend) {
-            var promise, result;
-
-            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {nested_test: {id: 123, nested_id: 1234, abc: 'xyz'}});
-
-            expect(promise = NestedTest.get({nestedId: 1234, id: 123})).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-
-            expect(result).toBeInstanceOf(NestedTest);
-            expect(result).toEqualData({id: 123, nestedId: 1234, abc: 'xyz'});
-
-            $httpBackend.expectPUT('/nested/1234/test/123', {nested_test: {id: 123, abc: 'xyz', xyz: 'abc', nested_id: 1234}}).respond(200, {nested_test: {id: 123, nested_id: 1234, abc_def: 'xyz', xyz: 'abc', extra: 'test'}});
-            result.xyz = 'abc';
-            result.update();
-            $httpBackend.flush();
-
-            // abc was originally set on the object so it should still be there after the update
-            expect(result).toEqualData({id: 123, nestedId: 1234, abc: 'xyz', abcDef: 'xyz', xyz: 'abc', extra: 'test'});
-        }));
-
-        it('update should handle 204 response', inject(function($httpBackend) {
-            var promise, result;
-
-            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {nested_test: {id: 123, nested_id: 1234, abc: 'xyz'}});
-
-            expect(promise = NestedTest.get({nestedId: 1234, id: 123})).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-
-            expect(result).toBeInstanceOf(NestedTest);
-            expect(result).toEqualData({id: 123, nestedId: 1234, abc: 'xyz'});
-
-            $httpBackend.expectPUT('/nested/1234/test/123', {nested_test: {id: 123, abc: 'xyz', xyz: 'abc', nested_id: 1234}}).respond(204);
-            result.xyz = 'abc';
-            result.update();
-            $httpBackend.flush();
-
-            expect(result).toEqualData({id: 123, nestedId: 1234, abc: 'xyz', xyz: 'abc'});
-        }));
-
-        it('should be able to delete instance returned from get', inject(function($httpBackend) {
-            var promise, result;
-
-            $httpBackend.expectGET('/nested/1234/test/123').respond(200, {nested_test: {id: 123, nestedId: 1234, abc: 'xyz'}});
-
-            expect(promise = NestedTest.get({nestedId: 1234, id: 123})).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-
-            expect(result).toBeInstanceOf(NestedTest);
-            expect(result).toEqualData({id: 123, nestedId: 1234, abc: 'xyz'});
-
-            $httpBackend.expectDELETE('/nested/1234/test/123').respond(204);
-            result.remove();
-            $httpBackend.flush();
-        }));
-
-        it('should be able to create new instance and update it', inject(function($httpBackend) {
-            var data = new NestedTest({abcDef: 'xyz'});
-
-            $httpBackend.expectPOST('/nested/1234/test', {nested_test: {abc_def: 'xyz', nested_id: 1234}}).respond(200, {nested_test: {id: 123, nested_id: 1234, abc_def: 'xyz'}});
-            data.nestedId = 1234;
-            data.create();
-            $httpBackend.flush(1);
-
-            expect(data).toEqualData({id: 123, nestedId: 1234, abcDef: 'xyz'});
-            expect(data).toBeInstanceOf(NestedTest);
-
-            $httpBackend.expectDELETE('/nested/1234/test/123').respond(204);
-            data.remove();
-            $httpBackend.flush();
-        }));
-
-        it('delete with default params should add parameter abc=1', inject(function($httpBackend) {
-            var Resource, data, defaultParamsConfig = {};
-
-            $httpBackend.expectDELETE('/nested/1234/test/123?abc=1').respond(204);
-
-            angular.copy(nestedConfig, defaultParamsConfig);
-            defaultParamsConfig.defaultParams = {abc: '1'};
-
-            Resource = factory(defaultParamsConfig);
-            data = new Resource();
-            data.id = 123;
-            data.nestedId = 1234;
-            data.remove();
-
-            $httpBackend.flush();
-        }));
-    });
-
-    describe('http settings', function() {
-        var $httpBackend, $rootScope, factory,
-            config = {
-                url: '/test',
-                name: 'test'
-            };
-
-        beforeEach(inject(function (_$httpBackend_, _$rootScope_, railsResourceFactory) {
-            $httpBackend = _$httpBackend_;
-            $rootScope = _$rootScope_;
-            factory = railsResourceFactory;
-        }));
-
-        afterEach(function() {
-            $httpBackend.verifyNoOutstandingExpectation();
-            $httpBackend.verifyNoOutstandingRequest();
-        });
-
-        function headerComparison(expectedHeaders) {
-            return function(headers) {
-                var matches = true;
-
-                angular.forEach(expectedHeaders, function (value, key) {
-                    if (headers[key] !== value) {
-                        matches = false;
-                    }
-                });
-
-                return matches;
-            };
-        }
-
-        it('query should pass default $http options', inject(function($httpBackend) {
-            var promise, result, Test;
-
-            $httpBackend.expectGET('/test', headerComparison({'Accept': 'application/json'})).respond(200, {test: {abc: 'xyz'}});
-
-            Test = factory(config);
-            expect(promise = Test.query()).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-        }));
-
-        it('query should allow custom Accept', inject(function($httpBackend) {
-            var promise, result, Test;
-
-            $httpBackend.expectGET('/test', headerComparison({'Accept': 'text/plain'})).respond(200, {test: {abc: 'xyz'}});
-
-            Test = factory(angular.extend(angular.copy(config), {httpConfig: {headers: {'Accept': 'text/plain'}}}));
-            expect(promise = Test.query()).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-        }));
-
-        it('query should allow custom header', inject(function($httpBackend) {
-            var promise, result, Test;
-
-            $httpBackend.expectGET('/test', headerComparison({'Accept': 'application/json', 'X-Test': 'test'})).respond(200, {test: {abc: 'xyz'}});
-
-            Test = factory(angular.extend(angular.copy(config), {httpConfig: {headers: {'X-Test': 'test'}}}));
-            expect(promise = Test.query()).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-        }));
-
-        it('get should pass default $http options', inject(function($httpBackend) {
-            var promise, result, Test;
-
-            $httpBackend.expectGET('/test/123', headerComparison({'Accept': 'application/json'})).respond(200, {test: {abc: 'xyz'}});
-
-            Test = factory(config);
-            expect(promise = Test.get(123)).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-        }));
-
-        it('get should allow custom Accept', inject(function($httpBackend) {
-            var promise, result, Test;
-
-            $httpBackend.expectGET('/test/123', headerComparison({'Accept': 'text/plain'})).respond(200, {test: {abc: 'xyz'}});
-
-            Test = factory(angular.extend(angular.copy(config), {httpConfig: {headers: {'Accept': 'text/plain'}}}));
-            expect(promise = Test.get(123)).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-        }));
-
-        it('get should allow custom header', inject(function($httpBackend) {
-            var promise, result, Test;
-
-            $httpBackend.expectGET('/test/123', headerComparison({'Accept': 'application/json', 'X-Test': 'test'})).respond(200, {test: {abc: 'xyz'}});
-
-            Test = factory(angular.extend(angular.copy(config), {httpConfig: {headers: {'X-Test': 'test'}}}));
-            expect(promise = Test.get(123)).toBeDefined();
-
-            promise.then(function (response) {
-                result = response;
-            });
-
-            $httpBackend.flush();
-        }));
-
-        it('create should pass default $http options', inject(function($httpBackend) {
-            var Test;
-
-            $httpBackend.expectPOST('/test', {test: {xyz: '123'}}, headerComparison({'Accept': 'application/json'})).respond(200, {test: {id: 123, xyz: '123'}});
-
-            Test = factory(config);
-            var test = new Test();
-            test.xyz = '123';
-            test.create();
-
-            $httpBackend.flush();
-        }));
-
-        it('create should allow custom Accept', inject(function($httpBackend) {
-            var Test;
-
-            $httpBackend.expectPOST('/test', {test: {xyz: '123'}}, headerComparison({'Accept': 'text/plain'})).respond(200, {test: {id: 123, xyz: '123'}});
-
-            Test = factory(angular.extend(angular.copy(config), {httpConfig: {headers: {'Accept': 'text/plain'}}}));
-            var test = new Test();
-            test.xyz = '123';
-            test.create();
-
-            $httpBackend.flush();
-        }));
-
-        it('create should allow custom header', inject(function($httpBackend) {
-            var Test;
-
-            $httpBackend.expectPOST('/test', {test: {xyz: '123'}}, headerComparison({'Accept': 'application/json', 'X-Test': 'test'})).respond(200, {test: {id: 123, xyz: '123'}});
-
-            Test = factory(angular.extend(angular.copy(config), {httpConfig: {headers: {'X-Test': 'test'}}}));
-            var test = new Test();
-            test.xyz = '123';
-            test.create();
-
-            $httpBackend.flush();
-        }));
-
-        it('update should pass default $http options', inject(function($httpBackend) {
-            var Test;
-
-            $httpBackend.expectPUT('/test/123', {test: {id: 123, xyz: '123'}}, headerComparison({'Accept': 'application/json'})).respond(200, {test: {id: 123, xyz: '123'}});
-
-            Test = factory(config);
-            var test = new Test();
-            test.id = 123;
-            test.xyz = '123';
-            test.update();
-
-            $httpBackend.flush();
-        }));
-
-        it('update should allow custom Accept', inject(function($httpBackend) {
-            var Test;
-
-            $httpBackend.expectPUT('/test/123', {test: {id: 123, xyz: '123'}}, headerComparison({'Accept': 'text/plain'})).respond(200, {test: {id: 123, xyz: '123'}});
-
-            Test = factory(angular.extend(angular.copy(config), {httpConfig: {headers: {'Accept': 'text/plain'}}}));
-            var test = new Test();
-            test.id = 123;
-            test.xyz = '123';
-            test.update();
-
-            $httpBackend.flush();
-        }));
-
-        it('update should allow custom header', inject(function($httpBackend) {
-            var Test;
-
-            $httpBackend.expectPUT('/test/123', {test: {id: 123, xyz: '123'}}, headerComparison({'Accept': 'application/json', 'X-Test': 'test'})).respond(200, {test: {id: 123, xyz: '123'}});
-
-            Test = factory(angular.extend(angular.copy(config), {httpConfig: {headers: {'X-Test': 'test'}}}));
-            var test = new Test();
-            test.id = 123;
-            test.xyz = '123';
-            test.update();
-
-            $httpBackend.flush();
-        }));
-    });
 });