active_model_serializers 0.10.0 → 0.10.6

data/test/serializers/options_test.rb

@@ -3,18 +3,29 @@ require 'test_helper'
 module ActiveModel
   class Serializer
     class OptionsTest < ActiveSupport::TestCase
-      def setup
-        @profile = Profile.new(name: 'Name 1', description: 'Description 1')
+      class ModelWithOptions < ActiveModelSerializers::Model
+        attributes :name, :description
+      end
+      class ModelWithOptionsSerializer < ActiveModel::Serializer
+        attributes :name, :description
+
+        def arguments_passed_in?
+          instance_options[:my_options] == :accessible
+        end
+      end
+
+      setup do
+        @model_with_options = ModelWithOptions.new(name: 'Name 1', description: 'Description 1')
       end
 
       def test_options_are_accessible
-        @profile_serializer = ProfileSerializer.new(@profile, my_options: :accessible)
-        assert @profile_serializer.arguments_passed_in?
+        model_with_options_serializer = ModelWithOptionsSerializer.new(@model_with_options, my_options: :accessible)
+        assert model_with_options_serializer.arguments_passed_in?
       end
 
       def test_no_option_is_passed_in
-        @profile_serializer = ProfileSerializer.new(@profile)
-        refute @profile_serializer.arguments_passed_in?
+        model_with_options_serializer = ModelWithOptionsSerializer.new(@model_with_options)
+        refute model_with_options_serializer.arguments_passed_in?
       end
     end
   end

data/test/serializers/read_attribute_for_serialization_test.rb

@@ -5,10 +5,10 @@ module ActiveModel
     class ReadAttributeForSerializationTest < ActiveSupport::TestCase
       # https://github.com/rails-api/active_model_serializers/issues/1653
       class Parent < ActiveModelSerializers::Model
-        attr_accessor :id
+        attributes :id
       end
       class Child < Parent
-        attr_accessor :name
+        attributes :name
       end
       class ParentSerializer < ActiveModel::Serializer
         attributes :$id
@@ -30,7 +30,7 @@ module ActiveModel
 
       # https://github.com/rails-api/active_model_serializers/issues/1658
       class ErrorResponse < ActiveModelSerializers::Model
-        attr_accessor :error
+        attributes :error
       end
       class ApplicationSerializer < ActiveModel::Serializer
         attributes :status

data/test/serializers/reflection_test.rb

@@ -0,0 +1,427 @@
+require 'test_helper'
+module ActiveModel
+  class Serializer
+    class ReflectionTest < ActiveSupport::TestCase
+      class Blog < ActiveModelSerializers::Model
+        attributes :id
+      end
+      class BlogSerializer < ActiveModel::Serializer
+        type 'blog'
+        attributes :id
+      end
+
+      setup do
+        @expected_meta = { id: 1 }
+        @expected_links = { self: 'no_uri_validation' }
+        @empty_links = {}
+        model_attributes = { blog: Blog.new(@expected_meta) }
+        @model = Class.new(ActiveModelSerializers::Model) do
+          attributes(*model_attributes.keys)
+
+          def self.name
+            'TestModel'
+          end
+        end.new(model_attributes)
+        @instance_options = {}
+      end
+
+      def evaluate_association_value(association)
+        association.lazy_association.eval_reflection_block
+      end
+
+      # TODO: Remaining tests
+      # test_reflection_value_block_with_scope
+      # test_reflection_value_uses_serializer_instance_method
+      # test_reflection_excluded_eh_blank_is_false
+      # test_reflection_excluded_eh_if
+      # test_reflection_excluded_eh_unless
+      # test_evaluate_condition_symbol_serializer_method
+      # test_evaluate_condition_string_serializer_method
+      # test_evaluate_condition_proc
+      # test_evaluate_condition_proc_yields_serializer
+      # test_evaluate_condition_other
+      # test_options_key
+      # test_options_polymorphic
+      # test_options_serializer
+      # test_options_virtual_value
+      # test_options_namespace
+
+      def test_reflection_value
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+
+        # Assert
+        assert_nil reflection.block
+        assert_equal Serializer.config.include_data_default, reflection.options.fetch(:include_data_setting)
+        assert_equal true, reflection.options.fetch(:include_data_setting)
+
+        include_slice = :does_not_matter
+        assert_equal @model.blog, reflection.send(:value, serializer_instance, include_slice)
+      end
+
+      def test_reflection_value_block
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            object.blog
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+
+        # Assert
+        assert_respond_to reflection.block, :call
+        assert_equal Serializer.config.include_data_default, reflection.options.fetch(:include_data_setting)
+        assert_equal true, reflection.options.fetch(:include_data_setting)
+
+        include_slice = :does_not_matter
+        assert_equal @model.blog, reflection.send(:value, serializer_instance, include_slice)
+      end
+
+      def test_reflection_value_block_with_explicit_include_data_true
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            include_data true
+            object.blog
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+
+        # Assert
+        assert_respond_to reflection.block, :call
+        assert_equal Serializer.config.include_data_default, reflection.options.fetch(:include_data_setting)
+        assert_equal true, reflection.options.fetch(:include_data_setting)
+
+        include_slice = :does_not_matter
+        assert_equal @model.blog, reflection.send(:value, serializer_instance, include_slice)
+      end
+
+      def test_reflection_value_block_with_include_data_false_mutates_the_reflection_include_data
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            include_data false
+            object.blog
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+
+        # Assert
+        assert_respond_to reflection.block, :call
+        assert_equal true, reflection.options.fetch(:include_data_setting)
+        include_slice = :does_not_matter
+        assert_nil reflection.send(:value, serializer_instance, include_slice)
+        assert_equal false, reflection.options.fetch(:include_data_setting)
+      end
+
+      def test_reflection_value_block_with_include_data_if_sideloaded_included_mutates_the_reflection_include_data
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            include_data :if_sideloaded
+            object.blog
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+
+        # Assert
+        assert_respond_to reflection.block, :call
+        assert_equal true, reflection.options.fetch(:include_data_setting)
+        include_slice = {}
+        assert_nil reflection.send(:value, serializer_instance, include_slice)
+        assert_equal :if_sideloaded, reflection.options.fetch(:include_data_setting)
+      end
+
+      def test_reflection_value_block_with_include_data_if_sideloaded_excluded_mutates_the_reflection_include_data
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            include_data :if_sideloaded
+            object.blog
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+
+        # Assert
+        assert_respond_to reflection.block, :call
+        assert_equal true, reflection.options.fetch(:include_data_setting)
+        include_slice = { blog: :does_not_matter }
+        assert_equal @model.blog, reflection.send(:value, serializer_instance, include_slice)
+        assert_equal :if_sideloaded, reflection.options.fetch(:include_data_setting)
+      end
+
+      def test_reflection_block_with_link_mutates_the_reflection_links
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            link :self, 'no_uri_validation'
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+        assert_equal @empty_links, reflection.options.fetch(:links)
+
+        # Build Association
+        association = reflection.build_association(serializer_instance, @instance_options)
+
+        # Assert association links empty when not yet evaluated
+        assert_equal @empty_links, reflection.options.fetch(:links)
+        assert_equal @empty_links, association.links
+
+        evaluate_association_value(association)
+
+        assert_equal @expected_links, association.links
+        assert_equal @expected_links, reflection.options.fetch(:links)
+      end
+
+      def test_reflection_block_with_link_block_mutates_the_reflection_links
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            link :self do
+              'no_uri_validation'
+            end
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+        assert_equal @empty_links, reflection.options.fetch(:links)
+
+        # Build Association
+        association = reflection.build_association(serializer_instance, @instance_options)
+
+        # Assert association links empty when not yet evaluated
+        assert_equal @empty_links, association.links
+
+        evaluate_association_value(association)
+
+        # Assert before instance_eval link
+        link = association.links.fetch(:self)
+        assert_respond_to link, :call
+        assert_respond_to reflection.options.fetch(:links).fetch(:self), :call
+
+        # Assert after instance_eval link
+        assert_equal @expected_links.fetch(:self), reflection.instance_eval(&link)
+        assert_respond_to reflection.options.fetch(:links).fetch(:self), :call
+      end
+
+      def test_reflection_block_with_meta_mutates_the_reflection_meta
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            meta(id: object.blog.id)
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+        assert_nil reflection.options.fetch(:meta)
+
+        # Build Association
+        association = reflection.build_association(serializer_instance, @instance_options)
+
+        evaluate_association_value(association)
+
+        assert_equal @expected_meta, association.meta
+        assert_equal @expected_meta, reflection.options.fetch(:meta)
+      end
+
+      def test_reflection_block_with_meta_block_mutates_the_reflection_meta
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            meta do
+              { id: object.blog.id }
+            end
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+        assert_nil reflection.options.fetch(:meta)
+
+        # Build Association
+        association = reflection.build_association(serializer_instance, @instance_options)
+        # Assert before instance_eval meta
+
+        evaluate_association_value(association)
+
+        assert_respond_to association.meta, :call
+        assert_respond_to reflection.options.fetch(:meta), :call
+
+        # Assert after instance_eval meta
+        assert_equal @expected_meta, reflection.instance_eval(&association.meta)
+        assert_respond_to reflection.options.fetch(:meta), :call
+        assert_respond_to association.meta, :call
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def test_reflection_block_with_meta_in_link_block_mutates_the_reflection_meta
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            link :self do
+              meta(id: object.blog.id)
+              'no_uri_validation'
+            end
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+        assert_nil reflection.options.fetch(:meta)
+        assert_equal @empty_links, reflection.options.fetch(:links)
+
+        # Build Association
+        association = reflection.build_association(serializer_instance, @instance_options)
+        # Assert before instance_eval link meta
+        assert_nil association.meta
+        assert_nil reflection.options.fetch(:meta)
+
+        evaluate_association_value(association)
+
+        link = association.links.fetch(:self)
+        assert_respond_to link, :call
+        assert_respond_to reflection.options.fetch(:links).fetch(:self), :call
+        assert_nil reflection.options.fetch(:meta)
+
+        # Assert after instance_eval link
+        assert_equal 'no_uri_validation', reflection.instance_eval(&link)
+        assert_equal @expected_meta, reflection.options.fetch(:meta)
+        assert_equal @expected_meta, association.meta
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize
+      def test_reflection_block_with_meta_block_in_link_block_mutates_the_reflection_meta
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            link :self do
+              meta do
+                { id: object.blog.id }
+              end
+              'no_uri_validation'
+            end
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+        assert_nil reflection.options.fetch(:meta)
+
+        # Build Association
+        association = reflection.build_association(serializer_instance, @instance_options)
+        assert_nil association.meta
+        assert_nil reflection.options.fetch(:meta)
+
+        # Assert before instance_eval link
+
+        evaluate_association_value(association)
+
+        link = association.links.fetch(:self)
+        assert_nil reflection.options.fetch(:meta)
+        assert_respond_to link, :call
+        assert_respond_to association.links.fetch(:self), :call
+
+        # Assert after instance_eval link
+        assert_equal 'no_uri_validation', reflection.instance_eval(&link)
+        assert_respond_to association.links.fetch(:self), :call
+        # Assert before instance_eval link meta
+        assert_respond_to reflection.options.fetch(:meta), :call
+        assert_respond_to association.meta, :call
+
+        # Assert after instance_eval link meta
+        assert_equal @expected_meta, reflection.instance_eval(&reflection.options.fetch(:meta))
+        assert_respond_to association.meta, :call
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def test_no_href_in_vanilla_reflection
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            link :self do
+              href 'no_uri_validation'
+            end
+          end
+        end
+        serializer_instance = serializer_class.new(@model, @instance_options)
+
+        # Get Reflection
+        reflection = serializer_class._reflections.fetch(:blog)
+        assert_equal @empty_links, reflection.options.fetch(:links)
+
+        # Build Association
+        association = reflection.build_association(serializer_instance, @instance_options)
+        # Assert before instance_eval link
+
+        evaluate_association_value(association)
+
+        link = association.links.fetch(:self)
+        assert_respond_to link, :call
+
+        # Assert after instance_eval link
+        exception = assert_raise(NoMethodError) do
+          reflection.instance_eval(&link)
+        end
+        assert_match(/undefined method `href'/, exception.message)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def test_mutating_reflection_block_is_not_thread_safe
+        serializer_class = Class.new(ActiveModel::Serializer) do
+          has_one :blog do
+            meta(id: object.blog.id)
+          end
+        end
+        model1_meta = @expected_meta
+        # Evaluate reflection meta for model with id 1
+        serializer_instance = serializer_class.new(@model, @instance_options)
+        reflection = serializer_class._reflections.fetch(:blog)
+        assert_nil reflection.options.fetch(:meta)
+        association = reflection.build_association(serializer_instance, @instance_options)
+
+        evaluate_association_value(association)
+
+        assert_equal model1_meta, association.meta
+        assert_equal model1_meta, reflection.options.fetch(:meta)
+
+        model2_meta = @expected_meta.merge(id: 2)
+        # Evaluate reflection meta for model with id 2
+        @model.blog.id = 2
+        assert_equal 2, @model.blog.id # sanity check
+        serializer_instance = serializer_class.new(@model, @instance_options)
+        reflection = serializer_class._reflections.fetch(:blog)
+
+        # WARN: Thread-safety issue
+        # Before the reflection is evaluated, it has the value from the previous evaluation
+        assert_equal model1_meta, reflection.options.fetch(:meta)
+
+        association = reflection.build_association(serializer_instance, @instance_options)
+
+        evaluate_association_value(association)
+
+        assert_equal model2_meta, association.meta
+        assert_equal model2_meta, reflection.options.fetch(:meta)
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/test/serializers/root_test.rb

@@ -8,7 +8,7 @@ module ActiveModel
       end
 
       def test_overwrite_root
-        serializer = VirtualValueSerializer.new(@virtual_value, { root: 'smth' })
+        serializer = VirtualValueSerializer.new(@virtual_value, root: 'smth')
         assert_equal('smth', serializer.json_key)
       end
 

data/test/serializers/serialization_test.rb

@@ -2,10 +2,10 @@ module ActiveModel
   class Serializer
     class SerializationTest < ActiveSupport::TestCase
       class Blog < ActiveModelSerializers::Model
-        attr_accessor :id, :name, :authors
+        attributes :id, :name, :authors
       end
       class Author < ActiveModelSerializers::Model
-        attr_accessor :id, :name
+        attributes :id, :name
       end
       class BlogSerializer < ActiveModel::Serializer
         attributes :id

data/test/serializers/serializer_for_test.rb

@@ -28,8 +28,8 @@ module ActiveModel
 
       class SerializerTest < ActiveSupport::TestCase
         module ResourceNamespace
-          Post    = Class.new(::Model)
-          Comment = Class.new(::Model)
+          class Post    < ::Model; end
+          class Comment < ::Model; end
 
           class PostSerializer < ActiveModel::Serializer
             class CommentSerializer < ActiveModel::Serializer
@@ -41,10 +41,12 @@ module ActiveModel
         end
 
         class CustomProfile
-          def serializer_class; ProfileSerializer; end
+          def serializer_class
+            ProfileSerializer
+          end
         end
 
-        Tweet = Class.new(::Model)
+        class Tweet < ::Model; end
         TweetSerializer = Class.new
 
         def setup
@@ -57,7 +59,7 @@ module ActiveModel
 
         def test_serializer_for_non_ams_serializer
           serializer = ActiveModel::Serializer.serializer_for(@tweet)
-          assert_equal nil, serializer
+          assert_nil serializer
         end
 
         def test_serializer_for_existing_serializer
@@ -69,12 +71,12 @@ module ActiveModel
           serializer = with_serializer_lookup_disabled do
             ActiveModel::Serializer.serializer_for(@profile)
           end
-          assert_equal nil, serializer
+          assert_nil serializer
         end
 
         def test_serializer_for_not_existing_serializer
           serializer = ActiveModel::Serializer.serializer_for(@model)
-          assert_equal nil, serializer
+          assert_nil serializer
         end
 
         def test_serializer_inherited_serializer
@@ -86,7 +88,7 @@ module ActiveModel
           serializer = with_serializer_lookup_disabled do
             ActiveModel::Serializer.serializer_for(@my_profile)
           end
-          assert_equal nil, serializer
+          assert_nil serializer
         end
 
         def test_serializer_custom_serializer
@@ -112,7 +114,7 @@ module ActiveModel
           serializer = with_serializer_lookup_disabled do
             ActiveModel::Serializer.serializer_for(post)
           end
-          assert_equal nil, serializer
+          assert_nil serializer
         end
 
         def test_serializer_for_nested_resource
@@ -126,7 +128,7 @@ module ActiveModel
           serializer = with_serializer_lookup_disabled do
             ResourceNamespace::PostSerializer.serializer_for(comment)
           end
-          assert_equal nil, serializer
+          assert_nil serializer
         end
       end
     end

data/test/serializers/serializer_for_with_namespace_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class SerializerForWithNamespaceTest < ActiveSupport::TestCase
+      class Book < ::Model
+        attributes :title, :author_name
+        associations :publisher, :pages
+      end
+      class Page < ::Model; attributes :number, :text end
+      class Publisher < ::Model; attributes :name end
+
+      module Api
+        module V3
+          class BookSerializer < ActiveModel::Serializer
+            attributes :title, :author_name
+
+            has_many :pages
+            belongs_to :publisher
+          end
+
+          class PageSerializer < ActiveModel::Serializer
+            attributes :number, :text
+          end
+
+          class PublisherSerializer < ActiveModel::Serializer
+            attributes :name
+          end
+        end
+      end
+
+      class BookSerializer < ActiveModel::Serializer
+        attributes :title, :author_name
+      end
+      test 'resource without a namespace' do
+        book = Book.new(title: 'A Post', author_name: 'hello')
+
+        # TODO: this should be able to pull up this serializer without explicitly specifying the serializer
+        #       currently, with no options, it still uses the Api::V3 serializer
+        result = ActiveModelSerializers::SerializableResource.new(book, serializer: BookSerializer).serializable_hash
+
+        expected = { title: 'A Post', author_name: 'hello' }
+        assert_equal expected, result
+      end
+
+      test 'resource with namespace' do
+        book = Book.new(title: 'A Post', author_name: 'hi')
+
+        result = ActiveModelSerializers::SerializableResource.new(book, namespace: Api::V3).serializable_hash
+
+        expected = { title: 'A Post', author_name: 'hi', pages: nil, publisher: nil }
+        assert_equal expected, result
+      end
+
+      test 'has_many with nested serializer under the namespace' do
+        page = Page.new(number: 1, text: 'hello')
+        book = Book.new(title: 'A Post', author_name: 'hi', pages: [page])
+
+        result = ActiveModelSerializers::SerializableResource.new(book, namespace: Api::V3).serializable_hash
+
+        expected = {
+          title: 'A Post', author_name: 'hi',
+          publisher: nil,
+          pages: [{
+            number: 1, text: 'hello'
+          }]
+        }
+        assert_equal expected, result
+      end
+
+      test 'belongs_to with nested serializer under the namespace' do
+        publisher = Publisher.new(name: 'Disney')
+        book = Book.new(title: 'A Post', author_name: 'hi', publisher: publisher)
+
+        result = ActiveModelSerializers::SerializableResource.new(book, namespace: Api::V3).serializable_hash
+
+        expected = {
+          title: 'A Post', author_name: 'hi',
+          pages: nil,
+          publisher: {
+            name: 'Disney'
+          }
+        }
+        assert_equal expected, result
+      end
+    end
+  end
+end

data/test/support/isolated_unit.rb

@@ -41,6 +41,7 @@ require 'active_support/core_ext/string/access'
 
 # These files do not require any others and are needed
 # to run the tests
+require 'active_support/testing/autorun'
 require 'active_support/testing/isolation'
 
 module TestHelpers
@@ -74,6 +75,8 @@ module TestHelpers
   end
 end
 
-class ActiveSupport::TestCase
-  include TestHelpers::Generation
+module ActiveSupport
+  class TestCase
+    include TestHelpers::Generation
+  end
 end