active_model_serializers 0.8.3 → 0.10.0.rc3

data/test/poro_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class PoroTest < Minitest::Test
+  include ActiveModel::Serializer::Lint::Tests
+
+  def setup
+    @resource = Model.new
+  end
+end

data/test/serializable_resource_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module ActiveModel
+  class SerializableResourceTest < Minitest::Test
+    def setup
+      @resource = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+      @serializer = ProfileSerializer.new(@resource)
+      @adapter = ActiveModel::Serializer::Adapter.create(@serializer)
+      @serializable_resource = ActiveModel::SerializableResource.new(@resource)
+    end
+
+    def test_serializable_resource_delegates_serializable_hash_to_the_adapter
+      options = nil
+      assert_equal @adapter.serializable_hash(options), @serializable_resource.serializable_hash(options)
+    end
+
+    def test_serializable_resource_delegates_to_json_to_the_adapter
+      options = nil
+      assert_equal @adapter.to_json(options), @serializable_resource.to_json(options)
+    end
+
+    def test_serializable_resource_delegates_as_json_to_the_adapter
+      options = nil
+      assert_equal @adapter.as_json(options), @serializable_resource.as_json(options)
+    end
+  end
+end

data/test/serializers/adapter_for_test.rb

@@ -0,0 +1,170 @@
+module ActiveModel
+  class Serializer
+    class AdapterForTest < Minitest::Test
+      UnknownAdapterError = ::ActiveModel::Serializer::Adapter::UnknownAdapterError
+
+      def setup
+        @previous_adapter = ActiveModel::Serializer.config.adapter
+        # Eager load adapters
+        ActiveModel::Serializer::Adapter.eager_load!
+        [:json_api, :flatten_json, :null, :json].each do |adapter_name|
+          ActiveModel::Serializer::Adapter.lookup(adapter_name)
+        end
+      end
+
+      def teardown
+        ActiveModel::Serializer.config.adapter = @previous_adapter
+      end
+
+      def test_returns_default_adapter
+        adapter = ActiveModel::Serializer.adapter
+        assert_equal ActiveModel::Serializer::Adapter::FlattenJson, adapter
+      end
+
+      def test_overwrite_adapter_with_symbol
+        ActiveModel::Serializer.config.adapter = :null
+
+        adapter = ActiveModel::Serializer.adapter
+        assert_equal ActiveModel::Serializer::Adapter::Null, adapter
+      ensure
+        ActiveModel::Serializer.config.adapter = @previous_adapter
+      end
+
+      def test_overwrite_adapter_with_class
+        ActiveModel::Serializer.config.adapter = ActiveModel::Serializer::Adapter::Null
+
+        adapter = ActiveModel::Serializer.adapter
+        assert_equal ActiveModel::Serializer::Adapter::Null, adapter
+      end
+
+      def test_raises_exception_if_invalid_symbol_given
+        ActiveModel::Serializer.config.adapter = :unknown
+
+        assert_raises UnknownAdapterError do
+          ActiveModel::Serializer.adapter
+        end
+      end
+
+      def test_raises_exception_if_it_does_not_know_hot_to_infer_adapter
+        ActiveModel::Serializer.config.adapter = 42
+
+        assert_raises UnknownAdapterError do
+          ActiveModel::Serializer.adapter
+        end
+      end
+
+      def test_adapter_class_for_known_adapter
+        klass = ActiveModel::Serializer::Adapter.adapter_class(:json_api)
+        assert_equal ActiveModel::Serializer::Adapter::JsonApi, klass
+      end
+
+      def test_adapter_class_for_unknown_adapter
+        assert_raises UnknownAdapterError do
+          ActiveModel::Serializer::Adapter.adapter_class(:json_simple)
+        end
+      end
+
+      def test_adapter_map
+        expected_adapter_map = {
+          'json'.freeze              => ActiveModel::Serializer::Adapter::Json,
+          'json_api'.freeze          => ActiveModel::Serializer::Adapter::JsonApi,
+          'flatten_json'.freeze      => ActiveModel::Serializer::Adapter::FlattenJson,
+          'null'.freeze              => ActiveModel::Serializer::Adapter::Null
+        }
+        assert_equal ActiveModel::Serializer::Adapter.adapter_map, expected_adapter_map
+      end
+
+      def test_adapters
+        assert_equal ActiveModel::Serializer::Adapter.adapters.sort, [
+          'flatten_json'.freeze,
+          'json'.freeze,
+          'json_api'.freeze,
+          'null'.freeze
+        ]
+      end
+
+      def test_lookup_adapter_by_string_name
+        assert_equal ActiveModel::Serializer::Adapter.lookup('json'.freeze), ActiveModel::Serializer::Adapter::Json
+      end
+
+      def test_lookup_adapter_by_symbol_name
+        assert_equal ActiveModel::Serializer::Adapter.lookup(:json), ActiveModel::Serializer::Adapter::Json
+      end
+
+      def test_lookup_adapter_by_class
+        klass = ActiveModel::Serializer::Adapter::Json
+        assert_equal ActiveModel::Serializer::Adapter.lookup(klass), klass
+      end
+
+      def test_lookup_adapter_from_environment_registers_adapter
+        ActiveModel::Serializer::Adapter.const_set(:AdapterFromEnvironment, Class.new)
+        klass = ::ActiveModel::Serializer::Adapter::AdapterFromEnvironment
+        name = 'adapter_from_environment'.freeze
+        assert_equal ActiveModel::Serializer::Adapter.lookup(name), klass
+        assert ActiveModel::Serializer::Adapter.adapters.include?(name)
+      ensure
+        ActiveModel::Serializer::Adapter.adapter_map.delete(name)
+        ActiveModel::Serializer::Adapter.send(:remove_const, :AdapterFromEnvironment)
+      end
+
+      def test_lookup_adapter_for_unknown_name
+        assert_raises UnknownAdapterError do
+          ActiveModel::Serializer::Adapter.lookup(:json_simple)
+        end
+      end
+
+      def test_adapter
+        assert_equal ActiveModel::Serializer.config.adapter, :flatten_json
+        assert_equal ActiveModel::Serializer.adapter, ActiveModel::Serializer::Adapter::FlattenJson
+      end
+
+      def test_register_adapter
+        new_adapter_name  = :foo
+        new_adapter_klass = Class.new
+        ActiveModel::Serializer::Adapter.register(new_adapter_name, new_adapter_klass)
+        assert ActiveModel::Serializer::Adapter.adapters.include?('foo'.freeze)
+        assert ActiveModel::Serializer::Adapter.lookup(:foo), new_adapter_klass
+      ensure
+        ActiveModel::Serializer::Adapter.adapter_map.delete(new_adapter_name.to_s)
+      end
+
+      def test_inherited_adapter_hooks_register_adapter
+        Object.const_set(:MyAdapter, Class.new)
+        my_adapter = MyAdapter
+        ActiveModel::Serializer::Adapter.inherited(my_adapter)
+        assert_equal ActiveModel::Serializer::Adapter.lookup(:my_adapter), my_adapter
+      ensure
+        ActiveModel::Serializer::Adapter.adapter_map.delete('my_adapter'.freeze)
+        Object.send(:remove_const, :MyAdapter)
+      end
+
+      def test_inherited_adapter_hooks_register_demodulized_adapter
+        Object.const_set(:MyNamespace, Module.new)
+        MyNamespace.const_set(:MyAdapter, Class.new)
+        my_adapter = MyNamespace::MyAdapter
+        ActiveModel::Serializer::Adapter.inherited(my_adapter)
+        assert_equal ActiveModel::Serializer::Adapter.lookup(:my_adapter), my_adapter
+      ensure
+        ActiveModel::Serializer::Adapter.adapter_map.delete('my_adapter'.freeze)
+        MyNamespace.send(:remove_const, :MyAdapter)
+        Object.send(:remove_const, :MyNamespace)
+      end
+
+      def test_inherited_adapter_hooks_register_subclass_of_registered_adapter
+        Object.const_set(:MyAdapter, Class.new)
+        my_adapter = MyAdapter
+        Object.const_set(:MySubclassedAdapter, Class.new(MyAdapter))
+        my_subclassed_adapter = MySubclassedAdapter
+        ActiveModel::Serializer::Adapter.inherited(my_adapter)
+        ActiveModel::Serializer::Adapter.inherited(my_subclassed_adapter)
+        assert_equal ActiveModel::Serializer::Adapter.lookup(:my_adapter), my_adapter
+        assert_equal ActiveModel::Serializer::Adapter.lookup(:my_subclassed_adapter), my_subclassed_adapter
+      ensure
+        ActiveModel::Serializer::Adapter.adapter_map.delete('my_adapter'.freeze)
+        ActiveModel::Serializer::Adapter.adapter_map.delete('my_subclassed_adapter'.freeze)
+        Object.send(:remove_const, :MyAdapter)
+        Object.send(:remove_const, :MySubclassedAdapter)
+      end
+    end
+  end
+end

data/test/serializers/association_macros_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AssociationMacrosTest < Minitest::Test
+      AuthorSummarySerializer = Class.new
+      class AssociationsTestSerializer < Serializer
+        belongs_to :author, serializer: AuthorSummarySerializer
+        has_many :comments
+        has_one :category
+      end
+
+      def before_setup
+        @reflections = AssociationsTestSerializer._reflections
+      end
+
+      def test_has_one_defines_reflection
+        has_one_reflection = HasOneReflection.new(:category, {})
+
+        assert_includes(@reflections, has_one_reflection)
+      end
+
+      def test_has_many_defines_reflection
+        has_many_reflection = HasManyReflection.new(:comments, {})
+
+        assert_includes(@reflections, has_many_reflection)
+      end
+
+      def test_belongs_to_defines_reflection
+        belongs_to_reflection = BelongsToReflection.new(:author, serializer: AuthorSummarySerializer)
+
+        assert_includes(@reflections, belongs_to_reflection)
+      end
+    end
+  end
+end

data/test/serializers/associations_test.rb

@@ -0,0 +1,150 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AssociationsTest < Minitest::Test
+      class Model
+        def initialize(hash = {})
+          @attributes = hash
+        end
+
+        def read_attribute_for_serialization(name)
+          @attributes[name]
+        end
+
+        def method_missing(meth, *args)
+          if meth.to_s =~ /^(.*)=$/
+            @attributes[$1.to_sym] = args[0]
+          elsif @attributes.key?(meth)
+            @attributes[meth]
+          else
+            super
+          end
+        end
+      end
+
+      def setup
+        @author = Author.new(name: 'Steve K.')
+        @author.bio = nil
+        @author.roles = []
+        @blog = Blog.new({ name: 'AMS Blog' })
+        @post = Post.new({ title: 'New Post', body: 'Body' })
+        @tag = Tag.new({ name: '#hashtagged' })
+        @comment = Comment.new({ id: 1, body: 'ZOMG A COMMENT' })
+        @post.comments = [@comment]
+        @post.tags = [@tag]
+        @post.blog = @blog
+        @comment.post = @post
+        @comment.author = nil
+        @post.author = @author
+        @author.posts = [@post]
+
+        @post_serializer = PostSerializer.new(@post, { custom_options: true })
+        @author_serializer = AuthorSerializer.new(@author)
+        @comment_serializer = CommentSerializer.new(@comment)
+      end
+
+      def test_has_many_and_has_one
+        @author_serializer.associations.each do |association|
+          key = association.key
+          serializer = association.serializer
+          options = association.options
+
+          case key
+          when :posts
+            assert_equal({}, options)
+            assert_kind_of(ActiveModel::Serializer.config.array_serializer, serializer)
+          when :bio
+            assert_equal({}, options)
+            assert_nil serializer
+          when :roles
+            assert_equal({}, options)
+            assert_kind_of(ActiveModel::Serializer.config.array_serializer, serializer)
+          else
+            flunk "Unknown association: #{key}"
+          end
+        end
+      end
+
+      def test_has_many_with_no_serializer
+        PostWithTagsSerializer.new(@post).associations.each do |association|
+          key = association.key
+          serializer = association.serializer
+          options = association.options
+
+          assert_equal key, :tags
+          assert_equal serializer, nil
+          assert_equal [{ attributes: { name: '#hashtagged' } }].to_json, options[:virtual_value].to_json
+        end
+      end
+
+      def test_serializer_options_are_passed_into_associations_serializers
+        association = @post_serializer
+                        .associations
+                        .detect { |assoc| assoc.key == :comments }
+
+        assert association.serializer.first.custom_options[:custom_options]
+      end
+
+      def test_belongs_to
+        @comment_serializer.associations.each do |association|
+          key = association.key
+          serializer = association.serializer
+
+          case key
+          when :post
+            assert_kind_of(PostSerializer, serializer)
+          when :author
+            assert_nil serializer
+          else
+            flunk "Unknown association: #{key}"
+          end
+
+          assert_equal({}, association.options)
+        end
+      end
+
+      def test_belongs_to_with_custom_method
+        assert(
+          @post_serializer.associations.any? do |association|
+            association.key == :blog
+          end
+        )
+      end
+
+      def test_associations_inheritance
+        inherited_klass = Class.new(PostSerializer)
+
+        assert_equal(PostSerializer._reflections, inherited_klass._reflections)
+      end
+
+      def test_associations_inheritance_with_new_association
+        inherited_klass = Class.new(PostSerializer) do
+          has_many :top_comments, serializer: CommentSerializer
+        end
+
+        assert(
+          PostSerializer._reflections.all? do |reflection|
+            inherited_klass._reflections.include?(reflection)
+          end
+        )
+
+        assert(
+          inherited_klass._reflections.any? do |reflection|
+            reflection.name == :top_comments
+          end
+        )
+      end
+
+      def test_associations_custom_keys
+        serializer = PostWithCustomKeysSerializer.new(@post)
+
+        expected_association_keys = serializer.associations.map(&:key)
+
+        assert expected_association_keys.include? :reviews
+        assert expected_association_keys.include? :writer
+        assert expected_association_keys.include? :site
+      end
+    end
+  end
+end

data/test/serializers/attribute_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AttributeTest < Minitest::Test
+      def setup
+        @blog = Blog.new({ id: 1, name: 'AMS Hints', type: 'stuff' })
+        @blog_serializer = AlternateBlogSerializer.new(@blog)
+      end
+
+      def test_attributes_definition
+        assert_equal([:id, :title],
+          @blog_serializer.class._attributes)
+      end
+
+      def test_json_serializable_hash
+        adapter = ActiveModel::Serializer::Adapter::Json.new(@blog_serializer)
+        assert_equal({ blog: { id: 1, title: 'AMS Hints' } }, adapter.serializable_hash)
+      end
+
+      def test_attribute_inheritance_with_key
+        inherited_klass = Class.new(AlternateBlogSerializer)
+        blog_serializer = inherited_klass.new(@blog)
+        adapter = ActiveModel::Serializer::Adapter::FlattenJson.new(blog_serializer)
+        assert_equal({ :id => 1, :title => 'AMS Hints' }, adapter.serializable_hash)
+      end
+
+      def test_multiple_calls_with_the_same_attribute
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          attribute :title
+          attribute :title
+        end
+
+        assert_equal([:title], serializer_class._attributes)
+      end
+
+      def test_id_attribute_override
+        serializer = Class.new(ActiveModel::Serializer) do
+          attribute :name, key: :id
+        end
+
+        adapter = ActiveModel::Serializer::Adapter::Json.new(serializer.new(@blog))
+        assert_equal({ blog: { id: 'AMS Hints' } }, adapter.serializable_hash)
+      end
+
+      def test_type_attribute
+        attribute_serializer = Class.new(ActiveModel::Serializer) do
+          attribute :id, key: :type
+        end
+        attributes_serializer = Class.new(ActiveModel::Serializer) do
+          attributes :type
+        end
+
+        adapter = ActiveModel::Serializer::Adapter::Json.new(attribute_serializer.new(@blog))
+        assert_equal({ blog: { type: 1 } }, adapter.serializable_hash)
+
+        adapter = ActiveModel::Serializer::Adapter::Json.new(attributes_serializer.new(@blog))
+        assert_equal({ blog: { type: 'stuff' } }, adapter.serializable_hash)
+      end
+    end
+  end
+end

data/test/serializers/attributes_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AttributesTest < Minitest::Test
+      def setup
+        @profile = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+        @profile_serializer = ProfileSerializer.new(@profile)
+        @comment = Comment.new(id: 1, body: 'ZOMG!!', date: '2015')
+        @serializer_klass = Class.new(CommentSerializer)
+        @serializer_klass_with_new_attributes = Class.new(CommentSerializer) do
+          attributes :date, :likes
+        end
+      end
+
+      def test_attributes_definition
+        assert_equal([:name, :description],
+          @profile_serializer.class._attributes)
+      end
+
+      def test_attributes_with_fields_option
+        assert_equal({ name: 'Name 1' },
+          @profile_serializer.attributes(fields: [:name]))
+      end
+
+      def test_attributes_inheritance_definition
+        assert_equal([:id, :body], @serializer_klass._attributes)
+      end
+
+      def test_attributes_inheritance
+        serializer = @serializer_klass.new(@comment)
+        assert_equal({ id: 1, body: 'ZOMG!!' },
+          serializer.attributes)
+      end
+
+      def test_attribute_inheritance_with_new_attribute_definition
+        assert_equal([:id, :body, :date, :likes], @serializer_klass_with_new_attributes._attributes)
+        assert_equal([:id, :body], CommentSerializer._attributes)
+      end
+
+      def test_attribute_inheritance_with_new_attribute
+        serializer = @serializer_klass_with_new_attributes.new(@comment)
+        assert_equal({ id: 1, body: 'ZOMG!!', date: '2015', likes: nil },
+          serializer.attributes)
+      end
+
+      def test_multiple_calls_with_the_same_attribute
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          attributes :id, :title
+          attributes :id, :title, :title, :body
+        end
+
+        assert_equal([:id, :title, :body], serializer_class._attributes)
+      end
+    end
+  end
+end

data/test/serializers/cache_test.rb

@@ -0,0 +1,165 @@
+require 'test_helper'
+require 'tempfile'
+module ActiveModel
+  class Serializer
+    class CacheTest < Minitest::Test
+      def setup
+        ActionController::Base.cache_store.clear
+        @comment        = Comment.new(id: 1, body: 'ZOMG A COMMENT')
+        @post           = Post.new(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: [])
+        @role           = Role.new(name: 'Great Author')
+        @location       = Location.new(lat: '-23.550520', lng: '-46.633309')
+        @place          = Place.new(name: 'Amazing Place')
+        @author.posts   = [@post]
+        @author.roles   = [@role]
+        @role.author    = @author
+        @author.bio     = @bio
+        @bio.author     = @author
+        @post.comments  = [@comment]
+        @post.author    = @author
+        @comment.post   = @post
+        @comment.author = @author
+        @post.blog      = @blog
+        @location.place = @place
+
+        @location_serializer = LocationSerializer.new(@location)
+        @bio_serializer      = BioSerializer.new(@bio)
+        @role_serializer     = RoleSerializer.new(@role)
+        @post_serializer     = PostSerializer.new(@post)
+        @author_serializer   = AuthorSerializer.new(@author)
+        @comment_serializer  = CommentSerializer.new(@comment)
+        @blog_serializer     = BlogSerializer.new(@blog)
+      end
+
+      def test_cache_definition
+        assert_equal(ActionController::Base.cache_store, @post_serializer.class._cache)
+        assert_equal(ActionController::Base.cache_store, @author_serializer.class._cache)
+        assert_equal(ActionController::Base.cache_store, @comment_serializer.class._cache)
+      end
+
+      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)
+      end
+
+      def test_cache_key_interpolation_with_updated_at
+        render_object_with_cache(@author)
+        assert_equal(nil, ActionController::Base.cache_store.fetch(@author.cache_key))
+        assert_equal(@author_serializer.attributes.to_json, ActionController::Base.cache_store.fetch("#{@author_serializer.class._cache_key}/#{@author_serializer.object.id}-#{@author_serializer.object.updated_at.strftime("%Y%m%d%H%M%S%9N")}").to_json)
+      end
+
+      def test_default_cache_key_fallback
+        render_object_with_cache(@comment)
+        assert_equal(@comment_serializer.attributes.to_json, ActionController::Base.cache_store.fetch(@comment.cache_key).to_json)
+      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_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([:content], @bio_serializer.class._cache_except)
+      end
+
+      def test_associations_separately_cache
+        ActionController::Base.cache_store.clear
+        assert_equal(nil, ActionController::Base.cache_store.fetch(@post.cache_key))
+        assert_equal(nil, ActionController::Base.cache_store.fetch(@comment.cache_key))
+
+        Timecop.freeze(Time.now) do
+          render_object_with_cache(@post)
+
+          assert_equal(@post_serializer.attributes, ActionController::Base.cache_store.fetch(@post.cache_key))
+          assert_equal(@comment_serializer.attributes, ActionController::Base.cache_store.fetch(@comment.cache_key))
+        end
+      end
+
+      def test_associations_cache_when_updated
+        # Clean the Cache
+        ActionController::Base.cache_store.clear
+
+        Timecop.freeze(Time.now) do
+          # Generate a new Cache of Post object and each objects related to it.
+          render_object_with_cache(@post)
+
+          # Check if it cached the objects separately
+          assert_equal(@post_serializer.attributes, ActionController::Base.cache_store.fetch(@post.cache_key))
+          assert_equal(@comment_serializer.attributes, ActionController::Base.cache_store.fetch(@comment.cache_key))
+
+          # Simulating update on comments relationship with Post
+          new_comment            = Comment.new(id: 2, body: 'ZOMG A NEW COMMENT')
+          new_comment_serializer = CommentSerializer.new(new_comment)
+          @post.comments         = [new_comment]
+
+          # Ask for the serialized object
+          render_object_with_cache(@post)
+
+          # Check if the the new comment was cached
+          assert_equal(new_comment_serializer.attributes, ActionController::Base.cache_store.fetch(new_comment.cache_key))
+          assert_equal(@post_serializer.attributes, ActionController::Base.cache_store.fetch(@post.cache_key))
+        end
+      end
+
+      def test_fragment_fetch_with_virtual_associations
+        expected_result = {
+          id: @location.id,
+          lat: @location.lat,
+          lng: @location.lng,
+          place: 'Nowhere'
+        }
+
+        hash = render_object_with_cache(@location)
+
+        assert_equal(hash, expected_result)
+        assert_equal({ place: 'Nowhere' }, ActionController::Base.cache_store.fetch(@location.cache_key))
+      end
+
+      def test_uses_file_digest_in_cache_key
+        render_object_with_cache(@blog)
+        assert_equal(@blog_serializer.attributes, ActionController::Base.cache_store.fetch(@blog.cache_key_with_digest))
+      end
+
+      def test_cache_digest_definition
+        assert_equal(::Model::FILE_DIGEST, @post_serializer.class._cache_digest)
+      end
+
+      def test_serializer_file_path_on_nix
+        path = '/Users/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb'
+        caller_line = "#{path}:1:in `<top (required)>'"
+        assert_equal caller_line[ActiveModel::Serializer::CALLER_FILE], path
+      end
+
+      def test_serializer_file_path_on_windows
+        path = 'c:/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb'
+        caller_line = "#{path}:1:in `<top (required)>'"
+        assert_equal caller_line[ActiveModel::Serializer::CALLER_FILE], path
+      end
+
+      def test_digest_caller_file
+        contents = "puts 'AMS rocks'!"
+        file = Tempfile.new('some_ruby.rb')
+        file.write(contents)
+        path = file.path
+        caller_line = "#{path}:1:in `<top (required)>'"
+        file.close
+        assert_equal ActiveModel::Serializer.digest_caller_file(caller_line), Digest::MD5.hexdigest(contents)
+      ensure
+        file.unlink
+      end
+
+      private
+
+      def render_object_with_cache(obj)
+        ActiveModel::SerializableResource.new(obj).serializable_hash
+      end
+    end
+  end
+end
+