active_model_serializers 0.10.0.rc4 → 0.10.0.rc5

data/test/collection_serializer_test.rb

@@ -3,6 +3,10 @@ require 'test_helper'
 module ActiveModel
   class Serializer
     class CollectionSerializerTest < ActiveSupport::TestCase
+      MessagesSerializer = Class.new(ActiveModel::Serializer) do
+        type 'messages'
+      end
+
       def setup
         @comment = Comment.new
         @post = Post.new
@@ -84,6 +88,12 @@ module ActiveModel
         assert_nil serializer.json_key
       end
 
+      def test_json_key_with_empty_resources_with_serializer
+        resource = []
+        serializer = collection_serializer.new(resource, serializer: MessagesSerializer)
+        assert_equal 'messages', serializer.json_key
+      end
+
       def test_json_key_with_root
         expected = 'custom_root'
         serializer = collection_serializer.new(@resource, root: expected)

data/test/fixtures/active_record.rb

@@ -2,6 +2,7 @@ require 'active_record'
 
 ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
 ActiveRecord::Schema.define do
+  self.verbose = false
   create_table :posts, force: true do |t|
     t.string :title
     t.text :body
@@ -18,6 +19,17 @@ ActiveRecord::Schema.define do
     t.references :post
     t.timestamp null: false
   end
+  create_table :employees, force: true do |t|
+    t.string :name
+    t.string :email
+    t.timestamp null: false
+  end
+  create_table :pictures, force: true do |t|
+    t.string :title
+    t.string :imageable_type
+    t.string :imageable_id
+    t.timestamp null: false
+  end
 end
 
 module ARModels

data/test/fixtures/poro.rb

@@ -21,10 +21,17 @@ class Model < ActiveModelSerializers::Model
   def respond_to_missing?(method_name, _include_private = false)
     attributes.key?(method_name.to_s.tr('=', '').to_sym) || super
   end
+end
 
-  def cache_key_with_digest
-    "#{cache_key}/#{FILE_DIGEST}"
-  end
+# see
+# https://github.com/rails/rails/blob/4-2-stable/activemodel/lib/active_model/errors.rb
+# The below allows you to do:
+#
+#   model = ModelWithErrors.new
+#   model.validate!            # => ["cannot be nil"]
+#   model.errors.full_messages # => ["name cannot be nil"]
+class ModelWithErrors < ::ActiveModelSerializers::Model
+  attr_accessor :name
 end
 
 class Profile < Model
@@ -61,6 +68,14 @@ Comment = Class.new(Model) do
   end
 end
 
+class Employee < ActiveRecord::Base
+  has_many :pictures, as: :imageable
+end
+
+class Picture < ActiveRecord::Base
+  belongs_to :imageable, polymorphic: true
+end
+
 module Spam; end
 Spam::UnrelatedLink = Class.new(Model)
 
@@ -222,6 +237,16 @@ VirtualValueSerializer = Class.new(ActiveModel::Serializer) do
   end
 end
 
+PolymorphicHasManySerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :name
+end
+
+PolymorphicBelongsToSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :title
+
+  has_one :imageable, serializer: PolymorphicHasManySerializer
+end
+
 Spam::UnrelatedLinkSerializer = Class.new(ActiveModel::Serializer) do
   cache only: [:id]
   attributes :id

data/test/grape_test.rb

@@ -15,11 +15,11 @@ class ActiveModelSerializers::GrapeTest < ActiveSupport::TestCase
 
     def self.all
       @all ||=
-      begin
-        model1.save!
-        model2.save!
-        ARModels::Post.all
-      end
+        begin
+          model1.save!
+          model2.save!
+          ARModels::Post.all
+        end
     end
   end
 

data/test/lint_test.rb

@@ -27,6 +27,15 @@ module ActiveModel
         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

data/test/serializable_resource_test.rb

@@ -1,12 +1,19 @@
 require 'test_helper'
 
-module ActiveModel
+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 = ActiveModel::Serializer::Adapter.create(@serializer)
-      @serializable_resource = ActiveModel::SerializableResource.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
@@ -23,5 +30,54 @@ module ActiveModel
       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/associations_test.rb

@@ -32,13 +32,13 @@ module ActiveModel
 
           case key
           when :posts
-            assert_equal({}, options)
+            assert_equal({ include_data: true }, options)
             assert_kind_of(ActiveModelSerializers.config.collection_serializer, serializer)
           when :bio
-            assert_equal({}, options)
+            assert_equal({ include_data: true }, options)
             assert_nil serializer
           when :roles
-            assert_equal({}, options)
+            assert_equal({ include_data: true }, options)
             assert_kind_of(ActiveModelSerializers.config.collection_serializer, serializer)
           else
             flunk "Unknown association: #{key}"
@@ -60,8 +60,8 @@ module ActiveModel
 
       def test_serializer_options_are_passed_into_associations_serializers
         association = @post_serializer
-                        .associations
-                        .detect { |assoc| assoc.key == :comments }
+                      .associations
+                      .detect { |assoc| assoc.key == :comments }
 
         assert association.serializer.first.custom_options[:custom_options]
       end
@@ -80,7 +80,7 @@ module ActiveModel
             flunk "Unknown association: #{key}"
           end
 
-          assert_equal({}, association.options)
+          assert_equal({ include_data: true }, association.options)
         end
       end
 
@@ -143,11 +143,11 @@ module ActiveModel
         )
         actual = serializable(post, adapter: :attributes, serializer: InlineAssociationTestPostSerializer).as_json
         expected = {
-          :comments =>           [
+          :comments => [
             { :id => 1, :contents => 'first comment' },
             { :id => 2, :contents => 'last comment' }
           ],
-          :last_comments =>           [
+          :last_comments => [
             { :id => 2, :contents => 'last comment' }
           ]
         }

data/test/serializers/attribute_test.rb

@@ -14,14 +14,14 @@ module ActiveModel
       end
 
       def test_json_serializable_hash
-        adapter = ActiveModel::Serializer::Adapter::Json.new(@blog_serializer)
+        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 = ActiveModel::Serializer::Adapter::Attributes.new(blog_serializer)
+        adapter = ActiveModelSerializers::Adapter::Attributes.new(blog_serializer)
         assert_equal({ :id => 1, :title => 'AMS Hints' }, adapter.serializable_hash)
       end
 
@@ -39,7 +39,7 @@ module ActiveModel
           attribute :name, key: :id
         end
 
-        adapter = ActiveModel::Serializer::Adapter::Json.new(serializer.new(@blog))
+        adapter = ActiveModelSerializers::Adapter::Json.new(serializer.new(@blog))
         assert_equal({ blog: { id: 'AMS Hints' } }, adapter.serializable_hash)
       end
 
@@ -48,7 +48,7 @@ module ActiveModel
           attribute :name, key: :object
         end
 
-        adapter = ActiveModel::Serializer::Adapter::Json.new(serializer.new(@blog))
+        adapter = ActiveModelSerializers::Adapter::Json.new(serializer.new(@blog))
         assert_equal({ blog: { object: 'AMS Hints' } }, adapter.serializable_hash)
       end
 
@@ -60,10 +60,10 @@ module ActiveModel
           attributes :type
         end
 
-        adapter = ActiveModel::Serializer::Adapter::Json.new(attribute_serializer.new(@blog))
+        adapter = ActiveModelSerializers::Adapter::Json.new(attribute_serializer.new(@blog))
         assert_equal({ blog: { type: 1 } }, adapter.serializable_hash)
 
-        adapter = ActiveModel::Serializer::Adapter::Json.new(attributes_serializer.new(@blog))
+        adapter = ActiveModelSerializers::Adapter::Json.new(attributes_serializer.new(@blog))
         assert_equal({ blog: { type: 'stuff' } }, adapter.serializable_hash)
       end
 
@@ -76,7 +76,7 @@ module ActiveModel
           attribute :id
         end
 
-        hash = ActiveModel::SerializableResource.new(@blog, adapter: :json, serializer: serializer).serializable_hash
+        hash = ActiveModelSerializers::SerializableResource.new(@blog, adapter: :json, serializer: serializer).serializable_hash
 
         assert_equal('custom', hash[:blog][:id])
       end

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