identity_cache 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 477c35f8ea40ea8d71d6937d63ab1842a7321871
-  data.tar.gz: 2729aa2c8c4c06dcf42b8be9f167b88aa79cc81b
+  metadata.gz: 46228f11af3be0212c16960de9cb1d321ceac8db
+  data.tar.gz: bf0fca38334faff8e71ea229bf472570efc969ff
 SHA512:
-  metadata.gz: efaef756ca74582dfb7b8669933720f482d95da1493a2f2173e88c8f6cdc79861225858ebced572386e499140f9eb41ecf20a519d4db7c8363e7693141816d81
-  data.tar.gz: e11dff95ae3b78d4d57fd305eb961c4bd21e40e34a7fd08df8cf529369be841a0a75ededa64a47943e7328d10c045cb698744b070d4da2d5301ea0cdb652f61d
+  metadata.gz: bcaccc11973f744fb68e25572a0cb90fafd6ad559b2c54764c61c6fa9d894305b5c59a0ca32c6f01e24bf3e539b5834288641f830e3034b3871cd8aa3204dd6b
+  data.tar.gz: dfe2fafe9f1c65a78a972cc0369078a17442e168436896f5600b6d964c2cca6ff3fdd10a0998d63e2f65c7fbe77c22ea5a007b42c40c9ade132d443cd59d3a46

checksums.yaml.gz.sig

@@ -0,0 +1 @@
+�V�u�UnH�͏Q�	�jP4���;wB]����4�ݼ�(���c�4ߟ�j���`��(�cg�����>

data/.travis.yml

@@ -3,7 +3,6 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.1
-  - jruby
 gemfile:
   - Gemfile32
   - Gemfile
@@ -11,8 +10,5 @@ gemfile:
 services:
   - memcache
   - mysql
-matrix:
-  allow_failures:
-    - rvm: jruby
 before_script:
   - mysql -e 'create database identity_cache_test'

data/README.md

@@ -217,6 +217,10 @@ Since everything is being marshalled and unmarshalled from Memcached changing Ru
 
 IdentityCache is also very much _opt-in_ by deliberate design. This means IdentityCache does not mess with the way normal Rails associations work, and including it in a model won't change any clients of that model until you switch them to use `fetch` instead of `find`. This is because there is no way IdentityCache is ever going to be 100% consistent. Processes die, execeptions happen, and network blips occur, which means there is a chance that some database transaction might commit but the corresponding memcached DEL operation does not make it. This means that you need to think carefully about when you use `fetch` and when you use `find`. For example, at Shopify, we never use any `fetch`ers on the path which moves money around, because IdentityCache could simply be wrong, and we want to charge people the right amount of money. We do however use the fetchers on performance critical paths where absolute correctness isn't the most important thing, and this is what IdentityCache is intended for.
 
+## Note
+
+JRuby will not work with this current version, as we are using the memcached gem internally to interface with memcache.
+
 ## Contributing
 
 Caching is hard. Chances are that if some feature was left out, it was left out on purpose because it didn't make sense to cache in that way. This is used in production at Shopify so we are very opinionated about the types of features we're going to add. Please start the discussion early, before even adding code, so that we can talk about the feature you are proposing and decide if it makes sense in IdentityCache.
@@ -243,5 +247,5 @@ Harry Brundage (@hornairs)
 Dylan Smith (@dylanahsmith)  
 Tobias Lütke (@tobi)  
 John Duff (@jduff)  
-Francis Bogsany (@fbogsany)  
+Francis Bogsanyi (@fbogsany)
 Arthur Neves (@arthurnn)

data/identity_cache.gemspec

@@ -2,7 +2,7 @@
 require File.expand_path('../lib/identity_cache/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Camilo Lopez", "Tom Burns", "Harry Brundage", "Dylan Smith", "Tobias Lutke", "Arthur Neves"]
+  gem.authors       = ["Camilo Lopez", "Tom Burns", "Harry Brundage", "Dylan Smith", "Tobias Lutke", "Arthur Neves", "Francis Bogsanyi"]
   gem.email         = ["harry.brundage@shopify.com"]
   gem.description   = %q{Opt in read through ActiveRecord caching.}
   gem.summary       = %q{IdentityCache lets you specify how you want to cache your model objects, at the model level, and adds a number of convenience methods for accessing those objects through the cache. Memcached is used as the backend cache store, and the database is only hit when a copy of the object cannot be found in Memcached.}
@@ -17,16 +17,16 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency('ar_transaction_changes', '~> 1.0')
   gem.add_dependency('activerecord', '>= 3.2')
+  gem.add_dependency('memcached', '~> 1.8.0')
 
-  gem.add_development_dependency('memcached_store', '~> 0.11.2')
+  gem.add_development_dependency('memcached_store', '~> 0.12.5')
   gem.add_development_dependency('rake')
   gem.add_development_dependency('mocha', '0.14.0')
   gem.add_development_dependency('spy')
+  gem.add_development_dependency('minitest', '>= 2.11.0')
 
   if RUBY_PLATFORM == 'java'
-    gem.add_development_dependency 'jruby-openssl'
-    gem.add_development_dependency 'activerecord-jdbcmysql-adapter'
-    gem.add_development_dependency 'jdbc-mysql'
+    raise NotImplementedError
   else
     gem.add_development_dependency('cityhash', '0.6.0')
     gem.add_development_dependency('mysql2')

data/lib/identity_cache/cache_fetcher.rb

@@ -0,0 +1,84 @@
+module IdentityCache
+  class CacheFetcher
+    attr_accessor :cache_backend
+
+    def initialize(cache_backend = nil)
+      @cache_backend = cache_backend || Rails.cache
+    end
+
+    def write(key, value)
+      @cache_backend.write(key, value)
+    end
+
+    def delete(key)
+      @cache_backend.write(key, IdentityCache::DELETED, :expires_in => IdentityCache::DELETED_TTL.seconds)
+    end
+
+    def clear
+      @cache_backend.clear
+    end
+
+    def fetch_multi(keys, &block)
+      results = cas_multi(keys, &block)
+      results = add_multi(keys, &block) if results.nil?
+      results
+    end
+
+    def fetch(key)
+      result = nil
+      yielded = false
+      @cache_backend.cas(key) do |value|
+        yielded = true
+        unless IdentityCache::DELETED == value
+          result = value
+          break
+        end
+        result = yield
+      end
+      unless yielded
+        result = yield
+        add(key, result)
+      end
+      result
+    end
+
+    private
+
+    def cas_multi(keys)
+      result = nil
+      @cache_backend.cas_multi(*keys) do |results|
+        deleted = results.select {|_, v| IdentityCache::DELETED == v }
+        results.reject! {|_, v| IdentityCache::DELETED == v }
+
+        result = results
+        updates = {}
+        missed_keys = keys - results.keys
+        unless missed_keys.empty?
+          missed_vals = yield missed_keys
+          missed_keys.zip(missed_vals) do |k, v|
+            result[k] = v
+            if deleted.include?(k)
+              updates[k] = v
+            else
+              add(k, v)
+            end
+          end
+        end
+
+        break if updates.empty?
+        updates
+      end
+      result
+    end
+
+    def add_multi(keys)
+      values = yield keys
+      result = Hash[keys.zip(values)]
+      result.each {|k, v| add(k, v) }
+    end
+
+    def add(key, value)
+      @cache_backend.write(key, value, :unless_exist => true)
+    end
+  end
+end

data/lib/identity_cache/memoized_cache_proxy.rb

@@ -2,13 +2,17 @@ require 'monitor'
 
 module IdentityCache
   class MemoizedCacheProxy
-    attr_accessor :cache_backend
+    attr_reader :cache_fetcher
 
-    def initialize(cache_backend = nil)
-      @cache_backend = cache_backend || Rails.cache
+    def initialize(cache_adaptor = nil)
+      @cache_fetcher = CacheFetcher.new(cache_adaptor)
       @key_value_maps = Hash.new {|h, k| h[k] = {} }
     end
 
+    def cache_backend=(cache_adaptor)
+      @cache_fetcher.cache_backend = cache_adaptor
+    end
+
     def memoized_key_values
       @key_value_maps[Thread.current]
     end
@@ -23,52 +27,52 @@ module IdentityCache
 
     def write(key, value)
       memoized_key_values[key] = value if memoizing?
-      @cache_backend.write(key, value)
+      @cache_fetcher.write(key, value)
     end
 
-    def read(key)
-      used_cache_backend = true
+    def delete(key)
+      memoized_key_values.delete(key) if memoizing?
+      result = @cache_fetcher.delete(key)
+      IdentityCache.logger.debug { "[IdentityCache] delete #{ result ? 'recorded'  : 'failed'  } for #{key}" }
+      result
+    end
 
-      result = if memoizing?
+    def fetch(key)
+      used_cache_backend = true
+      missed = false
+      value = if memoizing?
         used_cache_backend = false
-        mkv = memoized_key_values
-
-        mkv.fetch(key) do
+        memoized_key_values.fetch(key) do
           used_cache_backend = true
-          mkv[key] = @cache_backend.read(key)
+          memoized_key_values[key] = @cache_fetcher.fetch(key) do
+            missed = true
+            yield
+          end
         end
-
       else
-        @cache_backend.read(key)
+        @cache_fetcher.fetch(key) do
+          missed = true
+          yield
+        end
       end
 
-      if result
-        IdentityCache.logger.debug { "[IdentityCache] #{ used_cache_backend ? '(cache_backend)'  : '(memoized)'  } cache hit for #{key}" }
-      else
+      if missed
         IdentityCache.logger.debug { "[IdentityCache] cache miss for #{key}" }
+      else
+        IdentityCache.logger.debug { "[IdentityCache] #{ used_cache_backend ? '(cache_backend)' : '(memoized)' } cache hit for #{key}" }
       end
 
-      result
+      value
     end
 
-    def delete(key)
-      memoized_key_values.delete(key) if memoizing?
-      result = @cache_backend.delete(key)
-      IdentityCache.logger.debug { "[IdentityCache] delete #{ result ? 'hit'  : 'miss'  } for #{key}" }
-      result
-    end
-
-    def read_multi(*keys)
-
-      if IdentityCache.logger.debug?
-        memoized_keys , cache_backend_keys = [], []
-      end
+    def fetch_multi(*keys)
+      memoized_keys, missed_keys = [], [] if IdentityCache.logger.debug?
 
       result = if memoizing?
         hash = {}
         mkv = memoized_key_values
 
-        missing_keys = keys.reject do |key|
+        non_memoized_keys = keys.reject do |key|
           if mkv.has_key?(key)
             memoized_keys << key if IdentityCache.logger.debug?
             hit = mkv[key]
@@ -77,34 +81,30 @@ module IdentityCache
           end
         end
 
-        hits =   missing_keys.empty? ? {} : @cache_backend.read_multi(*missing_keys)
-
-        missing_keys.each do |key|
-          hit = hits[key]
-          mkv[key] = hit
-          hash[key] = hit unless hit.nil?
+        unless non_memoized_keys.empty?
+          results = @cache_fetcher.fetch_multi(non_memoized_keys) do |missing_keys|
+            missed_keys.concat(missing_keys) if IdentityCache.logger.debug?
+            yield missing_keys
+          end
+          mkv.merge! results
+          hash.merge! results
         end
         hash
       else
-        @cache_backend.read_multi(*keys)
-      end
-
-      if IdentityCache.logger.debug?
-
-        result.each do |k, v|
-          cache_backend_keys << k if !v.nil? && !memoized_keys.include?(k)
+        @cache_fetcher.fetch_multi(keys) do |missing_keys|
+          missed_keys.concat(missing_keys) if IdentityCache.logger.debug?
+          yield missing_keys
         end
-
-        memoized_keys.each{ |k| IdentityCache.logger.debug "[IdentityCache] (memoized) cache hit for #{k} (multi)" }
-        cache_backend_keys.each{ |k| IdentityCache.logger.debug "[IdentityCache] (cache_backend) cache hit for #{k} (multi)" }
       end
 
+      log_multi_result(memoized_keys, keys - missed_keys - memoized_keys, missed_keys) if IdentityCache.logger.debug?
+
       result
     end
 
     def clear
       clear_memoization
-      @cache_backend.clear
+      @cache_fetcher.clear
     end
 
     private
@@ -116,5 +116,11 @@ module IdentityCache
     def memoizing?
       Thread.current[:memoizing_idc]
     end
+
+    def log_multi_result(memoized_keys, backend_keys, missed_keys)
+      memoized_keys.each {|k| IdentityCache.logger.debug "[IdentityCache] (memoized) cache hit for #{k} (multi)" }
+      backend_keys.each {|k| IdentityCache.logger.debug "[IdentityCache] (backend) cache hit for #{k} (multi)" }
+      missed_keys.each {|k| IdentityCache.logger.debug "[IdentityCache] cache miss for #{k} (multi)" }
+    end
   end
 end

data/lib/identity_cache/query_api.rb

@@ -84,22 +84,7 @@ module IdentityCache
             coder = coder.dup
             coder['attributes'] = coder['attributes'].dup
           end
-          if record.class._initialize_callbacks.empty?
-            record.instance_eval do
-              @attributes = self.class.initialize_attributes(coder['attributes'])
-              @relation = nil
-
-              @attributes_cache, @previously_changed, @changed_attributes = {}, {}, {}
-              @association_cache = {}
-              @aggregation_cache = {}
-              @_start_transaction_state = {}
-              @readonly = @destroyed = @marked_for_destruction = false
-              @new_record = false
-              @column_types = self.class.column_types if self.class.respond_to?(:column_types)
-            end
-          else
-            record.init_with(coder)
-          end
+          record.init_with(coder)
 
           coder[:associations].each {|name, value| set_embedded_association(record, name, value) } if coder.has_key?(:associations)
           coder[:normalized_has_many].each {|name, ids| record.instance_variable_set(:"@#{record.class.cached_has_manys[name][:ids_variable_name]}", ids) } if coder.has_key?(:normalized_has_many)

data/lib/identity_cache/version.rb

@@ -1,4 +1,4 @@
 module IdentityCache
-  VERSION = "0.1.0"
-  CACHE_VERSION = 3
+  VERSION = "0.2.0"
+  CACHE_VERSION = 4
 end

data/lib/identity_cache.rb

@@ -11,10 +11,13 @@ require 'identity_cache/parent_model_expiration'
 require 'identity_cache/query_api'
 require "identity_cache/cache_hash"
 require "identity_cache/cache_invalidation"
+require "identity_cache/cache_fetcher"
 
 module IdentityCache
   CACHED_NIL = :idc_cached_nil
   BATCH_SIZE = 1000
+  DELETED = :idc_cached_deleted
+  DELETED_TTL = 1000
 
   class AlreadyIncludedError < StandardError; end
   class InverseAssociationError < StandardError
@@ -77,20 +80,11 @@ module IdentityCache
     # +key+ A cache key string
     #
     def fetch(key)
-      result = cache.read(key) if should_cache?
-
-      if result.nil?
-        if block_given?
-          result = yield
-          result = map_cached_nil_for(result)
-
-          if should_cache?
-            cache.write(key, result)
-          end
-        end
+      if should_cache?
+        unmap_cached_nil_for(cache.fetch(key) { map_cached_nil_for yield })
+      else
+        yield
       end
-
-      unmap_cached_nil_for(result)
     end
 
     def map_cached_nil_for(value)
@@ -109,28 +103,17 @@ module IdentityCache
     def fetch_multi(*keys)
       keys.flatten!(1)
       return {} if keys.size == 0
-      result = {}
-      result = read_in_batches(keys) if should_cache?
-
-      hit_keys = result.reject {|key, value| value == nil }.keys
-      missed_keys = keys - hit_keys
-
-      if missed_keys.size > 0
-        if block_given?
-          replacement_results = nil
-          replacement_results = yield missed_keys
-          missed_keys.zip(replacement_results) do |(key, replacement_result)|
-            if should_cache?
-              replacement_result  = map_cached_nil_for(replacement_result )
-              cache.write(key, replacement_result)
-              logger.debug { "[IdentityCache] cache miss for #{key} (multi)" }
-            end
-            result[key] = replacement_result
-          end
+
+      result = if should_cache?
+        fetch_in_batches(keys) do |missed_keys|
+          results = yield missed_keys
+          results.map {|e| map_cached_nil_for e }
         end
+      else
+        results = yield keys
+        Hash[keys.zip(results)]
       end
 
-
       result.each do |key, value|
         result[key] = unmap_cached_nil_for(value)
       end
@@ -140,9 +123,9 @@ module IdentityCache
 
     private
 
-    def read_in_batches(keys)
+    def fetch_in_batches(keys)
       keys.each_slice(BATCH_SIZE).each_with_object Hash.new do |slice, result|
-        result.merge! cache.read_multi(*slice)
+        result.merge! cache.fetch_multi(*slice) {|missed_keys| yield missed_keys }
       end
     end
   end

data/performance/cache_runner.rb

@@ -6,19 +6,14 @@ require 'identity_cache'
 require 'memcached_store'
 require 'active_support/cache/memcached_store'
 
-if ENV['BOXEN_HOME'].present?
-  $memcached_port = 21211
-  $mysql_port = 13306
-else
-  $memcached_port = 11211
-  $mysql_port = 3306
-end
+$memcached_port = 11211
+$mysql_port = 3306
 
 require File.dirname(__FILE__) + '/../test/helpers/active_record_objects'
 require File.dirname(__FILE__) + '/../test/helpers/database_connection'
 
 IdentityCache.logger = Logger.new(nil)
-IdentityCache.cache_backend = ActiveSupport::Cache::MemcachedStore.new("localhost:#{$memcached_port}")
+IdentityCache.cache_backend = ActiveSupport::Cache::MemcachedStore.new("localhost:#{$memcached_port}", :support_cas => true)
 
 
 def create_record(id)
@@ -108,6 +103,35 @@ module HitRunner
   end
 end
 
+module DeletedRunner
+  def prepare
+    super
+    (1..@count).each {|i| ::Item.find(i).send(:expire_cache) }
+  end
+end
+
+module ConflictRunner
+  def prepare
+    super
+    records = (1..@count).map {|id| ::Item.find(id) }
+    orig_resolve_cache_miss = ::Item.method(:resolve_cache_miss)
+
+    ::Item.define_singleton_method(:resolve_cache_miss) do |id|
+      records[id-1].send(:expire_cache)
+      orig_resolve_cache_miss.call(id)
+    end
+    IdentityCache.cache.clear
+  end
+end
+
+module DeletedConflictRunner
+  include ConflictRunner
+  def prepare
+    super
+    (1..@count).each {|i| ::Item.find(i).send(:expire_cache) }
+  end
+end
+
 class EmbedRunner < CacheRunner
   def setup_models
     super
@@ -135,6 +159,20 @@ class FetchEmbedHitRunner < EmbedRunner
 end
 CACHE_RUNNERS << FetchEmbedHitRunner
 
+class FetchEmbedDeletedRunner < EmbedRunner
+  include DeletedRunner
+end
+CACHE_RUNNERS << FetchEmbedDeletedRunner
+
+class FetchEmbedConflictRunner < EmbedRunner
+  include ConflictRunner
+end
+CACHE_RUNNERS << FetchEmbedConflictRunner
+
+class FetchEmbedDeletedConflictRunner < EmbedRunner
+  include DeletedConflictRunner
+end
+CACHE_RUNNERS << FetchEmbedDeletedConflictRunner
 
 class NormalizedRunner < CacheRunner
   def setup_models
@@ -164,3 +202,18 @@ class FetchNormalizedHitRunner < NormalizedRunner
   include HitRunner
 end
 CACHE_RUNNERS << FetchNormalizedHitRunner
+
+class FetchNormalizedDeletedRunner < NormalizedRunner
+  include DeletedRunner
+end
+CACHE_RUNNERS << FetchNormalizedDeletedRunner
+
+class FetchNormalizedConflictRunner < EmbedRunner
+  include ConflictRunner
+end
+CACHE_RUNNERS << FetchNormalizedConflictRunner
+
+class FetchNormalizedDeletedConflictRunner < EmbedRunner
+  include DeletedConflictRunner
+end
+CACHE_RUNNERS << FetchNormalizedDeletedConflictRunner

data/shipit.rubygems.yml

@@ -0,0 +1 @@
+# using the default shipit config

data/test/attribute_cache_test.rb

@@ -11,25 +11,27 @@ class AttributeCacheTest < IdentityCache::TestCase
     @record = @parent.associated_records.create!(:name => 'foo')
     @name_attribute_key = "#{NAMESPACE}attribute:AssociatedRecord:name:id:#{cache_hash(@record.id.to_s)}"
     @blob_key = "#{NAMESPACE}blob:AssociatedRecord:#{cache_hash("id:integer,item_id:integer,name:string")}:1"
+    IdentityCache.cache.clear
   end
 
   def test_attribute_values_are_returned_on_cache_hits
-    IdentityCache.cache.expects(:read).with(@name_attribute_key).returns('foo')
+    IdentityCache.cache.expects(:fetch).with(@name_attribute_key).returns('foo')
     assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
   end
 
   def test_attribute_values_are_fetched_and_returned_on_cache_misses
-    IdentityCache.cache.expects(:read).with(@name_attribute_key).returns(nil)
+    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
     Item.connection.expects(:exec_query)
       .with('SELECT  `associated_records`.`name` FROM `associated_records`  WHERE `associated_records`.`id` = 1 LIMIT 1', anything)
       .returns(ActiveRecord::Result.new(['name'], [['foo']]))
 
     assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+    assert fetch.has_been_called_with?(@name_attribute_key)
   end
 
   def test_attribute_values_are_stored_in_the_cache_on_cache_misses
     # Cache miss, so
-    IdentityCache.cache.expects(:read).with(@name_attribute_key).returns(nil)
+    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
 
     # Grab the value of the attribute from the DB
     Item.connection.expects(:exec_query)
@@ -37,14 +39,17 @@ class AttributeCacheTest < IdentityCache::TestCase
       .returns(ActiveRecord::Result.new(['name'], [['foo']]))
 
     # And write it back to the cache
-    IdentityCache.cache.expects(:write).with(@name_attribute_key, 'foo').returns(nil)
+    add = Spy.on(fetcher, :add).and_call_through
 
     assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+    assert fetch.has_been_called_with?(@name_attribute_key)
+    assert add.has_been_called_with?(@name_attribute_key, 'foo')
+    assert_equal 'foo', IdentityCache.cache.fetch(@name_attribute_key)
   end
 
   def test_nil_is_stored_in_the_cache_on_cache_misses
     # Cache miss, so
-    IdentityCache.cache.expects(:read).with(@name_attribute_key).returns(nil)
+    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
 
     # Grab the value of the attribute from the DB
     Item.connection.expects(:exec_query)
@@ -52,9 +57,11 @@ class AttributeCacheTest < IdentityCache::TestCase
       .returns(ActiveRecord::Result.new(['name'], []))
 
     # And write it back to the cache
-    IdentityCache.cache.expects(:write).with(@name_attribute_key, IdentityCache::CACHED_NIL).returns(nil)
+    add = Spy.on(fetcher, :add).and_call_through
 
     assert_equal nil, AssociatedRecord.fetch_name_by_id(1)
+    assert fetch.has_been_called_with?(@name_attribute_key)
+    assert add.has_been_called_with?(@name_attribute_key, IdentityCache::CACHED_NIL)
   end
 
   def test_cached_attribute_values_are_expired_from_the_cache_when_an_existing_record_is_saved

data/test/denormalized_has_many_test.rb

@@ -44,7 +44,7 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
   def test_changes_in_associated_records_should_expire_the_parents_cache
     Item.fetch(@record.id)
     key = @record.primary_cache_index_key
-    assert_not_nil IdentityCache.cache.read(key)
+    assert_not_nil IdentityCache.cache.fetch(key)
 
     IdentityCache.cache.expects(:delete).with(@record.associated_records.first.primary_cache_index_key)
     IdentityCache.cache.expects(:delete).with(key)

data/test/denormalized_has_one_test.rb

@@ -13,14 +13,15 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
   end
 
   def test_on_cache_miss_record_should_embed_associated_object
-    IdentityCache.cache.expects(:read).with(@record.secondary_cache_index_key_for_current_values([:title]))
-    IdentityCache.cache.expects(:read).with(@record.primary_cache_index_key)
+    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
 
     record_from_cache_miss = Item.fetch_by_title('foo')
 
     assert_equal @record, record_from_cache_miss
     assert_not_nil @record.fetch_associated
     assert_equal @record.associated, record_from_cache_miss.fetch_associated
+    assert fetch.has_been_called_with?(@record.secondary_cache_index_key_for_current_values([:title]))
+    assert fetch.has_been_called_with?(@record.primary_cache_index_key)
   end
 
   def test_on_cache_miss_record_should_embed_nil_object
@@ -31,8 +32,7 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
     @record.send(:populate_association_caches)
     Item.expects(:resolve_cache_miss).with(@record.id).once.returns(@record)
 
-    IdentityCache.cache.expects(:read).with(@record.secondary_cache_index_key_for_current_values([:title]))
-    IdentityCache.cache.expects(:read).with(@record.primary_cache_index_key)
+    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
 
     record_from_cache_miss = Item.fetch_by_title('foo')
     record_from_cache_miss.expects(:associated).never
@@ -41,6 +41,8 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
     5.times do
       assert_nil record_from_cache_miss.fetch_associated
     end
+    assert fetch.has_been_called_with?(@record.secondary_cache_index_key_for_current_values([:title]))
+    assert fetch.has_been_called_with?(@record.primary_cache_index_key)
   end
 
   def test_on_record_from_the_db_will_use_normal_association
@@ -83,7 +85,7 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
   def test_changes_in_associated_record_should_expire_the_parents_cache
     Item.fetch_by_title('foo')
     key = @record.primary_cache_index_key
-    assert_not_nil IdentityCache.cache.read(key)
+    assert_not_nil IdentityCache.cache.fetch(key)
 
     IdentityCache.cache.expects(:delete).at_least(1).with(key)
     IdentityCache.cache.expects(:delete).with(@record.associated.primary_cache_index_key)