angularjs-rails-resource 0.1.7 → 0.2.0

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

@@ -0,0 +1,333 @@
+describe('railsUrlSerializer', function () {
+    'use strict';
+    var factory, railsInjector;
+
+    function createSerializer(options, customizer) {
+        return railsInjector.createService(factory(options, customizer));
+    }
+
+    beforeEach(module('rails'));
+
+    beforeEach(inject(function (railsSerializer, RailsResourceInjector) {
+        factory = railsSerializer;
+        railsInjector = RailsResourceInjector;
+    }));
+
+    it('should support customizer being first parameter', function () {
+        var called = false;
+
+        createSerializer(function () {
+            called = true;
+        });
+
+        expect(called).toBeTruthy();
+    });
+
+    it('should support customizer with options as first parameter', function () {
+        var called = false;
+
+        createSerializer({}, function () {
+            called = true;
+        });
+
+        expect(called).toBeTruthy();
+
+    });
+
+    describe('default config', function () {
+        var serializer;
+
+        beforeEach(function () {
+            serializer = createSerializer();
+        });
+
+        it('should underscore attributes on single object', function () {
+            var orig = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'},
+                result = serializer.serialize(orig);
+            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
+            result = serializer.deserialize(result);
+            expect(result).toEqualData(orig);
+        });
+
+        it('should underscore attributes on nested objects', function () {
+            var orig = {id: 6, title: 'Winds of Winter', pages: 1105, publicationDate: '2020-05-25', author: {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'}},
+                result = serializer.serialize(orig);
+            expect(result).toEqualData({id: 6, title: 'Winds of Winter', pages: 1105, publication_date: '2020-05-25', author: {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'}});
+            result = serializer.deserialize(result);
+            expect(result).toEqualData(orig);
+        });
+
+        it('should underscore attribute inside array objects', function () {
+            var orig = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', books: [
+                    {id: 1, title: 'A Game of Thrones', publicationDate: '1996-08-06'}
+                ]},
+                result = serializer.serialize(orig);
+            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', books: [
+                {id: 1, title: 'A Game of Thrones', publication_date: '1996-08-06'}
+            ]});
+            result = serializer.deserialize(result);
+            expect(result).toEqualData(orig);
+        });
+
+        it('should support primitive arrays', function () {
+            var orig = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', books: [1, 2, 3]},
+                result = serializer.serialize(orig);
+            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', books: [1, 2, 3]});
+            result = serializer.deserialize(result);
+            expect(result).toEqualData(orig);
+        });
+
+        it('should exclude attributes that start with $', function () {
+            var result = serializer.serialize({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
+            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
+            result = serializer.deserialize({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
+            expect(result).toEqualData({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'});
+        });
+
+        it('should exclude functions', function () {
+            var result = serializer.serialize({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $books: [], getNumBooks: function () {
+                this.$books.length
+            }});
+            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
+        });
+
+    });
+
+    describe('custom options', function () {
+        it('should allow overriding attribute transformation functions with undefined', function () {
+            var test,
+                serializer = createSerializer({underscore: undefined, camelize: undefined});
+
+            test = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'};
+            expect(serializer.serialize(test)).toEqualData(test);
+            test = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'};
+            expect(serializer.deserialize(test)).toEqualData(test);
+        });
+
+        it('should allow overriding attribute transformation with custom function', function () {
+            var result,
+                serializer = createSerializer({
+                    underscore: function (attribute) {
+                        return 'x' + attribute
+                    },
+                    camelize: function (attribute) {
+                        return 'y' + attribute
+                    }
+                });
+
+            result = serializer.serialize({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'});
+            expect(result).toEqualData({xid: 1, xfirstName: 'George', xmiddleName: 'R. R.', xlastName: 'Martin'});
+            result = serializer.deserialize({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
+            expect(result).toEqualData({yid: 1, yfirst_name: 'George', ymiddle_name: 'R. R.', ylast_name: 'Martin'});
+        });
+
+        it('should allow safely ignore null excludePrefixes', function () {
+            var result, underscored, camelized,
+                serializer = createSerializer({exclusionMatchers: null});
+
+            camelized = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'};
+            underscored = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'};
+            result = serializer.serialize(camelized);
+            expect(result).toEqualData(underscored);
+            result = serializer.deserialize(underscored);
+            expect(result).toEqualData(camelized);
+        });
+
+        it('should allow safely ignore undefined excludePrefixes', function () {
+            var result, underscored, camelized,
+                serializer = createSerializer({exclusionMatchers: undefined});
+
+            camelized = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'};
+            underscored = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'};
+            result = serializer.serialize(camelized);
+            expect(result).toEqualData(underscored);
+            result = serializer.deserialize(underscored);
+            expect(result).toEqualData(camelized);
+        });
+
+        it('should allow empty excludePrefixes', function () {
+            var result, underscored, camelized,
+                serializer = createSerializer({exclusionMatchers: []});
+
+            camelized = {id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'};
+            underscored = {id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'};
+            result = serializer.serialize(camelized);
+            expect(result).toEqualData(underscored);
+            result = serializer.deserialize(underscored);
+            expect(result).toEqualData(camelized);
+        });
+
+        it('should treat exclusionMatcher strings as prefix exclusions', function () {
+            var result,
+                serializer = createSerializer({exclusionMatchers: ['x']});
+
+            result = serializer.serialize({xid: 1, firstNamex: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
+            expect(result).toEqualData({first_namex: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
+            result = serializer.deserialize({xid: 1, first_namex: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
+            expect(result).toEqualData({xid: 1, firstNamex: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
+        });
+
+        it('should use combination of string prefix, function, and regexp for exclusions', function () {
+            var result,
+                serializer = createSerializer({exclusionMatchers: ['x', /^$/, function (key) {
+                    return key === 'middleName';
+                }]});
+
+            result = serializer.serialize({xid: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birthDate: '1948-09-20'});
+            expect(result).toEqualData({first_name: 'George', last_name: 'Martin'});
+            result = serializer.deserialize({xid: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', $birth_date: '1948-09-20'});
+            expect(result).toEqualData({xid: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin', $birth_date: '1948-09-20'});
+        });
+    });
+
+    describe('customized serialization', function () {
+        var camelizedAuthor = {
+                id: 1,
+                firstName: 'George',
+                middleName: 'R. R.',
+                lastName: 'Martin',
+                birthDate: '1948-09-20',
+                books: [
+                    {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', publicationDate: '1996-08-06', authorId: 1},
+                    {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', publicationDate: '1999-03-01', authorId: 1},
+                ]
+            },
+            underscoredAuthor = {
+                id: 1,
+                first_name: 'George',
+                middle_name: 'R. R.',
+                last_name: 'Martin',
+                birth_date: '1948-09-20',
+                books: [
+                    {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', publication_date: '1996-08-06', author_id: 1},
+                    {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', publication_date: '1999-03-01', author_id: 1},
+                ]
+            };
+
+        it('should allow single exclusion', function () {
+            var result,
+                serializer = createSerializer(function (config) {
+                    config.exclude('books');
+                });
+
+            result = serializer.serialize(camelizedAuthor);
+            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin', birth_date: '1948-09-20'});
+            result = serializer.deserialize(underscoredAuthor);
+            expect(result).toEqualData(camelizedAuthor);
+        });
+
+        it('should allow variable exclusions', function () {
+            var result,
+                serializer = createSerializer(function (config) {
+                    config.exclude('books', 'birthDate');
+                });
+
+            result = serializer.serialize(camelizedAuthor);
+            expect(result).toEqualData({id: 1, first_name: 'George', middle_name: 'R. R.', last_name: 'Martin'});
+            result = serializer.deserialize(underscoredAuthor);
+            expect(result).toEqualData(camelizedAuthor);
+        });
+
+        it('should allow renaming attributes', function () {
+            var result,
+                serializer = createSerializer(function (config) {
+                    // this & config should be interchangeable
+                    this.exclude('books', 'birthDate');
+                    this.rename('id', 'authorId');
+                    this.rename('firstName', 'first');
+                    this.rename('middleName', 'middle');
+                    config.rename('lastName', 'last');
+                });
+
+            result = serializer.serialize(camelizedAuthor);
+            expect(result).toEqualData({author_id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+            result = serializer.deserialize({author_id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+            expect(result).toEqualData({id: 1, firstName: 'George', middleName: 'R. R.', lastName: 'Martin'});
+        });
+
+        it('should allow nested attributes', function () {
+            var result,
+                serializer = createSerializer(function () {
+                    this.nestedAttribute('books')
+                });
+
+            result = serializer.serialize(camelizedAuthor);
+            expect(result['books_attributes']).toEqualData([
+                {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', publication_date: '1996-08-06', author_id: 1},
+                {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', publication_date: '1999-03-01', author_id: 1}
+            ]);
+            result = serializer.deserialize(underscoredAuthor);
+            expect(result).toEqualData(camelizedAuthor);
+        });
+
+        it('should add custom attribute from function', function () {
+            var result,
+                serializer = createSerializer(function () {
+                    this.add('numBooks', function (author) {
+                        return author.books.length;
+                    });
+                });
+
+            result = serializer.serialize(camelizedAuthor);
+            expect(result['num_books']).toBe(2);
+        });
+
+        it('should add custom attribute from constant value', function () {
+            var result,
+                serializer = createSerializer(function () {
+                    this.add('numBooks', 2);
+                });
+
+            result = serializer.serialize(camelizedAuthor);
+            expect(result['num_books']).toBe(2);
+        });
+
+        it('should use custom serializer for books', function () {
+            var result, serializedBooks, underscored,
+                serializer = createSerializer(function () {
+                    this.serializeWith('books', factory(function () {
+                        this.rename('publicationDate', 'published');
+                    }));
+                });
+
+            result = serializer.serialize(camelizedAuthor);
+            serializedBooks = [
+                {id: 1, title: 'A Game of Thrones', pages: 694, series: 'A Song of Ice and Fire', published: '1996-08-06', author_id: 1},
+                {id: 2, title: 'A Clash of Kings', pages: 768, series: 'A Song of Ice and Fire', published: '1999-03-01', author_id: 1}
+            ];
+
+            expect(result['books']).toEqualData(serializedBooks);
+            underscored = angular.copy(underscoredAuthor);
+            underscored['books'] = serializedBooks;
+            result = serializer.deserialize(underscored);
+            expect(result).toEqualData(camelizedAuthor);
+        });
+    });
+
+    describe('default exclusion serialization', function () {
+        it('should only serialize id', function () {
+            var result,
+                serializer = createSerializer(function (config) {
+                    // this & config should be interchangeable
+                    this.only('id');
+                });
+
+            result = serializer.serialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+            expect(result).toEqualData({id: 1});
+            result = serializer.deserialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+            expect(result).toEqualData({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+        });
+
+        it('should only serialize id and last', function () {
+            var result,
+                serializer = createSerializer(function (config) {
+                    this.only('id', 'last');
+                });
+
+            result = serializer.serialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+            expect(result).toEqualData({id: 1, last: 'Martin'});
+            result = serializer.deserialize({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+            expect(result).toEqualData({id: 1, first: 'George', middle: 'R. R.', last: 'Martin'});
+        });
+    });
+});

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

@@ -0,0 +1,96 @@
+describe('transformers', function () {
+    'use strict';
+    var $httpBackend, $rootScope, factory, Test, testTransformer,
+        config = {
+            url: '/test',
+            name: 'test'
+        };
+
+    beforeEach(function() {
+        module('rails');
+
+        angular.module('rails').factory('railsTestTransformer', function () {
+            return function (data, resource) {
+                data.transformer_called = true;
+                return data;
+            }
+        });
+    });
+
+    beforeEach(inject(function (_$httpBackend_, _$rootScope_, railsResourceFactory, railsTestTransformer) {
+        $httpBackend = _$httpBackend_;
+        $rootScope = _$rootScope_;
+        factory = railsResourceFactory;
+        Test = railsResourceFactory(config);
+        testTransformer = railsTestTransformer;
+    }));
+
+    afterEach(function() {
+        $httpBackend.verifyNoOutstandingExpectation();
+        $httpBackend.verifyNoOutstandingRequest();
+    });
+
+
+    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.requestTransformers = ['railsTestTransformer'];
+        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.requestTransformers = [testTransformer];
+        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.beforeRequest(function (data, constructor) {
+            expect(data).toEqualData({id: 123});
+            expect(constructor).toEqual(Resource);
+            transformerCalled = true;
+        });
+
+        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.beforeRequest(function (data, resource) {
+            expect(data).toEqualData({id: 123});
+            expect(resource).toEqual(Resource);
+            transformerCalled = true;
+            return {id: 1};
+        });
+
+        new Resource({id: 123}).create();
+
+        $httpBackend.flush();
+        expect(transformerCalled).toBeTruthy();
+    });
+});

data/test/unit/angularjs/rails/utils/urlBuilderSpec.js

@@ -0,0 +1,40 @@
+describe("railsUrlBuilder", function () {
+    'use strict';
+
+    beforeEach(module('rails'));
+
+    it('should return custom function', inject(function (railsUrlBuilder) {
+        expect(railsUrlBuilder(function () { return 'test' })()).toEqualData('test')
+    }));
+
+    it('should return base url when no context object', inject(function (railsUrlBuilder) {
+        expect(railsUrlBuilder('/books')()).toEqualData('/books');
+    }));
+
+    it('should append id', inject(function (railsUrlBuilder) {
+        expect(railsUrlBuilder('/books')({id: 1})).toEqualData('/books/1');
+    }));
+
+    it('should use author id for book list', inject(function (railsUrlBuilder) {
+        expect(railsUrlBuilder('/authors/{{authorId}}/books/{{id}}')({authorId: 1})).toEqualData('/authors/1/books');
+    }));
+
+    it('should use author id and book id', inject(function (railsUrlBuilder) {
+        expect(railsUrlBuilder('/authors/{{authorId}}/books/{{id}}')({authorId: 1, id: 2})).toEqualData('/authors/1/books/2');
+    }));
+
+    describe('custom interpolation symbols', function() {
+        beforeEach(module(function($interpolateProvider) {
+              $interpolateProvider.startSymbol('--');
+              $interpolateProvider.endSymbol('--');
+        }));
+
+        it('should append id', inject(function (railsUrlBuilder) {
+            expect(railsUrlBuilder('/books')({id: 1})).toEqualData('/books/1');
+        }));
+
+        it('should use author id and book id', inject(function (railsUrlBuilder) {
+            expect(railsUrlBuilder('/authors/--authorId--/books/--id--')({authorId: 1, id: 2})).toEqualData('/authors/1/books/2');
+        }));
+    });
+});