active_model_serializers 0.8.3 → 0.10.8

data/test/adapter/json_api/relationship_test.rb

@@ -0,0 +1,397 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class RelationshipTest < ActiveSupport::TestCase
+        def test_relationship_with_data
+          expected = {
+            data: {
+              id: '1',
+              type: 'blogs'
+            }
+          }
+
+          model_attributes = { blog: Blog.new(id: 1) }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_with_nil_model
+          expected = { data: nil }
+
+          model_attributes = { blog: nil }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_with_data_array
+          expected = {
+            data: [
+              {
+                id: '1',
+                type: 'posts'
+              },
+              {
+                id: '2',
+                type: 'posts'
+              }
+            ]
+          }
+
+          model_attributes = { posts: [Post.new(id: 1), Post.new(id: 2)] }
+          relationship_name = :posts
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_many :posts
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_data_not_included
+          expected = { meta: {} }
+
+          model_attributes = { blog: :does_not_matter }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog do
+              include_data false
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_many_links
+          expected = {
+            links: {
+              self: 'a link',
+              related: 'another link'
+            }
+          }
+
+          model_attributes = { blog: :does_not_matter }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog do
+              include_data false
+              link :self, 'a link'
+              link :related, 'another link'
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_block_link_with_meta
+          expected = {
+            links: {
+              self: {
+                href: '1',
+                meta: { id: 1 }
+              }
+            }
+          }
+
+          model_attributes = { blog: Blog.new(id: 1) }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog do
+              include_data false
+              link :self do
+                href object.blog.id.to_s
+                meta(id: object.blog.id)
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_simple_meta
+          expected = { meta: { id: '1' } }
+
+          model_attributes = { blog: Blog.new(id: 1) }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog do
+              include_data false
+              meta(id: object.blog.id.to_s)
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_block_meta
+          expected = {
+            meta: {
+              id: 1
+            }
+          }
+
+          model_attributes = { blog: Blog.new(id: 1) }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :blog do
+              include_data false
+              meta(id: object.blog.id)
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_simple_link
+          expected = {
+            data: {
+              id: '1337',
+              type: 'bios'
+            },
+            links: {
+              self: '//example.com/link_author/relationships/bio'
+            }
+          }
+
+          model_attributes = { bio: Bio.new(id: 1337) }
+          relationship_name = :bio
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :bio do
+              link :self, '//example.com/link_author/relationships/bio'
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_block_link
+          expected = {
+            data: { id: '1337', type: 'profiles' },
+            links: { related: '//example.com/profiles/1337' }
+          }
+
+          model_attributes = { profile: Profile.new(id: 1337) }
+          relationship_name = :profile
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :profile do
+              id = object.profile.id
+              link :related do
+                "//example.com/profiles/#{id}" if id != 123
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        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 }
+          }
+
+          model_attributes = { likes: [Like.new(id: 1337)] }
+          relationship_name = :likes
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            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
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_nil_link
+          expected = {
+            data: { id: '123', type: 'profiles' }
+          }
+
+          model_attributes = { profile: Profile.new(id: 123) }
+          relationship_name = :profile
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_one :profile do
+              id = object.profile.id
+              link :related do
+                "//example.com/profiles/#{id}" if id != 123
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_block_link_href
+          expected = {
+            data: [{ id: '1337', type: 'locations' }],
+            links: {
+              related: { href: '//example.com/locations/1337' }
+            }
+          }
+
+          model_attributes = { locations: [Location.new(id: 1337)] }
+          relationship_name = :locations
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_many :locations do
+              link :related do
+                ids = object.locations.map(&:id).join(',')
+                href "//example.com/locations/#{ids}"
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        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' }
+              }
+            }
+          }
+
+          model_attributes =  { posts: [Post.new(id: 1337, comments: [], author: nil)] }
+          relationship_name = :posts
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_many :posts do
+              link :related do
+                ids = object.posts.map(&:id).join(',')
+                href "//example.com/posts/#{ids}"
+                meta ids: ids
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_block_link_meta
+          expected = {
+            data: [{ id: '1337', type: 'comments' }],
+            links: {
+              self: {
+                meta: { ids: [1] }
+              }
+            }
+          }
+
+          model_attributes = { comments: [Comment.new(id: 1337)] }
+          relationship_name = :comments
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_many :comments do
+              link :self do
+                meta ids: [1]
+              end
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_meta
+          expected = {
+            data: [{ id: 'from-serializer-method', type: 'roles' }],
+            meta: { count: 1 }
+          }
+
+          model_attributes = { roles: [Role.new(id: 'from-record')] }
+          relationship_name = :roles
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            has_many :roles do |serializer|
+              meta count: object.roles.count
+              serializer.cached_roles
+            end
+            def cached_roles
+              [
+                Role.new(id: 'from-serializer-method')
+              ]
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        def test_relationship_not_including_data
+          expected = {
+            links: { self: '//example.com/link_author/relationships/blog' }
+          }
+
+          model_attributes = { blog: Object }
+          relationship_name = :blog
+          model = new_model(model_attributes)
+          model.define_singleton_method(:read_attribute_for_serialization) do |attr|
+            fail 'should not be called' if attr == :blog
+            super(attr)
+          end
+          assert_nothing_raised do
+            actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+              has_one :blog do
+                link :self, '//example.com/link_author/relationships/blog'
+                include_data false
+              end
+            end
+            assert_equal(expected, actual)
+          end
+        end
+
+        def test_relationship_including_data_explicit
+          expected = {
+            data: { id: '1337', type: 'authors' },
+            meta: { name: 'Dan Brown' }
+          }
+
+          model_attributes = { reviewer: Author.new(id: 1337) }
+          relationship_name = :reviewer
+          model = new_model(model_attributes)
+          actual = build_serializer_and_serialize_relationship(model, relationship_name) do
+            belongs_to :reviewer do
+              meta name: 'Dan Brown'
+              include_data true
+            end
+          end
+          assert_equal(expected, actual)
+        end
+
+        private
+
+        def build_serializer_and_serialize_relationship(model, relationship_name, &block)
+          serializer_class = Class.new(ActiveModel::Serializer, &block)
+          hash = serializable(model, serializer: serializer_class, adapter: :json_api).serializable_hash
+          hash[:data][:relationships][relationship_name]
+        end
+
+        def new_model(model_attributes)
+          Class.new(ActiveModelSerializers::Model) do
+            attributes(*model_attributes.keys)
+
+            def self.name
+              'TestModel'
+            end
+          end.new(model_attributes)
+        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

data/test/adapter/json_api/toplevel_jsonapi_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class TopLevelJsonApiTest < ActiveSupport::TestCase
+        def setup
+          @author = Author.new(id: 1, name: 'Steve K.')
+          @author.bio = nil
+          @author.roles = []
+          @blog = Blog.new(id: 23, name: 'AMS Blog')
+          @post = Post.new(id: 42, title: 'New Post', body: 'Body')
+          @anonymous_post = Post.new(id: 43, title: 'Hello!!', body: 'Hello, world!!')
+          @comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
+          @post.comments = [@comment]
+          @post.blog = @blog
+          @anonymous_post.comments = []
+          @anonymous_post.blog = nil
+          @comment.post = @post
+          @comment.author = nil
+          @post.author = @author
+          @anonymous_post.author = nil
+          @blog = Blog.new(id: 1, name: 'My Blog!!')
+          @blog.writer = @author
+          @blog.articles = [@post, @anonymous_post]
+          @author.posts = []
+        end
+
+        def test_toplevel_jsonapi_defaults_to_false
+          assert_equal config.fetch(:jsonapi_include_toplevel_object), false
+        end
+
+        def test_disable_toplevel_jsonapi
+          with_config(jsonapi_include_toplevel_object: false) do
+            hash = serialize(@post)
+            assert_nil(hash[:jsonapi])
+          end
+        end
+
+        def test_enable_toplevel_jsonapi
+          with_config(jsonapi_include_toplevel_object: true) do
+            hash = serialize(@post)
+            refute_nil(hash[:jsonapi])
+          end
+        end
+
+        def test_default_toplevel_jsonapi_version
+          with_config(jsonapi_include_toplevel_object: true) do
+            hash = serialize(@post)
+            assert_equal('1.0', hash[:jsonapi][:version])
+          end
+        end
+
+        def test_toplevel_jsonapi_no_meta
+          with_config(jsonapi_include_toplevel_object: true) do
+            hash = serialize(@post)
+            assert_nil(hash[:jsonapi][:meta])
+          end
+        end
+
+        def test_toplevel_jsonapi_meta
+          new_config = {
+            jsonapi_include_toplevel_object: true,
+            jsonapi_toplevel_meta: {
+              'copyright' => 'Copyright 2015 Example Corp.'
+            }
+          }
+          with_config(new_config) do
+            hash = serialize(@post)
+            assert_equal(new_config[:jsonapi_toplevel_meta], hash.fetch(:jsonapi).fetch(:meta))
+          end
+        end
+
+        private
+
+        def serialize(resource, options = {})
+          serializable(resource, { adapter: :json_api }.merge!(options)).serializable_hash
+        end
+      end
+    end
+  end
+end