identity_cache 0.0.2 → 0.0.3

data/performance/cache_runner.rb

@@ -0,0 +1,123 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require 'active_record'
+require 'active_support/core_ext'
+require 'active_support/cache'
+require 'identity_cache'
+require 'memcache'
+
+if ENV['BOXEN_HOME'].present?
+  $memcached_port = 21211
+  $mysql_port = 13306
+else
+  $memcached_port = 11211
+  $mysql_port = 3306
+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'
+
+def create_record(id)
+  r = Record.new(id)
+end
+
+def database_ready(count)
+  Record.where(:id => (1..count)).count == count
+rescue
+  false
+end
+
+def create_database(count)
+  DatabaseConnection.setup
+  a = CacheRunner.new(count)
+
+  a.setup_models
+
+  DatabaseConnection.setup
+  # set up associations
+  Record.cache_has_one :associated
+  Record.cache_has_many :associated_records, :embed => true
+  Record.cache_index :title, :unique => :true
+  AssociatedRecord.cache_has_many :deeply_associated_records, :embed => true
+
+  return if database_ready(count)
+  puts "Database not ready for performance testing, generating records"
+
+  DatabaseConnection.drop_tables
+  DatabaseConnection.create_tables
+  existing = Record.all
+  (1..count).to_a.each do |i|
+    unless existing.any? { |e| e.id == i }
+      a = Record.new
+      a.id = i
+      a.associated = AssociatedRecord.new(name: "Associated for #{i}")
+      a.associated_records
+      (1..5).each do |j|
+        a.associated_records << AssociatedRecord.new(name: "Has Many #{j} for #{i}")
+      end
+      a.save
+    end
+  end
+end
+
+class CacheRunner
+  include ActiveRecordObjects
+  include DatabaseConnection
+
+  def initialize(count)
+    @count = count
+  end
+
+  def prepare
+  end
+end
+
+class FindRunner < CacheRunner
+  def run
+    i = 1
+    @count.times do
+      ::Record.find(i)
+      i+=1
+    end
+  end
+end
+
+class FetchMissRunner < CacheRunner
+  def prepare
+    IdentityCache.cache.clear
+  end
+
+  def run
+    i = 1
+    @count.times do
+      rec = ::Record.fetch(i)
+      rec.fetch_associated
+      rec.fetch_associated_records
+
+      i+=1
+    end
+  end
+end
+
+class FetchHitRunner < CacheRunner
+  def prepare
+    IdentityCache.cache.clear
+    i = 1
+    @count.times do
+      ::Record.fetch(i)
+      i+=1
+    end
+  end
+
+  def run
+    i = 1
+    @count.times do
+      rec = ::Record.fetch(i)
+      # these should all be no cost
+      rec.fetch_associated
+      rec.fetch_associated_records
+      i+=1
+    end
+  end
+end
+

data/performance/cpu.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'benchmark'
+
+require_relative 'cache_runner'
+
+RUNS = 4000
+
+class ARCreator
+  include ActiveRecordObjects
+end
+
+def run(obj, bench)
+  bench.report("#{obj.class.name}:") do
+    obj.prepare
+    obj.run
+  end
+end
+
+create_database(RUNS)
+
+Benchmark.bmbm do |x|
+  run(FindRunner.new(RUNS), x)
+
+  run(FetchMissRunner.new(RUNS), x)
+
+  run(FetchHitRunner.new(RUNS), x)
+
+end

data/performance/externals.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'benchmark'
+require 'ruby-prof'
+
+require_relative 'cache_runner'
+
+RUNS = 1000
+RubyProf.measure_mode = RubyProf::CPU_TIME
+
+EXTERNALS = {"Memcache" => ["MemCache#set", "MemCache#get"],
+             "Database" => ["Mysql2::Client#query"]}
+
+def run(obj)
+  obj.prepare
+  RubyProf.start
+  obj.run
+  result = RubyProf.stop
+  puts "Results for #{obj.class.name}:"
+  results = StringIO.new
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(results)
+  count_externals(results.string)
+end
+
+def count_externals(results)
+  count = {}
+  results.split(/\n/).each do |line|
+    fields = line.split
+    if ext = EXTERNALS.detect { |e| e[1].any? { |method| method == fields[-1] } }
+      count[ext[0]] ||= 0
+      count[ext[0]] += fields[-2].to_i
+    end
+  end
+  EXTERNALS.each do |ext|
+    puts "#{ext[0]}: #{count[ext[0]] || 0}"
+  end
+end
+
+create_database(RUNS)
+
+run(FindRunner.new(RUNS))
+
+run(FetchHitRunner.new(RUNS))
+
+run(FetchMissRunner.new(RUNS))

data/performance/profile.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'benchmark'
+require 'ruby-prof'
+
+require_relative 'cache_runner'
+
+RUNS = 1000
+RubyProf.measure_mode = RubyProf::CPU_TIME
+
+def run(obj)
+  obj.prepare
+  RubyProf.start
+  obj.run
+  result = RubyProf.stop
+  puts "Results for #{obj.class.name}:"
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
+end
+
+create_database(RUNS)
+
+run(FindRunner.new(RUNS))
+
+run(FetchMissRunner.new(RUNS))
+
+run(FetchHitRunner.new(RUNS))

data/test/attribute_cache_test.rb

@@ -19,7 +19,7 @@ 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)
-    Record.connection.expects(:select_value).with("SELECT name FROM associated_records WHERE id = 1 LIMIT 1").returns('foo')
+    Record.connection.expects(:select_value).with("SELECT `name` FROM `associated_records` WHERE `id` = 1 LIMIT 1").returns('foo')
     assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
   end
 
@@ -29,7 +29,7 @@ class AttributeCacheTest < IdentityCache::TestCase
     IdentityCache.cache.expects(:read).with(@name_attribute_key).returns(nil)
 
     # Grab the value of the attribute from the DB
-    Record.connection.expects(:select_value).with("SELECT name FROM associated_records WHERE id = 1 LIMIT 1").returns('foo')
+    Record.connection.expects(:select_value).with("SELECT `name` FROM `associated_records` WHERE `id` = 1 LIMIT 1").returns('foo')
 
     # And write it back to the cache
     IdentityCache.cache.expects(:write).with(@name_attribute_key, 'foo').returns(nil)
@@ -64,7 +64,7 @@ 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
 
-    Record.connection.expects(:select_value).with("SELECT name FROM associated_records WHERE id = 1 LIMIT 1").returns('foo')
+    Record.connection.expects(:select_value).with("SELECT `name` FROM `associated_records` WHERE `id` = 1 LIMIT 1").returns('foo')
 
     @record.transaction do
       assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)

data/test/fetch_multi_test.rb

@@ -6,10 +6,10 @@ class FetchMultiTest < IdentityCache::TestCase
     @bob = Record.create!(:title => 'bob')
     @joe = Record.create!(:title => 'joe')
     @fred = Record.create!(:title => 'fred')
-    @bob_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,title:string,updated_at:datetime")}:1"
-    @joe_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,title:string,updated_at:datetime")}:2"
-    @fred_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,title:string,updated_at:datetime")}:3"
-    @tenth_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,title:string,updated_at:datetime")}:10"
+    @bob_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:1"
+    @joe_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:2"
+    @fred_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:3"
+    @tenth_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:10"
   end
 
   def test_fetch_multi_with_no_records
@@ -107,48 +107,22 @@ class FetchMultiTest < IdentityCache::TestCase
     assert_equal [@joe, @bob, @joe], Record.fetch_multi(@joe.id, @bob.id, @joe.id)
   end
 
-  def test_fetch_multi_includes_cached_associations
-    Record.send(:cache_has_many, :associated_records, :embed => true)
-    Record.send(:cache_has_one, :associated)
-    Record.send(:cache_belongs_to, :record)
-
-    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)
-
+  def test_find_batch_coerces_ids_to_primary_key_type
     mock_relation = mock("ActiveRecord::Relation")
     Record.expects(:where).returns(mock_relation)
-    mock_relation.expects(:includes).with([:associated_records, :associated]).returns(stub(:all => [@bob, @joe, @fred]))
-    assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id)
-  end
+    mock_relation.expects(:includes).returns(stub(:all => [@bob, @joe, @fred]))
 
-  def test_fetch_multi_includes_cached_associations_and_other_asked_for_associations
-    Record.send(:cache_has_many, :associated_records, :embed => true)
-    Record.send(:cache_has_one, :associated)
-    Record.send(:cache_belongs_to, :record)
+    Record.find_batch([@bob, @joe, @fred].map(&:id).map(&:to_s))
+  end
 
+  def test_fetch_multi_doesnt_freeze_keys
     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")
-    Record.expects(:where).returns(mock_relation)
-    mock_relation.expects(:includes).with([:associated_records, :associated, {:record => []}]).returns(stub(:all => [@bob, @joe, @fred]))
-    assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id, {:includes => :record})
-  end
+    cache_response[@bob_blob_key] = @bob
+    cache_response[@joe_blob_key] = @fred
 
-  def test_find_batch_coerces_ids_to_primary_key_type
-    mock_relation = mock("ActiveRecord::Relation")
-    Record.expects(:where).returns(mock_relation)
-    mock_relation.expects(:includes).returns(stub(:all => [@bob, @joe, @fred]))
+    IdentityCache.expects(:fetch_multi).with{ |*args| args.none?(&:frozen?) }.returns(cache_response)
 
-    Record.find_batch([@bob, @joe, @fred].map(&:id).map(&:to_s))
+    Record.fetch_multi(@bob.id, @joe.id)
   end
 
   private

data/test/fetch_multi_with_batched_associations_test.rb

@@ -0,0 +1,236 @@
+require "test_helper"
+
+class FetchMultiTest < IdentityCache::TestCase
+  def setup
+    super
+    @bob = Record.create!(:title => 'bob')
+    @joe = Record.create!(:title => 'joe')
+    @fred = Record.create!(:title => 'fred')
+    @bob_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:1"
+    @joe_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:2"
+    @fred_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:3"
+    @tenth_blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:10"
+  end
+
+  def test_fetch_multi_includes_cached_associations_in_the_database_find
+    Record.send(:cache_has_many, :associated_records, :embed => true)
+    Record.send(:cache_has_one, :associated)
+    Record.send(:cache_belongs_to, :record)
+
+    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")
+    Record.expects(:where).returns(mock_relation)
+    mock_relation.expects(:includes).with([:associated_records, :associated]).returns(stub(:all => [@bob, @joe, @fred]))
+    assert_equal [@bob, @joe, @fred], Record.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
+    Record.send(:cache_has_many, :associated_records, :embed => true)
+    Record.send(:cache_has_one, :associated)
+    Record.send(:cache_belongs_to, :record)
+
+    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")
+    Record.expects(:where).returns(mock_relation)
+    mock_relation.expects(:includes).with([:associated_records, :associated, {:record => []}]).returns(stub(:all => [@bob, @joe, @fred]))
+    assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id, {:includes => :record})
+  end
+
+  def test_fetch_multi_batch_fetches_non_embedded_first_level_has_many_associations
+    Record.send(:cache_has_many, :associated_records, :embed => false)
+
+    child_records = []
+    [@bob, @joe].each do |parent|
+      3.times do |i|
+        child_records << (child_record = parent.associated_records.create!(:name => i.to_s))
+        AssociatedRecord.fetch(child_record.id)
+      end
+    end
+
+    Record.fetch_multi(@bob.id, @joe.id) # populate the cache entries and associated children ID variables
+
+    assert_memcache_operations(2) do
+      @cached_bob, @cached_joe = Record.fetch_multi(@bob.id, @joe.id, :includes => :associated_records)
+      assert_equal child_records[0..2].sort, @cached_bob.fetch_associated_records.sort
+      assert_equal child_records[3..5].sort, @cached_joe.fetch_associated_records.sort
+    end
+  end
+
+  def test_fetch_multi_batch_fetches_first_level_belongs_to_associations
+    AssociatedRecord.send(:cache_belongs_to, :record, :embed => false)
+
+    @bob_child  = @bob.associated_records.create!(:name => "bob child")
+    @fred_child = @fred.associated_records.create!(:name => "fred child")
+
+    # populate the cache entries and associated children ID variables
+    AssociatedRecord.fetch_multi(@bob_child.id, @fred_child.id)
+    Record.fetch_multi(@bob.id, @fred.id)
+
+    assert_memcache_operations(2) do
+      @cached_bob_child, @cached_fred_child = AssociatedRecord.fetch_multi(@bob_child.id, @fred_child.id, :includes => :record)
+      assert_equal @bob,  @cached_bob_child.fetch_record
+      assert_equal @fred, @cached_fred_child.fetch_record
+    end
+  end
+
+  def test_fetch_multi_batch_fetches_first_level_associations_who_dont_include_identity_cache
+    Record.send(:has_many, :not_cached_records)
+    Record.send(:cache_has_many, :not_cached_records, :embed => true)
+
+    @bob_child  = @bob.not_cached_records.create!(:name => "bob child")
+    @fred_child = @fred.not_cached_records.create!(:name => "fred child")
+
+    # populate the cache entries and associated children ID variables
+    Record.fetch_multi(@bob.id, @fred.id)
+
+    assert_memcache_operations(1) do
+      @cached_bob_child, @cached_fred_child = Record.fetch_multi(@bob.id, @fred.id, :includes => :not_cached_records)
+    end
+  end
+
+  def test_fetch_multi_batch_fetches_non_embedded_second_level_has_many_associations
+    Record.send(:cache_has_many, :associated_records, :embed => false)
+    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => false)
+
+    child_records, grandchildren = setup_has_many_children_and_grandchildren(@bob, @joe)
+
+    assert_memcache_operations(3) do
+      @cached_bob, @cached_joe = Record.fetch_multi(@bob.id, @joe.id, :includes => {:associated_records => :deeply_associated_records})
+      bob_children = @cached_bob.fetch_associated_records.sort
+      joe_children = @cached_joe.fetch_associated_records.sort
+
+      assert_equal grandchildren[0..2].sort,   bob_children[0].fetch_deeply_associated_records.sort
+      assert_equal grandchildren[3..5].sort,   bob_children[1].fetch_deeply_associated_records.sort
+      assert_equal grandchildren[6..8].sort,   bob_children[2].fetch_deeply_associated_records.sort
+      assert_equal grandchildren[9..11].sort,  joe_children[0].fetch_deeply_associated_records.sort
+      assert_equal grandchildren[12..14].sort, joe_children[1].fetch_deeply_associated_records.sort
+      assert_equal grandchildren[15..17].sort, joe_children[2].fetch_deeply_associated_records.sort
+    end
+  end
+
+  def test_fetch_multi_batch_fetches_non_embedded_second_level_belongs_to_associations
+    Record.send(:cache_belongs_to, :record, :embed => false)
+    AssociatedRecord.send(:cache_belongs_to, :record, :embed => false)
+
+    @bob_child  = @bob.associated_records.create!(:name => "bob child")
+    @fred_child = @fred.associated_records.create!(:name => "fred child")
+    @bob.update_attribute(:record_id, @bob.id)
+    @fred.update_attribute(:record_id, @fred.id)
+
+    # populate the cache entries and associated children ID variables
+    AssociatedRecord.fetch_multi(@bob_child.id, @fred_child.id)
+    Record.fetch_multi(@bob.id, @fred.id)
+
+    assert_memcache_operations(3) do
+      @cached_bob_child, @cached_fred_child = AssociatedRecord.fetch_multi(@bob_child.id, @fred_child.id, :includes => {:record => :record})
+
+      @cached_bob_parent  = @cached_bob_child.fetch_record
+      @cached_fred_parent = @cached_fred_child.fetch_record
+      assert_equal @bob,  @cached_bob_parent.fetch_record
+      assert_equal @fred, @cached_fred_parent.fetch_record
+    end
+  end
+
+  def test_fetch_multi_doesnt_batch_fetches_belongs_to_associations_if_the_foreign_key_isnt_present
+    AssociatedRecord.send(:cache_belongs_to, :record, :embed => false)
+    @child = AssociatedRecord.create!(:name => "bob child")
+    # populate the cache entry
+    AssociatedRecord.fetch_multi(@child.id)
+
+    assert_memcache_operations(1) do
+      @cached_child = AssociatedRecord.fetch_multi(@child.id, :includes => :record)
+    end
+  end
+
+
+  def test_fetch_multi_batch_fetches_non_embedded_second_level_associations_through_embedded_first_level_has_many_associations
+    Record.send(:cache_has_many, :associated_records, :embed => true)
+    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => false)
+
+    child_records, grandchildren = setup_has_many_children_and_grandchildren(@bob, @joe)
+
+    assert_memcache_operations(2) do
+      @cached_bob, @cached_joe = Record.fetch_multi(@bob.id, @joe.id, :includes => {:associated_records => :deeply_associated_records})
+      bob_children = @cached_bob.fetch_associated_records.sort
+      joe_children = @cached_joe.fetch_associated_records.sort
+
+      assert_equal grandchildren[0..2].sort,   bob_children[0].fetch_deeply_associated_records.sort
+      assert_equal grandchildren[3..5].sort,   bob_children[1].fetch_deeply_associated_records.sort
+      assert_equal grandchildren[6..8].sort,   bob_children[2].fetch_deeply_associated_records.sort
+      assert_equal grandchildren[9..11].sort,  joe_children[0].fetch_deeply_associated_records.sort
+      assert_equal grandchildren[12..14].sort, joe_children[1].fetch_deeply_associated_records.sort
+      assert_equal grandchildren[15..17].sort, joe_children[2].fetch_deeply_associated_records.sort
+    end
+  end
+
+  def test_fetch_multi_batch_fetches_non_embedded_second_level_associations_through_embedded_first_level_has_one_associations
+    Record.send(:cache_has_one, :associated, :embed => true)
+    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => false)
+
+    @bob_child = @bob.create_associated!(:name => "bob child")
+    @joe_child = @joe.create_associated!(:name => "joe child")
+
+    grandchildren = setup_grandchildren(@bob_child, @joe_child)
+    AssociatedRecord.fetch_multi(@bob_child.id, @joe_child.id)
+    Record.fetch_multi(@bob.id, @joe.id)
+
+    assert_memcache_operations(2) do
+      @cached_bob, @cached_joe = Record.fetch_multi(@bob.id, @joe.id, :includes => {:associated => :deeply_associated_records})
+      bob_child = @cached_bob.fetch_associated
+      joe_child = @cached_joe.fetch_associated
+
+      assert_equal grandchildren[0..2].sort,   bob_child.fetch_deeply_associated_records.sort
+      assert_equal grandchildren[3..5].sort,   joe_child.fetch_deeply_associated_records.sort
+    end
+  end
+
+  def test_find_batch_coerces_ids_to_primary_key_type
+    mock_relation = mock("ActiveRecord::Relation")
+    Record.expects(:where).returns(mock_relation)
+    mock_relation.expects(:includes).returns(stub(:all => [@bob, @joe, @fred]))
+
+    Record.find_batch([@bob, @joe, @fred].map(&:id).map(&:to_s))
+  end
+
+  private
+
+  def setup_has_many_children_and_grandchildren(*parents)
+    child_records = []
+    grandchildren = []
+
+    parents.each do |parent|
+      3.times do |i|
+        child_records << (child = parent.associated_records.create!(:name => i.to_s))
+        grandchildren.concat setup_grandchildren(child)
+        AssociatedRecord.fetch(child.id)
+      end
+    end
+
+    Record.fetch_multi(*parents.map(&:id)) # populate the cache entries and associated children ID variables
+
+    return child_records, grandchildren
+  end
+
+  def setup_grandchildren(*children)
+    grandchildren = []
+    children.each do |child|
+      3.times do |j|
+        grandchildren << (grandchild = child.deeply_associated_records.create!(:name => j.to_s))
+        DeeplyAssociatedRecord.fetch(grandchild.id)
+      end
+    end
+    grandchildren
+  end
+end

data/test/fetch_test.rb

@@ -9,7 +9,7 @@ class FetchTest < IdentityCache::TestCase
     @record = Record.new
     @record.id = 1
     @record.title = 'bob'
-    @blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,title:string,updated_at:datetime")}:1"
+    @blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:1"
     @index_key = "IDC:index:Record:title:#{cache_hash('bob')}"
   end
 

data/test/helpers/active_record_objects.rb

@@ -0,0 +1,43 @@
+module ActiveRecordObjects
+  def setup_models(base = ActiveRecord::Base)
+    Object.send :const_set, 'DeeplyAssociatedRecord', Class.new(base).tap {|klass|
+      klass.send :include, IdentityCache
+      klass.belongs_to :associated_record
+    }
+
+    Object.send :const_set, 'AssociatedRecord', Class.new(base).tap {|klass|
+      klass.send :include, IdentityCache
+      klass.belongs_to :record
+      klass.has_many :deeply_associated_records, :order => "name DESC"
+    }
+
+    Object.send :const_set, 'NotCachedRecord', Class.new(base).tap {|klass|
+      klass.belongs_to :record, :touch => true
+    }
+
+    Object.send :const_set, 'PolymorphicRecord', Class.new(base).tap {|klass|
+      klass.belongs_to :owner, :polymorphic => true
+    }
+
+    Object.send :const_set, 'Record', Class.new(base).tap {|klass|
+      klass.send :include, IdentityCache
+      klass.belongs_to :record
+      klass.has_many :associated_records, :order => "id DESC"
+      klass.has_many :not_cached_records, :order => "id DESC"
+      klass.has_many :polymorphic_records, :as => 'owner'
+      klass.has_one :polymorphic_record, :as => 'owner'
+      klass.has_one :associated, :class_name => 'AssociatedRecord', :order => "id ASC"
+    }
+  end
+
+  def teardown_models
+    ActiveSupport::DescendantsTracker.clear
+    ActiveSupport::Dependencies.clear
+    Object.send :remove_const, 'DeeplyAssociatedRecord'
+    Object.send :remove_const, 'PolymorphicRecord'
+    Object.send :remove_const, 'AssociatedRecord'
+    Object.send :remove_const, 'NotCachedRecord'
+    Object.send :remove_const, 'Record'
+  end
+end
+

data/test/helpers/cache.rb

@@ -1,3 +1,5 @@
+require 'logger'
+
 module Rails
 
   class Cache < ActiveSupport::Cache::MemCacheStore
@@ -7,18 +9,7 @@ module Rails
     @@cache ||= Cache.new("localhost:#{$memcached_port}")
   end
 
-  class Logger
-    def info(string)
-    end
-
-    def debug(string)
-    end
-
-    def error(string)
-    end
-  end
-
   def self.logger
-    @logger = Logger.new
+    @logger ||= Logger.new(nil)
   end
 end

data/test/helpers/database_connection.rb

@@ -30,7 +30,8 @@ module DatabaseConnection
     :deeply_associated_records  => [[:string, :name], [:integer, :associated_record_id]],
     :associated_records         => [[:string, :name], [:integer, :record_id]],
     :not_cached_records         => [[:string, :name], [:integer, :record_id]],
-    :records                    => [[:string, :title], [:timestamps]]
+    :records                    => [[:integer, :record_id], [:string, :title], [:timestamps]],
+    :records2                   => [[:integer, :record_id], [:string, :title], [:timestamps]]
   }
 
   DATABASE_CONFIG = {

data/test/index_cache_test.rb

@@ -93,4 +93,11 @@ class ExpirationTest < IdentityCache::TestCase
     assert_equal nil, IdentityCache.cache.read(@cache_key)
   end
 
+  def test_set_table_name_cache_fetch
+    Record.cache_index :title
+    Record.table_name = 'records2'
+    @record.save!
+    assert_equal [@record], Record.fetch_by_title('bob')
+    assert_equal [@record.id], IdentityCache.cache.read(@cache_key)
+  end
 end