active_model_serializers_custom 0.10.90

data/test/benchmark/bm_lookup_chain.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative './benchmarking_support'
+require_relative './app'
+
+time = 10
+disable_gc = true
+ActiveModelSerializers.config.key_transform = :unaltered
+
+module AmsBench
+  module Api
+    module V1
+      class PrimaryResourceSerializer < ActiveModel::Serializer
+        attributes :title, :body
+
+        has_many :has_many_relationships
+      end
+
+      class HasManyRelationshipSerializer < ActiveModel::Serializer
+        attribute :body
+      end
+    end
+  end
+  class PrimaryResourceSerializer < ActiveModel::Serializer
+    attributes :title, :body
+
+    has_many :has_many_relationships
+
+    class HasManyRelationshipSerializer < ActiveModel::Serializer
+      attribute :body
+    end
+  end
+end
+
+resource = PrimaryResource.new(
+  id: 1,
+  title: 'title',
+  body: 'body',
+  has_many_relationships: [
+    HasManyRelationship.new(id: 1, body: 'body1'),
+    HasManyRelationship.new(id: 2, body: 'body1')
+  ]
+)
+
+serialization = lambda do
+  ActiveModelSerializers::SerializableResource.new(resource, serializer: AmsBench::PrimaryResourceSerializer).as_json
+  ActiveModelSerializers::SerializableResource.new(resource, namespace: AmsBench::Api::V1).as_json
+  ActiveModelSerializers::SerializableResource.new(resource).as_json
+end
+
+def clear_cache
+  AmsBench::PrimaryResourceSerializer.serializers_cache.clear
+  AmsBench::Api::V1::PrimaryResourceSerializer.serializers_cache.clear
+  ActiveModel::Serializer.serializers_cache.clear
+end
+
+configurable = lambda do
+  clear_cache
+  Benchmark.ams('Configurable Lookup Chain', time: time, disable_gc: disable_gc, &serialization)
+end
+
+old = lambda do
+  clear_cache
+  module ActiveModel
+    class Serializer
+      def self.serializer_lookup_chain_for(klass, namespace = nil)
+        chain = []
+
+        resource_class_name = klass.name.demodulize
+        resource_namespace = klass.name.deconstantize
+        serializer_class_name = "#{resource_class_name}Serializer"
+
+        chain.push("#{namespace}::#{serializer_class_name}") if namespace
+        chain.push("#{name}::#{serializer_class_name}") if self != ActiveModel::Serializer
+        chain.push("#{resource_namespace}::#{serializer_class_name}")
+        chain
+      end
+    end
+  end
+
+  Benchmark.ams('Old Lookup Chain (v0.10)', time: time, disable_gc: disable_gc, &serialization)
+end
+
+configurable.call
+old.call

data/test/benchmark/bm_transform.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative './benchmarking_support'
+require_relative './app'
+
+time = 10
+disable_gc = true
+ActiveModelSerializers.config.key_transform = :unaltered
+has_many_relationships = (0..50).map do |i|
+  HasManyRelationship.new(id: i, body: 'ZOMG A HAS MANY RELATIONSHIP')
+end
+has_one_relationship = HasOneRelationship.new(
+  id: 42,
+  first_name: 'Joao',
+  last_name: 'Moura'
+)
+primary_resource = PrimaryResource.new(
+  id: 1337,
+  title: 'New PrimaryResource',
+  virtual_attribute: nil,
+  body: 'Body',
+  has_many_relationships: has_many_relationships,
+  has_one_relationship: has_one_relationship
+)
+serializer = PrimaryResourceSerializer.new(primary_resource)
+adapter = ActiveModelSerializers::Adapter::JsonApi.new(serializer)
+serialization = adapter.as_json
+
+Benchmark.ams('camel', time: time, disable_gc: disable_gc) do
+  CaseTransform.camel(serialization)
+end
+
+Benchmark.ams('camel_lower', time: time, disable_gc: disable_gc) do
+  CaseTransform.camel_lower(serialization)
+end
+
+Benchmark.ams('dash', time: time, disable_gc: disable_gc) do
+  CaseTransform.dash(serialization)
+end
+
+Benchmark.ams('unaltered', time: time, disable_gc: disable_gc) do
+  CaseTransform.unaltered(serialization)
+end
+
+Benchmark.ams('underscore', time: time, disable_gc: disable_gc) do
+  CaseTransform.underscore(serialization)
+end

data/test/benchmark/config.ru

@@ -0,0 +1,3 @@
+require File.expand_path(['..', 'app'].join(File::SEPARATOR), __FILE__)
+
+run Rails.application

data/test/benchmark/controllers.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+class PrimaryResourceController < ActionController::Base
+  PRIMARY_RESOURCE =
+    begin
+      if ENV['BENCH_STRESS']
+        has_many_relationships = (0..50).map do |i|
+          HasManyRelationship.new(id: i, body: 'ZOMG A HAS MANY RELATIONSHIP')
+        end
+      else
+        has_many_relationships = [HasManyRelationship.new(id: 1, body: 'ZOMG A HAS MANY RELATIONSHIP')]
+      end
+      has_one_relationship = HasOneRelationship.new(id: 42, first_name: 'Joao', last_name: 'Moura')
+      PrimaryResource.new(id: 1337, title: 'New PrimaryResource', virtual_attribute: nil, body: 'Body', has_many_relationships: has_many_relationships, has_one_relationship: has_one_relationship)
+    end
+
+  def render_with_caching_serializer
+    toggle_cache_status
+    render json: PRIMARY_RESOURCE, serializer: CachingPrimaryResourceSerializer, adapter: :json, meta: { caching: perform_caching }
+  end
+
+  def render_with_fragment_caching_serializer
+    toggle_cache_status
+    render json: PRIMARY_RESOURCE, serializer: FragmentCachingPrimaryResourceSerializer, adapter: :json, meta: { caching: perform_caching }
+  end
+
+  def render_with_non_caching_serializer
+    toggle_cache_status
+    render json: PRIMARY_RESOURCE, adapter: :json, meta: { caching: perform_caching }
+  end
+
+  def render_cache_status
+    toggle_cache_status
+    # Uncomment to debug
+    # STDERR.puts cache_store.class
+    # STDERR.puts cache_dependencies
+    # ActiveSupport::Cache::Store.logger.debug [ActiveModelSerializers.config.cache_store, ActiveModelSerializers.config.perform_caching, CachingPrimaryResourceSerializer._cache, perform_caching, params].inspect
+    render json: { caching: perform_caching, meta: { cache_log: cache_messages, cache_status: cache_status } }.to_json
+  end
+
+  def clear
+    ActionController::Base.cache_store.clear
+    # Test caching is on
+    # Uncomment to turn on logger; possible performance issue
+    # logger = BenchmarkLogger.new
+    # ActiveSupport::Cache::Store.logger = logger # seems to be the best way
+    #
+    # the below is used in some rails tests but isn't available/working in all versions, so far as I can tell
+    # https://github.com/rails/rails/pull/15943
+    # ActiveSupport::Notifications.subscribe(/^cache_(.*)\.active_support$/) do |*args|
+    #   logger.debug ActiveSupport::Notifications::Event.new(*args)
+    # end
+    render json: 'ok'.to_json
+  end
+
+  private
+
+  def cache_status
+    {
+      controller: perform_caching,
+      app: Rails.configuration.action_controller.perform_caching,
+      serializers: Rails.configuration.serializers.each_with_object({}) { |serializer, data| data[serializer.name] = serializer._cache.present? }
+    }
+  end
+
+  def cache_messages
+    ActiveSupport::Cache::Store.logger.is_a?(BenchmarkLogger) && ActiveSupport::Cache::Store.logger.messages.split("\n")
+  end
+
+  def toggle_cache_status
+    case params[:on]
+    when 'on'.freeze then self.perform_caching = true
+    when 'off'.freeze then self.perform_caching = false
+    else nil # no-op
+    end
+  end
+end
+
+Rails.application.routes.draw do
+  get '/status(/:on)' => 'primary_resource#render_cache_status'
+  get '/clear' => 'primary_resource#clear'
+  get '/caching(/:on)' => 'primary_resource#render_with_caching_serializer'
+  get '/fragment_caching(/:on)' => 'primary_resource#render_with_fragment_caching_serializer'
+  get '/non_caching(/:on)' => 'primary_resource#render_with_non_caching_serializer'
+end

data/test/benchmark/fixtures.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+Rails.configuration.serializers = []
+class HasOneRelationshipSerializer < ActiveModel::Serializer
+  attributes :id, :first_name, :last_name
+
+  has_many :primary_resources, embed: :ids
+  has_one :bio
+end
+Rails.configuration.serializers << HasOneRelationshipSerializer
+
+class VirtualAttributeSerializer < ActiveModel::Serializer
+  attributes :id, :name
+end
+Rails.configuration.serializers << VirtualAttributeSerializer
+
+class HasManyRelationshipSerializer < ActiveModel::Serializer
+  attributes :id, :body
+
+  belongs_to :primary_resource
+  belongs_to :has_one_relationship
+end
+Rails.configuration.serializers << HasManyRelationshipSerializer
+
+class PrimaryResourceSerializer < ActiveModel::Serializer
+  attributes :id, :title, :body
+
+  has_many :has_many_relationships, serializer: HasManyRelationshipSerializer
+  belongs_to :virtual_attribute, serializer: VirtualAttributeSerializer
+  belongs_to :has_one_relationship, serializer: HasOneRelationshipSerializer
+
+  link(:primary_resource_has_one_relationships) { 'https://example.com/primary_resource_has_one_relationships' }
+
+  meta do
+    {
+      rating: 5,
+      favorite_count: 10
+    }
+  end
+
+  def virtual_attribute
+    VirtualAttribute.new(id: 999, name: 'Free-Range Virtual Attribute')
+  end
+end
+Rails.configuration.serializers << PrimaryResourceSerializer
+
+class CachingHasOneRelationshipSerializer < HasOneRelationshipSerializer
+  cache key: 'writer', skip_digest: true
+end
+Rails.configuration.serializers << CachingHasOneRelationshipSerializer
+
+class CachingHasManyRelationshipSerializer < HasManyRelationshipSerializer
+  cache expires_in: 1.day, skip_digest: true
+end
+Rails.configuration.serializers << CachingHasManyRelationshipSerializer
+
+# see https://github.com/rails-api/active_model_serializers/pull/1690/commits/68715b8f99bc29677e8a47bb3f305f23c077024b#r60344532
+class CachingPrimaryResourceSerializer < ActiveModel::Serializer
+  cache key: 'primary_resource', expires_in: 0.1, skip_digest: true
+
+  attributes :id, :title, :body
+
+  belongs_to :virtual_attribute, serializer: VirtualAttributeSerializer
+  belongs_to :has_one_relationship, serializer: CachingHasOneRelationshipSerializer
+  has_many :has_many_relationships, serializer: CachingHasManyRelationshipSerializer
+
+  link(:primary_resource_has_one_relationships) { 'https://example.com/primary_resource_has_one_relationships' }
+
+  meta do
+    {
+      rating: 5,
+      favorite_count: 10
+    }
+  end
+
+  def virtual_attribute
+    VirtualAttribute.new(id: 999, name: 'Free-Range Virtual Attribute')
+  end
+end
+Rails.configuration.serializers << CachingPrimaryResourceSerializer
+
+class FragmentCachingHasOneRelationshipSerializer < HasOneRelationshipSerializer
+  cache key: 'writer', only: [:first_name, :last_name], skip_digest: true
+end
+Rails.configuration.serializers << FragmentCachingHasOneRelationshipSerializer
+
+class FragmentCachingHasManyRelationshipSerializer < HasManyRelationshipSerializer
+  cache expires_in: 1.day, except: [:body], skip_digest: true
+end
+Rails.configuration.serializers << CachingHasManyRelationshipSerializer
+
+# see https://github.com/rails-api/active_model_serializers/pull/1690/commits/68715b8f99bc29677e8a47bb3f305f23c077024b#r60344532
+class FragmentCachingPrimaryResourceSerializer < ActiveModel::Serializer
+  cache key: 'primary_resource', expires_in: 0.1, skip_digest: true
+
+  attributes :id, :title, :body
+
+  belongs_to :virtual_attribute, serializer: VirtualAttributeSerializer
+  belongs_to :has_one_relationship, serializer: FragmentCachingHasOneRelationshipSerializer
+  has_many :has_many_relationships, serializer: FragmentCachingHasManyRelationshipSerializer
+
+  link(:primary_resource_has_one_relationships) { 'https://example.com/primary_resource_has_one_relationships' }
+
+  meta do
+    {
+      rating: 5,
+      favorite_count: 10
+    }
+  end
+
+  def virtual_attribute
+    VirtualAttribute.new(id: 999, name: 'Free-Range Virtual Attribute')
+  end
+end
+Rails.configuration.serializers << FragmentCachingPrimaryResourceSerializer
+
+if ENV['ENABLE_ACTIVE_RECORD'] == 'true'
+  require 'active_record'
+
+  ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+  ActiveRecord::Schema.define do
+    self.verbose = false
+
+    create_table :virtual_attributes, force: true do |t|
+      t.string :name
+      t.timestamps null: false
+    end
+    create_table :has_one_relationships, force: true do |t|
+      t.string :first_name
+      t.string :last_name
+      t.timestamps null: false
+    end
+    create_table :primary_resources, force: true do |t|
+      t.string :title
+      t.text :body
+      t.references :has_one_relationship
+      t.references :virtual_attribute
+      t.timestamps null: false
+    end
+    create_table :has_many_relationships, force: true do |t|
+      t.text :body
+      t.references :has_one_relationship
+      t.references :primary_resource
+      t.timestamps null: false
+    end
+  end
+
+  class HasManyRelationship < ActiveRecord::Base
+    belongs_to :has_one_relationship
+    belongs_to :primary_resource
+  end
+
+  class HasOneRelationship < ActiveRecord::Base
+    has_many :primary_resources
+    has_many :has_many_relationships
+  end
+
+  class PrimaryResource < ActiveRecord::Base
+    has_many :has_many_relationships
+    belongs_to :has_one_relationship
+    belongs_to :virtual_attribute
+  end
+
+  class VirtualAttribute < ActiveRecord::Base
+    has_many :primary_resources
+  end
+else
+  # ActiveModelSerializers::Model is a convenient
+  # serializable class to inherit from when making
+  # serializable non-activerecord objects.
+  class BenchmarkModel
+    include ActiveModel::Model
+    include ActiveModel::Serializers::JSON
+
+    attr_reader :attributes
+
+    def initialize(attributes = {})
+      @attributes = attributes
+      super
+    end
+
+    # Defaults to the downcased model name.
+    def id
+      attributes.fetch(:id) { self.class.name.downcase }
+    end
+
+    # Defaults to the downcased model name and updated_at
+    def cache_key
+      attributes.fetch(:cache_key) { "#{self.class.name.downcase}/#{id}" }
+    end
+
+    # Defaults to the time the serializer file was modified.
+    def updated_at
+      @updated_at ||= attributes.fetch(:updated_at) { File.mtime(__FILE__) }
+    end
+
+    def read_attribute_for_serialization(key)
+      if key == :id || key == 'id'
+        attributes.fetch(key) { id }
+      else
+        attributes[key]
+      end
+    end
+  end
+
+  class HasManyRelationship < BenchmarkModel
+    attr_accessor :id, :body
+  end
+
+  class HasOneRelationship < BenchmarkModel
+    attr_accessor :id, :first_name, :last_name, :primary_resources
+  end
+
+  class PrimaryResource < BenchmarkModel
+    attr_accessor :id, :title, :body, :has_many_relationships, :virtual_attribute, :has_one_relationship
+  end
+
+  class VirtualAttribute < BenchmarkModel
+    attr_accessor :id, :name
+  end
+end

data/test/cache_test.rb

@@ -0,0 +1,717 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'tmpdir'
+require 'tempfile'
+
+module ActiveModelSerializers
+  class CacheTest < ActiveSupport::TestCase
+    class Article < ::Model
+      attributes :title
+      # To confirm error is raised when cache_key is not set and cache_key option not passed to cache
+      undef_method :cache_key
+    end
+    class ArticleSerializer < ActiveModel::Serializer
+      cache only: [:place], skip_digest: true
+      attributes :title
+    end
+
+    class Author < ::Model
+      attributes :id, :name
+      associations :posts, :bio, :roles
+    end
+    # Instead of a primitive cache key (i.e. a string), this class
+    # returns a list of objects that require to be expanded themselves.
+    class AuthorWithExpandableCacheElements < Author
+      # For the test purposes it's important that #to_s for HasCacheKey differs
+      # between instances, hence not a Struct.
+      class HasCacheKey
+        attr_reader :cache_key
+        def initialize(cache_key)
+          @cache_key = cache_key
+        end
+
+        def to_s
+          "HasCacheKey##{object_id}"
+        end
+      end
+
+      def cache_key
+        [
+          HasCacheKey.new(name),
+          HasCacheKey.new(id)
+        ]
+      end
+    end
+    class UncachedAuthor < Author
+      # To confirm cache_key is set using updated_at and cache_key option passed to cache
+      undef_method :cache_key
+    end
+    class AuthorSerializer < ActiveModel::Serializer
+      cache key: 'writer', skip_digest: true
+      attributes :id, :name
+
+      has_many :posts
+      has_many :roles
+      has_one :bio
+    end
+    class AuthorSerializerWithCache < ActiveModel::Serializer
+      cache
+
+      attributes :name
+    end
+
+    class Blog < ::Model
+      attributes :name
+      associations :writer
+    end
+    class BlogSerializer < ActiveModel::Serializer
+      cache key: 'blog'
+      attributes :id, :name
+
+      belongs_to :writer
+    end
+
+    class Comment < ::Model
+      attributes :id, :body
+      associations :post, :author
+
+      # Uses a custom non-time-based cache key
+      def cache_key
+        "comment/#{id}"
+      end
+    end
+    class CommentSerializer < ActiveModel::Serializer
+      cache expires_in: 1.day, skip_digest: true
+      attributes :id, :body
+      belongs_to :post
+      belongs_to :author
+    end
+
+    class Post < ::Model
+      attributes :id, :title, :body
+      associations :author, :comments, :blog
+    end
+    class PostSerializer < ActiveModel::Serializer
+      cache key: 'post', expires_in: 0.1, skip_digest: true
+      attributes :id, :title, :body
+
+      has_many :comments
+      belongs_to :blog
+      belongs_to :author
+    end
+
+    class Role < ::Model
+      attributes :name, :description, :special_attribute
+      associations :author
+    end
+    class RoleSerializer < ActiveModel::Serializer
+      cache only: [:name, :slug], skip_digest: true
+      attributes :id, :name, :description
+      attribute :friendly_id, key: :slug
+      belongs_to :author
+
+      def friendly_id
+        "#{object.name}-#{object.id}"
+      end
+    end
+    class InheritedRoleSerializer < RoleSerializer
+      cache key: 'inherited_role', only: [:name, :special_attribute]
+      attribute :special_attribute
+    end
+
+    setup do
+      cache_store.clear
+      @comment        = Comment.new(id: 1, body: 'ZOMG A COMMENT')
+      @post           = Post.new(id: 'post', title: 'New Post', body: 'Body')
+      @bio            = Bio.new(id: 1, content: 'AMS Contributor')
+      @author         = Author.new(id: 'author', name: 'Joao M. D. Moura')
+      @blog           = Blog.new(id: 999, name: 'Custom blog', writer: @author)
+      @role           = Role.new(name: 'Great Author')
+      @location       = Location.new(lat: '-23.550520', lng: '-46.633309')
+      @place          = Place.new(name: 'Amazing Place')
+      @author.posts   = [@post]
+      @author.roles   = [@role]
+      @role.author    = @author
+      @author.bio     = @bio
+      @bio.author     = @author
+      @post.comments  = [@comment]
+      @post.author    = @author
+      @comment.post   = @post
+      @comment.author = @author
+      @post.blog      = @blog
+      @location.place = @place
+
+      @location_serializer = LocationSerializer.new(@location)
+      @bio_serializer      = BioSerializer.new(@bio)
+      @role_serializer     = RoleSerializer.new(@role)
+      @post_serializer     = PostSerializer.new(@post)
+      @author_serializer   = AuthorSerializer.new(@author)
+      @comment_serializer  = CommentSerializer.new(@comment)
+      @blog_serializer     = BlogSerializer.new(@blog)
+    end
+
+    def test_expiring_of_cache_at_update_of_record
+      original_cache_versioning = :none
+
+      if ARModels::Author.respond_to?(:cache_versioning)
+        original_cache_versioning = ARModels::Author.cache_versioning
+        ARModels::Author.cache_versioning = true
+      end
+
+      author = ARModels::Author.create(name: 'Foo')
+      author_json = AuthorSerializerWithCache.new(author).as_json
+
+      assert_equal 'Foo', author_json[:name]
+
+      author.update_attributes(name: 'Bar')
+      author_json = AuthorSerializerWithCache.new(author).as_json
+
+      expected = 'Bar'
+      actual = author_json[:name]
+      if ENV['APPVEYOR'] && actual != expected
+        skip('Cache expiration tests sometimes fail on Appveyor. FIXME :)')
+      else
+        assert_equal expected, actual
+      end
+    ensure
+      ARModels::Author.cache_versioning = original_cache_versioning unless original_cache_versioning == :none
+    end
+
+    def test_cache_expiration_in_collection_on_update_of_record
+      original_cache_versioning = :none
+
+      if ARModels::Author.respond_to?(:cache_versioning)
+        original_cache_versioning = ARModels::Author.cache_versioning
+        ARModels::Author.cache_versioning = true
+      end
+
+      foo               = 'Foo'
+      foo2              = 'Foo2'
+      author            = ARModels::Author.create(name: foo)
+      author2           = ARModels::Author.create(name: foo2)
+      author_collection = [author, author, author2]
+
+      collection_json = render_object_with_cache(author_collection, each_serializer: AuthorSerializerWithCache)
+      actual = collection_json
+      expected = [{ name: foo }, { name: foo }, { name: foo2 }]
+      if ENV['APPVEYOR'] && actual != expected
+        skip('Cache expiration tests sometimes fail on Appveyor. FIXME :)')
+      else
+        assert_equal expected, actual
+      end
+
+      bar = 'Bar'
+      author.update!(name: bar)
+
+      collection_json = render_object_with_cache(author_collection, each_serializer: AuthorSerializerWithCache)
+      assert_equal [{ name: bar }, { name: bar }, { name: foo2 }], collection_json
+    ensure
+      ARModels::Author.cache_versioning = original_cache_versioning unless original_cache_versioning == :none
+    end
+
+    def test_explicit_cache_store
+      default_store = Class.new(ActiveModel::Serializer) do
+        cache
+      end
+      explicit_store = Class.new(ActiveModel::Serializer) do
+        cache cache_store: ActiveSupport::Cache::FileStore
+      end
+
+      assert ActiveSupport::Cache::MemoryStore, ActiveModelSerializers.config.cache_store
+      assert ActiveSupport::Cache::MemoryStore, default_store.cache_store
+      assert ActiveSupport::Cache::FileStore, explicit_store.cache_store
+    end
+
+    def test_inherited_cache_configuration
+      inherited_serializer = Class.new(PostSerializer)
+
+      assert_equal PostSerializer._cache_key, inherited_serializer._cache_key
+      assert_equal PostSerializer._cache_options, inherited_serializer._cache_options
+    end
+
+    def test_override_cache_configuration
+      inherited_serializer = Class.new(PostSerializer) do
+        cache key: 'new-key'
+      end
+
+      assert_equal PostSerializer._cache_key, 'post'
+      assert_equal inherited_serializer._cache_key, 'new-key'
+    end
+
+    def test_cache_definition
+      assert_equal(cache_store, @post_serializer.class._cache)
+      assert_equal(cache_store, @author_serializer.class._cache)
+      assert_equal(cache_store, @comment_serializer.class._cache)
+    end
+
+    def test_cache_key_definition
+      assert_equal('post', @post_serializer.class._cache_key)
+      assert_equal('writer', @author_serializer.class._cache_key)
+      assert_nil(@comment_serializer.class._cache_key)
+    end
+
+    def test_cache_key_interpolation_with_updated_at_when_cache_key_is_not_defined_on_object
+      uncached_author            = UncachedAuthor.new(name: 'Joao M. D. Moura')
+      uncached_author_serializer = AuthorSerializer.new(uncached_author)
+
+      render_object_with_cache(uncached_author)
+      key = "#{uncached_author_serializer.class._cache_key}/#{uncached_author_serializer.object.id}-#{uncached_author_serializer.object.updated_at.strftime('%Y%m%d%H%M%S%9N')}"
+      key = "#{key}/#{adapter.cache_key}"
+      assert_equal(uncached_author_serializer.attributes.to_json, cache_store.fetch(key).to_json)
+    end
+
+    def test_cache_key_expansion
+      author = AuthorWithExpandableCacheElements.new(id: 10, name: 'hello')
+      same_author = AuthorWithExpandableCacheElements.new(id: 10, name: 'hello')
+      diff_author = AuthorWithExpandableCacheElements.new(id: 11, name: 'hello')
+
+      author_serializer = AuthorSerializer.new(author)
+      same_author_serializer = AuthorSerializer.new(same_author)
+      diff_author_serializer = AuthorSerializer.new(diff_author)
+      adapter = AuthorSerializer.serialization_adapter_instance
+
+      assert_equal(author_serializer.cache_key(adapter), same_author_serializer.cache_key(adapter))
+      refute_equal(author_serializer.cache_key(adapter), diff_author_serializer.cache_key(adapter))
+    end
+
+    def test_default_cache_key_fallback
+      render_object_with_cache(@comment)
+      key = "#{@comment.cache_key}/#{adapter.cache_key}"
+      assert_equal(@comment_serializer.attributes.to_json, cache_store.fetch(key).to_json)
+    end
+
+    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 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 'ActiveModelSerializers::CacheTest::ArticleSerializer.cache'/, e.message)
+    end
+
+    def test_cache_options_definition
+      assert_equal({ expires_in: 0.1, skip_digest: true }, @post_serializer.class._cache_options)
+      assert_nil(@blog_serializer.class._cache_options)
+      assert_equal({ expires_in: 1.day, skip_digest: true }, @comment_serializer.class._cache_options)
+    end
+
+    def test_fragment_cache_definition
+      assert_equal([:name, :slug], @role_serializer.class._cache_only)
+      assert_equal([:content], @bio_serializer.class._cache_except)
+    end
+
+    def test_associations_separately_cache
+      cache_store.clear
+      assert_nil(cache_store.fetch(@post.cache_key))
+      assert_nil(cache_store.fetch(@comment.cache_key))
+
+      Timecop.freeze(Time.current) do
+        render_object_with_cache(@post)
+
+        key = "#{@post.cache_key}/#{adapter.cache_key}"
+        assert_equal(@post_serializer.attributes, cache_store.fetch(key))
+        key = "#{@comment.cache_key}/#{adapter.cache_key}"
+        assert_equal(@comment_serializer.attributes, cache_store.fetch(key))
+      end
+    end
+
+    def test_associations_cache_when_updated
+      Timecop.freeze(Time.current) do
+        # Generate a new Cache of Post object and each objects related to it.
+        render_object_with_cache(@post)
+
+        # Check if it cached the objects separately
+        key = "#{@post.cache_key}/#{adapter.cache_key}"
+        assert_equal(@post_serializer.attributes, cache_store.fetch(key))
+        key = "#{@comment.cache_key}/#{adapter.cache_key}"
+        assert_equal(@comment_serializer.attributes, cache_store.fetch(key))
+
+        # Simulating update on comments relationship with Post
+        new_comment            = Comment.new(id: 2567, body: 'ZOMG A NEW COMMENT')
+        new_comment_serializer = CommentSerializer.new(new_comment)
+        @post.comments         = [new_comment]
+
+        # Ask for the serialized object
+        render_object_with_cache(@post)
+
+        # Check if the the new comment was cached
+        key = "#{new_comment.cache_key}/#{adapter.cache_key}"
+        assert_equal(new_comment_serializer.attributes, cache_store.fetch(key))
+        key = "#{@post.cache_key}/#{adapter.cache_key}"
+        assert_equal(@post_serializer.attributes, cache_store.fetch(key))
+      end
+    end
+
+    def test_fragment_fetch_with_virtual_associations
+      expected_result = {
+        id: @location.id,
+        lat: @location.lat,
+        lng: @location.lng,
+        address: 'Nowhere'
+      }
+
+      hash = render_object_with_cache(@location)
+
+      assert_equal(hash, expected_result)
+      key = "#{@location.cache_key}/#{adapter.cache_key}"
+      assert_equal({ address: 'Nowhere' }, cache_store.fetch(key))
+    end
+
+    def test_fragment_cache_with_inheritance
+      inherited = render_object_with_cache(@role, serializer: InheritedRoleSerializer)
+      base = render_object_with_cache(@role)
+
+      assert_includes(inherited.keys, :special_attribute)
+      refute_includes(base.keys, :special_attribute)
+    end
+
+    def test_uses_adapter_in_cache_key
+      render_object_with_cache(@post)
+      key = "#{@post.cache_key}/#{adapter.class.to_s.demodulize.underscore}"
+      assert_equal(@post_serializer.attributes, cache_store.fetch(key))
+    end
+
+    # Based on original failing test by @kevintyll
+    # rubocop:disable Metrics/AbcSize
+    def test_a_serializer_rendered_by_two_adapter_returns_differently_fetch_attributes
+      Object.const_set(:Alert, Class.new(ActiveModelSerializers::Model) do
+        attributes :id, :status, :resource, :started_at, :ended_at, :updated_at, :created_at
+      end)
+      Object.const_set(:UncachedAlertSerializer, Class.new(ActiveModel::Serializer) do
+        attributes :id, :status, :resource, :started_at, :ended_at, :updated_at, :created_at
+      end)
+      Object.const_set(:AlertSerializer, Class.new(UncachedAlertSerializer) do
+        cache
+      end)
+
+      alert = Alert.new(
+        id: 1,
+        status: 'fail',
+        resource: 'resource-1',
+        started_at: Time.new(2016, 3, 31, 21, 36, 35, 0),
+        ended_at: nil,
+        updated_at: Time.new(2016, 3, 31, 21, 27, 35, 0),
+        created_at: Time.new(2016, 3, 31, 21, 37, 35, 0)
+      )
+
+      expected_fetch_attributes = {
+        id: 1,
+        status: 'fail',
+        resource: 'resource-1',
+        started_at: alert.started_at,
+        ended_at: nil,
+        updated_at: alert.updated_at,
+        created_at: alert.created_at
+      }.with_indifferent_access
+      expected_cached_jsonapi_attributes = {
+        id: '1',
+        type: 'alerts',
+        attributes: {
+          status: 'fail',
+          resource: 'resource-1',
+          started_at: alert.started_at,
+          ended_at: nil,
+          updated_at: alert.updated_at,
+          created_at: alert.created_at
+        }
+      }.with_indifferent_access
+
+      # Assert attributes are serialized correctly
+      serializable_alert = serializable(alert, serializer: AlertSerializer, adapter: :attributes)
+      attributes_serialization = serializable_alert.as_json.with_indifferent_access
+      assert_equal expected_fetch_attributes, alert.attributes
+      assert_equal alert.attributes, attributes_serialization
+      attributes_cache_key = serializable_alert.adapter.serializer.cache_key(serializable_alert.adapter)
+      assert_equal attributes_serialization, cache_store.fetch(attributes_cache_key).with_indifferent_access
+
+      serializable_alert = serializable(alert, serializer: AlertSerializer, adapter: :json_api)
+      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
+      jsonapi_serialization = serializable_alert.as_json
+      assert_equal alert.status, jsonapi_serialization.fetch(:data).fetch(:attributes).fetch(:status)
+      serializable_alert = serializable(alert, serializer: UncachedAlertSerializer, adapter: :json_api)
+      assert_equal serializable_alert.as_json, jsonapi_serialization
+
+      cached_serialization = cache_store.fetch(jsonapi_cache_key).with_indifferent_access
+      assert_equal expected_cached_jsonapi_attributes, cached_serialization
+    ensure
+      Object.send(:remove_const, :Alert)
+      Object.send(:remove_const, :AlertSerializer)
+      Object.send(:remove_const, :UncachedAlertSerializer)
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def test_uses_file_digest_in_cache_key
+      render_object_with_cache(@blog)
+      file_digest = Digest::MD5.hexdigest(File.open(__FILE__).read)
+      key = "#{@blog.cache_key}/#{adapter.cache_key}/#{file_digest}"
+      assert_equal(@blog_serializer.attributes, cache_store.fetch(key))
+    end
+
+    def test_cache_digest_definition
+      file_digest = Digest::MD5.hexdigest(File.open(__FILE__).read)
+      assert_equal(file_digest, @post_serializer.class._cache_digest)
+    end
+
+    def test_object_cache_keys
+      serializable = ActiveModelSerializers::SerializableResource.new([@comment, @comment])
+      include_directive = JSONAPI::IncludeDirective.new('*', allow_wildcard: true)
+
+      actual = ActiveModel::Serializer.object_cache_keys(serializable.adapter.serializer, serializable.adapter, include_directive)
+
+      assert_equal 3, actual.size
+      expected_key = "comment/1/#{serializable.adapter.cache_key}"
+      assert actual.any? { |key| key == expected_key }, "actual '#{actual}' should include #{expected_key}"
+      expected_key = %r{post/post-\d+}
+      assert actual.any? { |key| key =~ expected_key }, "actual '#{actual}' should match '#{expected_key}'"
+      expected_key = %r{author/author-\d+}
+      assert actual.any? { |key| key =~ expected_key }, "actual '#{actual}' should match '#{expected_key}'"
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def test_fetch_attributes_from_cache
+      serializers = ActiveModel::Serializer::CollectionSerializer.new([@comment, @comment])
+
+      Timecop.freeze(Time.current) do
+        render_object_with_cache(@comment)
+
+        options = {}
+        adapter_options = {}
+        adapter_instance = ActiveModelSerializers::Adapter::Attributes.new(serializers, adapter_options)
+        serializers.serializable_hash(adapter_options, options, adapter_instance)
+        cached_attributes = options.fetch(:cached_attributes).with_indifferent_access
+
+        include_directive = ActiveModelSerializers.default_include_directive
+        manual_cached_attributes = ActiveModel::Serializer.cache_read_multi(serializers, adapter_instance, include_directive).with_indifferent_access
+        assert_equal manual_cached_attributes, cached_attributes
+
+        assert_equal cached_attributes["#{@comment.cache_key}/#{adapter_instance.cache_key}"], Comment.new(id: 1, body: 'ZOMG A COMMENT').attributes
+        assert_equal cached_attributes["#{@comment.post.cache_key}/#{adapter_instance.cache_key}"], Post.new(id: 'post', title: 'New Post', body: 'Body').attributes
+
+        writer = @comment.post.blog.writer
+        writer_cache_key = writer.cache_key
+        assert_equal cached_attributes["#{writer_cache_key}/#{adapter_instance.cache_key}"], Author.new(id: 'author', name: 'Joao M. D. Moura').attributes
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def test_cache_read_multi_with_fragment_cache_enabled
+      post_serializer = Class.new(ActiveModel::Serializer) do
+        cache except: [:body]
+      end
+
+      serializers = ActiveModel::Serializer::CollectionSerializer.new([@post, @post], serializer: post_serializer)
+
+      Timecop.freeze(Time.current) do
+        # Warming up.
+        options = {}
+        adapter_options = {}
+        adapter_instance = ActiveModelSerializers::Adapter::Attributes.new(serializers, adapter_options)
+        serializers.serializable_hash(adapter_options, options, adapter_instance)
+
+        # Should find something with read_multi now
+        options = {}
+        serializers.serializable_hash(adapter_options, options, adapter_instance)
+        cached_attributes = options.fetch(:cached_attributes)
+
+        include_directive = ActiveModelSerializers.default_include_directive
+        manual_cached_attributes = ActiveModel::Serializer.cache_read_multi(serializers, adapter_instance, include_directive)
+
+        refute_equal 0, cached_attributes.size
+        refute_equal 0, manual_cached_attributes.size
+        assert_equal manual_cached_attributes, cached_attributes
+      end
+    end
+
+    def test_serializer_file_path_on_nix
+      path = '/Users/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb'
+      caller_line = "#{path}:1:in `<top (required)>'"
+      assert_equal caller_line[ActiveModel::Serializer::CALLER_FILE], path
+    end
+
+    def test_serializer_file_path_on_windows
+      path = 'c:/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb'
+      caller_line = "#{path}:1:in `<top (required)>'"
+      assert_equal caller_line[ActiveModel::Serializer::CALLER_FILE], path
+    end
+
+    def test_serializer_file_path_with_space
+      path = '/Users/git/ember js/ember-crm-backend/app/serializers/lead_serializer.rb'
+      caller_line = "#{path}:1:in `<top (required)>'"
+      assert_equal caller_line[ActiveModel::Serializer::CALLER_FILE], path
+    end
+
+    def test_serializer_file_path_with_submatch
+      # The submatch in the path ensures we're using a correctly greedy regexp.
+      path = '/Users/git/ember js/ember:123:in x/app/serializers/lead_serializer.rb'
+      caller_line = "#{path}:1:in `<top (required)>'"
+      assert_equal caller_line[ActiveModel::Serializer::CALLER_FILE], path
+    end
+
+    def test_digest_caller_file
+      contents = "puts 'AMS rocks'!"
+      dir = Dir.mktmpdir('space char')
+      file = Tempfile.new('some_ruby.rb', dir)
+      file.write(contents)
+      path = file.path
+      caller_line = "#{path}:1:in `<top (required)>'"
+      file.close
+      assert_equal ActiveModel::Serializer.digest_caller_file(caller_line), Digest::MD5.hexdigest(contents)
+    ensure
+      file.unlink
+      FileUtils.remove_entry dir
+    end
+
+    def test_warn_on_serializer_not_defined_in_file
+      called = false
+      serializer = Class.new(ActiveModel::Serializer)
+      assert_output(nil, /_cache_digest/) do
+        serializer.digest_caller_file('')
+        called = true
+      end
+      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)
+      adapter_instance = ActiveModelSerializers::Adapter.configured_adapter.new(role_serializer)
+      expected_result = {
+        id: role.id,
+        description: role.description,
+        slug: "#{role.name}-#{role.id}",
+        name: role.name
+      }
+      cache_store.clear
+
+      role_hash = role_serializer.fetch_attributes_fragment(adapter_instance)
+      assert_equal(role_hash, expected_result)
+
+      role.id = 'this has been updated'
+      role.name = 'this was cached'
+
+      role_hash = role_serializer.fetch_attributes_fragment(adapter_instance)
+      assert_equal(expected_result.merge(id: role.id), role_hash)
+    end
+
+    def test_fragment_fetch_with_except
+      adapter_instance = ActiveModelSerializers::Adapter.configured_adapter.new(@bio_serializer)
+      expected_result = {
+        id: @bio.id,
+        rating: nil,
+        content: @bio.content
+      }
+      cache_store.clear
+
+      bio_hash = @bio_serializer.fetch_attributes_fragment(adapter_instance)
+      assert_equal(expected_result, bio_hash)
+
+      @bio.content = 'this has been updated'
+      @bio.rating = 'this was cached'
+
+      bio_hash = @bio_serializer.fetch_attributes_fragment(adapter_instance)
+      assert_equal(expected_result.merge(content: @bio.content), bio_hash)
+    end
+
+    def test_fragment_fetch_with_namespaced_object
+      @spam            = Spam::UnrelatedLink.new(id: 'spam-id-1')
+      @spam_serializer = Spam::UnrelatedLinkSerializer.new(@spam)
+      adapter_instance = ActiveModelSerializers::Adapter.configured_adapter.new(@spam_serializer)
+      @spam_hash       = @spam_serializer.fetch_attributes_fragment(adapter_instance)
+      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
+    end
+
+    def adapter
+      @serializable_resource.adapter
+    end
+  end
+end