active_model_serializers 0.10.0 → 0.10.3

data/test/adapter/json_api/relationship_test.rb

@@ -4,13 +4,6 @@ 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: {
@@ -18,26 +11,29 @@ module ActiveModelSerializers
               type: 'blogs'
             }
           }
-          test_relationship(expected, options: { include_data: true })
+
+          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
-          @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 })
+          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
-          posts = [Post.new(id: 1), Post.new(id: 2)]
-          @serializer = ActiveModel::Serializer::CollectionSerializer.new(posts)
-          @author.posts = posts
-          @author.blog = nil
           expected = {
             data: [
               {
@@ -50,110 +46,350 @@ module ActiveModelSerializers
               }
             ]
           }
-          test_relationship(expected, options: { include_data: true })
+
+          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
-          test_relationship({}, options: { include_data: false })
-        end
+          expected = { meta: {} }
 
-        def test_relationship_simple_link
-          links = { self: 'a link' }
-          test_relationship({ links: { self: 'a link' } }, links: links)
+          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
-          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)
+          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
-          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 }
+                href: '1',
+                meta: { id: 1 }
               }
             }
           }
-          test_relationship(expected, links: links)
+
+          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
-          meta = { id: '1' }
-          expected = { meta: meta }
-          test_relationship(expected, meta: 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
-          meta =  proc do
-            { id: object.id }
-          end
           expected = {
             meta: {
-              id: @blog.id
+              id: 1
             }
           }
-          test_relationship(expected, meta: meta)
+
+          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_with_everything
-          links = {
-            self: 'a link',
-            related: proc do
-              href object.id.to_s
-              meta object.id
+        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' }
           }
-          meta = proc do
-            { id: object.id }
+
+          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: '1',
-              type: 'blogs'
-            },
+            data: [{ id: '1337', type: 'likes' }],
             links: {
-              self: 'a link',
               related: {
-                href: '1', meta: 1
+                href: '//example.com/likes/1337',
+                meta: { ids: '1337' }
               }
             },
-            meta: {
-              id: @blog.id
+            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] }
+              }
             }
           }
-          test_relationship(expected, meta: meta, options: { include_data: true }, links: links)
+
+          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 test_relationship(expected, params = {})
-          parent_serializer = AuthorSerializer.new(@author)
-          relationship = Relationship.new(parent_serializer, @serializer, nil, params)
-          assert_equal(expected, relationship.as_json)
+        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
+            attr_accessor(*model_attributes.keys)
+
+            def self.name
+              'TestModel'
+            end
+          end.new(model_attributes)
         end
       end
     end

data/test/adapter/json_api/resource_identifier_test.rb

@@ -14,7 +14,13 @@ module ActiveModelSerializers
           end
         end
 
-        class FragmentedSerializer < ActiveModel::Serializer; end
+        class FragmentedSerializer < ActiveModel::Serializer
+          cache only: :id
+
+          def id
+            'special_id'
+          end
+        end
 
         setup do
           @model = Author.new(id: 1, name: 'Steve K.')
@@ -33,6 +39,26 @@ module ActiveModelSerializers
           test_type_inflection(AuthorSerializer, 'authors', :plural)
         end
 
+        def test_type_with_namespace
+          Object.const_set(:Admin, Module.new)
+          model = Class.new(::Model)
+          Admin.const_set(:PowerUser, model)
+          serializer = Class.new(ActiveModel::Serializer)
+          Admin.const_set(:PowerUserSerializer, serializer)
+          with_namespace_separator '--' do
+            admin_user = Admin::PowerUser.new
+            serializer = Admin::PowerUserSerializer.new(admin_user)
+            expected = {
+              id: admin_user.id,
+              type: 'admin--power-users'
+            }
+
+            identifier = ResourceIdentifier.new(serializer, {})
+            actual = identifier.as_json
+            assert_equal(expected, actual)
+          end
+        end
+
         def test_id_defined_on_object
           test_id(AuthorSerializer, @model.id.to_s)
         end
@@ -42,7 +68,6 @@ module ActiveModelSerializers
         end
 
         def test_id_defined_on_fragmented
-          FragmentedSerializer.fragmented(WithDefinedIdSerializer.new(@model))
           test_id(FragmentedSerializer, 'special_id')
         end
 

data/test/adapter/json_api/resource_meta_test.rb

@@ -68,9 +68,9 @@ module ActiveModel
               adapter: :json_api
             ).serializable_hash
             expected = {
-              :data => [
-                { :id => '1337', :type => 'posts', :meta => { :"comments-count" => 0 } },
-                { :id => '1339', :type => 'posts', :meta => { :"comments-count" => 1 } }
+              data: [
+                { id: '1337', type: 'posts', meta: { :"comments-count" => 0 } },
+                { id: '1339', type: 'posts', meta: { :"comments-count" => 1 } }
               ]
             }
             assert_equal(expected, hash)