active_model_serializers 0.8.3 → 0.10.0

data/test/serializers/caching_configuration_test_isolated.rb

@@ -0,0 +1,170 @@
+# 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_equal nil, @non_cached_serializer._cache
+      assert_equal nil, @non_cached_serializer.cache_store
+      assert_equal 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_equal nil, @non_cached_serializer._cache
+      assert_equal nil, @non_cached_serializer.cache_store
+      assert_equal 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

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

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

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

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class OptionsTest < ActiveSupport::TestCase
+      def setup
+        @profile = Profile.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?
+      end
+
+      def test_no_option_is_passed_in
+        @profile_serializer = ProfileSerializer.new(@profile)
+        refute @profile_serializer.arguments_passed_in?
+      end
+    end
+  end
+end

data/test/serializers/read_attribute_for_serialization_test.rb

@@ -0,0 +1,79 @@
+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
+        attr_accessor :id
+      end
+      class Child < Parent
+        attr_accessor :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
+        attr_accessor :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

data/test/serializers/root_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class RootTest < ActiveSupport::TestCase
+      def setup
+        @virtual_value = VirtualValue.new(id: 1)
+      end
+
+      def test_overwrite_root
+        serializer = VirtualValueSerializer.new(@virtual_value, { root: 'smth' })
+        assert_equal('smth', serializer.json_key)
+      end
+
+      def test_underscore_in_root
+        serializer = VirtualValueSerializer.new(@virtual_value)
+        assert_equal('virtual_value', serializer.json_key)
+      end
+    end
+  end
+end

data/test/serializers/serialization_test.rb

@@ -0,0 +1,55 @@
+module ActiveModel
+  class Serializer
+    class SerializationTest < ActiveSupport::TestCase
+      class Blog < ActiveModelSerializers::Model
+        attr_accessor :id, :name, :authors
+      end
+      class Author < ActiveModelSerializers::Model
+        attr_accessor :id, :name
+      end
+      class BlogSerializer < ActiveModel::Serializer
+        attributes :id
+        attribute :name, key: :title
+
+        has_many :authors
+      end
+      class AuthorSerializer < ActiveModel::Serializer
+        attributes :id, :name
+      end
+
+      setup do
+        @authors = [Author.new(id: 1, name: 'Blog Author')]
+        @blog = Blog.new(id: 2, name: 'The Blog', authors: @authors)
+        @serializer_instance = BlogSerializer.new(@blog)
+        @serializable = ActiveModelSerializers::SerializableResource.new(@blog, serializer: BlogSerializer, adapter: :attributes)
+        @expected_hash = { id: 2, title: 'The Blog', authors: [{ id: 1, name: 'Blog Author' }] }
+        @expected_json = '{"id":2,"title":"The Blog","authors":[{"id":1,"name":"Blog Author"}]}'
+      end
+
+      test '#serializable_hash is the same as generated by the attributes adapter' do
+        assert_equal @serializable.serializable_hash, @serializer_instance.serializable_hash
+        assert_equal @expected_hash, @serializer_instance.serializable_hash
+      end
+
+      test '#as_json is the same as generated by the attributes adapter' do
+        assert_equal @serializable.as_json, @serializer_instance.as_json
+        assert_equal @expected_hash, @serializer_instance.as_json
+      end
+
+      test '#to_json is the same as generated by the attributes adapter' do
+        assert_equal @serializable.to_json, @serializer_instance.to_json
+        assert_equal @expected_json, @serializer_instance.to_json
+      end
+
+      test '#to_h is an alias for #serializable_hash' do
+        assert_equal @serializable.serializable_hash, @serializer_instance.to_h
+        assert_equal @expected_hash, @serializer_instance.to_h
+      end
+
+      test '#to_hash is an alias for #serializable_hash' do
+        assert_equal @serializable.serializable_hash, @serializer_instance.to_hash
+        assert_equal @expected_hash, @serializer_instance.to_hash
+      end
+    end
+  end
+end