active_model_serializers 0.8.3 → 0.10.0

data/test/serializable_resource_test.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+module ActiveModelSerializers
+  class SerializableResourceTest < ActiveSupport::TestCase
+    def setup
+      @resource = Profile.new({ name: 'Name 1', description: 'Description 1', comments: 'Comments 1' })
+      @serializer = ProfileSerializer.new(@resource)
+      @adapter = ActiveModelSerializers::Adapter.create(@serializer)
+      @serializable_resource = SerializableResource.new(@resource)
+    end
+
+    def test_deprecation
+      assert_output(nil, /deprecated/) do
+        deprecated_serializable_resource = ActiveModel::SerializableResource.new(@resource)
+        assert_equal(@serializable_resource.as_json, deprecated_serializable_resource.as_json)
+      end
+    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
+
+    def test_use_adapter_with_adapter_option
+      assert SerializableResource.new(@resource, { adapter: 'json' }).use_adapter?
+    end
+
+    def test_use_adapter_with_adapter_option_as_false
+      refute SerializableResource.new(@resource, { adapter: false }).use_adapter?
+    end
+
+    class SerializableResourceErrorsTest < Minitest::Test
+      def test_serializable_resource_with_errors
+        options = nil
+        resource = ModelWithErrors.new
+        resource.errors.add(:name, 'must be awesome')
+        serializable_resource = ActiveModelSerializers::SerializableResource.new(
+          resource, {
+            serializer: ActiveModel::Serializer::ErrorSerializer,
+            adapter: :json_api
+          })
+        expected_response_document =
+          { :errors =>
+            [
+              { :source => { :pointer => '/data/attributes/name' }, :detail => 'must be awesome' }
+            ]
+        }
+        assert_equal serializable_resource.as_json(options), expected_response_document
+      end
+
+      def test_serializable_resource_with_collection_containing_errors
+        options = nil
+        resources = []
+        resources << resource = ModelWithErrors.new
+        resource.errors.add(:title, 'must be amazing')
+        resources << ModelWithErrors.new
+        serializable_resource = SerializableResource.new(
+          resources, {
+            serializer: ActiveModel::Serializer::ErrorsSerializer,
+            each_serializer: ActiveModel::Serializer::ErrorSerializer,
+            adapter: :json_api
+          })
+        expected_response_document =
+          { :errors =>
+            [
+              { :source => { :pointer => '/data/attributes/title' }, :detail => 'must be amazing' }
+            ]
+        }
+        assert_equal serializable_resource.as_json(options), expected_response_document
+      end
+    end
+  end
+end

data/test/serializers/association_macros_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AssociationMacrosTest < ActiveSupport::TestCase
+      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,295 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AssociationsTest < ActiveSupport::TestCase
+      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({ include_data: true }, options)
+            assert_kind_of(ActiveModelSerializers.config.collection_serializer, serializer)
+          when :bio
+            assert_equal({ include_data: true }, options)
+            assert_nil serializer
+          when :roles
+            assert_equal({ include_data: true }, options)
+            assert_kind_of(ActiveModelSerializers.config.collection_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 :tags, key
+          assert_nil serializer
+          assert_equal [{ 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({ include_data: true }, 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
+
+      class InlineAssociationTestPostSerializer < ActiveModel::Serializer
+        has_many :comments
+        has_many :comments, key: :last_comments do
+          object.comments.last(1)
+        end
+      end
+
+      def test_virtual_attribute_block
+        comment1 = ::ARModels::Comment.create!(contents: 'first comment')
+        comment2 = ::ARModels::Comment.create!(contents: 'last comment')
+        post = ::ARModels::Post.create!(
+          title: 'inline association test',
+          body: 'etc',
+          comments: [comment1, comment2]
+        )
+        actual = serializable(post, adapter: :attributes, serializer: InlineAssociationTestPostSerializer).as_json
+        expected = {
+          :comments => [
+            { :id => 1, :contents => 'first comment' },
+            { :id => 2, :contents => 'last comment' }
+          ],
+          :last_comments => [
+            { :id => 2, :contents => 'last comment' }
+          ]
+        }
+
+        assert_equal expected, actual
+      ensure
+        ::ARModels::Post.delete_all
+        ::ARModels::Comment.delete_all
+      end
+
+      class NamespacedResourcesTest < ActiveSupport::TestCase
+        class ResourceNamespace
+          Post    = Class.new(::Model)
+          Comment = Class.new(::Model)
+          Author  = Class.new(::Model)
+          Description = Class.new(::Model)
+          class PostSerializer < ActiveModel::Serializer
+            has_many :comments
+            belongs_to :author
+            has_one :description
+          end
+          CommentSerializer     = Class.new(ActiveModel::Serializer)
+          AuthorSerializer      = Class.new(ActiveModel::Serializer)
+          DescriptionSerializer = Class.new(ActiveModel::Serializer)
+        end
+
+        def setup
+          @comment = ResourceNamespace::Comment.new
+          @author = ResourceNamespace::Author.new
+          @description = ResourceNamespace::Description.new
+          @post = ResourceNamespace::Post.new(comments: [@comment],
+                                              author: @author,
+                                              description: @description)
+          @post_serializer = ResourceNamespace::PostSerializer.new(@post)
+        end
+
+        def test_associations_namespaced_resources
+          @post_serializer.associations.each do |association|
+            case association.key
+            when :comments
+              assert_instance_of(ResourceNamespace::CommentSerializer, association.serializer.first)
+            when :author
+              assert_instance_of(ResourceNamespace::AuthorSerializer, association.serializer)
+            when :description
+              assert_instance_of(ResourceNamespace::DescriptionSerializer, association.serializer)
+            else
+              flunk "Unknown association: #{key}"
+            end
+          end
+        end
+      end
+
+      class NestedSerializersTest < ActiveSupport::TestCase
+        Post    = Class.new(::Model)
+        Comment = Class.new(::Model)
+        Author  = Class.new(::Model)
+        Description = Class.new(::Model)
+        class PostSerializer < ActiveModel::Serializer
+          has_many :comments
+          CommentSerializer = Class.new(ActiveModel::Serializer)
+          belongs_to :author
+          AuthorSerializer = Class.new(ActiveModel::Serializer)
+          has_one :description
+          DescriptionSerializer = Class.new(ActiveModel::Serializer)
+        end
+
+        def setup
+          @comment = Comment.new
+          @author = Author.new
+          @description = Description.new
+          @post = Post.new(comments: [@comment],
+                           author: @author,
+                           description: @description)
+          @post_serializer = PostSerializer.new(@post)
+        end
+
+        def test_associations_namespaced_resources
+          @post_serializer.associations.each do |association|
+            case association.key
+            when :comments
+              assert_instance_of(PostSerializer::CommentSerializer, association.serializer.first)
+            when :author
+              assert_instance_of(PostSerializer::AuthorSerializer, association.serializer)
+            when :description
+              assert_instance_of(PostSerializer::DescriptionSerializer, association.serializer)
+            else
+              flunk "Unknown association: #{key}"
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def test_conditional_associations
+          model = ::Model.new(true: true, false: false)
+
+          scenarios = [
+            { options: { if:     :true  }, included: true  },
+            { options: { if:     :false }, included: false },
+            { options: { unless: :false }, included: true  },
+            { options: { unless: :true  }, included: false },
+            { options: { if:     'object.true'  }, included: true  },
+            { options: { if:     'object.false' }, included: false },
+            { options: { unless: 'object.false' }, included: true  },
+            { options: { unless: 'object.true'  }, included: false },
+            { options: { if:     -> { object.true }  }, included: true  },
+            { options: { if:     -> { object.false } }, included: false },
+            { options: { unless: -> { object.false } }, included: true  },
+            { options: { unless: -> { object.true }  }, included: false },
+            { options: { if:     -> (s) { s.object.true }  }, included: true  },
+            { options: { if:     -> (s) { s.object.false } }, included: false },
+            { options: { unless: -> (s) { s.object.false } }, included: true  },
+            { options: { unless: -> (s) { s.object.true }  }, included: false }
+          ]
+
+          scenarios.each do |s|
+            serializer = Class.new(ActiveModel::Serializer) do
+              belongs_to :association, s[:options]
+
+              def true
+                true
+              end
+
+              def false
+                false
+              end
+            end
+
+            hash = serializable(model, serializer: serializer).serializable_hash
+            assert_equal(s[:included], hash.key?(:association), "Error with #{s[:options]}")
+          end
+        end
+
+        def test_illegal_conditional_associations
+          exception = assert_raises(TypeError) do
+            Class.new(ActiveModel::Serializer) do
+              belongs_to :x, if: nil
+            end
+          end
+
+          assert_match(/:if should be a Symbol, String or Proc/, exception.message)
+        end
+      end
+    end
+  end
+end

data/test/serializers/attribute_test.rb

@@ -0,0 +1,151 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AttributeTest < ActiveSupport::TestCase
+      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 = ActiveModelSerializers::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 = ActiveModelSerializers::Adapter::Attributes.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 = ActiveModelSerializers::Adapter::Json.new(serializer.new(@blog))
+        assert_equal({ blog: { id: 'AMS Hints' } }, adapter.serializable_hash)
+      end
+
+      def test_object_attribute_override
+        serializer = Class.new(ActiveModel::Serializer) do
+          attribute :name, key: :object
+        end
+
+        adapter = ActiveModelSerializers::Adapter::Json.new(serializer.new(@blog))
+        assert_equal({ blog: { object: '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 = ActiveModelSerializers::Adapter::Json.new(attribute_serializer.new(@blog))
+        assert_equal({ blog: { type: 1 } }, adapter.serializable_hash)
+
+        adapter = ActiveModelSerializers::Adapter::Json.new(attributes_serializer.new(@blog))
+        assert_equal({ blog: { type: 'stuff' } }, adapter.serializable_hash)
+      end
+
+      def test_id_attribute_override_before
+        serializer = Class.new(ActiveModel::Serializer) do
+          def id
+            'custom'
+          end
+
+          attribute :id
+        end
+
+        hash = ActiveModelSerializers::SerializableResource.new(@blog, adapter: :json, serializer: serializer).serializable_hash
+
+        assert_equal('custom', hash[:blog][:id])
+      end
+
+      PostWithVirtualAttribute = Class.new(::Model)
+      class PostWithVirtualAttributeSerializer < ActiveModel::Serializer
+        attribute :name do
+          "#{object.first_name} #{object.last_name}"
+        end
+      end
+
+      def test_virtual_attribute_block
+        post = PostWithVirtualAttribute.new(first_name: 'Lucas', last_name: 'Hosseini')
+        hash = serializable(post).serializable_hash
+        expected = { name: 'Lucas Hosseini' }
+
+        assert_equal(expected, hash)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def test_conditional_associations
+        model = ::Model.new(true: true, false: false)
+
+        scenarios = [
+          { options: { if:     :true  }, included: true  },
+          { options: { if:     :false }, included: false },
+          { options: { unless: :false }, included: true  },
+          { options: { unless: :true  }, included: false },
+          { options: { if:     'object.true'  }, included: true  },
+          { options: { if:     'object.false' }, included: false },
+          { options: { unless: 'object.false' }, included: true  },
+          { options: { unless: 'object.true'  }, included: false },
+          { options: { if:     -> { object.true }  }, included: true  },
+          { options: { if:     -> { object.false } }, included: false },
+          { options: { unless: -> { object.false } }, included: true  },
+          { options: { unless: -> { object.true }  }, included: false },
+          { options: { if:     -> (s) { s.object.true }  }, included: true  },
+          { options: { if:     -> (s) { s.object.false } }, included: false },
+          { options: { unless: -> (s) { s.object.false } }, included: true  },
+          { options: { unless: -> (s) { s.object.true }  }, included: false }
+        ]
+
+        scenarios.each do |s|
+          serializer = Class.new(ActiveModel::Serializer) do
+            attribute :attribute, s[:options]
+
+            def true
+              true
+            end
+
+            def false
+              false
+            end
+          end
+
+          hash = serializable(model, serializer: serializer).serializable_hash
+          assert_equal(s[:included], hash.key?(:attribute), "Error with #{s[:options]}")
+        end
+      end
+
+      def test_illegal_conditional_attributes
+        exception = assert_raises(TypeError) do
+          Class.new(ActiveModel::Serializer) do
+            attribute :x, if: nil
+          end
+        end
+
+        assert_match(/:if should be a Symbol, String or Proc/, exception.message)
+      end
+    end
+  end
+end

data/test/serializers/attributes_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class AttributesTest < ActiveSupport::TestCase
+      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_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