identity_cache 0.0.7 → 0.1.0

data/lib/identity_cache.rb

@@ -10,9 +10,11 @@ require 'identity_cache/configuration_dsl'
 require 'identity_cache/parent_model_expiration'
 require 'identity_cache/query_api'
 require "identity_cache/cache_hash"
+require "identity_cache/cache_invalidation"
 
 module IdentityCache
   CACHED_NIL = :idc_cached_nil
+  BATCH_SIZE = 1000
 
   class AlreadyIncludedError < StandardError; end
   class InverseAssociationError < StandardError
@@ -38,6 +40,7 @@ module IdentityCache
       base.send(:include, IdentityCache::CacheKeyGeneration)
       base.send(:include, IdentityCache::ConfigurationDSL)
       base.send(:include, IdentityCache::QueryAPI)
+      base.send(:include, IdentityCache::CacheInvalidation)
     end
 
     # Sets the cache adaptor IdentityCache will be using
@@ -73,7 +76,7 @@ module IdentityCache
     # == Parameters
     # +key+ A cache key string
     #
-    def fetch(key, &block)
+    def fetch(key)
       result = cache.read(key) if should_cache?
 
       if result.nil?
@@ -99,16 +102,17 @@ module IdentityCache
     end
 
     # Same as +fetch+, except that it will try a collection of keys, using the
-    # multiget operation of the cache adaptor
+    # multiget operation of the cache adaptor.
     #
     # == Parameters
-    # +keys+ A collection of key strings
-    def fetch_multi(*keys, &block)
+    # +keys+ A collection or array of key strings
+    def fetch_multi(*keys)
+      keys.flatten!(1)
       return {} if keys.size == 0
       result = {}
-      result = cache.read_multi(*keys) if should_cache?
+      result = read_in_batches(keys) if should_cache?
 
-      hit_keys = result.select {|key, value| value.present? }.keys
+      hit_keys = result.reject {|key, value| value == nil }.keys
       missed_keys = keys - hit_keys
 
       if missed_keys.size > 0
@@ -127,11 +131,19 @@ module IdentityCache
       end
 
 
-      result.keys.each do |key|
-        result[key] = unmap_cached_nil_for(result[key])
+      result.each do |key, value|
+        result[key] = unmap_cached_nil_for(value)
       end
 
       result
     end
+
+    private
+
+    def read_in_batches(keys)
+      keys.each_slice(BATCH_SIZE).each_with_object Hash.new do |slice, result|
+        result.merge! cache.read_multi(*slice)
+      end
+    end
   end
 end

data/performance/cache_runner.rb

@@ -16,7 +16,10 @@ end
 
 require File.dirname(__FILE__) + '/../test/helpers/active_record_objects'
 require File.dirname(__FILE__) + '/../test/helpers/database_connection'
-require File.dirname(__FILE__) + '/../test/helpers/cache'
+
+IdentityCache.logger = Logger.new(nil)
+IdentityCache.cache_backend = ActiveSupport::Cache::MemcachedStore.new("localhost:#{$memcached_port}")
+
 
 def create_record(id)
   Item.new(id)
@@ -85,7 +88,7 @@ CACHE_RUNNERS = []
 class FindRunner < CacheRunner
   def run
     (1..@count).each do |i|
-      ::Item.find(i, :include => [:associated, {:associated_records => :deeply_associated_records}])
+      ::Item.includes(:associated, {:associated_records => :deeply_associated_records}).find(i)
     end
   end
 end
@@ -137,8 +140,8 @@ class NormalizedRunner < CacheRunner
   def setup_models
     super
     Item.cache_has_one :associated # :embed => false isn't supported
-    Item.cache_has_many :associated_records, :embed => false
-    AssociatedRecord.cache_has_many :deeply_associated_records, :embed => false
+    Item.cache_has_many :associated_records, :embed => :ids
+    AssociatedRecord.cache_has_many :deeply_associated_records, :embed => :ids
   end
 
   def run

data/performance/profile.rb

@@ -6,13 +6,14 @@ require_relative 'cache_runner'
 
 RUNS = 1000
 
-def run(obj)
+def run(obj, filename: nil)
   puts "#{obj.class.name}:"
   obj.prepare
   data = StackProf.run(mode: :cpu) do
     obj.run
   end
   StackProf::Report.new(data).print_text(false, 20)
+  File.write(filename, Marshal.dump(data)) if filename
   puts
 ensure
   obj.cleanup
@@ -20,6 +21,15 @@ end
 
 create_database(RUNS)
 
-CACHE_RUNNERS.each do |runner|
-  run(runner.new(RUNS))
+if runner_name = ENV['RUNNER']
+  if runner = CACHE_RUNNERS.find{ |r| r.name == runner_name }
+    run(runner.new(RUNS), filename: ENV['FILENAME'])
+  else
+    puts "Couldn't find cache runner #{runner_name.inspect}"
+    exit 1
+  end
+else
+  CACHE_RUNNERS.each do |runner|
+    run(runner.new(RUNS))
+  end
 end

data/test/attribute_cache_test.rb

@@ -20,7 +20,10 @@ class AttributeCacheTest < IdentityCache::TestCase
 
   def test_attribute_values_are_fetched_and_returned_on_cache_misses
     IdentityCache.cache.expects(:read).with(@name_attribute_key).returns(nil)
-    Item.connection.expects(:select_value).with("SELECT `name` FROM `associated_records` WHERE `id` = 1 LIMIT 1").returns('foo')
+    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)
   end
 
@@ -29,7 +32,9 @@ class AttributeCacheTest < IdentityCache::TestCase
     IdentityCache.cache.expects(:read).with(@name_attribute_key).returns(nil)
 
     # Grab the value of the attribute from the DB
-    Item.connection.expects(:select_value).with("SELECT `name` FROM `associated_records` WHERE `id` = 1 LIMIT 1").returns('foo')
+    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']]))
 
     # And write it back to the cache
     IdentityCache.cache.expects(:write).with(@name_attribute_key, 'foo').returns(nil)
@@ -42,7 +47,9 @@ class AttributeCacheTest < IdentityCache::TestCase
     IdentityCache.cache.expects(:read).with(@name_attribute_key).returns(nil)
 
     # Grab the value of the attribute from the DB
-    Item.connection.expects(:select_value).with("SELECT `name` FROM `associated_records` WHERE `id` = 1 LIMIT 1").returns(nil)
+    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'], []))
 
     # And write it back to the cache
     IdentityCache.cache.expects(:write).with(@name_attribute_key, IdentityCache::CACHED_NIL).returns(nil)
@@ -81,7 +88,9 @@ class AttributeCacheTest < IdentityCache::TestCase
   def test_fetching_by_attribute_delegates_to_block_if_transactions_are_open
     IdentityCache.cache.expects(:read).with(@name_attribute_key).never
 
-    Item.connection.expects(:select_value).with("SELECT `name` FROM `associated_records` WHERE `id` = 1 LIMIT 1").returns('foo')
+    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']]))
 
     @record.transaction do
       assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)

data/test/cache_fetch_includes_test.rb

@@ -11,7 +11,7 @@ class CacheFetchIncludesTest < IdentityCache::TestCase
   end
 
   def test_cached_nonembedded_has_manys_are_included_in_includes
-    Item.send(:cache_has_many, :associated_records, :embed => false)
+    Item.send(:cache_has_many, :associated_records, :embed => :ids)
     assert_equal [], Item.send(:cache_fetch_includes)
   end
 
@@ -42,47 +42,4 @@ class CacheFetchIncludesTest < IdentityCache::TestCase
       {:associated => [:deeply_associated_records]}
     ],  Item.send(:cache_fetch_includes)
   end
-
-  def test_empty_additions_for_top_level_associations_makes_no_difference
-    Item.send(:cache_has_many, :associated_records, :embed => true)
-    assert_equal [:associated_records], Item.send(:cache_fetch_includes, {})
-  end
-
-  def test_top_level_additions_are_included_in_includes
-    assert_equal [{:associated_records => []}], Item.send(:cache_fetch_includes, {:associated_records => []})
-  end
-
-  def test_top_level_additions_alongside_top_level_cached_associations_are_included_in_includes
-    Item.send(:cache_has_many, :associated_records, :embed => true)
-    assert_equal [
-      :associated_records,
-      {:polymorphic_records => []}
-    ], Item.send(:cache_fetch_includes, {:polymorphic_records => []})
-  end
-
-  def test_child_level_additions_for_top_level_cached_associations_are_included_in_includes
-    Item.send(:cache_has_many, :associated_records, :embed => true)
-    assert_equal [
-      {:associated_records => [{:deeply_associated_records => []}]}
-    ], Item.send(:cache_fetch_includes, {:associated_records => :deeply_associated_records})
-  end
-
-  def test_array_child_level_additions_for_top_level_cached_associations_are_included_in_includes
-    Item.send(:cache_has_many, :associated_records, :embed => true)
-    assert_equal [
-      {:associated_records => [{:deeply_associated_records => []}]}
-    ], Item.send(:cache_fetch_includes, {:associated_records => [:deeply_associated_records]})
-  end
-
-  def test_array_child_level_additions_for_child_level_cached_associations_are_included_in_includes
-    Item.send(:cache_has_many, :associated_records, :embed => true)
-    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => true)
-    assert_equal [
-      {:associated_records => [
-        :deeply_associated_records,
-        {:record => []}
-      ]}
-    ], Item.send(:cache_fetch_includes, {:associated_records => [:record]})
-  end
-
 end

data/test/cache_invalidation_test.rb

@@ -0,0 +1,52 @@
+require "test_helper"
+
+class CacheInvalidationTest < IdentityCache::TestCase
+  def setup
+    super
+    Item.cache_has_many :associated_records, :embed => :ids
+
+    @record = Item.new(:title => 'foo')
+    @record.associated_records << AssociatedRecord.new(:name => 'bar')
+    @record.associated_records << AssociatedRecord.new(:name => 'baz')
+    @record.save
+    @record.reload
+    @baz, @bar = @record.associated_records[0], @record.associated_records[1]
+  end
+
+  def test_reload_invalidate_cached_ids
+    variable_name = "@#{@record.class.send(:embedded_associations)[:associated_records][:ids_variable_name]}"
+
+    @record.fetch_associated_record_ids
+    assert_equal [@baz.id, @bar.id], @record.instance_variable_get(variable_name)
+
+    @record.reload
+    assert_equal nil, @record.instance_variable_get(variable_name)
+
+    @record.fetch_associated_record_ids
+    assert_equal [@baz.id, @bar.id], @record.instance_variable_get(variable_name)
+  end
+
+  def test_reload_invalidate_cached_objects
+    variable_name = "@#{@record.class.send(:embedded_associations)[:associated_records][:records_variable_name]}"
+
+    @record.fetch_associated_records
+    assert_equal [@baz, @bar], @record.instance_variable_get(variable_name)
+
+    @record.reload
+    assert_equal nil, @record.instance_variable_get(variable_name)
+
+    @record.fetch_associated_records
+    assert_equal [@baz, @bar], @record.instance_variable_get(variable_name)
+  end
+
+  def test_after_a_reload_the_cache_perform_as_expected
+    assert_equal [@baz, @bar], @record.associated_records
+    assert_equal [@baz, @bar], @record.fetch_associated_records
+
+    @baz.destroy
+    @record.reload
+
+    assert_equal [@bar], @record.associated_records
+    assert_equal [@bar], @record.fetch_associated_records
+  end
+end

data/test/denormalized_has_many_test.rb

@@ -54,13 +54,13 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
   def test_changes_in_associated_records_foreign_keys_should_expire_new_parent_and_old_parents_cache
     @associatated_record = @record.associated_records.first
     old_key = @record.primary_cache_index_key
-    @new_record = Item.create
+    @new_record = Item.create!
     new_key = @new_record.primary_cache_index_key
 
     IdentityCache.cache.expects(:delete).with(@associatated_record.primary_cache_index_key)
     IdentityCache.cache.expects(:delete).with(old_key)
     IdentityCache.cache.expects(:delete).with(new_key)
-    @associatated_record.item_id = @new_record.id
+    @associatated_record.item = @new_record
     @associatated_record.save!
   end
 
@@ -82,10 +82,10 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
     end
   end
 
-  def test_touching_associated_records_should_expire_itself_and_the_parents_cache
+  def test_saving_associated_records_should_expire_itself_and_the_parents_cache
     child = @record.associated_records.first
     IdentityCache.cache.expects(:delete).with(child.primary_cache_index_key).once
     IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key)
-    child.touch
+    child.save!
   end
 end

data/test/fetch_multi_test.rb

@@ -100,6 +100,18 @@ class FetchMultiTest < IdentityCache::TestCase
     assert_equal fetch_result, results
   end
 
+  def test_fetch_multi_works_with_blanks
+    cache_result = {1 => false, 2 => '   '}
+
+    IdentityCache.cache.expects(:read_multi).with(1,2).returns(cache_result)
+
+    results = IdentityCache.fetch_multi(1,2) do |keys|
+      flunk "Contents should have been fetched from cache successfully"
+    end
+
+    assert_equal cache_result, results
+  end
+
   def test_fetch_multi_duplicate_ids
     assert_equal [@joe, @bob, @joe], Item.fetch_multi(@joe.id, @bob.id, @joe.id)
   end
@@ -115,6 +127,11 @@ class FetchMultiTest < IdentityCache::TestCase
     assert_equal [@joe, @bob, @fred], Item.fetch_multi(@joe.id, @bob.id, @fred.id)
   end
 
+  def test_fetch_multi_with_open_transactions_should_compacts_returned_array
+    Item.connection.expects(:open_transactions).at_least_once.returns(1)
+    assert_equal [@joe, @fred], Item.fetch_multi(@joe.id, 0, @fred.id)
+  end
+
   def test_fetch_multi_with_duplicate_ids_in_transaction_returns_results_in_the_order_of_the_passed_ids
     Item.connection.expects(:open_transactions).at_least_once.returns(1)
     assert_equal [@joe, @bob, @joe], Item.fetch_multi(@joe.id, @bob.id, @joe.id)
@@ -138,6 +155,33 @@ class FetchMultiTest < IdentityCache::TestCase
     Item.fetch_multi(@bob.id, @joe.id)
   end
 
+  def test_fetch_multi_array
+    assert_equal [@joe, @bob], Item.fetch_multi([@joe.id, @bob.id])
+  end
+
+  def test_fetch_multi_reads_in_batches
+    cache_response = {}
+    cache_response[@bob_blob_key] = cache_response_for(@bob)
+    cache_response[@joe_blob_key] = cache_response_for(@joe)
+
+    with_batch_size 1 do
+      IdentityCache.cache.expects(:read_multi).with(@bob_blob_key).returns(cache_response).once
+      IdentityCache.cache.expects(:read_multi).with(@joe_blob_key).returns(cache_response).once
+      assert_equal [@bob, @joe], Item.fetch_multi(@bob.id, @joe.id)
+    end
+  end
+
+  def test_fetch_multi_max_stack_level
+    cache_response = { @fred_blob_key => cache_response_for(@fred) }
+    IdentityCache.cache.stubs(:read_multi).returns(cache_response)
+    assert_nothing_raised { Item.fetch_multi([@fred.id] * 200_000) }
+  end
+
+  def test_fetch_multi_with_non_id_primary_key
+    fixture = KeyedRecord.create!(:value => "a") { |r| r.hashed_key = 123 }
+    assert_equal [fixture], KeyedRecord.fetch_multi(123, 456)
+  end
+
   private
 
   def populate_only_fred
@@ -153,4 +197,14 @@ class FetchMultiTest < IdentityCache::TestCase
     record.encode_with(coder)
     coder
   end
+
+  def with_batch_size(size)
+    previous_batch_size = IdentityCache::BATCH_SIZE
+    IdentityCache.send(:remove_const, :BATCH_SIZE)
+    IdentityCache.const_set(:BATCH_SIZE, size)
+    yield
+  ensure
+    IdentityCache.send(:remove_const, :BATCH_SIZE)
+    IdentityCache.const_set(:BATCH_SIZE, previous_batch_size)
+  end
 end

data/test/fetch_multi_with_batched_associations_test.rb

@@ -14,44 +14,22 @@ class FetchMultiWithBatchedAssociationsTest < IdentityCache::TestCase
     @tenth_blob_key = "#{NAMESPACE}blob:Item:#{cache_hash("created_at:datetime,id:integer,item_id:integer,title:string,updated_at:datetime")}:10"
   end
 
-  def test_fetch_multi_includes_cached_associations_in_the_database_find
-    Item.send(:cache_has_many, :associated_records, :embed => true)
-    Item.send(:cache_has_one, :associated)
-    Item.send(:cache_belongs_to, :item)
-
-    cache_response = {}
-    cache_response[@bob_blob_key] = nil
-    cache_response[@joe_blob_key] = nil
-    cache_response[@fred_blob_key] = nil
-
-    IdentityCache.cache.expects(:read_multi).with(@bob_blob_key, @joe_blob_key, @fred_blob_key).returns(cache_response)
-
-    mock_relation = mock("ActiveRecord::Relation")
-    Item.expects(:where).returns(mock_relation)
-    mock_relation.expects(:includes).with([:associated_records, :associated]).returns(stub(:to_a => [@bob, @joe, @fred]))
-    assert_equal [@bob, @joe, @fred], Item.fetch_multi(@bob.id, @joe.id, @fred.id)
-  end
-
-  def test_fetch_multi_includes_cached_associations_and_other_asked_for_associations_in_the_database_find
-    Item.send(:cache_has_many, :associated_records, :embed => true)
-    Item.send(:cache_has_one, :associated)
+  def test_fetch_multi_with_includes_option_preloads_associations
     Item.send(:cache_belongs_to, :item)
+    john = Item.create!(:title => 'john')
+    jim = Item.create!(:title => 'jim')
+    @bob.update_column(:item_id, john)
+    @joe.update_column(:item_id, jim)
 
-    cache_response = {}
-    cache_response[@bob_blob_key] = nil
-    cache_response[@joe_blob_key] = nil
-    cache_response[@fred_blob_key] = nil
+    spy = Spy.on(Item, :fetch_multi).and_call_through
 
-    IdentityCache.cache.expects(:read_multi).with(@bob_blob_key, @joe_blob_key, @fred_blob_key).returns(cache_response)
+    items = Item.fetch_multi(@bob.id, @joe.id, @fred.id, :includes => :item)
 
-    mock_relation = mock("ActiveRecord::Relation")
-    Item.expects(:where).returns(mock_relation)
-    mock_relation.expects(:includes).with([:associated_records, :associated, {:item => []}]).returns(stub(:to_a => [@bob, @joe, @fred]))
-    assert_equal [@bob, @joe, @fred], Item.fetch_multi(@bob.id, @joe.id, @fred.id, {:includes => :item})
+    assert spy.calls.one?{ |call| call.args == [[john.id, jim.id]] }
   end
 
   def test_fetch_multi_batch_fetches_non_embedded_first_level_has_many_associations
-    Item.send(:cache_has_many, :associated_records, :embed => false)
+    Item.send(:cache_has_many, :associated_records, :embed => :ids)
 
     child_records = []
     [@bob, @joe].each do |parent|
@@ -103,8 +81,8 @@ class FetchMultiWithBatchedAssociationsTest < IdentityCache::TestCase
   end
 
   def test_fetch_multi_batch_fetches_non_embedded_second_level_has_many_associations
-    Item.send(:cache_has_many, :associated_records, :embed => false)
-    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => false)
+    Item.send(:cache_has_many, :associated_records, :embed => :ids)
+    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => :ids)
 
     child_records, grandchildren = setup_has_many_children_and_grandchildren(@bob, @joe)
 
@@ -159,7 +137,7 @@ class FetchMultiWithBatchedAssociationsTest < IdentityCache::TestCase
 
   def test_fetch_multi_batch_fetches_non_embedded_second_level_associations_through_embedded_first_level_has_many_associations
     Item.send(:cache_has_many, :associated_records, :embed => true)
-    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => false)
+    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => :ids)
 
     child_records, grandchildren = setup_has_many_children_and_grandchildren(@bob, @joe)
 
@@ -179,7 +157,7 @@ class FetchMultiWithBatchedAssociationsTest < IdentityCache::TestCase
 
   def test_fetch_multi_batch_fetches_non_embedded_second_level_associations_through_embedded_first_level_has_one_associations
     Item.send(:cache_has_one, :associated, :embed => true)
-    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => false)
+    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => :ids)
 
     @bob_child = @bob.create_associated!(:name => "bob child")
     @joe_child = @joe.create_associated!(:name => "joe child")

data/test/fetch_test.rb

@@ -17,6 +17,14 @@ class FetchTest < IdentityCache::TestCase
     @index_key = "#{NAMESPACE}index:Item:title:#{cache_hash('bob')}"
   end
 
+  def test_fetch_with_garbage_input
+    Item.connection.expects(:exec_query)
+      .with('SELECT  `items`.* FROM `items`  WHERE `items`.`id` = 0 LIMIT 1', anything)
+      .returns(ActiveRecord::Result.new([], []))
+
+    assert_equal nil, Item.fetch_by_id('garbage')
+  end
+
   def test_fetch_cache_hit
     IdentityCache.cache.expects(:read).with(@blob_key).returns(@cached_value)
 
@@ -64,6 +72,12 @@ class FetchTest < IdentityCache::TestCase
     assert_equal @record, Item.fetch(1)
   end
 
+  def test_fetch_miss_with_non_id_primary_key
+    hashed_key = Zlib::crc32("foo") % (2 ** 30 - 1)
+    fixture = KeyedRecord.create!(:value => "foo") { |r| r.hashed_key = hashed_key }
+    assert_equal fixture, KeyedRecord.fetch(hashed_key)
+  end
+
   def test_fetch_by_id_not_found_should_return_nil
     nonexistent_record_id = 10
     IdentityCache.cache.expects(:write).with(@blob_key + '0', IdentityCache::CACHED_NIL)
@@ -93,7 +107,7 @@ class FetchTest < IdentityCache::TestCase
     IdentityCache.cache.expects(:read).with(@index_key).returns(nil)
 
     # - not found, use sql, SELECT id FROM records WHERE title = '...' LIMIT 1"
-    Item.connection.expects(:select_value).returns(1)
+    Item.connection.expects(:exec_query).returns(ActiveRecord::Result.new(['id'], [[1]]))
 
     # cache sql result
     IdentityCache.cache.expects(:write).with(@index_key, 1)
@@ -113,17 +127,17 @@ class FetchTest < IdentityCache::TestCase
   end
 
   def test_fetch_by_title_stores_idcnil
-    Item.connection.expects(:select_value).once.returns(nil)
-    Rails.cache.expects(:write).with(@index_key, IdentityCache::CACHED_NIL)
-    Rails.cache.expects(:read).with(@index_key).times(3).returns(nil, IdentityCache::CACHED_NIL, IdentityCache::CACHED_NIL)
-    assert_equal nil, Item.fetch_by_title('bob') # select_value => nil
+    Item.connection.expects(:exec_query).once.returns(ActiveRecord::Result.new([], []))
+    IdentityCache.cache.expects(:write).with(@index_key, IdentityCache::CACHED_NIL)
+    IdentityCache.cache.expects(:read).with(@index_key).times(3).returns(nil, IdentityCache::CACHED_NIL, IdentityCache::CACHED_NIL)
+    assert_equal nil, Item.fetch_by_title('bob') # exec_query => nil
 
     assert_equal nil, Item.fetch_by_title('bob') # returns cached nil
     assert_equal nil, Item.fetch_by_title('bob') # returns cached nil
   end
 
   def test_fetch_by_bang_method
-    Item.connection.expects(:select_value).returns(nil)
+    Item.connection.expects(:exec_query).returns(ActiveRecord::Result.new([], []))
     assert_raises ActiveRecord::RecordNotFound do
       Item.fetch_by_title!('bob')
     end

data/test/helpers/active_record_objects.rb

@@ -26,7 +26,7 @@ module ActiveRecordObjects
 
     Object.send :const_set, 'AssociatedRecord', Class.new(base) {
       include IdentityCache
-      belongs_to :item
+      belongs_to :item, inverse_of: :associated_records
       has_many :deeply_associated_records
       default_scope { order('id DESC') }
     }
@@ -49,13 +49,18 @@ module ActiveRecordObjects
     Object.send :const_set, 'Item', Class.new(base) {
       include IdentityCache
       belongs_to :item
-      has_many :associated_records
+      has_many :associated_records, inverse_of: :item
       has_many :normalized_associated_records
       has_many :not_cached_records
       has_many :polymorphic_records, :as => 'owner'
       has_one :polymorphic_record, :as => 'owner'
       has_one :associated, :class_name => 'AssociatedRecord'
     }
+
+    Object.send :const_set, 'KeyedRecord', Class.new(base) {
+      include IdentityCache
+      self.primary_key = "hashed_key"
+    }
   end
 
   def teardown_models
@@ -67,5 +72,6 @@ module ActiveRecordObjects
     Object.send :remove_const, 'AssociatedRecord'
     Object.send :remove_const, 'NotCachedRecord'
     Object.send :remove_const, 'Item'
+    Object.send :remove_const, 'KeyedRecord'
   end
 end

data/test/helpers/database_connection.rb

@@ -17,7 +17,9 @@ module DatabaseConnection
 
   def self.create_tables
     TABLES.each do |table, fields|
-      ActiveRecord::Base.connection.create_table(table) do |t|
+      fields = fields.dup
+      options = fields.last.is_a?(Hash) ? fields.pop : {}
+      ActiveRecord::Base.connection.create_table(table, options) do |t|
         fields.each do |column_type, *args|
           t.send(column_type, *args)
         end
@@ -27,12 +29,13 @@ module DatabaseConnection
 
   TABLES = {
     :polymorphic_records           => [[:string, :owner_type], [:integer, :owner_id], [:timestamps]],
-    :deeply_associated_records     => [[:string, :name], [:integer, :associated_record_id]],
+    :deeply_associated_records     => [[:string, :name], [:integer, :associated_record_id], [:timestamps]],
     :associated_records            => [[:string, :name], [:integer, :item_id]],
-    :normalized_associated_records => [[:string, :name], [:integer, :item_id]],
-    :not_cached_records            => [[:string, :name], [:integer, :item_id]],
+    :normalized_associated_records => [[:string, :name], [:integer, :item_id], [:timestamps]],
+    :not_cached_records            => [[:string, :name], [:integer, :item_id], [:timestamps]],
     :items                         => [[:integer, :item_id], [:string, :title], [:timestamps]],
-    :items2                        => [[:integer, :item_id], [:string, :title], [:timestamps]]
+    :items2                        => [[:integer, :item_id], [:string, :title], [:timestamps]],
+    :keyed_records                 => [[:string, :value], :primary_key => "hashed_key"],
   }
 
   DATABASE_CONFIG = {

data/test/helpers/serialization_format.rb

@@ -4,17 +4,20 @@ module SerializationFormat
     AssociatedRecord.cache_belongs_to :item, :embed => false
     Item.cache_has_many :associated_records, :embed => true
     Item.cache_has_one :associated
+    time = Time.parse('1970-01-01T00:00:00 UTC')
 
     record = Item.new(:title => 'foo')
     record.associated_records << AssociatedRecord.new(:name => 'bar')
     record.associated_records << AssociatedRecord.new(:name => 'baz')
     record.associated = AssociatedRecord.new(:name => 'bork')
-    record.not_cached_records << NotCachedRecord.new(:name => 'NoCache')
-    record.associated.deeply_associated_records << DeeplyAssociatedRecord.new(:name => "corge")
-    record.associated.deeply_associated_records << DeeplyAssociatedRecord.new(:name => "qux")
-    record.created_at = Time.parse('1970-01-01T00:00:00 UTC')
+    record.not_cached_records << NotCachedRecord.new(:name => 'NoCache', created_at: time)
+    record.associated.deeply_associated_records << DeeplyAssociatedRecord.new(:name => "corge", created_at: time)
+    record.associated.deeply_associated_records << DeeplyAssociatedRecord.new(:name => "qux", created_at: time)
+    record.created_at = time
     record.save
-    Item.where(id: record.id).update_all(updated_at: record.created_at)
+    [Item, NotCachedRecord, DeeplyAssociatedRecord].each do |model|
+      model.update_all(updated_at: time)
+    end
     record.reload
     Item.fetch(record.id)
     IdentityCache.fetch(record.primary_cache_index_key)
@@ -29,6 +32,7 @@ module SerializationFormat
       :version => IdentityCache::CACHE_VERSION,
       :record => record
     }
+
     if anIO
       Marshal.dump(hash, anIO)
     else

data/test/helpers/update_serialization_format.rb

@@ -1,6 +1,7 @@
 $LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
 
 require 'active_record'
+require 'memcached_store'
 require_relative 'serialization_format'
 require_relative 'cache'
 require_relative 'database_connection'