active_model_serializers 0.10.0.rc2 → 0.10.0.rc3

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

@@ -4,7 +4,7 @@ module ActiveModel
   class Serializer
     class AssociationsTest < Minitest::Test
       class Model
-        def initialize(hash={})
+        def initialize(hash = {})
           @attributes = hash
         end
 
@@ -29,98 +29,121 @@ module ActiveModel
         @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})
+        @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
-        assert_equal(
-          { posts: { type: :has_many, association_options: { embed: :ids } },
-            roles: { type: :has_many, association_options: { embed: :ids } },
-            bio: { type: :has_one, association_options: {} } },
-          @author_serializer.class._associations
-        )
-        @author_serializer.each_association do |name, serializer, options|
-          if name == :posts
-            assert_equal({embed: :ids}, options)
+        @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)
-          elsif name == :bio
+          when :bio
             assert_equal({}, options)
             assert_nil serializer
-          elsif name == :roles
-            assert_equal({embed: :ids}, options)
+          when :roles
+            assert_equal({}, options)
             assert_kind_of(ActiveModel::Serializer.config.array_serializer, serializer)
           else
-            flunk "Unknown association: #{name}"
+            flunk "Unknown association: #{key}"
           end
         end
       end
 
-      def test_serializer_options_are_passed_into_associations_serializers
-        @post_serializer.each_association do |name, association|
-          if name == :comments
-            assert association.first.custom_options[:custom_options]
-          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
-        assert_equal(
-          { post: { type: :belongs_to, association_options: {} },
-            author: { type: :belongs_to, association_options: {} } },
-          @comment_serializer.class._associations
-        )
-        @comment_serializer.each_association do |name, serializer, options|
-          if name == :post
-            assert_equal({}, options)
+        @comment_serializer.associations.each do |association|
+          key = association.key
+          serializer = association.serializer
+
+          case key
+          when :post
             assert_kind_of(PostSerializer, serializer)
-          elsif name == :author
-            assert_equal({}, options)
+          when :author
             assert_nil serializer
           else
-            flunk "Unknown association: #{name}"
+            flunk "Unknown association: #{key}"
           end
+
+          assert_equal({}, association.options)
         end
       end
 
       def test_belongs_to_with_custom_method
-        blog_is_present = false
-
-        @post_serializer.each_association do |name, serializer, options|
-          blog_is_present = true if name == :blog
-        end
-
-        assert blog_is_present
+        assert(
+          @post_serializer.associations.any? do |association|
+            association.key == :blog
+          end
+        )
       end
 
       def test_associations_inheritance
         inherited_klass = Class.new(PostSerializer)
 
-        assert_equal(PostSerializer._associations, inherited_klass._associations)
+        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
-        expected_associations = PostSerializer._associations.merge(
-          top_comments: {
-            type: :has_many,
-            association_options: {
-              serializer: CommentSerializer
-            }
-          }
+
+        assert(
+          PostSerializer._reflections.all? do |reflection|
+            inherited_klass._reflections.include?(reflection)
+          end
         )
-        assert_equal(inherited_klass._associations, expected_associations)
+
+        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

data/test/serializers/attribute_test.rb

@@ -4,25 +4,25 @@ module ActiveModel
   class Serializer
     class AttributeTest < Minitest::Test
       def setup
-        @blog = Blog.new({ id: 1, name: 'AMS Hints' })
+        @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)
+          @blog_serializer.class._attributes)
       end
 
       def test_json_serializable_hash
         adapter = ActiveModel::Serializer::Adapter::Json.new(@blog_serializer)
-        assert_equal({alternate_blog: { id:1, title:"AMS Hints"}}, adapter.serializable_hash)
+        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)
+        assert_equal({ :id => 1, :title => 'AMS Hints' }, adapter.serializable_hash)
       end
 
       def test_multiple_calls_with_the_same_attribute
@@ -33,6 +33,30 @@ module ActiveModel
 
         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

@@ -6,7 +6,7 @@ module ActiveModel
       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")
+        @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
@@ -15,18 +15,12 @@ module ActiveModel
 
       def test_attributes_definition
         assert_equal([:name, :description],
-                     @profile_serializer.class._attributes)
+          @profile_serializer.class._attributes)
       end
 
       def test_attributes_with_fields_option
-        assert_equal({name: 'Name 1'},
-                     @profile_serializer.attributes(fields: [:name]))
-      end
-
-      def test_required_fields
-        assert_equal({name: 'Name 1', description: 'Description 1'},
-                     @profile_serializer.attributes(fields: [:name, :description], required_fields: [:name]))
-
+        assert_equal({ name: 'Name 1' },
+          @profile_serializer.attributes(fields: [:name]))
       end
 
       def test_attributes_inheritance_definition
@@ -35,8 +29,8 @@ module ActiveModel
 
       def test_attributes_inheritance
         serializer = @serializer_klass.new(@comment)
-        assert_equal({id: 1, body: "ZOMG!!"},
-                     serializer.attributes)
+        assert_equal({ id: 1, body: 'ZOMG!!' },
+          serializer.attributes)
       end
 
       def test_attribute_inheritance_with_new_attribute_definition
@@ -46,8 +40,8 @@ module ActiveModel
 
       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)
+        assert_equal({ id: 1, body: 'ZOMG!!', date: '2015', likes: nil },
+          serializer.attributes)
       end
 
       def test_multiple_calls_with_the_same_attribute

data/test/serializers/cache_test.rb

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'tempfile'
 module ActiveModel
   class Serializer
     class CacheTest < Minitest::Test
@@ -8,7 +9,7 @@ module ActiveModel
         @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: [])
+        @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')
@@ -46,20 +47,20 @@ module ActiveModel
       end
 
       def test_cache_key_interpolation_with_updated_at
-        author = render_object_with_cache(@author)
+        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}").to_json)
+        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
-        comment = render_object_with_cache(@comment)
+        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({ 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)
+        assert_equal({ expires_in: 1.day, skip_digest: true }, @comment_serializer.class._cache_options)
       end
 
       def test_fragment_cache_definition
@@ -72,34 +73,38 @@ module ActiveModel
         assert_equal(nil, ActionController::Base.cache_store.fetch(@post.cache_key))
         assert_equal(nil, ActionController::Base.cache_store.fetch(@comment.cache_key))
 
-        post = render_object_with_cache(@post)
+        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))
+          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
 
-        # Generate a new Cache of Post object and each objects related to it.
-        render_object_with_cache(@post)
+        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 if cache 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))
+          # 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]
+          # 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)
+          # 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))
+          # 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
@@ -113,24 +118,46 @@ module ActiveModel
         hash = render_object_with_cache(@location)
 
         assert_equal(hash, expected_result)
-        assert_equal({place: 'Nowhere'}, ActionController::Base.cache_store.fetch(@location.cache_key))
+        assert_equal({ place: 'Nowhere' }, ActionController::Base.cache_store.fetch(@location.cache_key))
       end
 
-      def test_uses_file_digest_in_cahe_key
-        blog = render_object_with_cache(@blog)
+      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 _cache_digest_definition
+      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)
-        serializer_class = ActiveModel::Serializer.serializer_for(obj)
-        serializer = serializer_class.new(obj)
-        adapter = ActiveModel::Serializer.adapter.new(serializer)
-        adapter.serializable_hash
+        ActiveModel::SerializableResource.new(obj).serializable_hash
       end
     end
   end