active_model_serializers 0.10.0 → 0.10.12

data/test/include_tree/from_string_test.rb

@@ -1,94 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class IncludeTree
-      class FromStringTest < ActiveSupport::TestCase
-        def test_single_string
-          input = 'author'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:author))
-        end
-
-        def test_multiple_strings
-          input = 'author,comments'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_multiple_strings_with_space
-          input = 'author, comments'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_nested_string
-          input = 'posts.author'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:author))
-        end
-
-        def test_multiple_nested_string
-          input = 'posts.author,posts.comments.author,comments'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:author))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_toplevel_star_string
-          input = '*'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:comments))
-        end
-
-        def test_nested_star_string
-          input = 'posts.*'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-        end
-
-        def test_nested_star_middle_string
-          input = 'posts.*.author'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-          refute(actual[:posts][:comments].key?(:unspecified))
-        end
-
-        def test_nested_star_lower_precedence_string
-          input = 'posts.comments.author,posts.*'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-        end
-
-        def test_toplevel_double_star_string
-          input = '**'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:posts))
-        end
-
-        def test_nested_double_star_string
-          input = 'comments, posts.**'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:comments))
-          refute(actual[:comments].key?(:author))
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:posts))
-        end
-      end
-    end
-  end
-end

data/test/include_tree/include_args_to_hash_test.rb

@@ -1,64 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class IncludeTree
-      module Parsing
-        class IncludeArgsToHashTest < MiniTest::Test
-          def test_include_args_to_hash_from_symbol
-            expected = { author: {} }
-            input = :author
-            actual = Parsing.include_args_to_hash(input)
-
-            assert_equal(expected, actual)
-          end
-
-          def test_include_args_to_hash_from_array
-            expected = { author: {}, comments: {} }
-            input = [:author, :comments]
-            actual = Parsing.include_args_to_hash(input)
-
-            assert_equal(expected, actual)
-          end
-
-          def test_include_args_to_hash_from_nested_array
-            expected = { author: {}, comments: { author: {} } }
-            input = [:author, comments: [:author]]
-            actual = Parsing.include_args_to_hash(input)
-
-            assert_equal(expected, actual)
-          end
-
-          def test_include_args_to_hash_from_array_of_hashes
-            expected = {
-              author: {},
-              blogs: { posts: { contributors: {} } },
-              comments: { author: { blogs: { posts: {} } } }
-            }
-            input = [
-              :author,
-              blogs: [posts: :contributors],
-              comments: { author: { blogs: :posts } }
-            ]
-            actual = Parsing.include_args_to_hash(input)
-
-            assert_equal(expected, actual)
-          end
-
-          def test_array_of_string
-            expected = {
-              comments: { author: {}, attachment: {} }
-            }
-            input = [
-              'comments.author',
-              'comments.attachment'
-            ]
-            actual = Parsing.include_args_to_hash(input)
-
-            assert_equal(expected, actual)
-          end
-        end
-      end
-    end
-  end
-end

data/test/lint_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class LintTest < ActiveSupport::TestCase
-      include ActiveModel::Serializer::Lint::Tests
-
-      class CompliantResource
-        def serializable_hash(options = nil)
-        end
-
-        def read_attribute_for_serialization(name)
-        end
-
-        def as_json(options = nil)
-        end
-
-        def to_json(options = nil)
-        end
-
-        def cache_key
-        end
-
-        def id
-        end
-
-        def updated_at
-        end
-
-        def errors
-        end
-
-        def self.human_attribute_name(attr, options = {})
-        end
-
-        def self.lookup_ancestors
-        end
-
-        def self.model_name
-          @_model_name ||= ActiveModel::Name.new(self)
-        end
-      end
-
-      def setup
-        @resource = CompliantResource.new
-      end
-    end
-  end
-end

data/test/logger_test.rb

@@ -1,18 +0,0 @@
-require 'test_helper'
-
-class ActiveModelSerializers::LoggerTest < ActiveSupport::TestCase
-  def test_logger_is_set_to_action_controller_logger_when_initializer_runs
-    assert_equal $action_controller_logger, ActionController::Base.logger # rubocop:disable Style/GlobalVars
-  end
-
-  def test_logger_can_be_set
-    original_logger = ActiveModelSerializers.logger
-    logger = Logger.new(STDOUT)
-
-    ActiveModelSerializers.logger = logger
-
-    assert_equal ActiveModelSerializers.logger, logger
-  ensure
-    ActiveModelSerializers.logger = original_logger
-  end
-end

data/test/poro_test.rb

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

data/test/serializable_resource_test.rb

@@ -1,83 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,295 +0,0 @@
-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