active_model_serializers 0.10.0 → 0.10.7

data/test/cache_test.rb

@@ -4,22 +4,111 @@ require 'tempfile'
 
 module ActiveModelSerializers
   class CacheTest < ActiveSupport::TestCase
-    UncachedAuthor = Class.new(Author) do
-      # To confirm cache_key is set using updated_at and cache_key option passed to cache
+    class Article < ::Model
+      attributes :title
+      # To confirm error is raised when cache_key is not set and cache_key option not passed to cache
       undef_method :cache_key
     end
+    class ArticleSerializer < ActiveModel::Serializer
+      cache only: [:place], skip_digest: true
+      attributes :title
+    end
 
-    Article = Class.new(::Model) do
-      # To confirm error is raised when cache_key is not set and cache_key option not passed to cache
+    class Author < ::Model
+      attributes :id, :name
+      associations :posts, :bio, :roles
+    end
+    # Instead of a primitive cache key (i.e. a string), this class
+    # returns a list of objects that require to be expanded themselves.
+    class AuthorWithExpandableCacheElements < Author
+      # For the test purposes it's important that #to_s for HasCacheKey differs
+      # between instances, hence not a Struct.
+      class HasCacheKey
+        attr_reader :cache_key
+        def initialize(cache_key)
+          @cache_key = cache_key
+        end
+
+        def to_s
+          "HasCacheKey##{object_id}"
+        end
+      end
+
+      def cache_key
+        [
+          HasCacheKey.new(name),
+          HasCacheKey.new(id)
+        ]
+      end
+    end
+    class UncachedAuthor < Author
+      # To confirm cache_key is set using updated_at and cache_key option passed to cache
       undef_method :cache_key
     end
+    class AuthorSerializer < ActiveModel::Serializer
+      cache key: 'writer', skip_digest: true
+      attributes :id, :name
 
-    ArticleSerializer = Class.new(ActiveModel::Serializer) do
-      cache only: [:place], skip_digest: true
-      attributes :title
+      has_many :posts
+      has_many :roles
+      has_one :bio
+    end
+
+    class Blog < ::Model
+      attributes :name
+      associations :writer
+    end
+    class BlogSerializer < ActiveModel::Serializer
+      cache key: 'blog'
+      attributes :id, :name
+
+      belongs_to :writer
+    end
+
+    class Comment < ::Model
+      attributes :id, :body
+      associations :post, :author
+
+      # Uses a custom non-time-based cache key
+      def cache_key
+        "comment/#{id}"
+      end
+    end
+    class CommentSerializer < ActiveModel::Serializer
+      cache expires_in: 1.day, skip_digest: true
+      attributes :id, :body
+      belongs_to :post
+      belongs_to :author
     end
 
-    InheritedRoleSerializer = Class.new(RoleSerializer) do
+    class Post < ::Model
+      attributes :id, :title, :body
+      associations :author, :comments, :blog
+    end
+    class PostSerializer < ActiveModel::Serializer
+      cache key: 'post', expires_in: 0.1, skip_digest: true
+      attributes :id, :title, :body
+
+      has_many :comments
+      belongs_to :blog
+      belongs_to :author
+    end
+
+    class Role < ::Model
+      attributes :name, :description, :special_attribute
+      associations :author
+    end
+    class RoleSerializer < ActiveModel::Serializer
+      cache only: [:name, :slug], skip_digest: true
+      attributes :id, :name, :description
+      attribute :friendly_id, key: :slug
+      belongs_to :author
+
+      def friendly_id
+        "#{object.name}-#{object.id}"
+      end
+    end
+    class InheritedRoleSerializer < RoleSerializer
       cache key: 'inherited_role', only: [:name, :special_attribute]
       attribute :special_attribute
     end
@@ -27,10 +116,10 @@ module ActiveModelSerializers
     setup do
       cache_store.clear
       @comment        = Comment.new(id: 1, body: 'ZOMG A COMMENT')
-      @post           = Post.new(title: 'New Post', body: 'Body')
+      @post           = Post.new(id: 'post', title: 'New Post', body: 'Body')
       @bio            = Bio.new(id: 1, content: 'AMS Contributor')
-      @author         = Author.new(name: 'Joao M. D. Moura')
-      @blog           = Blog.new(id: 999, name: 'Custom blog', writer: @author, articles: [])
+      @author         = Author.new(id: 'author', name: 'Joao M. D. Moura')
+      @blog           = Blog.new(id: 999, name: 'Custom blog', writer: @author)
       @role           = Role.new(name: 'Great Author')
       @location       = Location.new(lat: '-23.550520', lng: '-46.633309')
       @place          = Place.new(name: 'Amazing Place')
@@ -93,7 +182,7 @@ module ActiveModelSerializers
     def test_cache_key_definition
       assert_equal('post', @post_serializer.class._cache_key)
       assert_equal('writer', @author_serializer.class._cache_key)
-      assert_equal(nil, @comment_serializer.class._cache_key)
+      assert_nil(@comment_serializer.class._cache_key)
     end
 
     def test_cache_key_interpolation_with_updated_at_when_cache_key_is_not_defined_on_object
@@ -101,14 +190,28 @@ module ActiveModelSerializers
       uncached_author_serializer = AuthorSerializer.new(uncached_author)
 
       render_object_with_cache(uncached_author)
-      key = "#{uncached_author_serializer.class._cache_key}/#{uncached_author_serializer.object.id}-#{uncached_author_serializer.object.updated_at.strftime("%Y%m%d%H%M%S%9N")}"
-      key = "#{key}/#{adapter.cached_name}"
+      key = "#{uncached_author_serializer.class._cache_key}/#{uncached_author_serializer.object.id}-#{uncached_author_serializer.object.updated_at.strftime('%Y%m%d%H%M%S%9N')}"
+      key = "#{key}/#{adapter.cache_key}"
       assert_equal(uncached_author_serializer.attributes.to_json, cache_store.fetch(key).to_json)
     end
 
+    def test_cache_key_expansion
+      author = AuthorWithExpandableCacheElements.new(id: 10, name: 'hello')
+      same_author = AuthorWithExpandableCacheElements.new(id: 10, name: 'hello')
+      diff_author = AuthorWithExpandableCacheElements.new(id: 11, name: 'hello')
+
+      author_serializer = AuthorSerializer.new(author)
+      same_author_serializer = AuthorSerializer.new(same_author)
+      diff_author_serializer = AuthorSerializer.new(diff_author)
+      adapter = AuthorSerializer.serialization_adapter_instance
+
+      assert_equal(author_serializer.cache_key(adapter), same_author_serializer.cache_key(adapter))
+      refute_equal(author_serializer.cache_key(adapter), diff_author_serializer.cache_key(adapter))
+    end
+
     def test_default_cache_key_fallback
       render_object_with_cache(@comment)
-      key = "#{@comment.cache_key}/#{adapter.cached_name}"
+      key = "#{@comment.cache_key}/#{adapter.cache_key}"
       assert_equal(@comment_serializer.attributes.to_json, cache_store.fetch(key).to_json)
     end
 
@@ -117,31 +220,31 @@ module ActiveModelSerializers
       e = assert_raises ActiveModel::Serializer::UndefinedCacheKey do
         render_object_with_cache(article)
       end
-      assert_match(/ActiveModelSerializers::CacheTest::Article must define #cache_key, or the 'key:' option must be passed into 'CachedActiveModelSerializers_CacheTest_ArticleSerializer.cache'/, e.message)
+      assert_match(/ActiveModelSerializers::CacheTest::Article must define #cache_key, or the 'key:' option must be passed into 'ActiveModelSerializers::CacheTest::ArticleSerializer.cache'/, e.message)
     end
 
     def test_cache_options_definition
       assert_equal({ expires_in: 0.1, skip_digest: true }, @post_serializer.class._cache_options)
-      assert_equal(nil, @blog_serializer.class._cache_options)
+      assert_nil(@blog_serializer.class._cache_options)
       assert_equal({ expires_in: 1.day, skip_digest: true }, @comment_serializer.class._cache_options)
     end
 
     def test_fragment_cache_definition
-      assert_equal([:name], @role_serializer.class._cache_only)
+      assert_equal([:name, :slug], @role_serializer.class._cache_only)
       assert_equal([:content], @bio_serializer.class._cache_except)
     end
 
     def test_associations_separately_cache
       cache_store.clear
-      assert_equal(nil, cache_store.fetch(@post.cache_key))
-      assert_equal(nil, cache_store.fetch(@comment.cache_key))
+      assert_nil(cache_store.fetch(@post.cache_key))
+      assert_nil(cache_store.fetch(@comment.cache_key))
 
       Timecop.freeze(Time.current) do
         render_object_with_cache(@post)
 
-        key = "#{@post.cache_key}/#{adapter.cached_name}"
+        key = "#{@post.cache_key}/#{adapter.cache_key}"
         assert_equal(@post_serializer.attributes, cache_store.fetch(key))
-        key = "#{@comment.cache_key}/#{adapter.cached_name}"
+        key = "#{@comment.cache_key}/#{adapter.cache_key}"
         assert_equal(@comment_serializer.attributes, cache_store.fetch(key))
       end
     end
@@ -152,9 +255,9 @@ module ActiveModelSerializers
         render_object_with_cache(@post)
 
         # Check if it cached the objects separately
-        key = "#{@post.cache_key}/#{adapter.cached_name}"
+        key = "#{@post.cache_key}/#{adapter.cache_key}"
         assert_equal(@post_serializer.attributes, cache_store.fetch(key))
-        key = "#{@comment.cache_key}/#{adapter.cached_name}"
+        key = "#{@comment.cache_key}/#{adapter.cache_key}"
         assert_equal(@comment_serializer.attributes, cache_store.fetch(key))
 
         # Simulating update on comments relationship with Post
@@ -166,9 +269,9 @@ module ActiveModelSerializers
         render_object_with_cache(@post)
 
         # Check if the the new comment was cached
-        key = "#{new_comment.cache_key}/#{adapter.cached_name}"
+        key = "#{new_comment.cache_key}/#{adapter.cache_key}"
         assert_equal(new_comment_serializer.attributes, cache_store.fetch(key))
-        key = "#{@post.cache_key}/#{adapter.cached_name}"
+        key = "#{@post.cache_key}/#{adapter.cache_key}"
         assert_equal(@post_serializer.attributes, cache_store.fetch(key))
       end
     end
@@ -178,14 +281,14 @@ module ActiveModelSerializers
         id: @location.id,
         lat: @location.lat,
         lng: @location.lng,
-        place: 'Nowhere'
+        address: 'Nowhere'
       }
 
       hash = render_object_with_cache(@location)
 
       assert_equal(hash, expected_result)
-      key = "#{@location.cache_key}/#{adapter.cached_name}"
-      assert_equal({ place: 'Nowhere' }, cache_store.fetch(key))
+      key = "#{@location.cache_key}/#{adapter.cache_key}"
+      assert_equal({ address: 'Nowhere' }, cache_store.fetch(key))
     end
 
     def test_fragment_cache_with_inheritance
@@ -204,9 +307,9 @@ module ActiveModelSerializers
 
     # Based on original failing test by @kevintyll
     # rubocop:disable Metrics/AbcSize
-    def test_a_serializer_rendered_by_two_adapter_returns_differently_cached_attributes
+    def test_a_serializer_rendered_by_two_adapter_returns_differently_fetch_attributes
       Object.const_set(:Alert, Class.new(ActiveModelSerializers::Model) do
-        attr_accessor :id, :status, :resource, :started_at, :ended_at, :updated_at, :created_at
+        attributes :id, :status, :resource, :started_at, :ended_at, :updated_at, :created_at
       end)
       Object.const_set(:UncachedAlertSerializer, Class.new(ActiveModel::Serializer) do
         attributes :id, :status, :resource, :started_at, :ended_at, :updated_at, :created_at
@@ -225,7 +328,7 @@ module ActiveModelSerializers
         created_at: Time.new(2016, 3, 31, 21, 37, 35, 0)
       )
 
-      expected_cached_attributes = {
+      expected_fetch_attributes = {
         id: 1,
         status: 'fail',
         resource: 'resource-1',
@@ -233,7 +336,7 @@ module ActiveModelSerializers
         ended_at: nil,
         updated_at: alert.updated_at,
         created_at: alert.created_at
-      }
+      }.with_indifferent_access
       expected_cached_jsonapi_attributes = {
         id: '1',
         type: 'alerts',
@@ -245,15 +348,15 @@ module ActiveModelSerializers
           updated_at: alert.updated_at,
           created_at: alert.created_at
         }
-      }
+      }.with_indifferent_access
 
       # Assert attributes are serialized correctly
       serializable_alert = serializable(alert, serializer: AlertSerializer, adapter: :attributes)
-      attributes_serialization = serializable_alert.as_json
-      assert_equal expected_cached_attributes, alert.attributes
+      attributes_serialization = serializable_alert.as_json.with_indifferent_access
+      assert_equal expected_fetch_attributes, alert.attributes
       assert_equal alert.attributes, attributes_serialization
       attributes_cache_key = serializable_alert.adapter.serializer.cache_key(serializable_alert.adapter)
-      assert_equal attributes_serialization, cache_store.fetch(attributes_cache_key)
+      assert_equal attributes_serialization, cache_store.fetch(attributes_cache_key).with_indifferent_access
 
       serializable_alert = serializable(alert, serializer: AlertSerializer, adapter: :json_api)
       jsonapi_cache_key = serializable_alert.adapter.serializer.cache_key(serializable_alert.adapter)
@@ -265,7 +368,7 @@ module ActiveModelSerializers
       serializable_alert = serializable(alert, serializer: UncachedAlertSerializer, adapter: :json_api)
       assert_equal serializable_alert.as_json, jsonapi_serialization
 
-      cached_serialization = cache_store.fetch(jsonapi_cache_key)
+      cached_serialization = cache_store.fetch(jsonapi_cache_key).with_indifferent_access
       assert_equal expected_cached_jsonapi_attributes, cached_serialization
     ensure
       Object.send(:remove_const, :Alert)
@@ -276,43 +379,83 @@ module ActiveModelSerializers
 
     def test_uses_file_digest_in_cache_key
       render_object_with_cache(@blog)
-      key = "#{@blog.cache_key}/#{adapter.cached_name}/#{::Model::FILE_DIGEST}"
+      file_digest = Digest::MD5.hexdigest(File.open(__FILE__).read)
+      key = "#{@blog.cache_key}/#{adapter.cache_key}/#{file_digest}"
       assert_equal(@blog_serializer.attributes, cache_store.fetch(key))
     end
 
     def test_cache_digest_definition
-      assert_equal(::Model::FILE_DIGEST, @post_serializer.class._cache_digest)
+      file_digest = Digest::MD5.hexdigest(File.open(__FILE__).read)
+      assert_equal(file_digest, @post_serializer.class._cache_digest)
     end
 
     def test_object_cache_keys
       serializable = ActiveModelSerializers::SerializableResource.new([@comment, @comment])
-      include_tree = ActiveModel::Serializer::IncludeTree.from_include_args('*')
+      include_directive = JSONAPI::IncludeDirective.new('*', allow_wildcard: true)
 
-      actual = ActiveModel::Serializer.object_cache_keys(serializable.adapter.serializer, serializable.adapter, include_tree)
+      actual = ActiveModel::Serializer.object_cache_keys(serializable.adapter.serializer, serializable.adapter, include_directive)
 
       assert_equal 3, actual.size
-      assert actual.any? { |key| key == "comment/1/#{serializable.adapter.cached_name}" }
-      assert actual.any? { |key| key =~ %r{post/post-\d+} }
-      assert actual.any? { |key| key =~ %r{author/author-\d+} }
+      expected_key = "comment/1/#{serializable.adapter.cache_key}"
+      assert actual.any? { |key| key == expected_key }, "actual '#{actual}' should include #{expected_key}"
+      expected_key = %r{post/post-\d+}
+      assert actual.any? { |key| key =~ expected_key }, "actual '#{actual}' should match '#{expected_key}'"
+      expected_key = %r{author/author-\d+}
+      assert actual.any? { |key| key =~ expected_key }, "actual '#{actual}' should match '#{expected_key}'"
     end
 
-    def test_cached_attributes
-      serializer = ActiveModel::Serializer::CollectionSerializer.new([@comment, @comment])
+    # rubocop:disable Metrics/AbcSize
+    def test_fetch_attributes_from_cache
+      serializers = ActiveModel::Serializer::CollectionSerializer.new([@comment, @comment])
 
       Timecop.freeze(Time.current) do
         render_object_with_cache(@comment)
 
-        attributes = Adapter::Attributes.new(serializer)
-        attributes.send(:cache_attributes)
-        cached_attributes = attributes.instance_variable_get(:@cached_attributes)
+        options = {}
+        adapter_options = {}
+        adapter_instance = ActiveModelSerializers::Adapter::Attributes.new(serializers, adapter_options)
+        serializers.serializable_hash(adapter_options, options, adapter_instance)
+        cached_attributes = adapter_options.fetch(:cached_attributes).with_indifferent_access
+
+        include_directive = ActiveModelSerializers.default_include_directive
+        manual_cached_attributes = ActiveModel::Serializer.cache_read_multi(serializers, adapter_instance, include_directive).with_indifferent_access
+        assert_equal manual_cached_attributes, cached_attributes
 
-        assert_equal cached_attributes["#{@comment.cache_key}/#{attributes.cached_name}"], Comment.new(id: 1, body: 'ZOMG A COMMENT').attributes
-        assert_equal cached_attributes["#{@comment.post.cache_key}/#{attributes.cached_name}"], Post.new(id: 'post', title: 'New Post', body: 'Body').attributes
+        assert_equal cached_attributes["#{@comment.cache_key}/#{adapter_instance.cache_key}"], Comment.new(id: 1, body: 'ZOMG A COMMENT').attributes
+        assert_equal cached_attributes["#{@comment.post.cache_key}/#{adapter_instance.cache_key}"], Post.new(id: 'post', title: 'New Post', body: 'Body').attributes
 
         writer = @comment.post.blog.writer
         writer_cache_key = writer.cache_key
+        assert_equal cached_attributes["#{writer_cache_key}/#{adapter_instance.cache_key}"], Author.new(id: 'author', name: 'Joao M. D. Moura').attributes
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def test_cache_read_multi_with_fragment_cache_enabled
+      post_serializer = Class.new(ActiveModel::Serializer) do
+        cache except: [:body]
+      end
 
-        assert_equal cached_attributes["#{writer_cache_key}/#{attributes.cached_name}"], Author.new(id: 'author', name: 'Joao M. D. Moura').attributes
+      serializers = ActiveModel::Serializer::CollectionSerializer.new([@post, @post], serializer: post_serializer)
+
+      Timecop.freeze(Time.current) do
+        # Warming up.
+        options = {}
+        adapter_options = {}
+        adapter_instance = ActiveModelSerializers::Adapter::Attributes.new(serializers, adapter_options)
+        serializers.serializable_hash(adapter_options, options, adapter_instance)
+
+        # Should find something with read_multi now
+        adapter_options = {}
+        serializers.serializable_hash(adapter_options, options, adapter_instance)
+        cached_attributes = adapter_options.fetch(:cached_attributes)
+
+        include_directive = ActiveModelSerializers.default_include_directive
+        manual_cached_attributes = ActiveModel::Serializer.cache_read_multi(serializers, adapter_instance, include_directive)
+
+        refute_equal 0, cached_attributes.size
+        refute_equal 0, manual_cached_attributes.size
+        assert_equal manual_cached_attributes, cached_attributes
       end
     end
 
@@ -429,25 +572,53 @@ module ActiveModelSerializers
     end
 
     def test_fragment_fetch_with_virtual_attributes
-      @author          = Author.new(name: 'Joao M. D. Moura')
-      @role            = Role.new(name: 'Great Author', description: nil)
-      @role.author     = [@author]
-      @role_serializer = RoleSerializer.new(@role)
-      @role_hash       = @role_serializer.fetch_fragment_cache(ActiveModelSerializers::Adapter.configured_adapter.new(@role_serializer))
+      author          = Author.new(name: 'Joao M. D. Moura')
+      role            = Role.new(name: 'Great Author', description: nil)
+      role.author     = [author]
+      role_serializer = RoleSerializer.new(role)
+      adapter_instance = ActiveModelSerializers::Adapter.configured_adapter.new(role_serializer)
+      expected_result = {
+        id: role.id,
+        description: role.description,
+        slug: "#{role.name}-#{role.id}",
+        name: role.name
+      }
+      cache_store.clear
+
+      role_hash = role_serializer.fetch_attributes_fragment(adapter_instance)
+      assert_equal(role_hash, expected_result)
 
+      role.id = 'this has been updated'
+      role.name = 'this was cached'
+
+      role_hash = role_serializer.fetch_attributes_fragment(adapter_instance)
+      assert_equal(expected_result.merge(id: role.id), role_hash)
+    end
+
+    def test_fragment_fetch_with_except
+      adapter_instance = ActiveModelSerializers::Adapter.configured_adapter.new(@bio_serializer)
       expected_result = {
-        id: @role.id,
-        description: @role.description,
-        slug: "#{@role.name}-#{@role.id}",
-        name: @role.name
+        id: @bio.id,
+        rating: nil,
+        content: @bio.content
       }
-      assert_equal(@role_hash, expected_result)
+      cache_store.clear
+
+      bio_hash = @bio_serializer.fetch_attributes_fragment(adapter_instance)
+      assert_equal(expected_result, bio_hash)
+
+      @bio.content = 'this has been updated'
+      @bio.rating = 'this was cached'
+
+      bio_hash = @bio_serializer.fetch_attributes_fragment(adapter_instance)
+      assert_equal(expected_result.merge(content: @bio.content), bio_hash)
     end
 
     def test_fragment_fetch_with_namespaced_object
       @spam            = Spam::UnrelatedLink.new(id: 'spam-id-1')
       @spam_serializer = Spam::UnrelatedLinkSerializer.new(@spam)
-      @spam_hash       = @spam_serializer.fetch_fragment_cache(ActiveModelSerializers::Adapter.configured_adapter.new(@spam_serializer))
+      adapter_instance = ActiveModelSerializers::Adapter.configured_adapter.new(@spam_serializer)
+      @spam_hash       = @spam_serializer.fetch_attributes_fragment(adapter_instance)
       expected_result = {
         id: @spam.id
       }
@@ -476,10 +647,5 @@ module ActiveModelSerializers
     def adapter
       @serializable_resource.adapter
     end
-
-    def cached_serialization(serializer)
-      cache_key = serializer.cache_key(adapter)
-      cache_store.fetch(cache_key)
-    end
   end
 end

data/test/collection_serializer_test.rb

@@ -3,15 +3,28 @@ require 'test_helper'
 module ActiveModel
   class Serializer
     class CollectionSerializerTest < ActiveSupport::TestCase
-      MessagesSerializer = Class.new(ActiveModel::Serializer) do
+      class SingularModel < ::Model; end
+      class SingularModelSerializer < ActiveModel::Serializer
+      end
+      class HasManyModel < ::Model
+        associations :singular_models
+      end
+      class HasManyModelSerializer < ActiveModel::Serializer
+        has_many :singular_models
+
+        def custom_options
+          instance_options
+        end
+      end
+      class MessagesSerializer < ActiveModel::Serializer
         type 'messages'
       end
 
       def setup
-        @comment = Comment.new
-        @post = Post.new
-        @resource = build_named_collection @comment, @post
-        @serializer = collection_serializer.new(@resource, { some: :options })
+        @singular_model = SingularModel.new
+        @has_many_model = HasManyModel.new
+        @resource = build_named_collection @singular_model, @has_many_model
+        @serializer = collection_serializer.new(@resource, some: :options)
       end
 
       def collection_serializer
@@ -34,29 +47,29 @@ module ActiveModel
       def test_each_object_should_be_serialized_with_appropriate_serializer
         serializers =  @serializer.to_a
 
-        assert_kind_of CommentSerializer, serializers.first
-        assert_kind_of Comment, serializers.first.object
+        assert_kind_of SingularModelSerializer, serializers.first
+        assert_kind_of SingularModel, serializers.first.object
 
-        assert_kind_of PostSerializer, serializers.last
-        assert_kind_of Post, serializers.last.object
+        assert_kind_of HasManyModelSerializer, serializers.last
+        assert_kind_of HasManyModel, serializers.last.object
 
         assert_equal :options, serializers.last.custom_options[:some]
       end
 
       def test_serializer_option_not_passed_to_each_serializer
-        serializers = collection_serializer.new([@post], { serializer: PostSerializer }).to_a
+        serializers = collection_serializer.new([@has_many_model], serializer: HasManyModelSerializer).to_a
 
         refute serializers.first.custom_options.key?(:serializer)
       end
 
       def test_root_default
-        @serializer = collection_serializer.new([@comment, @post])
+        @serializer = collection_serializer.new([@singular_model, @has_many_model])
         assert_nil @serializer.root
       end
 
       def test_root
         expected =  'custom_root'
-        @serializer = collection_serializer.new([@comment, @post], root: expected)
+        @serializer = collection_serializer.new([@singular_model, @has_many_model], root: expected)
         assert_equal expected, @serializer.root
       end
 
@@ -80,12 +93,16 @@ module ActiveModel
         resource = []
         resource.define_singleton_method(:name) { nil }
         serializer = collection_serializer.new(resource)
-        assert_nil serializer.json_key
+        assert_raise ArgumentError do
+          serializer.json_key
+        end
       end
 
       def test_json_key_with_resource_without_name_and_no_serializers
         serializer = collection_serializer.new([])
-        assert_nil serializer.json_key
+        assert_raise ArgumentError do
+          serializer.json_key
+        end
       end
 
       def test_json_key_with_empty_resources_with_serializer

data/test/fixtures/active_record.rb

@@ -47,16 +47,6 @@ module ARModels
     has_many :comments
     belongs_to :author
   end
-
-  class Comment < ActiveRecord::Base
-    belongs_to :post
-    belongs_to :author
-  end
-
-  class Author < ActiveRecord::Base
-    has_many :posts
-  end
-
   class PostSerializer < ActiveModel::Serializer
     attributes :id, :title, :body
 
@@ -64,15 +54,60 @@ module ARModels
     belongs_to :author
   end
 
+  class Comment < ActiveRecord::Base
+    belongs_to :post
+    belongs_to :author
+  end
   class CommentSerializer < ActiveModel::Serializer
     attributes :id, :contents
 
     belongs_to :author
   end
 
+  class Author < ActiveRecord::Base
+    has_many :posts
+  end
   class AuthorSerializer < ActiveModel::Serializer
     attributes :id, :name
 
     has_many :posts
   end
 end
+
+class Employee < ActiveRecord::Base
+  has_many :pictures, as: :imageable
+  has_many :object_tags, as: :taggable
+end
+
+class PolymorphicSimpleSerializer < ActiveModel::Serializer
+  attributes :id
+end
+
+class ObjectTag < ActiveRecord::Base
+  belongs_to :poly_tag
+  belongs_to :taggable, polymorphic: true
+end
+class PolymorphicObjectTagSerializer < ActiveModel::Serializer
+  attributes :id
+  belongs_to :taggable, serializer: PolymorphicSimpleSerializer, polymorphic: true
+end
+
+class PolyTag < ActiveRecord::Base
+  has_many :object_tags
+end
+class PolymorphicTagSerializer < ActiveModel::Serializer
+  attributes :id, :phrase
+  has_many :object_tags, serializer: PolymorphicObjectTagSerializer
+end
+
+class Picture < ActiveRecord::Base
+  belongs_to :imageable, polymorphic: true
+  has_many :object_tags, as: :taggable
+end
+class PolymorphicHasManySerializer < ActiveModel::Serializer
+  attributes :id, :name
+end
+class PolymorphicBelongsToSerializer < ActiveModel::Serializer
+  attributes :id, :title
+  belongs_to :imageable, serializer: PolymorphicHasManySerializer, polymorphic: true
+end