active_model_serializers 0.10.3 → 0.10.12

data/test/adapter/json_api/type_test.rb

@@ -1,61 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    module Adapter
-      class JsonApi
-        class TypeTest < ActiveSupport::TestCase
-          class StringTypeSerializer < ActiveModel::Serializer
-            attribute :name
-            type 'profile'
-          end
-
-          class SymbolTypeSerializer < ActiveModel::Serializer
-            attribute :name
-            type :profile
-          end
-
-          setup do
-            @author = Author.new(id: 1, name: 'Steve K.')
-          end
-
-          def test_config_plural
-            with_jsonapi_resource_type :plural do
-              assert_type(@author, 'authors')
-            end
-          end
-
-          def test_config_singular
-            with_jsonapi_resource_type :singular do
-              assert_type(@author, 'author')
-            end
-          end
-
-          def test_explicit_string_type_value
-            assert_type(@author, 'profile', serializer: StringTypeSerializer)
-          end
-
-          def test_explicit_symbol_type_value
-            assert_type(@author, 'profile', serializer: SymbolTypeSerializer)
-          end
-
-          private
-
-          def assert_type(resource, expected_type, opts = {})
-            opts = opts.reverse_merge(adapter: :json_api)
-            hash = serializable(resource, opts).serializable_hash
-            assert_equal(expected_type, hash.fetch(:data).fetch(:type))
-          end
-
-          def with_jsonapi_resource_type(inflection)
-            old_inflection = ActiveModelSerializers.config.jsonapi_resource_type
-            ActiveModelSerializers.config.jsonapi_resource_type = inflection
-            yield
-          ensure
-            ActiveModelSerializers.config.jsonapi_resource_type = old_inflection
-          end
-        end
-      end
-    end
-  end
-end

data/test/adapter/json_test.rb

@@ -1,46 +0,0 @@
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class JsonTest < ActiveSupport::TestCase
-      def setup
-        ActionController::Base.cache_store.clear
-        @author = Author.new(id: 1, name: 'Steve K.')
-        @post = Post.new(id: 1, title: 'New Post', body: 'Body')
-        @first_comment = Comment.new(id: 1, body: 'ZOMG A COMMENT')
-        @second_comment = Comment.new(id: 2, body: 'ZOMG ANOTHER COMMENT')
-        @post.comments = [@first_comment, @second_comment]
-        @first_comment.post = @post
-        @second_comment.post = @post
-        @post.author = @author
-        @blog = Blog.new(id: 1, name: 'My Blog!!')
-        @post.blog = @blog
-
-        @serializer = PostSerializer.new(@post)
-        @adapter = ActiveModelSerializers::Adapter::Json.new(@serializer)
-      end
-
-      def test_has_many
-        assert_equal([
-                       { id: 1, body: 'ZOMG A COMMENT' },
-                       { id: 2, body: 'ZOMG ANOTHER COMMENT' }
-                     ], @adapter.serializable_hash[:post][:comments])
-      end
-
-      def test_custom_keys
-        serializer = PostWithCustomKeysSerializer.new(@post)
-        adapter = ActiveModelSerializers::Adapter::Json.new(serializer)
-
-        assert_equal({
-                       id: 1,
-                       reviews: [
-                         { id: 1, body: 'ZOMG A COMMENT' },
-                         { id: 2, body: 'ZOMG ANOTHER COMMENT' }
-                       ],
-                       writer: { id: 1, name: 'Steve K.' },
-                       site: { id: 1, name: 'My Blog!!' }
-                     }, adapter.serializable_hash[:post])
-      end
-    end
-  end
-end

data/test/adapter/null_test.rb

@@ -1,22 +0,0 @@
-require 'test_helper'
-
-module ActiveModelSerializers
-  module Adapter
-    class NullTest < ActiveSupport::TestCase
-      def setup
-        profile = Profile.new(name: 'Name 1', description: 'Description 1', comments: 'Comments 1')
-        serializer = ProfileSerializer.new(profile)
-
-        @adapter = Null.new(serializer)
-      end
-
-      def test_serializable_hash
-        assert_equal({}, @adapter.serializable_hash)
-      end
-
-      def test_it_returns_empty_json
-        assert_equal('{}', @adapter.to_json)
-      end
-    end
-  end
-end

data/test/adapter/polymorphic_test.rb

@@ -1,171 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    module Adapter
-      class PolymorphicTest < ActiveSupport::TestCase
-        setup do
-          @employee = Employee.new(id: 42, name: 'Zoop Zoopler', email: 'zoop@example.com')
-          @picture = @employee.pictures.new(id: 1, title: 'headshot-1.jpg')
-          @picture.imageable = @employee
-        end
-
-        def serialization(resource, adapter = :attributes)
-          serializable(resource, adapter: adapter, serializer: PolymorphicBelongsToSerializer).as_json
-        end
-
-        def tag_serialization(adapter = :attributes)
-          tag = PolyTag.new(id: 1, phrase: 'foo')
-          tag.object_tags << ObjectTag.new(id: 1, poly_tag_id: 1, taggable: @employee)
-          tag.object_tags << ObjectTag.new(id: 5, poly_tag_id: 1, taggable: @picture)
-          serializable(tag, adapter: adapter, serializer: PolymorphicTagSerializer, include: '*.*').as_json
-        end
-
-        def test_attributes_serialization
-          expected =
-            {
-              id: 1,
-              title: 'headshot-1.jpg',
-              imageable: {
-                type: 'employee',
-                employee: {
-                  id: 42,
-                  name: 'Zoop Zoopler'
-                }
-              }
-            }
-
-          assert_equal(expected, serialization(@picture))
-        end
-
-        def test_attributes_serialization_without_polymorphic_association
-          expected =
-            {
-              id: 2,
-              title: 'headshot-2.jpg',
-              imageable: nil
-            }
-
-          simple_picture = Picture.new(id: 2, title: 'headshot-2.jpg')
-          assert_equal(expected, serialization(simple_picture))
-        end
-
-        def test_attributes_serialization_with_polymorphic_has_many
-          expected =
-            {
-              id: 1,
-              phrase: 'foo',
-              object_tags: [
-                {
-                  id: 1,
-                  taggable: {
-                    type: 'employee',
-                    employee: {
-                      id: 42
-                    }
-                  }
-                },
-                {
-                  id: 5,
-                  taggable: {
-                    type: 'picture',
-                    picture: {
-                      id: 1
-                    }
-                  }
-                }
-              ]
-            }
-          assert_equal(expected, tag_serialization)
-        end
-
-        def test_json_serialization
-          expected =
-            {
-              picture: {
-                id: 1,
-                title: 'headshot-1.jpg',
-                imageable: {
-                  type: 'employee',
-                  employee: {
-                    id: 42,
-                    name: 'Zoop Zoopler'
-                  }
-                }
-              }
-            }
-
-          assert_equal(expected, serialization(@picture, :json))
-        end
-
-        def test_json_serialization_without_polymorphic_association
-          expected =
-            {
-              picture: {
-                id: 2,
-                title: 'headshot-2.jpg',
-                imageable: nil
-              }
-            }
-
-          simple_picture = Picture.new(id: 2, title: 'headshot-2.jpg')
-          assert_equal(expected, serialization(simple_picture, :json))
-        end
-
-        def test_json_serialization_with_polymorphic_has_many
-          expected =
-            {
-              poly_tag: {
-                id: 1,
-                phrase: 'foo',
-                object_tags: [
-                  {
-                    id: 1,
-                    taggable: {
-                      type: 'employee',
-                      employee: {
-                        id: 42
-                      }
-                    }
-                  },
-                  {
-                    id: 5,
-                    taggable: {
-                      type: 'picture',
-                      picture: {
-                        id: 1
-                      }
-                    }
-                  }
-                ]
-              }
-            }
-          assert_equal(expected, tag_serialization(:json))
-        end
-
-        def test_json_api_serialization
-          expected =
-            {
-              data: {
-                id: '1',
-                type: 'pictures',
-                attributes: {
-                  title: 'headshot-1.jpg'
-                },
-                relationships: {
-                  imageable: {
-                    data: {
-                      id: '42',
-                      type: 'employees'
-                    }
-                  }
-                }
-              }
-            }
-
-          assert_equal(expected, serialization(@picture, :json_api))
-        end
-      end
-    end
-  end
-end

data/test/adapter_test.rb

@@ -1,67 +0,0 @@
-require 'test_helper'
-
-module ActiveModelSerializers
-  class AdapterTest < ActiveSupport::TestCase
-    def setup
-      profile = Profile.new
-      @serializer = ProfileSerializer.new(profile)
-      @adapter = ActiveModelSerializers::Adapter::Base.new(@serializer)
-    end
-
-    def test_serializable_hash_is_abstract_method
-      assert_raises(NotImplementedError) do
-        @adapter.serializable_hash(only: [:name])
-      end
-    end
-
-    def test_serialization_options_ensures_option_is_a_hash
-      adapter = Class.new(ActiveModelSerializers::Adapter::Base) do
-        def serializable_hash(options = nil)
-          serialization_options(options)
-        end
-      end.new(@serializer)
-      assert_equal({}, adapter.serializable_hash(nil))
-      assert_equal({}, adapter.serializable_hash({}))
-    ensure
-      ActiveModelSerializers::Adapter.adapter_map.delete_if { |k, _| k =~ /class/ }
-    end
-
-    def test_serialization_options_ensures_option_is_one_of_valid_options
-      adapter = Class.new(ActiveModelSerializers::Adapter::Base) do
-        def serializable_hash(options = nil)
-          serialization_options(options)
-        end
-      end.new(@serializer)
-      filtered_options = { now: :see_me, then: :not }
-      valid_options = ActiveModel::Serializer::SERIALIZABLE_HASH_VALID_KEYS.each_with_object({}) do |option, result|
-        result[option] = option
-      end
-      assert_equal(valid_options, adapter.serializable_hash(filtered_options.merge(valid_options)))
-    ensure
-      ActiveModelSerializers::Adapter.adapter_map.delete_if { |k, _| k =~ /class/ }
-    end
-
-    def test_serializer
-      assert_equal @serializer, @adapter.serializer
-    end
-
-    def test_create_adapter
-      adapter = ActiveModelSerializers::Adapter.create(@serializer)
-      assert_equal ActiveModelSerializers::Adapter::Attributes, adapter.class
-    end
-
-    def test_create_adapter_with_override
-      adapter = ActiveModelSerializers::Adapter.create(@serializer, adapter: :json_api)
-      assert_equal ActiveModelSerializers::Adapter::JsonApi, adapter.class
-    end
-
-    def test_inflected_adapter_class_for_known_adapter
-      ActiveSupport::Inflector.inflections(:en) { |inflect| inflect.acronym 'API' }
-      klass = ActiveModelSerializers::Adapter.adapter_class(:json_api)
-
-      ActiveSupport::Inflector.inflections.acronyms.clear
-
-      assert_equal ActiveModelSerializers::Adapter::JsonApi, klass
-    end
-  end
-end

data/test/array_serializer_test.rb

@@ -1,22 +0,0 @@
-require 'test_helper'
-require_relative 'collection_serializer_test'
-
-module ActiveModel
-  class Serializer
-    class ArraySerializerTest < CollectionSerializerTest
-      extend Minitest::Assertions
-      def self.run_one_method(*)
-        _, stderr = capture_io do
-          super
-        end
-        if stderr !~ /NOTE: ActiveModel::Serializer::ArraySerializer.new is deprecated/
-          fail Minitest::Assertion, stderr
-        end
-      end
-
-      def collection_serializer
-        ArraySerializer
-      end
-    end
-  end
-end

data/test/benchmark/app.rb

@@ -1,65 +0,0 @@
-# https://github.com/rails-api/active_model_serializers/pull/872
-# approx ref 792fb8a9053f8db3c562dae4f40907a582dd1720 to test against
-require 'bundler/setup'
-
-require 'rails'
-require 'active_model'
-require 'active_support'
-require 'active_support/json'
-require 'action_controller'
-require 'action_controller/test_case'
-require 'action_controller/railtie'
-abort "Rails application already defined: #{Rails.application.class}" if Rails.application
-
-class NullLogger < Logger
-  def initialize(*_args)
-  end
-
-  def add(*_args, &_block)
-  end
-end
-class BenchmarkLogger < ActiveSupport::Logger
-  def initialize
-    @file = StringIO.new
-    super(@file)
-  end
-
-  def messages
-    @file.rewind
-    @file.read
-  end
-end
-# ref: https://gist.github.com/bf4/8744473
-class BenchmarkApp < Rails::Application
-  # Set up production configuration
-  config.eager_load = true
-  config.cache_classes = true
-  # CONFIG: CACHE_ON={on,off}
-  config.action_controller.perform_caching = ENV['CACHE_ON'] != 'off'
-  config.action_controller.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
-
-  config.active_support.test_order = :random
-  config.secret_token = 'S' * 30
-  config.secret_key_base = 'abc123'
-  config.consider_all_requests_local = false
-
-  # otherwise deadlock occurred
-  config.middleware.delete 'Rack::Lock'
-
-  # to disable log files
-  config.logger = NullLogger.new
-  config.active_support.deprecation = :log
-  config.log_level = :info
-end
-
-require 'active_model_serializers'
-
-# Initialize app before any serializers are defined, for running across revisions.
-# ref: https://github.com/rails-api/active_model_serializers/pull/1478
-Rails.application.initialize!
-# HACK: Serializer::cache depends on the ActionController-dependent configs being set.
-ActiveSupport.on_load(:action_controller) do
-  require_relative 'fixtures'
-end
-
-require_relative 'controllers'