identity_cache 0.0.4 → 0.0.5

data/test/cache_fetch_includes_test.rb

@@ -6,83 +6,83 @@ class CacheFetchIncludesTest < IdentityCache::TestCase
   end
 
   def test_cached_embedded_has_manys_are_included_in_includes
-    Record.send(:cache_has_many, :associated_records, :embed => true)
-    assert_equal [:associated_records], Record.cache_fetch_includes
+    Item.send(:cache_has_many, :associated_records, :embed => true)
+    assert_equal [:associated_records], Item.cache_fetch_includes
   end
 
   def test_cached_nonembedded_has_manys_are_included_in_includes
-    Record.send(:cache_has_many, :associated_records, :embed => false)
-    assert_equal [], Record.cache_fetch_includes
+    Item.send(:cache_has_many, :associated_records, :embed => false)
+    assert_equal [], Item.cache_fetch_includes
   end
 
   def test_cached_has_ones_are_included_in_includes
-    Record.send(:cache_has_one, :associated)
-    assert_equal [:associated], Record.cache_fetch_includes
+    Item.send(:cache_has_one, :associated)
+    assert_equal [:associated], Item.cache_fetch_includes
   end
 
   def test_cached_nonembedded_belongs_tos_are_not_included_in_includes
-    Record.send(:cache_belongs_to, :record)
-    assert_equal [], Record.cache_fetch_includes
+    Item.send(:cache_belongs_to, :item)
+    assert_equal [], Item.cache_fetch_includes
   end
 
   def test_cached_child_associations_are_included_in_includes
-    Record.send(:cache_has_many, :associated_records, :embed => true)
+    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.cache_fetch_includes
+    assert_equal [{:associated_records => [:deeply_associated_records]}], Item.cache_fetch_includes
   end
 
   def test_multiple_cached_associations_and_child_associations_are_included_in_includes
-    Record.send(:cache_has_many, :associated_records, :embed => true)
-    Record.send(:cache_has_many, :polymorphic_records, {:inverse_name => :owner, :embed => true})
-    Record.send(:cache_has_one, :associated, :embed => true)
+    Item.send(:cache_has_many, :associated_records, :embed => true)
+    Item.send(:cache_has_many, :polymorphic_records, {:inverse_name => :owner, :embed => true})
+    Item.send(:cache_has_one, :associated, :embed => true)
     AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => true)
     assert_equal [
       {:associated_records => [:deeply_associated_records]},
       :polymorphic_records,
       {:associated => [:deeply_associated_records]}
-    ],  Record.cache_fetch_includes
+    ],  Item.cache_fetch_includes
   end
 
   def test_empty_additions_for_top_level_associations_makes_no_difference
-    Record.send(:cache_has_many, :associated_records, :embed => true)
-    assert_equal [:associated_records], Record.cache_fetch_includes({})
+    Item.send(:cache_has_many, :associated_records, :embed => true)
+    assert_equal [:associated_records], Item.cache_fetch_includes({})
   end
 
   def test_top_level_additions_are_included_in_includes
-    assert_equal [{:associated_records => []}], Record.cache_fetch_includes({:associated_records => []})
+    assert_equal [{:associated_records => []}], Item.cache_fetch_includes({:associated_records => []})
   end
 
   def test_top_level_additions_alongside_top_level_cached_associations_are_included_in_includes
-    Record.send(:cache_has_many, :associated_records, :embed => true)
+    Item.send(:cache_has_many, :associated_records, :embed => true)
     assert_equal [
       :associated_records,
       {:polymorphic_records => []}
-    ], Record.cache_fetch_includes({:polymorphic_records => []})
+    ], Item.cache_fetch_includes({:polymorphic_records => []})
   end
 
   def test_child_level_additions_for_top_level_cached_associations_are_included_in_includes
-    Record.send(:cache_has_many, :associated_records, :embed => true)
+    Item.send(:cache_has_many, :associated_records, :embed => true)
     assert_equal [
       {:associated_records => [{:deeply_associated_records => []}]}
-    ], Record.cache_fetch_includes({:associated_records => :deeply_associated_records})
+    ], Item.cache_fetch_includes({:associated_records => :deeply_associated_records})
   end
 
   def test_array_child_level_additions_for_top_level_cached_associations_are_included_in_includes
-    Record.send(:cache_has_many, :associated_records, :embed => true)
+    Item.send(:cache_has_many, :associated_records, :embed => true)
     assert_equal [
       {:associated_records => [{:deeply_associated_records => []}]}
-    ], Record.cache_fetch_includes({:associated_records => [:deeply_associated_records]})
+    ], Item.cache_fetch_includes({:associated_records => [:deeply_associated_records]})
   end
 
   def test_array_child_level_additions_for_child_level_cached_associations_are_included_in_includes
-    Record.send(:cache_has_many, :associated_records, :embed => true)
+    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 => []}
       ]}
-    ], Record.cache_fetch_includes({:associated_records => [:record]})
+    ], Item.cache_fetch_includes({:associated_records => [:record]})
   end
 
 end

data/test/denormalized_has_many_test.rb

@@ -3,9 +3,9 @@ require "test_helper"
 class DenormalizedHasManyTest < IdentityCache::TestCase
   def setup
     super
-    Record.cache_has_many :associated_records, :embed => true
+    Item.cache_has_many :associated_records, :embed => true
 
-    @record = Record.new(:title => 'foo')
+    @record = Item.new(:title => 'foo')
     @record.associated_records << AssociatedRecord.new(:name => 'bar')
     @record.associated_records << AssociatedRecord.new(:name => 'baz')
     @record.save
@@ -14,27 +14,27 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
 
   def test_uncached_record_from_the_db_will_use_normal_association
     expected = @record.associated_records
-    record_from_db = Record.find(@record.id)
+    record_from_db = Item.find(@record.id)
 
-    Record.any_instance.expects(:associated_records).returns(expected)
+    Item.any_instance.expects(:associated_records).returns(expected)
 
     assert_equal @record, record_from_db
     assert_equal expected, record_from_db.fetch_associated_records
   end
 
   def test_on_cache_hit_record_should_come_back_with_cached_association
-    Record.fetch(@record.id) # warm cache
+    Item.fetch(@record.id) # warm cache
 
-    record_from_cache_hit = Record.fetch(@record.id)
+    record_from_cache_hit = Item.fetch(@record.id)
     assert_equal @record, record_from_cache_hit
 
     expected = @record.associated_records
-    Record.any_instance.expects(:associated_records).never
+    Item.any_instance.expects(:associated_records).never
     assert_equal expected, record_from_cache_hit.fetch_associated_records
   end
 
   def test_on_cache_miss_record_should_embed_associated_objects_and_return
-    record_from_cache_miss = Record.fetch(@record.id)
+    record_from_cache_miss = Item.fetch(@record.id)
     expected = @record.associated_records
 
     assert_equal @record, record_from_cache_miss
@@ -42,10 +42,11 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
   end
 
   def test_changes_in_associated_records_should_expire_the_parents_cache
-    Record.fetch(@record.id)
+    Item.fetch(@record.id)
     key = @record.primary_cache_index_key
     assert_not_nil IdentityCache.cache.read(key)
 
+    IdentityCache.cache.expects(:delete).with(@record.associated_records.first.primary_cache_index_key)
     IdentityCache.cache.expects(:delete).with(key)
     @record.associated_records.first.save
   end
@@ -53,12 +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 = Record.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.record_id = @new_record.id
+    @associatated_record.item_id = @new_record.id
     @associatated_record.save!
   end
 
@@ -70,13 +72,13 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
 
   def test_cache_without_guessable_inverse_name_raises
     assert_raises IdentityCache::InverseAssociationError do
-      Record.cache_has_many :polymorphic_records, :embed => true
+      Item.cache_has_many :polymorphic_records, :embed => true
     end
   end
 
   def test_cache_without_guessable_inverse_name_does_not_raise_when_inverse_name_specified
     assert_nothing_raised do
-      Record.cache_has_many :polymorphic_records, :inverse_name => :owner, :embed => true
+      Item.cache_has_many :polymorphic_records, :inverse_name => :owner, :embed => true
     end
   end
 

data/test/denormalized_has_one_test.rb

@@ -3,9 +3,9 @@ require "test_helper"
 class DenormalizedHasOneTest < IdentityCache::TestCase
   def setup
     super
-    Record.cache_has_one :associated
-    Record.cache_index :title, :unique => true
-    @record = Record.new(:title => 'foo')
+    Item.cache_has_one :associated
+    Item.cache_index :title, :unique => true
+    @record = Item.new(:title => 'foo')
     @record.associated = AssociatedRecord.new(:name => 'bar')
     @record.save
 
@@ -16,7 +16,7 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
     IdentityCache.cache.expects(:read).with(@record.secondary_cache_index_key_for_current_values([:title]))
     IdentityCache.cache.expects(:read).with(@record.primary_cache_index_key)
 
-    record_from_cache_miss = Record.fetch_by_title('foo')
+    record_from_cache_miss = Item.fetch_by_title('foo')
 
     assert_equal @record, record_from_cache_miss
     assert_not_nil @record.fetch_associated
@@ -28,11 +28,13 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
     @record.associated = nil
     @record.save!
     @record.reload
-    Record.expects(:find_by_id).with(@record.id, :include => Record.cache_fetch_includes).returns(@record)
+    @record.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)
 
-    record_from_cache_miss = Record.fetch_by_title('foo')
+    record_from_cache_miss = Item.fetch_by_title('foo')
     record_from_cache_miss.expects(:associated).never
 
     assert_equal @record, record_from_cache_miss
@@ -42,17 +44,18 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
   end
 
   def test_on_record_from_the_db_will_use_normal_association
-    record_from_db = Record.find_by_title('foo')
+    record_from_db = Item.find_by_title('foo')
 
     assert_equal @record, record_from_db
     assert_not_nil record_from_db.fetch_associated
   end
 
   def test_on_cache_hit_record_should_come_back_with_cached_association
-    Record.expects(:find_by_id).with(1, :include => Record.cache_fetch_includes).once.returns(@record)
-    Record.fetch_by_title('foo')
+    @record.populate_association_caches
+    Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
+    Item.fetch_by_title('foo')
 
-    record_from_cache_hit = Record.fetch_by_title('foo')
+    record_from_cache_hit = Item.fetch_by_title('foo')
     expected = @record.associated
 
     assert_equal @record, record_from_cache_hit
@@ -64,10 +67,11 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
     @record.save!
     @record.reload
 
-    Record.expects(:find_by_id).with(1, :include => Record.cache_fetch_includes).once.returns(@record)
-    Record.fetch_by_title('foo')
+    @record.populate_association_caches
+    Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
+    Item.fetch_by_title('foo')
 
-    record_from_cache_hit = Record.fetch_by_title('foo')
+    record_from_cache_hit = Item.fetch_by_title('foo')
     record_from_cache_hit.expects(:associated).never
 
     assert_equal @record, record_from_cache_hit
@@ -77,11 +81,13 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
   end
 
   def test_changes_in_associated_record_should_expire_the_parents_cache
-    Record.fetch_by_title('foo')
+    Item.fetch_by_title('foo')
     key = @record.primary_cache_index_key
     assert_not_nil IdentityCache.cache.read(key)
 
     IdentityCache.cache.expects(:delete).at_least(1).with(key)
+    IdentityCache.cache.expects(:delete).with(@record.associated.primary_cache_index_key)
+
     @record.associated.save
   end
 
@@ -93,13 +99,13 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
 
   def test_cache_without_guessable_inverse_name_raises
     assert_raises IdentityCache::InverseAssociationError do
-      Record.cache_has_one :polymorphic_record, :embed => true
+      Item.cache_has_one :polymorphic_record, :embed => true
     end
   end
 
   def test_cache_without_guessable_inverse_name_does_not_raise_when_inverse_name_specified
     assert_nothing_raised do
-      Record.cache_has_one :polymorphic_record, :inverse_name => :owner, :embed => true
+      Item.cache_has_one :polymorphic_record, :inverse_name => :owner, :embed => true
     end
   end
 end

data/test/fetch_multi_test.rb

@@ -1,32 +1,32 @@
 require "test_helper"
 
 class FetchMultiTest < IdentityCache::TestCase
-  NAMESPACE = IdentityCache::CacheKeyGeneration::DEFAULT_NAMESPACE unless const_defined?(:NAMESPACE)
+  NAMESPACE = IdentityCache.cache_namespace
 
   def setup
     super
-    @bob = Record.create!(:title => 'bob')
-    @joe = Record.create!(:title => 'joe')
-    @fred = Record.create!(:title => 'fred')
-    @bob_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:1"
-    @joe_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:2"
-    @fred_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:3"
-    @tenth_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:10"
+    @bob = Item.create!(:title => 'bob')
+    @joe = Item.create!(:title => 'joe')
+    @fred = Item.create!(:title => 'fred')
+    @bob_blob_key = "#{NAMESPACE}blob:Item:#{cache_hash("created_at:datetime,id:integer,item_id:integer,title:string,updated_at:datetime")}:1"
+    @joe_blob_key = "#{NAMESPACE}blob:Item:#{cache_hash("created_at:datetime,id:integer,item_id:integer,title:string,updated_at:datetime")}:2"
+    @fred_blob_key = "#{NAMESPACE}blob:Item:#{cache_hash("created_at:datetime,id:integer,item_id:integer,title:string,updated_at:datetime")}:3"
+    @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_with_no_records
-    assert_equal [], Record.fetch_multi
+    assert_equal [], Item.fetch_multi
   end
 
   def test_fetch_multi_namespace
-    Record.send(:include, SwitchNamespace)
+    Item.send(:include, SwitchNamespace)
     bob_blob_key, joe_blob_key, fred_blob_key = [@bob_blob_key, @joe_blob_key, @fred_blob_key].map { |k| "ns:#{k}" }
     cache_response = {}
     cache_response[bob_blob_key] = cache_response_for(@bob)
     cache_response[joe_blob_key] = cache_response_for(@joe)
     cache_response[fred_blob_key] = cache_response_for(@fred)
     IdentityCache.cache.expects(:read_multi).with(bob_blob_key, joe_blob_key, fred_blob_key).returns(cache_response)
-    assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id)
+    assert_equal [@bob, @joe, @fred], Item.fetch_multi(@bob.id, @joe.id, @fred.id)
   end
 
   def test_fetch_multi_with_all_hits
@@ -35,7 +35,7 @@ class FetchMultiTest < IdentityCache::TestCase
     cache_response[@joe_blob_key] = cache_response_for(@joe)
     cache_response[@fred_blob_key] = cache_response_for(@fred)
     IdentityCache.cache.expects(:read_multi).with(@bob_blob_key, @joe_blob_key, @fred_blob_key).returns(cache_response)
-    assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id)
+    assert_equal [@bob, @joe, @fred], Item.fetch_multi(@bob.id, @joe.id, @fred.id)
   end
 
   def test_fetch_multi_with_all_misses
@@ -44,7 +44,7 @@ class FetchMultiTest < IdentityCache::TestCase
     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)
-    assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id)
+    assert_equal [@bob, @joe, @fred], Item.fetch_multi(@bob.id, @joe.id, @fred.id)
   end
 
   def test_fetch_multi_with_mixed_hits_and_misses
@@ -53,7 +53,7 @@ class FetchMultiTest < IdentityCache::TestCase
     cache_response[@joe_blob_key] = nil
     cache_response[@fred_blob_key] = cache_response_for(@fred)
     IdentityCache.cache.expects(:read_multi).with(@bob_blob_key, @joe_blob_key, @fred_blob_key).returns(cache_response)
-    assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id)
+    assert_equal [@bob, @joe, @fred], Item.fetch_multi(@bob.id, @joe.id, @fred.id)
   end
 
   def test_fetch_multi_with_mixed_hits_and_misses_and_responses_in_the_wrong_order
@@ -62,21 +62,21 @@ class FetchMultiTest < IdentityCache::TestCase
     cache_response[@joe_blob_key] = nil
     cache_response[@fred_blob_key] = cache_response_for(@fred)
     IdentityCache.cache.expects(:read_multi).with(@bob_blob_key, @fred_blob_key, @joe_blob_key).returns(cache_response)
-    assert_equal [@bob, @fred, @joe], Record.fetch_multi(@bob.id, @fred.id, @joe.id)
+    assert_equal [@bob, @fred, @joe], Item.fetch_multi(@bob.id, @fred.id, @joe.id)
   end
 
   def test_fetch_multi_with_mixed_hits_and_misses_and_non_existant_keys_1
     populate_only_fred
 
     IdentityCache.cache.expects(:read_multi).with(@tenth_blob_key, @bob_blob_key, @joe_blob_key, @fred_blob_key).returns(@cache_response)
-    assert_equal [@bob, @joe, @fred], Record.fetch_multi(10, @bob.id, @joe.id, @fred.id)
+    assert_equal [@bob, @joe, @fred], Item.fetch_multi(10, @bob.id, @joe.id, @fred.id)
   end
 
   def test_fetch_multi_with_mixed_hits_and_misses_and_non_existant_keys_2
     populate_only_fred
 
     IdentityCache.cache.expects(:read_multi).with(@fred_blob_key, @bob_blob_key, @tenth_blob_key, @joe_blob_key).returns(@cache_response)
-    assert_equal [@fred, @bob, @joe], Record.fetch_multi(@fred.id, @bob.id, 10, @joe.id)
+    assert_equal [@fred, @bob, @joe], Item.fetch_multi(@fred.id, @bob.id, 10, @joe.id)
   end
 
 
@@ -101,31 +101,31 @@ class FetchMultiTest < IdentityCache::TestCase
   end
 
   def test_fetch_multi_duplicate_ids
-    assert_equal [@joe, @bob, @joe], Record.fetch_multi(@joe.id, @bob.id, @joe.id)
+    assert_equal [@joe, @bob, @joe], Item.fetch_multi(@joe.id, @bob.id, @joe.id)
   end
 
   def test_fetch_multi_with_open_transactions_hits_the_database
-    Record.connection.expects(:open_transactions).at_least_once.returns(1)
+    Item.connection.expects(:open_transactions).at_least_once.returns(1)
     IdentityCache.cache.expects(:read_multi).never
-    assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id)
+    assert_equal [@bob, @joe, @fred], Item.fetch_multi(@bob.id, @joe.id, @fred.id)
   end
 
   def test_fetch_multi_with_open_transactions_returns_results_in_the_order_of_the_passed_ids
-    Record.connection.expects(:open_transactions).at_least_once.returns(1)
-    assert_equal [@joe, @bob, @fred], Record.fetch_multi(@joe.id, @bob.id, @fred.id)
+    Item.connection.expects(:open_transactions).at_least_once.returns(1)
+    assert_equal [@joe, @bob, @fred], Item.fetch_multi(@joe.id, @bob.id, @fred.id)
   end
 
   def test_fetch_multi_with_duplicate_ids_in_transaction_returns_results_in_the_order_of_the_passed_ids
-    Record.connection.expects(:open_transactions).at_least_once.returns(1)
-    assert_equal [@joe, @bob, @joe], Record.fetch_multi(@joe.id, @bob.id, @joe.id)
+    Item.connection.expects(:open_transactions).at_least_once.returns(1)
+    assert_equal [@joe, @bob, @joe], Item.fetch_multi(@joe.id, @bob.id, @joe.id)
   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]))
+    Item.expects(:where).returns(mock_relation)
+    mock_relation.expects(:includes).returns(stub(:to_a => [@bob, @joe, @fred]))
 
-    Record.find_batch([@bob, @joe, @fred].map(&:id).map(&:to_s))
+    Item.find_batch([@bob, @joe, @fred].map(&:id).map(&:to_s))
   end
 
   def test_fetch_multi_doesnt_freeze_keys
@@ -135,7 +135,7 @@ class FetchMultiTest < IdentityCache::TestCase
 
     IdentityCache.expects(:fetch_multi).with{ |*args| args.none?(&:frozen?) }.returns(cache_response)
 
-    Record.fetch_multi(@bob.id, @joe.id)
+    Item.fetch_multi(@bob.id, @joe.id)
   end
 
   private

data/test/fetch_multi_with_batched_associations_test.rb

@@ -1,23 +1,23 @@
 require "test_helper"
 
-class FetchMultiTest < IdentityCache::TestCase
-  NAMESPACE = IdentityCache::CacheKeyGeneration::DEFAULT_NAMESPACE unless const_defined?(:NAMESPACE)
+class FetchMultiWithBatchedAssociationsTest < IdentityCache::TestCase
+  NAMESPACE = IdentityCache.cache_namespace
 
   def setup
     super
-    @bob = Record.create!(:title => 'bob')
-    @joe = Record.create!(:title => 'joe')
-    @fred = Record.create!(:title => 'fred')
-    @bob_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:1"
-    @joe_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:2"
-    @fred_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:3"
-    @tenth_blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:10"
+    @bob = Item.create!(:title => 'bob')
+    @joe = Item.create!(:title => 'joe')
+    @fred = Item.create!(:title => 'fred')
+    @bob_blob_key = "#{NAMESPACE}blob:Item:#{cache_hash("created_at:datetime,id:integer,item_id:integer,title:string,updated_at:datetime")}:1"
+    @joe_blob_key = "#{NAMESPACE}blob:Item:#{cache_hash("created_at:datetime,id:integer,item_id:integer,title:string,updated_at:datetime")}:2"
+    @fred_blob_key = "#{NAMESPACE}blob:Item:#{cache_hash("created_at:datetime,id:integer,item_id:integer,title:string,updated_at:datetime")}:3"
+    @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
-    Record.send(:cache_has_many, :associated_records, :embed => true)
-    Record.send(:cache_has_one, :associated)
-    Record.send(:cache_belongs_to, :record)
+    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
@@ -27,15 +27,15 @@ class FetchMultiTest < IdentityCache::TestCase
     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)
+    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
-    Record.send(:cache_has_many, :associated_records, :embed => true)
-    Record.send(:cache_has_one, :associated)
-    Record.send(:cache_belongs_to, :record)
+    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
@@ -45,13 +45,13 @@ class FetchMultiTest < IdentityCache::TestCase
     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})
+    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})
   end
 
   def test_fetch_multi_batch_fetches_non_embedded_first_level_has_many_associations
-    Record.send(:cache_has_many, :associated_records, :embed => false)
+    Item.send(:cache_has_many, :associated_records, :embed => false)
 
     child_records = []
     [@bob, @joe].each do |parent|
@@ -61,55 +61,55 @@ class FetchMultiTest < IdentityCache::TestCase
       end
     end
 
-    Record.fetch_multi(@bob.id, @joe.id) # populate the cache entries and associated children ID variables
+    Item.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)
+      @cached_bob, @cached_joe = Item.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)
+    AssociatedRecord.send(:cache_belongs_to, :item, :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)
+    Item.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
+      @cached_bob_child, @cached_fred_child = AssociatedRecord.fetch_multi(@bob_child.id, @fred_child.id, :includes => :item)
+      assert_equal @bob,  @cached_bob_child.fetch_item
+      assert_equal @fred, @cached_fred_child.fetch_item
     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)
+    Item.send(:has_many, :not_cached_records)
+    Item.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)
+    Item.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)
+      @cached_bob_child, @cached_fred_child = Item.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)
+    Item.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})
+      @cached_bob, @cached_joe = Item.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
 
@@ -123,48 +123,48 @@ class FetchMultiTest < IdentityCache::TestCase
   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)
+    Item.send(:cache_belongs_to, :item, :embed => false)
+    AssociatedRecord.send(:cache_belongs_to, :item, :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)
+    @bob.update_attribute(:item_id, @bob.id)
+    @fred.update_attribute(:item_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)
+    Item.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_child, @cached_fred_child = AssociatedRecord.fetch_multi(@bob_child.id, @fred_child.id, :includes => {:item => :item})
 
-      @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
+      @cached_bob_parent  = @cached_bob_child.fetch_item
+      @cached_fred_parent = @cached_fred_child.fetch_item
+      assert_equal @bob,  @cached_bob_parent.fetch_item
+      assert_equal @fred, @cached_fred_parent.fetch_item
     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)
+    AssociatedRecord.send(:cache_belongs_to, :item, :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)
+      @cached_child = AssociatedRecord.fetch_multi(@child.id, :includes => :item)
     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)
+    Item.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})
+      @cached_bob, @cached_joe = Item.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
 
@@ -178,7 +178,7 @@ class FetchMultiTest < IdentityCache::TestCase
   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)
+    Item.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")
@@ -186,10 +186,10 @@ class FetchMultiTest < IdentityCache::TestCase
 
     grandchildren = setup_grandchildren(@bob_child, @joe_child)
     AssociatedRecord.fetch_multi(@bob_child.id, @joe_child.id)
-    Record.fetch_multi(@bob.id, @joe.id)
+    Item.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})
+      @cached_bob, @cached_joe = Item.fetch_multi(@bob.id, @joe.id, :includes => {:associated => :deeply_associated_records})
       bob_child = @cached_bob.fetch_associated
       joe_child = @cached_joe.fetch_associated
 
@@ -200,10 +200,10 @@ class FetchMultiTest < IdentityCache::TestCase
 
   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]))
+    Item.expects(:where).returns(mock_relation)
+    mock_relation.expects(:includes).returns(stub(:to_a => [@bob, @joe, @fred]))
 
-    Record.find_batch([@bob, @joe, @fred].map(&:id).map(&:to_s))
+    Item.find_batch([@bob, @joe, @fred].map(&:id).map(&:to_s))
   end
 
   private
@@ -220,7 +220,7 @@ class FetchMultiTest < IdentityCache::TestCase
       end
     end
 
-    Record.fetch_multi(*parents.map(&:id)) # populate the cache entries and associated children ID variables
+    Item.fetch_multi(*parents.map(&:id)) # populate the cache entries and associated children ID variables
 
     return child_records, grandchildren
   end