identity_cache 0.0.4 → 0.0.5

data/test/fetch_test.rb

@@ -5,81 +5,83 @@ class FetchTest < IdentityCache::TestCase
 
   def setup
     super
-    Record.cache_index :title, :unique => true
-    Record.cache_index :id, :title, :unique => true
+    Item.cache_index :title, :unique => true
+    Item.cache_index :id, :title, :unique => true
 
-    @record = Record.new
+    @record = Item.new
     @record.id = 1
     @record.title = 'bob'
     @cached_value = {:class => @record.class}
     @record.encode_with(@cached_value)
-    @blob_key = "#{NAMESPACE}blob:Record:#{cache_hash("created_at:datetime,id:integer,record_id:integer,title:string,updated_at:datetime")}:1"
-    @index_key = "#{NAMESPACE}index:Record:title:#{cache_hash('bob')}"
+    @blob_key = "#{NAMESPACE}blob:Item:#{cache_hash("created_at:datetime,id:integer,item_id:integer,title:string,updated_at:datetime")}:1"
+    @index_key = "#{NAMESPACE}index:Item:title:#{cache_hash('bob')}"
   end
 
   def test_fetch_cache_hit
     IdentityCache.cache.expects(:read).with(@blob_key).returns(@cached_value)
 
-    assert_equal @record, Record.fetch(1)
+    assert_equal @record, Item.fetch(1)
   end
 
   def test_fetch_hit_cache_namespace
-    Record.send(:include, SwitchNamespace)
-    Record.namespace = 'test_namespace'
+    old_ns = IdentityCache.cache_namespace
+    IdentityCache.cache_namespace = proc { |model| "#{model.table_name}:#{old_ns}" }
 
-    new_blob_key = "test_namespace:#{@blob_key}"
+    new_blob_key = "items:#{@blob_key}"
     IdentityCache.cache.expects(:read).with(new_blob_key).returns(@cached_value)
 
-    assert_equal @record, Record.fetch(1)
+    assert_equal @record, Item.fetch(1)
+  ensure
+    IdentityCache.cache_namespace = old_ns
   end
 
   def test_exists_with_identity_cache_when_cache_hit
     IdentityCache.cache.expects(:read).with(@blob_key).returns(@cached_value)
 
-    assert Record.exists_with_identity_cache?(1)
+    assert Item.exists_with_identity_cache?(1)
   end
 
   def test_exists_with_identity_cache_when_cache_miss_and_in_db
     IdentityCache.cache.expects(:read).with(@blob_key).returns(nil)
-    Record.expects(:find_by_id).with(1, :include => []).returns(@record)
+    Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
 
-    assert Record.exists_with_identity_cache?(1)
+    assert Item.exists_with_identity_cache?(1)
   end
 
   def test_exists_with_identity_cache_when_cache_miss_and_not_in_db
     IdentityCache.cache.expects(:read).with(@blob_key).returns(nil)
-    Record.expects(:find_by_id).with(1, :include => []).returns(nil)
+    Item.expects(:resolve_cache_miss).with(1).once.returns(nil)
 
-    assert !Record.exists_with_identity_cache?(1)
+    assert !Item.exists_with_identity_cache?(1)
   end
 
   def test_fetch_miss
-    Record.expects(:find_by_id).with(1, :include => []).returns(@record)
+    Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
 
     IdentityCache.cache.expects(:read).with(@blob_key).returns(nil)
     IdentityCache.cache.expects(:write).with(@blob_key, @cached_value)
 
-    assert_equal @record, Record.fetch(1)
+    assert_equal @record, Item.fetch(1)
   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)
 
-    assert_equal nil, Record.fetch_by_id(nonexistent_record_id)
+    assert_equal nil, Item.fetch_by_id(nonexistent_record_id)
   end
 
   def test_fetch_not_found_should_raise
     nonexistent_record_id = 10
     IdentityCache.cache.expects(:write).with(@blob_key + '0', IdentityCache::CACHED_NIL)
 
-    assert_raises(ActiveRecord::RecordNotFound) { Record.fetch(nonexistent_record_id) }
+    assert_raises(ActiveRecord::RecordNotFound) { Item.fetch(nonexistent_record_id) }
   end
 
   def test_cached_nil_expiry_on_record_creation
     key = @record.primary_cache_index_key
 
-    assert_equal nil, Record.fetch_by_id(@record.id)
+    assert_equal nil, Item.fetch_by_id(@record.id)
     assert_equal IdentityCache::CACHED_NIL, IdentityCache.cache.read(key)
 
     @record.save!
@@ -91,7 +93,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"
-    Record.connection.expects(:select_value).returns(1)
+    Item.connection.expects(:select_value).returns(1)
 
     # cache sql result
     IdentityCache.cache.expects(:write).with(@index_key, 1)
@@ -99,31 +101,37 @@ class FetchTest < IdentityCache::TestCase
     # got id, do memcache lookup on that, hit -> done
     IdentityCache.cache.expects(:read).with(@blob_key).returns(@cached_value)
 
-    assert_equal @record, Record.fetch_by_title('bob')
+    assert_equal @record, Item.fetch_by_title('bob')
   end
 
   def test_fetch_by_title_cache_namespace
-    Record.send(:include, SwitchNamespace)
+    Item.send(:include, SwitchNamespace)
     IdentityCache.cache.expects(:read).with("ns:#{@index_key}").returns(1)
     IdentityCache.cache.expects(:read).with("ns:#{@blob_key}").returns(@cached_value)
 
-    assert_equal @record, Record.fetch_by_title('bob')
+    assert_equal @record, Item.fetch_by_title('bob')
   end
 
   def test_fetch_by_title_stores_idcnil
-    Record.connection.expects(:select_value).once.returns(nil)
+    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, Record.fetch_by_title('bob') # select_value => nil
+    assert_equal nil, Item.fetch_by_title('bob') # select_value => nil
 
-    assert_equal nil, Record.fetch_by_title('bob') # returns cached nil
-    assert_equal nil, Record.fetch_by_title('bob') # returns cached 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
-    Record.connection.expects(:select_value).returns(nil)
+    Item.connection.expects(:select_value).returns(nil)
     assert_raises ActiveRecord::RecordNotFound do
-      Record.fetch_by_title!('bob')
+      Item.fetch_by_title!('bob')
     end
   end
+
+  def test_fetch_does_not_communicate_to_cache_with_nil_id
+    IdentityCache.cache.expects(:read).never
+    IdentityCache.cache.expects(:write).never
+    assert_raises(ActiveRecord::RecordNotFound) { Item.fetch(nil) }
+  end
 end

data/test/helpers/active_record_objects.rb

@@ -18,39 +18,43 @@ end
 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, 'DeeplyAssociatedRecord', Class.new(base) {
+      include IdentityCache
+      belongs_to :associated_record
+      default_scope { order('name DESC') }
     }
 
-    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, 'AssociatedRecord', Class.new(base) {
+      include IdentityCache
+      belongs_to :item
+      has_many :deeply_associated_records
+      default_scope { order('id DESC') }
     }
 
-    Object.send :const_set, 'NormalizedAssociatedRecord', Class.new(base).tap {|klass|
-      klass.send :include, IdentityCache
-      klass.belongs_to :record
+    Object.send :const_set, 'NormalizedAssociatedRecord', Class.new(base) {
+      include IdentityCache
+      belongs_to :item
+      default_scope { order('id DESC') }
     }
 
-    Object.send :const_set, 'NotCachedRecord', Class.new(base).tap {|klass|
-      klass.belongs_to :record, :touch => true
+    Object.send :const_set, 'NotCachedRecord', Class.new(base) {
+      belongs_to :item, :touch => true
+      default_scope { order('id DESC') }
     }
 
-    Object.send :const_set, 'PolymorphicRecord', Class.new(base).tap {|klass|
-      klass.belongs_to :owner, :polymorphic => true
+    Object.send :const_set, 'PolymorphicRecord', Class.new(base) {
+      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 :normalized_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"
+    Object.send :const_set, 'Item', Class.new(base) {
+      include IdentityCache
+      belongs_to :item
+      has_many :associated_records
+      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'
     }
   end
 
@@ -62,6 +66,6 @@ module ActiveRecordObjects
     Object.send :remove_const, 'NormalizedAssociatedRecord'
     Object.send :remove_const, 'AssociatedRecord'
     Object.send :remove_const, 'NotCachedRecord'
-    Object.send :remove_const, 'Record'
+    Object.send :remove_const, 'Item'
   end
 end

data/test/helpers/database_connection.rb

@@ -28,11 +28,11 @@ module DatabaseConnection
   TABLES = {
     :polymorphic_records           => [[:string, :owner_type], [:integer, :owner_id], [:timestamps]],
     :deeply_associated_records     => [[:string, :name], [:integer, :associated_record_id]],
-    :associated_records            => [[:string, :name], [:integer, :record_id]],
-    :normalized_associated_records => [[:string, :name], [:integer, :record_id]],
-    :not_cached_records            => [[:string, :name], [:integer, :record_id]],
-    :records                       => [[:integer, :record_id], [:string, :title], [:timestamps]],
-    :records2                      => [[:integer, :record_id], [:string, :title], [:timestamps]]
+    :associated_records            => [[:string, :name], [:integer, :item_id]],
+    :normalized_associated_records => [[:string, :name], [:integer, :item_id]],
+    :not_cached_records            => [[:string, :name], [:integer, :item_id]],
+    :items                         => [[:integer, :item_id], [:string, :title], [:timestamps]],
+    :items2                        => [[:integer, :item_id], [:string, :title], [:timestamps]]
   }
 
   DATABASE_CONFIG = {

data/test/helpers/serialization_format.rb

@@ -1,22 +1,22 @@
 module SerializationFormat
   def serialized_record
     AssociatedRecord.cache_has_many :deeply_associated_records, :embed => true
-    AssociatedRecord.cache_belongs_to :record, :embed => false
-    Record.cache_has_many :associated_records, :embed => true
-    Record.cache_has_one :associated
+    AssociatedRecord.cache_belongs_to :item, :embed => false
+    Item.cache_has_many :associated_records, :embed => true
+    Item.cache_has_one :associated
 
-    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.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 = DateTime.new
+    record.created_at = Time.parse('1970-01-01T00:00:00 UTC')
     record.save
-    Record.update_all("updated_at='#{record.created_at}'", "id='#{record.id}'")
+    Item.where(id: record.id).update_all(updated_at: record.created_at)
     record.reload
-    Record.fetch(record.id)
+    Item.fetch(record.id)
     IdentityCache.fetch(record.primary_cache_index_key)
   end
 

data/test/index_cache_test.rb

@@ -5,82 +5,81 @@ class ExpirationTest < IdentityCache::TestCase
 
   def setup
     super
-    @record = Record.new
+    @record = Item.new
     @record.id = 1
     @record.title = 'bob'
-    @cache_key = "#{NAMESPACE}index:Record:title:#{cache_hash(@record.title)}"
+    @cache_key = "#{NAMESPACE}index:Item:title:#{cache_hash(@record.title)}"
   end
 
   def test_unique_index_caches_nil
-    Record.cache_index :title, :unique => true
-    assert_equal nil, Record.fetch_by_title('bob')
+    Item.cache_index :title, :unique => true
+    assert_equal nil, Item.fetch_by_title('bob')
     assert_equal IdentityCache::CACHED_NIL, IdentityCache.cache.read(@cache_key)
   end
 
   def test_unique_index_expired_by_new_record
-    Record.cache_index :title, :unique => true
+    Item.cache_index :title, :unique => true
     IdentityCache.cache.write(@cache_key, IdentityCache::CACHED_NIL)
     @record.save!
     assert_equal nil, IdentityCache.cache.read(@cache_key)
   end
 
   def test_unique_index_filled_on_fetch_by
-    Record.cache_index :title, :unique => true
+    Item.cache_index :title, :unique => true
     @record.save!
-    assert_equal @record, Record.fetch_by_title('bob')
+    assert_equal @record, Item.fetch_by_title('bob')
     assert_equal @record.id, IdentityCache.cache.read(@cache_key)
   end
 
   def test_unique_index_expired_by_updated_record
-    Record.cache_index :title, :unique => true
+    Item.cache_index :title, :unique => true
     @record.save!
     IdentityCache.cache.write(@cache_key, @record.id)
 
     @record.title = 'robert'
-    new_cache_key = "#{NAMESPACE}index:Record:title:#{cache_hash(@record.title)}"
+    new_cache_key = "#{NAMESPACE}index:Item:title:#{cache_hash(@record.title)}"
     IdentityCache.cache.write(new_cache_key, IdentityCache::CACHED_NIL)
     @record.save!
     assert_equal nil, IdentityCache.cache.read(@cache_key)
     assert_equal nil, IdentityCache.cache.read(new_cache_key)
   end
 
-
   def test_non_unique_index_caches_empty_result
-    Record.cache_index :title
-    assert_equal [], Record.fetch_by_title('bob')
+    Item.cache_index :title
+    assert_equal [], Item.fetch_by_title('bob')
     assert_equal [], IdentityCache.cache.read(@cache_key)
   end
 
   def test_non_unique_index_expired_by_new_record
-    Record.cache_index :title
+    Item.cache_index :title
     IdentityCache.cache.write(@cache_key, [])
     @record.save!
     assert_equal nil, IdentityCache.cache.read(@cache_key)
   end
 
   def test_non_unique_index_filled_on_fetch_by
-    Record.cache_index :title
+    Item.cache_index :title
     @record.save!
-    assert_equal [@record], Record.fetch_by_title('bob')
+    assert_equal [@record], Item.fetch_by_title('bob')
     assert_equal [@record.id], IdentityCache.cache.read(@cache_key)
   end
 
   def test_non_unique_index_fetches_multiple_records
-    Record.cache_index :title
+    Item.cache_index :title
     @record.save!
-    record2 = Record.create(:id => 2, :title => 'bob')
+    record2 = Item.create(:id => 2, :title => 'bob')
 
-    assert_equal [@record, record2], Record.fetch_by_title('bob')
+    assert_equal [@record, record2], Item.fetch_by_title('bob')
     assert_equal [1, 2], IdentityCache.cache.read(@cache_key)
   end
 
   def test_non_unique_index_expired_by_updating_record
-    Record.cache_index :title
+    Item.cache_index :title
     @record.save!
     IdentityCache.cache.write(@cache_key, [@record.id])
 
     @record.title = 'robert'
-    new_cache_key = "#{NAMESPACE}index:Record:title:#{cache_hash(@record.title)}"
+    new_cache_key = "#{NAMESPACE}index:Item:title:#{cache_hash(@record.title)}"
     IdentityCache.cache.write(new_cache_key, [])
     @record.save!
     assert_equal nil, IdentityCache.cache.read(@cache_key)
@@ -88,7 +87,7 @@ class ExpirationTest < IdentityCache::TestCase
   end
 
   def test_non_unique_index_expired_by_destroying_record
-    Record.cache_index :title
+    Item.cache_index :title
     @record.save!
     IdentityCache.cache.write(@cache_key, [@record.id])
     @record.destroy
@@ -96,10 +95,10 @@ class ExpirationTest < IdentityCache::TestCase
   end
 
   def test_set_table_name_cache_fetch
-    Record.cache_index :title
-    Record.table_name = 'records2'
+    Item.cache_index :title
+    Item.table_name = 'items2'
     @record.save!
-    assert_equal [@record], Record.fetch_by_title('bob')
+    assert_equal [@record], Item.fetch_by_title('bob')
     assert_equal [@record.id], IdentityCache.cache.read(@cache_key)
   end
 end

data/test/memoized_cache_proxy_test.rb

@@ -102,4 +102,9 @@ class MemoizedCacheProxyTest < IdentityCache::TestCase
     assert_equal 'bar', Rails.cache.read('foo')
   end
 
+  def test_set_backend_should_not_touch_rails
+    Rails.expects(:cache).never
+    IdentityCache.instance_variable_set(:@cache, nil)
+    IdentityCache.cache_backend = Rails::Cache.new
+  end
 end

data/test/normalized_belongs_to_test.rb

@@ -3,9 +3,9 @@ require "test_helper"
 class NormalizedBelongsToTest < IdentityCache::TestCase
   def setup
     super
-    AssociatedRecord.cache_belongs_to :record, :embed => false
+    AssociatedRecord.cache_belongs_to :item, :embed => false
 
-    @parent_record = Record.new(:title => 'foo')
+    @parent_record = Item.new(:title => 'foo')
     @parent_record.associated_records << AssociatedRecord.new(:name => 'bar')
     @parent_record.save
     @parent_record.reload
@@ -13,34 +13,34 @@ class NormalizedBelongsToTest < IdentityCache::TestCase
   end
 
   def test_fetching_the_association_should_delegate_to_the_normal_association_fetcher_if_any_transactions_are_open
-    Record.expects(:fetch_by_id).never
+    Item.expects(:fetch_by_id).never
     @record.transaction do
-      assert_equal @parent_record, @record.fetch_record
+      assert_equal @parent_record, @record.fetch_item
     end
   end
 
   def test_fetching_the_association_should_delegate_to_the_normal_association_fetcher_if_the_normal_association_is_loaded
     # Warm the ActiveRecord association
-    @record.record
+    @record.item
 
-    Record.expects(:fetch_by_id).never
-    assert_equal @parent_record, @record.fetch_record
+    Item.expects(:fetch_by_id).never
+    assert_equal @parent_record, @record.fetch_item
   end
 
   def test_fetching_the_association_should_fetch_the_record_from_identity_cache
-    Record.expects(:fetch_by_id).with(@parent_record.id).returns(@parent_record)
-    assert_equal @parent_record, @record.fetch_record
+    Item.expects(:fetch_by_id).with(@parent_record.id).returns(@parent_record)
+    assert_equal @parent_record, @record.fetch_item
   end
 
   def test_fetching_the_association_should_assign_the_result_to_the_association_so_that_successive_accesses_are_cached
-    Record.expects(:fetch_by_id).with(@parent_record.id).returns(@parent_record)
-    @record.fetch_record
-    assert @record.association(:record).loaded?
-    assert_equal @parent_record, @record.record
+    Item.expects(:fetch_by_id).with(@parent_record.id).returns(@parent_record)
+    @record.fetch_item
+    assert @record.association(:item).loaded?
+    assert_equal @parent_record, @record.item
   end
 
   def test_fetching_the_association_shouldnt_raise_if_the_record_cant_be_found
-    Record.expects(:fetch_by_id).with(@parent_record.id).returns(nil)
-    assert_equal nil, @record.fetch_record
+    Item.expects(:fetch_by_id).with(@parent_record.id).returns(nil)
+    assert_equal nil, @record.fetch_item
   end
 end