active_model_serializers 0.8.3 → 0.10.0

data/test/adapter/json_api/parse_test.rb

@@ -0,0 +1,137 @@
+require 'test_helper'
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      module Deserialization
+        class ParseTest < Minitest::Test
+          def setup
+            @hash = {
+              'data' => {
+                'type' => 'photos',
+                'id' => 'zorglub',
+                'attributes' => {
+                  'title' => 'Ember Hamster',
+                  'src' => 'http://example.com/images/productivity.png'
+                },
+                'relationships' => {
+                  'author' => {
+                    'data' => nil
+                  },
+                  'photographer' => {
+                    'data' => { 'type' => 'people', 'id' => '9' }
+                  },
+                  'comments' => {
+                    'data' => [
+                      { 'type' => 'comments', 'id' => '1' },
+                      { 'type' => 'comments', 'id' => '2' }
+                    ]
+                  }
+                }
+              }
+            }
+            @params = ActionController::Parameters.new(@hash)
+            @expected = {
+              id: 'zorglub',
+              title: 'Ember Hamster',
+              src: 'http://example.com/images/productivity.png',
+              author_id: nil,
+              photographer_id: '9',
+              comment_ids: %w(1 2)
+            }
+
+            @illformed_payloads = [nil,
+                                   {},
+                                   {
+                                     'data' => nil
+                                   }, {
+                                     'data' => { 'attributes' => [] }
+                                   }, {
+                                     'data' => { 'relationships' => [] }
+                                   }, {
+                                     'data' => {
+                                       'relationships' => { 'rel' => nil }
+                                     }
+                                   }, {
+                                     'data' => {
+                                       'relationships' => { 'rel' => {} }
+                                     }
+                                   }]
+          end
+
+          def test_hash
+            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@hash)
+            assert_equal(@expected, parsed_hash)
+          end
+
+          def test_actioncontroller_parameters
+            assert_equal(false, @params.permitted?)
+            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@params)
+            assert_equal(@expected, parsed_hash)
+          end
+
+          def test_illformed_payloads_safe
+            @illformed_payloads.each do |p|
+              parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse(p)
+              assert_equal({}, parsed_hash)
+            end
+          end
+
+          def test_illformed_payloads_unsafe
+            @illformed_payloads.each do |p|
+              assert_raises(InvalidDocument) do
+                ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(p)
+              end
+            end
+          end
+
+          def test_filter_fields_only
+            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@hash, only: [:id, :title, :author])
+            expected = {
+              id: 'zorglub',
+              title: 'Ember Hamster',
+              author_id: nil
+            }
+            assert_equal(expected, parsed_hash)
+          end
+
+          def test_filter_fields_except
+            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@hash, except: [:id, :title, :author])
+            expected = {
+              src: 'http://example.com/images/productivity.png',
+              photographer_id: '9',
+              comment_ids: %w(1 2)
+            }
+            assert_equal(expected, parsed_hash)
+          end
+
+          def test_keys
+            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@hash, keys: { author: :user, title: :post_title })
+            expected = {
+              id: 'zorglub',
+              post_title: 'Ember Hamster',
+              src: 'http://example.com/images/productivity.png',
+              user_id: nil,
+              photographer_id: '9',
+              comment_ids: %w(1 2)
+            }
+            assert_equal(expected, parsed_hash)
+          end
+
+          def test_polymorphic
+            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!(@hash, polymorphic: [:photographer])
+            expected = {
+              id: 'zorglub',
+              title: 'Ember Hamster',
+              src: 'http://example.com/images/productivity.png',
+              author_id: nil,
+              photographer_id: '9',
+              photographer_type: 'people',
+              comment_ids: %w(1 2)
+            }
+            assert_equal(expected, parsed_hash)
+          end
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/relationship_test.rb

@@ -0,0 +1,161 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class RelationshipTest < ActiveSupport::TestCase
+        setup do
+          @blog = Blog.new(id: 1)
+          @author = Author.new(id: 1, name: 'Steve K.', blog: @blog)
+          @serializer = BlogSerializer.new(@blog)
+          ActionController::Base.cache_store.clear
+        end
+
+        def test_relationship_with_data
+          expected = {
+            data: {
+              id: '1',
+              type: 'blogs'
+            }
+          }
+          test_relationship(expected, options: { include_data: true })
+        end
+
+        def test_relationship_with_nil_model
+          @serializer = BlogSerializer.new(nil)
+          expected = { data: nil }
+          test_relationship(expected, options: { include_data: true })
+        end
+
+        def test_relationship_with_nil_serializer
+          @serializer = nil
+          expected = { data: nil }
+          test_relationship(expected, options: { include_data: true })
+        end
+
+        def test_relationship_with_data_array
+          posts = [Post.new(id: 1), Post.new(id: 2)]
+          @serializer = ActiveModel::Serializer::CollectionSerializer.new(posts)
+          @author.posts = posts
+          @author.blog = nil
+          expected = {
+            data: [
+              {
+                id: '1',
+                type: 'posts'
+              },
+              {
+                id: '2',
+                type: 'posts'
+              }
+            ]
+          }
+          test_relationship(expected, options: { include_data: true })
+        end
+
+        def test_relationship_data_not_included
+          test_relationship({}, options: { include_data: false })
+        end
+
+        def test_relationship_simple_link
+          links = { self: 'a link' }
+          test_relationship({ links: { self: 'a link' } }, links: links)
+        end
+
+        def test_relationship_many_links
+          links = {
+            self: 'a link',
+            related: 'another link'
+          }
+          expected = {
+            links: {
+              self: 'a link',
+              related: 'another link'
+            }
+          }
+          test_relationship(expected, links: links)
+        end
+
+        def test_relationship_block_link
+          links = { self: proc { object.id.to_s } }
+          expected = { links: { self: @blog.id.to_s } }
+          test_relationship(expected, links: links)
+        end
+
+        def test_relationship_block_link_with_meta
+          links = {
+            self: proc do
+              href object.id.to_s
+              meta(id: object.id)
+            end
+          }
+          expected = {
+            links: {
+              self: {
+                href: @blog.id.to_s,
+                meta: { id: @blog.id }
+              }
+            }
+          }
+          test_relationship(expected, links: links)
+        end
+
+        def test_relationship_simple_meta
+          meta = { id: '1' }
+          expected = { meta: meta }
+          test_relationship(expected, meta: meta)
+        end
+
+        def test_relationship_block_meta
+          meta =  proc do
+            { id: object.id }
+          end
+          expected = {
+            meta: {
+              id: @blog.id
+            }
+          }
+          test_relationship(expected, meta: meta)
+        end
+
+        def test_relationship_with_everything
+          links = {
+            self: 'a link',
+            related: proc do
+              href object.id.to_s
+              meta object.id
+            end
+
+          }
+          meta = proc do
+            { id: object.id }
+          end
+          expected = {
+            data: {
+              id: '1',
+              type: 'blogs'
+            },
+            links: {
+              self: 'a link',
+              related: {
+                href: '1', meta: 1
+              }
+            },
+            meta: {
+              id: @blog.id
+            }
+          }
+          test_relationship(expected, meta: meta, options: { include_data: true }, links: links)
+        end
+
+        private
+
+        def test_relationship(expected, params = {})
+          parent_serializer = AuthorSerializer.new(@author)
+          relationship = Relationship.new(parent_serializer, @serializer, nil, params)
+          assert_equal(expected, relationship.as_json)
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/relationships_test.rb

@@ -0,0 +1,199 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        class RelationshipTest < ActiveSupport::TestCase
+          RelationshipAuthor = Class.new(::Model)
+          class RelationshipAuthorSerializer < ActiveModel::Serializer
+            has_one :bio do
+              link :self, '//example.com/link_author/relationships/bio'
+            end
+
+            has_one :profile do
+              link :related do
+                "//example.com/profiles/#{object.profile.id}"
+              end
+            end
+
+            has_many :locations do
+              link :related do
+                ids = object.locations.map(&:id).join(',')
+                href "//example.com/locations/#{ids}"
+              end
+            end
+
+            has_many :posts do
+              link :related do
+                ids = object.posts.map(&:id).join(',')
+                href "//example.com/posts/#{ids}"
+                meta ids: ids
+              end
+            end
+
+            has_many :comments do
+              link :self do
+                meta ids: [1]
+              end
+            end
+
+            has_many :roles do |serializer|
+              meta count: object.posts.count
+              serializer.cached_roles
+            end
+
+            has_one :blog do
+              link :self, '//example.com/link_author/relationships/blog'
+              include_data false
+            end
+
+            belongs_to :reviewer do
+              meta name: 'Dan Brown'
+              include_data true
+            end
+
+            has_many :likes do
+              link :related do
+                ids = object.likes.map(&:id).join(',')
+                href "//example.com/likes/#{ids}"
+                meta ids: ids
+              end
+              meta liked: object.likes.any?
+            end
+
+            def cached_roles
+              [
+                Role.new(id: 'from-serializer-method')
+              ]
+            end
+          end
+
+          def setup
+            @post = Post.new(id: 1337, comments: [], author: nil)
+            @blog = Blog.new(id: 1337, name: 'extra')
+            @bio = Bio.new(id: 1337)
+            @like = Like.new(id: 1337)
+            @role = Role.new(id: 'from-record')
+            @profile = Profile.new(id: 1337)
+            @location = Location.new(id: 1337)
+            @reviewer = Author.new(id: 1337)
+            @comment = Comment.new(id: 1337)
+            @author = RelationshipAuthor.new(
+              id: 1337,
+              posts: [@post],
+              blog: @blog,
+              reviewer: @reviewer,
+              bio: @bio,
+              likes: [@like],
+              roles: [@role],
+              locations: [@location],
+              profile: @profile,
+              comments: [@comment]
+            )
+          end
+
+          def test_relationship_simple_link
+            expected = {
+              data: {
+                id: '1337',
+                type: 'bios'
+              },
+              links: {
+                self: '//example.com/link_author/relationships/bio'
+              }
+            }
+            assert_relationship(:bio, expected)
+          end
+
+          def test_relationship_block_link
+            expected = {
+              data: { id: '1337', type: 'profiles' },
+              links: { related: '//example.com/profiles/1337' }
+            }
+            assert_relationship(:profile, expected)
+          end
+
+          def test_relationship_block_link_href
+            expected = {
+              data: [{ id: '1337', type: 'locations' }],
+              links: {
+                related: { href: '//example.com/locations/1337' }
+              }
+            }
+            assert_relationship(:locations, expected)
+          end
+
+          def test_relationship_block_link_href_and_meta
+            expected = {
+              data: [{ id: '1337', type: 'posts' }],
+              links: {
+                related: {
+                  href: '//example.com/posts/1337',
+                  meta: { ids: '1337' }
+                }
+              }
+            }
+            assert_relationship(:posts, expected)
+          end
+
+          def test_relationship_block_link_meta
+            expected = {
+              data: [{ id: '1337', type: 'comments' }],
+              links: {
+                self: {
+                  meta: { ids: [1] }
+                }
+              }
+            }
+            assert_relationship(:comments, expected)
+          end
+
+          def test_relationship_meta
+            expected = {
+              data: [{ id: 'from-serializer-method', type: 'roles' }],
+              meta: { count: 1 }
+            }
+            assert_relationship(:roles, expected)
+          end
+
+          def test_relationship_not_including_data
+            expected = {
+              links: { self: '//example.com/link_author/relationships/blog' }
+            }
+            assert_relationship(:blog, expected)
+          end
+
+          def test_relationship_including_data_explicit
+            expected = {
+              data: { id: '1337', type: 'authors' },
+              meta: { name: 'Dan Brown' }
+            }
+            assert_relationship(:reviewer, expected)
+          end
+
+          def test_relationship_with_everything
+            expected = {
+              data: [{ id: '1337', type: 'likes' }],
+              links: {
+                related: {
+                  href: '//example.com/likes/1337',
+                  meta: { ids: '1337' }
+                }
+              },
+              meta: { liked: true }
+            }
+            assert_relationship(:likes, expected)
+          end
+
+          private
+
+          def assert_relationship(relationship_name, expected)
+            hash = serializable(@author, adapter: :json_api).serializable_hash
+            assert_equal(expected, hash[:data][:relationships][relationship_name])
+          end
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/resource_identifier_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class ResourceIdentifierTest < ActiveSupport::TestCase
+        class WithDefinedTypeSerializer < ActiveModel::Serializer
+          type 'with_defined_type'
+        end
+
+        class WithDefinedIdSerializer < ActiveModel::Serializer
+          def id
+            'special_id'
+          end
+        end
+
+        class FragmentedSerializer < ActiveModel::Serializer; end
+
+        setup do
+          @model = Author.new(id: 1, name: 'Steve K.')
+          ActionController::Base.cache_store.clear
+        end
+
+        def test_defined_type
+          test_type(WithDefinedTypeSerializer, 'with-defined-type')
+        end
+
+        def test_singular_type
+          test_type_inflection(AuthorSerializer, 'author', :singular)
+        end
+
+        def test_plural_type
+          test_type_inflection(AuthorSerializer, 'authors', :plural)
+        end
+
+        def test_id_defined_on_object
+          test_id(AuthorSerializer, @model.id.to_s)
+        end
+
+        def test_id_defined_on_serializer
+          test_id(WithDefinedIdSerializer, 'special_id')
+        end
+
+        def test_id_defined_on_fragmented
+          FragmentedSerializer.fragmented(WithDefinedIdSerializer.new(@model))
+          test_id(FragmentedSerializer, 'special_id')
+        end
+
+        private
+
+        def test_type_inflection(serializer_class, expected_type, inflection)
+          original_inflection = ActiveModelSerializers.config.jsonapi_resource_type
+          ActiveModelSerializers.config.jsonapi_resource_type = inflection
+          test_type(serializer_class, expected_type)
+        ensure
+          ActiveModelSerializers.config.jsonapi_resource_type = original_inflection
+        end
+
+        def test_type(serializer_class, expected_type)
+          serializer = serializer_class.new(@model)
+          resource_identifier = ResourceIdentifier.new(serializer, nil)
+          expected = {
+            id: @model.id.to_s,
+            type: expected_type
+          }
+
+          assert_equal(expected, resource_identifier.as_json)
+        end
+
+        def test_id(serializer_class, id)
+          serializer = serializer_class.new(@model)
+          resource_identifier = ResourceIdentifier.new(serializer, nil)
+          inflection = ActiveModelSerializers.config.jsonapi_resource_type
+          type = @model.class.model_name.send(inflection)
+          expected = {
+            id: id,
+            type: type
+          }
+
+          assert_equal(expected, resource_identifier.as_json)
+        end
+      end
+    end
+  end
+end

data/test/adapter/json_api/resource_meta_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        class ResourceMetaTest < Minitest::Test
+          class MetaHashPostSerializer < ActiveModel::Serializer
+            attributes :id
+            meta stuff: 'value'
+          end
+
+          class MetaBlockPostSerializer < ActiveModel::Serializer
+            attributes :id
+            meta do
+              { comments_count: object.comments.count }
+            end
+          end
+
+          class MetaBlockPostBlankMetaSerializer < ActiveModel::Serializer
+            attributes :id
+            meta do
+              {}
+            end
+          end
+
+          class MetaBlockPostEmptyStringSerializer < ActiveModel::Serializer
+            attributes :id
+            meta do
+              ''
+            end
+          end
+
+          def setup
+            @post = Post.new(id: 1337, comments: [], author: nil)
+          end
+
+          def test_meta_hash_object_resource
+            hash = ActiveModelSerializers::SerializableResource.new(
+              @post,
+              serializer: MetaHashPostSerializer,
+              adapter: :json_api
+            ).serializable_hash
+            expected = {
+              stuff: 'value'
+            }
+            assert_equal(expected, hash[:data][:meta])
+          end
+
+          def test_meta_block_object_resource
+            hash = ActiveModelSerializers::SerializableResource.new(
+              @post,
+              serializer: MetaBlockPostSerializer,
+              adapter: :json_api
+            ).serializable_hash
+            expected = {
+              :"comments-count" => @post.comments.count
+            }
+            assert_equal(expected, hash[:data][:meta])
+          end
+
+          def test_meta_object_resource_in_array
+            post2 = Post.new(id: 1339, comments: [Comment.new])
+            posts = [@post, post2]
+            hash = ActiveModelSerializers::SerializableResource.new(
+              posts,
+              each_serializer: MetaBlockPostSerializer,
+              adapter: :json_api
+            ).serializable_hash
+            expected = {
+              :data => [
+                { :id => '1337', :type => 'posts', :meta => { :"comments-count" => 0 } },
+                { :id => '1339', :type => 'posts', :meta => { :"comments-count" => 1 } }
+              ]
+            }
+            assert_equal(expected, hash)
+          end
+
+          def test_meta_object_blank_omitted
+            hash = ActiveModelSerializers::SerializableResource.new(
+              @post,
+              serializer: MetaBlockPostBlankMetaSerializer,
+              adapter: :json_api
+            ).serializable_hash
+            refute hash[:data].key? :meta
+          end
+
+          def test_meta_object_empty_string_omitted
+            hash = ActiveModelSerializers::SerializableResource.new(
+              @post,
+              serializer: MetaBlockPostEmptyStringSerializer,
+              adapter: :json_api
+            ).serializable_hash
+            refute hash[:data].key? :meta
+          end
+        end
+      end
+    end
+  end
+end