active_model_serializers 0.10.9 → 0.10.13

data/test/serializers/attributes_test.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-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

data/test/serializers/caching_configuration_test_isolated.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-# Execute this test in isolation
-require 'support/isolated_unit'
-
-class CachingConfigurationTest < ActiveSupport::TestCase
-  include ActiveSupport::Testing::Isolation
-
-  setup do
-    require 'rails'
-    # AMS needs to be required before Rails.application is initialized for
-    # Railtie's to fire in Rails.application.initialize!
-    # (and make_basic_app initializes the app)
-    require 'active_model_serializers'
-    # Create serializers before Rails.application.initialize!
-    # To ensure we're testing that the cache settings depend on
-    # the Railtie firing, not on the ActionController being loaded.
-    create_serializers
-  end
-
-  def create_serializers
-    @cached_serializer = Class.new(ActiveModel::Serializer) do
-      cache skip_digest: true
-      attributes :id, :name, :title
-    end
-    @fragment_cached_serializer = Class.new(ActiveModel::Serializer) do
-      cache only: :id
-      attributes :id, :name, :title
-    end
-    @non_cached_serializer = Class.new(ActiveModel::Serializer) do
-      attributes :id, :name, :title
-    end
-  end
-
-  class PerformCachingTrue < CachingConfigurationTest
-    setup do
-      # Let's make that Rails app and initialize it!
-      make_basic_app do |app|
-        app.config.action_controller.perform_caching = true
-        app.config.action_controller.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
-      end
-      controller_cache_store # Force ActiveSupport.on_load(:action_controller) to run
-    end
-
-    test 'it sets perform_caching to true on AMS.config and serializers' do
-      assert Rails.configuration.action_controller.perform_caching
-      assert ActiveModelSerializers.config.perform_caching
-      assert ActiveModel::Serializer.perform_caching?
-      assert @cached_serializer.perform_caching?
-      assert @non_cached_serializer.perform_caching?
-      assert @fragment_cached_serializer.perform_caching?
-    end
-
-    test 'it sets the AMS.config.cache_store to the controller cache_store' do
-      assert_equal controller_cache_store, ActiveSupport::Cache::MemoryStore
-      assert_equal controller_cache_store, ActiveModelSerializers.config.cache_store.class
-    end
-
-    test 'it sets the cached serializer cache_store to the ActionController::Base.cache_store' do
-      assert_equal ActiveSupport::Cache::NullStore, @cached_serializer._cache.class
-      assert_equal controller_cache_store, @cached_serializer.cache_store.class
-      assert_equal ActiveSupport::Cache::MemoryStore, @cached_serializer._cache.class
-    end
-
-    test 'the cached serializer has cache_enabled?' do
-      assert @cached_serializer.cache_enabled?
-    end
-
-    test 'the cached serializer does not have fragment_cache_enabled?' do
-      refute @cached_serializer.fragment_cache_enabled?
-    end
-
-    test 'the non-cached serializer cache_store is nil' do
-      assert_nil @non_cached_serializer._cache
-      assert_nil @non_cached_serializer.cache_store
-      assert_nil @non_cached_serializer._cache
-    end
-
-    test 'the non-cached serializer does not have cache_enabled?' do
-      refute @non_cached_serializer.cache_enabled?
-    end
-
-    test 'the non-cached serializer does not have fragment_cache_enabled?' do
-      refute @non_cached_serializer.fragment_cache_enabled?
-    end
-
-    test 'it sets the fragment cached serializer cache_store to the ActionController::Base.cache_store' do
-      assert_equal ActiveSupport::Cache::NullStore, @fragment_cached_serializer._cache.class
-      assert_equal controller_cache_store, @fragment_cached_serializer.cache_store.class
-      assert_equal ActiveSupport::Cache::MemoryStore, @fragment_cached_serializer._cache.class
-    end
-
-    test 'the fragment cached serializer does not have cache_enabled?' do
-      refute @fragment_cached_serializer.cache_enabled?
-    end
-
-    test 'the fragment cached serializer has fragment_cache_enabled?' do
-      assert @fragment_cached_serializer.fragment_cache_enabled?
-    end
-  end
-
-  class PerformCachingFalse < CachingConfigurationTest
-    setup do
-      # Let's make that Rails app and initialize it!
-      make_basic_app do |app|
-        app.config.action_controller.perform_caching = false
-        app.config.action_controller.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
-      end
-      controller_cache_store # Force ActiveSupport.on_load(:action_controller) to run
-    end
-
-    test 'it sets perform_caching to false on AMS.config and serializers' do
-      refute Rails.configuration.action_controller.perform_caching
-      refute ActiveModelSerializers.config.perform_caching
-      refute ActiveModel::Serializer.perform_caching?
-      refute @cached_serializer.perform_caching?
-      refute @non_cached_serializer.perform_caching?
-      refute @fragment_cached_serializer.perform_caching?
-    end
-
-    test 'it sets the AMS.config.cache_store to the controller cache_store' do
-      assert_equal controller_cache_store, ActiveSupport::Cache::MemoryStore
-      assert_equal controller_cache_store, ActiveModelSerializers.config.cache_store.class
-    end
-
-    test 'it sets the cached serializer cache_store to the ActionController::Base.cache_store' do
-      assert_equal ActiveSupport::Cache::NullStore, @cached_serializer._cache.class
-      assert_equal controller_cache_store, @cached_serializer.cache_store.class
-      assert_equal ActiveSupport::Cache::MemoryStore, @cached_serializer._cache.class
-    end
-
-    test 'the cached serializer does not have cache_enabled?' do
-      refute @cached_serializer.cache_enabled?
-    end
-
-    test 'the cached serializer does not have fragment_cache_enabled?' do
-      refute @cached_serializer.fragment_cache_enabled?
-    end
-
-    test 'the non-cached serializer cache_store is nil' do
-      assert_nil @non_cached_serializer._cache
-      assert_nil @non_cached_serializer.cache_store
-      assert_nil @non_cached_serializer._cache
-    end
-
-    test 'the non-cached serializer does not have cache_enabled?' do
-      refute @non_cached_serializer.cache_enabled?
-    end
-
-    test 'the non-cached serializer does not have fragment_cache_enabled?' do
-      refute @non_cached_serializer.fragment_cache_enabled?
-    end
-
-    test 'it sets the fragment cached serializer cache_store to the ActionController::Base.cache_store' do
-      assert_equal ActiveSupport::Cache::NullStore, @fragment_cached_serializer._cache.class
-      assert_equal controller_cache_store, @fragment_cached_serializer.cache_store.class
-      assert_equal ActiveSupport::Cache::MemoryStore, @fragment_cached_serializer._cache.class
-    end
-
-    test 'the fragment cached serializer does not have cache_enabled?' do
-      refute @fragment_cached_serializer.cache_enabled?
-    end
-
-    test 'the fragment cached serializer does not have fragment_cache_enabled?' do
-      refute @fragment_cached_serializer.fragment_cache_enabled?
-    end
-  end
-
-  def controller_cache_store
-    ActionController::Base.cache_store.class
-  end
-end

data/test/serializers/configuration_test.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class ConfigurationTest < ActiveSupport::TestCase
-      def test_collection_serializer
-        assert_equal ActiveModel::Serializer::CollectionSerializer, ActiveModelSerializers.config.collection_serializer
-      end
-
-      def test_array_serializer
-        assert_equal ActiveModel::Serializer::CollectionSerializer, ActiveModelSerializers.config.array_serializer
-      end
-
-      def test_setting_array_serializer_sets_collection_serializer
-        config = ActiveModelSerializers.config
-        old_config = config.dup
-        begin
-          assert_equal ActiveModel::Serializer::CollectionSerializer, config.collection_serializer
-          config.array_serializer = :foo
-          assert_equal config.array_serializer, :foo
-          assert_equal config.collection_serializer, :foo
-        ensure
-          ActiveModelSerializers.config.replace(old_config)
-        end
-      end
-
-      def test_default_adapter
-        assert_equal :attributes, ActiveModelSerializers.config.adapter
-      end
-    end
-  end
-end

data/test/serializers/fieldset_test.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class FieldsetTest < ActiveSupport::TestCase
-      def test_fieldset_with_hash
-        fieldset = ActiveModel::Serializer::Fieldset.new('post' => %w(id title), 'comment' => ['body'])
-        expected = { post: [:id, :title], comment: [:body] }
-
-        assert_equal(expected, fieldset.fields)
-      end
-    end
-  end
-end

data/test/serializers/meta_test.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class MetaTest < ActiveSupport::TestCase
-      def setup
-        @blog = Blog.new(id: 1,
-                         name: 'AMS Hints',
-                         writer: Author.new(id: 2, name: 'Steve'),
-                         articles: [Post.new(id: 3, title: 'AMS')])
-      end
-
-      def test_meta_is_present_with_root
-        actual = ActiveModelSerializers::SerializableResource.new(
-          @blog,
-          adapter: :json,
-          serializer: AlternateBlogSerializer,
-          meta: { total: 10 }
-        ).as_json
-        expected = {
-          blog: {
-            id: 1,
-            title: 'AMS Hints'
-          },
-          'meta' => {
-            total: 10
-          }
-        }
-        assert_equal(expected, actual)
-      end
-
-      def test_meta_is_not_included_when_blank
-        actual = ActiveModelSerializers::SerializableResource.new(
-          @blog,
-          adapter: :json,
-          serializer: AlternateBlogSerializer,
-          meta: {}
-        ).as_json
-        expected = {
-          blog: {
-            id: 1,
-            title: 'AMS Hints'
-          }
-        }
-        assert_equal(expected, actual)
-      end
-
-      def test_meta_is_not_included_when_empty_string
-        actual = ActiveModelSerializers::SerializableResource.new(
-          @blog,
-          adapter: :json,
-          serializer: AlternateBlogSerializer,
-          meta: ''
-        ).as_json
-        expected = {
-          blog: {
-            id: 1,
-            title: 'AMS Hints'
-          }
-        }
-        assert_equal(expected, actual)
-      end
-
-      def test_meta_is_not_included_when_root_is_missing
-        actual = ActiveModelSerializers::SerializableResource.new(
-          @blog,
-          adapter: :attributes,
-          serializer: AlternateBlogSerializer,
-          meta: { total: 10 }
-        ).as_json
-        expected = {
-          id: 1,
-          title: 'AMS Hints'
-        }
-        assert_equal(expected, actual)
-      end
-
-      def test_meta_key_is_used
-        actual = ActiveModelSerializers::SerializableResource.new(
-          @blog,
-          adapter: :json,
-          serializer: AlternateBlogSerializer,
-          meta: { total: 10 },
-          meta_key: 'haha_meta'
-        ).as_json
-        expected = {
-          blog: {
-            id: 1,
-            title: 'AMS Hints'
-          },
-          'haha_meta' => {
-            total: 10
-          }
-        }
-        assert_equal(expected, actual)
-      end
-
-      def test_meta_key_is_not_used_with_json_api
-        actual = ActiveModelSerializers::SerializableResource.new(
-          @blog,
-          adapter: :json_api,
-          serializer: AlternateBlogSerializer,
-          meta: { total: 10 },
-          meta_key: 'haha_meta'
-        ).as_json
-        expected = {
-          data: {
-            id: '1',
-            type: 'blogs',
-            attributes: { title: 'AMS Hints' }
-          },
-          meta: { total: 10 }
-        }
-        assert_equal(expected, actual)
-      end
-
-      def test_meta_key_is_not_present_when_empty_hash_with_json_api
-        actual = ActiveModelSerializers::SerializableResource.new(
-          @blog,
-          adapter: :json_api,
-          serializer: AlternateBlogSerializer,
-          meta: {}
-        ).as_json
-        expected = {
-          data: {
-            id: '1',
-            type: 'blogs',
-            attributes: { title: 'AMS Hints' }
-          }
-        }
-        assert_equal(expected, actual)
-      end
-
-      def test_meta_key_is_not_present_when_empty_string_with_json_api
-        actual = ActiveModelSerializers::SerializableResource.new(
-          @blog,
-          adapter: :json_api,
-          serializer: AlternateBlogSerializer,
-          meta: ''
-        ).as_json
-        expected = {
-          data: {
-            id: '1',
-            type: 'blogs',
-            attributes: { title: 'AMS Hints' }
-          }
-        }
-        assert_equal(expected, actual)
-      end
-
-      def test_meta_is_not_present_on_arrays_without_root
-        actual = ActiveModelSerializers::SerializableResource.new(
-          [@blog],
-          adapter: :attributes,
-          meta: { total: 10 }
-        ).as_json
-        expected = [{
-          id: 1,
-          name: 'AMS Hints',
-          writer: {
-            id: 2,
-            name: 'Steve'
-          },
-          articles: [{
-            id: 3,
-            title: 'AMS',
-            body: nil
-          }]
-        }]
-        assert_equal(expected, actual)
-      end
-
-      def test_meta_is_present_on_arrays_with_root
-        actual = ActiveModelSerializers::SerializableResource.new(
-          [@blog],
-          adapter: :json,
-          meta: { total: 10 },
-          meta_key: 'haha_meta'
-        ).as_json
-        expected = {
-          blogs: [{
-            id: 1,
-            name: 'AMS Hints',
-            writer: {
-              id: 2,
-              name: 'Steve'
-            },
-            articles: [{
-              id: 3,
-              title: 'AMS',
-              body: nil
-            }]
-          }],
-          'haha_meta' => {
-            total: 10
-          }
-        }
-        assert_equal(expected, actual)
-      end
-    end
-  end
-end

data/test/serializers/options_test.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class OptionsTest < ActiveSupport::TestCase
-      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
-        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
-        model_with_options_serializer = ModelWithOptionsSerializer.new(@model_with_options)
-        refute model_with_options_serializer.arguments_passed_in?
-      end
-    end
-  end
-end

data/test/serializers/read_attribute_for_serialization_test.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class ReadAttributeForSerializationTest < ActiveSupport::TestCase
-      # https://github.com/rails-api/active_model_serializers/issues/1653
-      class Parent < ActiveModelSerializers::Model
-        attributes :id
-      end
-      class Child < Parent
-        attributes :name
-      end
-      class ParentSerializer < ActiveModel::Serializer
-        attributes :$id
-
-        define_method(:$id) do
-          object.id
-        end
-      end
-      class ChildSerializer < ParentSerializer
-        attributes :name
-      end
-
-      def test_child_serializer_calls_dynamic_method_in_parent_serializer
-        parent = ParentSerializer.new(Parent.new(id: 5))
-        child  = ChildSerializer.new(Child.new(id: 6, name: 'Child'))
-        assert_equal 5, parent.read_attribute_for_serialization(:$id)
-        assert_equal 6, child.read_attribute_for_serialization(:$id)
-      end
-
-      # https://github.com/rails-api/active_model_serializers/issues/1658
-      class ErrorResponse < ActiveModelSerializers::Model
-        attributes :error
-      end
-      class ApplicationSerializer < ActiveModel::Serializer
-        attributes :status
-
-        def status
-          object.try(:errors).blank? && object.try(:error).blank?
-        end
-      end
-      class ErrorResponseSerializer < ApplicationSerializer
-        attributes :error
-      end
-      class ErrorResponseWithSuperSerializer < ApplicationSerializer
-        attributes :error
-
-        def success
-          super
-        end
-      end
-
-      def test_child_serializer_with_error_attribute
-        error = ErrorResponse.new(error: 'i have an error')
-        serializer = ErrorResponseSerializer.new(error)
-        serializer_with_super = ErrorResponseWithSuperSerializer.new(error)
-        assert_equal false, serializer.read_attribute_for_serialization(:status)
-        assert_equal false, serializer_with_super.read_attribute_for_serialization(:status)
-      end
-
-      def test_child_serializer_with_errors
-        error = ErrorResponse.new
-        error.errors.add(:invalid, 'i am not valid')
-        serializer = ErrorResponseSerializer.new(error)
-        serializer_with_super = ErrorResponseWithSuperSerializer.new(error)
-        assert_equal false, serializer.read_attribute_for_serialization(:status)
-        assert_equal false, serializer_with_super.read_attribute_for_serialization(:status)
-      end
-
-      def test_child_serializer_no_error_attribute_or_errors
-        error = ErrorResponse.new
-        serializer = ErrorResponseSerializer.new(error)
-        serializer_with_super = ErrorResponseWithSuperSerializer.new(error)
-        assert_equal true, serializer.read_attribute_for_serialization(:status)
-        assert_equal true, serializer_with_super.read_attribute_for_serialization(:status)
-      end
-    end
-  end
-end