active_model_serializers 0.10.0.rc5 → 0.10.0

data/test/benchmark/controllers.rb

@@ -1,12 +1,13 @@
 class PostController < ActionController::Base
   POST =
     begin
+      updated_at = Time.current
       if ENV['BENCH_STRESS']
         comments = (0..50).map do |i|
-          Comment.new(id: i, body: 'ZOMG A COMMENT')
+          Comment.new(id: i, body: 'ZOMG A COMMENT', updated_at: updated_at + i)
         end
       else
-        comments = [Comment.new(id: 1, body: 'ZOMG A COMMENT')]
+        comments = [Comment.new(id: 1, body: 'ZOMG A COMMENT', updated_at: updated_at)]
       end
       author = Author.new(id: 42, first_name: 'Joao', last_name: 'Moura')
       Post.new(id: 1337, title: 'New Post', blog: nil, body: 'Body', comments: comments, author: author)
@@ -17,6 +18,11 @@ class PostController < ActionController::Base
     render json: POST, serializer: CachingPostSerializer, adapter: :json, meta: { caching: perform_caching }
   end
 
+  def render_with_fragment_caching_serializer
+    toggle_cache_status
+    render json: POST, serializer: FragmentCachingPostSerializer, adapter: :json, meta: { caching: perform_caching }
+  end
+
   def render_with_non_caching_serializer
     toggle_cache_status
     render json: POST, adapter: :json, meta: { caching: perform_caching }
@@ -73,5 +79,6 @@ Rails.application.routes.draw do
   get '/status(/:on)' => 'post#render_cache_status'
   get '/clear' => 'post#clear'
   get '/caching(/:on)' => 'post#render_with_caching_serializer'
+  get '/fragment_caching(/:on)' => 'post#render_with_fragment_caching_serializer'
   get '/non_caching(/:on)' => 'post#render_with_non_caching_serializer'
 end

data/test/benchmark/fixtures.rb

@@ -13,7 +13,7 @@ end
 Rails.configuration.serializers << BlogSerializer
 
 class CommentSerializer < ActiveModel::Serializer
-  attributes :id, :body
+  attributes :id, :body, :updated_at
 
   belongs_to :post
   belongs_to :author
@@ -43,7 +43,7 @@ end
 Rails.configuration.serializers << PostSerializer
 
 class CachingAuthorSerializer < AuthorSerializer
-  cache key: 'writer', only: [:first_name, :last_name], skip_digest: true
+  cache key: 'writer', skip_digest: true
 end
 Rails.configuration.serializers << CachingAuthorSerializer
 
@@ -52,14 +52,66 @@ class CachingCommentSerializer < CommentSerializer
 end
 Rails.configuration.serializers << CachingCommentSerializer
 
-class CachingPostSerializer < PostSerializer
+# see https://github.com/rails-api/active_model_serializers/pull/1690/commits/68715b8f99bc29677e8a47bb3f305f23c077024b#r60344532
+class CachingPostSerializer < ActiveModel::Serializer
   cache key: 'post', expires_in: 0.1, skip_digest: true
+
+  attributes :id, :title, :body
+
   belongs_to :blog, serializer: BlogSerializer
   belongs_to :author, serializer: CachingAuthorSerializer
   has_many :comments, serializer: CachingCommentSerializer
+
+  link(:post_authors) { 'https://example.com/post_authors' }
+
+  meta do
+    {
+      rating: 5,
+      favorite_count: 10
+    }
+  end
+
+  def blog
+    Blog.new(id: 999, name: 'Custom blog')
+  end
 end
 Rails.configuration.serializers << CachingPostSerializer
 
+class FragmentCachingAuthorSerializer < AuthorSerializer
+  cache key: 'writer', only: [:first_name, :last_name], skip_digest: true
+end
+Rails.configuration.serializers << FragmentCachingAuthorSerializer
+
+class FragmentCachingCommentSerializer < CommentSerializer
+  cache expires_in: 1.day, except: [:updated_at], skip_digest: true
+end
+Rails.configuration.serializers << CachingCommentSerializer
+
+# see https://github.com/rails-api/active_model_serializers/pull/1690/commits/68715b8f99bc29677e8a47bb3f305f23c077024b#r60344532
+class FragmentCachingPostSerializer < ActiveModel::Serializer
+  cache key: 'post', expires_in: 0.1, skip_digest: true
+
+  attributes :id, :title, :body
+
+  belongs_to :blog, serializer: BlogSerializer
+  belongs_to :author, serializer: FragmentCachingAuthorSerializer
+  has_many :comments, serializer: FragmentCachingCommentSerializer
+
+  link(:post_authors) { 'https://example.com/post_authors' }
+
+  meta do
+    {
+      rating: 5,
+      favorite_count: 10
+    }
+  end
+
+  def blog
+    Blog.new(id: 999, name: 'Custom blog')
+  end
+end
+Rails.configuration.serializers << FragmentCachingPostSerializer
+
 if ENV['ENABLE_ACTIVE_RECORD'] == 'true'
   require 'active_record'
 
@@ -150,7 +202,7 @@ else
   end
 
   class Comment < BenchmarkModel
-    attr_accessor :id, :body
+    attr_accessor :id, :body, :updated_at
   end
 
   class Author < BenchmarkModel

data/test/cache_test.rb

@@ -114,7 +114,7 @@ module ActiveModelSerializers
 
     def test_error_is_raised_if_cache_key_is_not_defined_on_object_or_passed_as_cache_option
       article = Article.new(title: 'Must Read')
-      e = assert_raises ActiveModelSerializers::CachedSerializer::UndefinedCacheKey do
+      e = assert_raises ActiveModel::Serializer::UndefinedCacheKey do
         render_object_with_cache(article)
       end
       assert_match(/ActiveModelSerializers::CacheTest::Article must define #cache_key, or the 'key:' option must be passed into 'CachedActiveModelSerializers_CacheTest_ArticleSerializer.cache'/, e.message)
@@ -252,11 +252,11 @@ module ActiveModelSerializers
       attributes_serialization = serializable_alert.as_json
       assert_equal expected_cached_attributes, alert.attributes
       assert_equal alert.attributes, attributes_serialization
-      attributes_cache_key = CachedSerializer.new(serializable_alert.adapter.serializer).cache_key(serializable_alert.adapter)
+      attributes_cache_key = serializable_alert.adapter.serializer.cache_key(serializable_alert.adapter)
       assert_equal attributes_serialization, cache_store.fetch(attributes_cache_key)
 
       serializable_alert = serializable(alert, serializer: AlertSerializer, adapter: :json_api)
-      jsonapi_cache_key = CachedSerializer.new(serializable_alert.adapter.serializer).cache_key(serializable_alert.adapter)
+      jsonapi_cache_key = serializable_alert.adapter.serializer.cache_key(serializable_alert.adapter)
       # Assert cache keys differ
       refute_equal attributes_cache_key, jsonapi_cache_key
       # Assert (cached) serializations differ
@@ -288,9 +288,9 @@ module ActiveModelSerializers
       serializable = ActiveModelSerializers::SerializableResource.new([@comment, @comment])
       include_tree = ActiveModel::Serializer::IncludeTree.from_include_args('*')
 
-      actual = CachedSerializer.object_cache_keys(serializable.adapter.serializer, serializable.adapter, include_tree)
+      actual = ActiveModel::Serializer.object_cache_keys(serializable.adapter.serializer, serializable.adapter, include_tree)
 
-      assert_equal actual.size, 3
+      assert_equal 3, actual.size
       assert actual.any? { |key| key == "comment/1/#{serializable.adapter.cached_name}" }
       assert actual.any? { |key| key =~ %r{post/post-\d+} }
       assert actual.any? { |key| key =~ %r{author/author-\d+} }
@@ -365,12 +365,109 @@ module ActiveModelSerializers
       assert called
     end
 
+    def test_cached_false_without_cache_store
+      cached_serializer = build_cached_serializer do |serializer|
+        serializer._cache = nil
+      end
+      refute cached_serializer.class.cache_enabled?
+    end
+
+    def test_cached_true_with_cache_store_and_without_cache_only_and_cache_except
+      cached_serializer = build_cached_serializer do |serializer|
+        serializer._cache = Object
+      end
+      assert cached_serializer.class.cache_enabled?
+    end
+
+    def test_cached_false_with_cache_store_and_with_cache_only
+      cached_serializer = build_cached_serializer do |serializer|
+        serializer._cache = Object
+        serializer._cache_only = [:name]
+      end
+      refute cached_serializer.class.cache_enabled?
+    end
+
+    def test_cached_false_with_cache_store_and_with_cache_except
+      cached_serializer = build_cached_serializer do |serializer|
+        serializer._cache = Object
+        serializer._cache_except = [:content]
+      end
+      refute cached_serializer.class.cache_enabled?
+    end
+
+    def test_fragment_cached_false_without_cache_store
+      cached_serializer = build_cached_serializer do |serializer|
+        serializer._cache = nil
+        serializer._cache_only = [:name]
+      end
+      refute cached_serializer.class.fragment_cache_enabled?
+    end
+
+    def test_fragment_cached_true_with_cache_store_and_cache_only
+      cached_serializer = build_cached_serializer do |serializer|
+        serializer._cache = Object
+        serializer._cache_only = [:name]
+      end
+      assert cached_serializer.class.fragment_cache_enabled?
+    end
+
+    def test_fragment_cached_true_with_cache_store_and_cache_except
+      cached_serializer = build_cached_serializer do |serializer|
+        serializer._cache = Object
+        serializer._cache_except = [:content]
+      end
+      assert cached_serializer.class.fragment_cache_enabled?
+    end
+
+    def test_fragment_cached_false_with_cache_store_and_cache_except_and_cache_only
+      cached_serializer = build_cached_serializer do |serializer|
+        serializer._cache = Object
+        serializer._cache_except = [:content]
+        serializer._cache_only = [:name]
+      end
+      refute cached_serializer.class.fragment_cache_enabled?
+    end
+
+    def test_fragment_fetch_with_virtual_attributes
+      @author          = Author.new(name: 'Joao M. D. Moura')
+      @role            = Role.new(name: 'Great Author', description: nil)
+      @role.author     = [@author]
+      @role_serializer = RoleSerializer.new(@role)
+      @role_hash       = @role_serializer.fetch_fragment_cache(ActiveModelSerializers::Adapter.configured_adapter.new(@role_serializer))
+
+      expected_result = {
+        id: @role.id,
+        description: @role.description,
+        slug: "#{@role.name}-#{@role.id}",
+        name: @role.name
+      }
+      assert_equal(@role_hash, expected_result)
+    end
+
+    def test_fragment_fetch_with_namespaced_object
+      @spam            = Spam::UnrelatedLink.new(id: 'spam-id-1')
+      @spam_serializer = Spam::UnrelatedLinkSerializer.new(@spam)
+      @spam_hash       = @spam_serializer.fetch_fragment_cache(ActiveModelSerializers::Adapter.configured_adapter.new(@spam_serializer))
+      expected_result = {
+        id: @spam.id
+      }
+      assert_equal(@spam_hash, expected_result)
+    end
+
     private
 
     def cache_store
       ActiveModelSerializers.config.cache_store
     end
 
+    def build_cached_serializer
+      serializer = Class.new(ActiveModel::Serializer)
+      serializer._cache_key = nil
+      serializer._cache_options = nil
+      yield serializer if block_given?
+      serializer.new(Object)
+    end
+
     def render_object_with_cache(obj, options = {})
       @serializable_resource = serializable(obj, options)
       @serializable_resource.serializable_hash
@@ -381,7 +478,7 @@ module ActiveModelSerializers
     end
 
     def cached_serialization(serializer)
-      cache_key = CachedSerializer.new(serializer).cache_key(adapter)
+      cache_key = serializer.cache_key(adapter)
       cache_store.fetch(cache_key)
     end
   end

data/test/fixtures/active_record.rb

@@ -24,6 +24,16 @@ ActiveRecord::Schema.define do
     t.string :email
     t.timestamp null: false
   end
+  create_table :object_tags, force: true do |t|
+    t.string :poly_tag_id
+    t.string :taggable_type
+    t.string :taggable_id
+    t.timestamp null: false
+  end
+  create_table :poly_tags, force: true do |t|
+    t.string :phrase
+    t.timestamp null: false
+  end
   create_table :pictures, force: true do |t|
     t.string :title
     t.string :imageable_type

data/test/fixtures/poro.rb

@@ -70,10 +70,21 @@ end
 
 class Employee < ActiveRecord::Base
   has_many :pictures, as: :imageable
+  has_many :object_tags, as: :taggable
+end
+
+class ObjectTag < ActiveRecord::Base
+  belongs_to :poly_tag
+  belongs_to :taggable, polymorphic: true
 end
 
 class Picture < ActiveRecord::Base
   belongs_to :imageable, polymorphic: true
+  has_many :object_tags, as: :taggable
+end
+
+class PolyTag < ActiveRecord::Base
+  has_many :object_tags
 end
 
 module Spam; end
@@ -227,8 +238,9 @@ end
 VirtualValueSerializer = Class.new(ActiveModel::Serializer) do
   attributes :id
 
-  has_many :reviews, virtual_value: [{ id: 1 }, { id: 2 }]
-  has_one :maker, virtual_value: { id: 1 }
+  has_many :reviews, virtual_value: [{ type: 'reviews', id: '1' },
+                                     { type: 'reviews', id: '2' }]
+  has_one :maker, virtual_value: { type: 'makers', id: '1' }
 
   def reviews
   end
@@ -244,7 +256,23 @@ end
 PolymorphicBelongsToSerializer = Class.new(ActiveModel::Serializer) do
   attributes :id, :title
 
-  has_one :imageable, serializer: PolymorphicHasManySerializer
+  has_one :imageable, serializer: PolymorphicHasManySerializer, polymorphic: true
+end
+
+PolymorphicSimpleSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+end
+
+PolymorphicObjectTagSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id
+
+  has_many :taggable, serializer: PolymorphicSimpleSerializer, polymorphic: true
+end
+
+PolymorphicTagSerializer = Class.new(ActiveModel::Serializer) do
+  attributes :id, :phrase
+
+  has_many :object_tags, serializer: PolymorphicObjectTagSerializer
 end
 
 Spam::UnrelatedLinkSerializer = Class.new(ActiveModel::Serializer) do

data/test/serializers/associations_test.rb

@@ -239,27 +239,55 @@ module ActiveModel
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def test_conditional_associations
-          serializer = Class.new(ActiveModel::Serializer) do
-            belongs_to :if_assoc_included, if: :true
-            belongs_to :if_assoc_excluded, if: :false
-            belongs_to :unless_assoc_included, unless: :false
-            belongs_to :unless_assoc_excluded, unless: :true
-
-            def true
-              true
-            end
+          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
+              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
 
-          model = ::Model.new
-          hash = serializable(model, serializer: serializer).serializable_hash
-          expected = { if_assoc_included: nil, unless_assoc_included: nil }
+        def test_illegal_conditional_associations
+          exception = assert_raises(TypeError) do
+            Class.new(ActiveModel::Serializer) do
+              belongs_to :x, if: nil
+            end
+          end
 
-          assert_equal(expected, hash)
+          assert_match(/:if should be a Symbol, String or Proc/, exception.message)
         end
       end
     end

data/test/serializers/attribute_test.rb

@@ -96,27 +96,55 @@ module ActiveModel
         assert_equal(expected, hash)
       end
 
-      def test_conditional_attributes
-        serializer = Class.new(ActiveModel::Serializer) do
-          attribute :if_attribute_included, if: :true
-          attribute :if_attribute_excluded, if: :false
-          attribute :unless_attribute_included, unless: :false
-          attribute :unless_attribute_excluded, unless: :true
-
-          def true
-            true
+      # 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
+            attribute :attribute, s[:options]
+
+            def true
+              true
+            end
+
+            def false
+              false
+            end
           end
 
-          def false
-            false
-          end
+          hash = serializable(model, serializer: serializer).serializable_hash
+          assert_equal(s[:included], hash.key?(:attribute), "Error with #{s[:options]}")
         end
+      end
 
-        model = ::Model.new
-        hash = serializable(model, serializer: serializer).serializable_hash
-        expected = { if_attribute_included: nil, unless_attribute_included: nil }
+      def test_illegal_conditional_attributes
+        exception = assert_raises(TypeError) do
+          Class.new(ActiveModel::Serializer) do
+            attribute :x, if: nil
+          end
+        end
 
-        assert_equal(expected, hash)
+        assert_match(/:if should be a Symbol, String or Proc/, exception.message)
       end
     end
   end