identity_cache 0.3.1 → 0.3.2

data/lib/identity_cache.rb

@@ -40,6 +40,25 @@ module IdentityCache
     mattr_accessor :cache_namespace
     self.cache_namespace = "IDC:#{CACHE_VERSION}:".freeze
 
+    version = Gem::Version.new(IdentityCache::VERSION)
+
+    # fetch_#{association} for a cache_has_many association returns a relation
+    # when fetch_returns_relation is set to true and an array when set to false.
+    mattr_accessor :fetch_returns_relation
+    self.fetch_returns_relation = version < Gem::Version.new("0.4")
+
+    # Inverse active record associations are set when loading embedded
+    # cache_has_many associations from the cache when never_set_inverse_association
+    # is false. When set to true, it will only set the inverse cached association.
+    mattr_accessor :never_set_inverse_association
+    self.never_set_inverse_association = version >= Gem::Version.new("0.4")
+
+    # Fetched records are not read-only and this could sometimes prevent IDC from
+    # reflecting what's truly in the database when fetch_read_only_records is false.
+    # When set to true, it will only return read-only records when cache is used.
+    mattr_accessor :fetch_read_only_records
+    self.fetch_read_only_records = version >= Gem::Version.new("0.4")
+
     def included(base) #:nodoc:
       raise AlreadyIncludedError if base.include?(IdentityCache::ConfigurationDSL)
 
@@ -58,7 +77,7 @@ module IdentityCache
     # +cache_adaptor+ - A ActiveSupport::Cache::Store
     #
     def cache_backend=(cache_adaptor)
-      if @cache
+      if defined?(@cache)
         cache.cache_backend = cache_adaptor
       else
         @cache = MemoizedCacheProxy.new(cache_adaptor)
@@ -131,6 +150,31 @@ module IdentityCache
       result
     end
 
+    def with_fetch_returns_relation(value = true)
+      previous_value = self.fetch_returns_relation
+      self.fetch_returns_relation = value
+      yield
+    ensure
+      self.fetch_returns_relation = previous_value
+    end
+
+    def with_never_set_inverse_association(value = true)
+      old_value = self.never_set_inverse_association
+      self.never_set_inverse_association = value
+      yield
+    ensure
+      self.never_set_inverse_association = old_value
+    end
+
+
+    def with_fetch_read_only_records(value = true)
+      old_value = self.fetch_read_only_records
+      self.fetch_read_only_records = value
+      yield
+    ensure
+      self.fetch_read_only_records = old_value
+    end
+
     private
 
     def fetch_in_batches(keys)

data/performance/cache_runner.rb

@@ -14,7 +14,7 @@ require File.dirname(__FILE__) + '/../test/helpers/database_connection'
 
 IdentityCache.logger = Logger.new(nil)
 IdentityCache.cache_backend = ActiveSupport::Cache::MemcachedStore.new("localhost:#{$memcached_port}", :support_cas => true)
-
+ActiveRecord::Base.raise_in_transactional_callbacks = true
 
 def create_record(id)
   Item.new(id)

data/test/cache_hash_test.rb

@@ -3,8 +3,6 @@ require 'test_helper'
 class CacheHashTest < IdentityCache::TestCase
 
   def test_memcache_hash
-
-    prng = Random.new(Time.now.to_i)
     3.times do
       random_str = Array.new(200){rand(36).to_s(36)}.join
       hash_val = IdentityCache.memcache_hash(random_str)

data/test/cache_invalidation_test.rb

@@ -10,6 +10,7 @@ class CacheInvalidationTest < IdentityCache::TestCase
     @record.save
     @record.reload
     @baz, @bar = @record.associated_records[0], @record.associated_records[1]
+    @record.reload
   end
 
   def test_reload_invalidate_cached_ids
@@ -21,7 +22,7 @@ class CacheInvalidationTest < IdentityCache::TestCase
     assert_equal [@baz.id, @bar.id], @record.instance_variable_get(variable_name)
 
     @record.reload
-    assert_equal nil, @record.instance_variable_get(variable_name)
+    assert_equal false, @record.instance_variable_defined?(variable_name)
 
     @record.fetch_associated_record_ids
     assert_equal [@baz.id, @bar.id], @record.instance_variable_get(variable_name)
@@ -36,7 +37,7 @@ class CacheInvalidationTest < IdentityCache::TestCase
     assert_equal [@baz, @bar], @record.instance_variable_get(variable_name)
 
     @record.reload
-    assert_equal nil, @record.instance_variable_get(variable_name)
+    assert_equal false, @record.instance_variable_defined?(variable_name)
 
     @record.fetch_associated_records
     assert_equal [@baz, @bar], @record.instance_variable_get(variable_name)
@@ -45,14 +46,14 @@ class CacheInvalidationTest < IdentityCache::TestCase
   def test_after_a_reload_the_cache_perform_as_expected
     Item.cache_has_many :associated_records, :embed => :ids
 
-    assert_equal [@baz, @bar], @record.associated_records
     assert_equal [@baz, @bar], @record.fetch_associated_records
+    assert_equal [@baz, @bar], @record.associated_records
 
     @baz.destroy
     @record.reload
 
-    assert_equal [@bar], @record.associated_records
     assert_equal [@bar], @record.fetch_associated_records
+    assert_equal [@bar], @record.associated_records
   end
 
   def test_cache_invalidation_expire_properly_if_child_is_embed_in_multiple_parents

data/test/denormalized_has_many_test.rb

@@ -12,6 +12,14 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
     @record.reload
   end
 
+  def test_uncached_record_from_the_db_should_come_back_with_association_array_when_fetch_returns_array
+    IdentityCache.with_fetch_returns_relation(false) do    
+      assert_equal IdentityCache.fetch_returns_relation, false
+      record_from_db = Item.find(@record.id)
+      assert_equal Array, record_from_db.fetch_associated_records.class
+    end
+  end
+
   def test_uncached_record_from_the_db_will_use_normal_association
     expected = @record.associated_records
     record_from_db = Item.find(@record.id)
@@ -22,6 +30,17 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
     assert_equal expected, record_from_db.fetch_associated_records
   end
 
+  def test_on_cache_hit_record_should_come_back_with_cached_association_array_when_fetch_returns_array
+    IdentityCache.with_fetch_returns_relation(false) do  
+      assert_equal IdentityCache.fetch_returns_relation, false
+      Item.fetch(@record.id) # warm cache
+
+      record_from_cache_hit = Item.fetch(@record.id)
+      assert_equal @record, record_from_cache_hit
+      assert_equal Array, record_from_cache_hit.fetch_associated_records.class
+    end
+  end
+
   def test_on_cache_hit_record_should_come_back_with_cached_association
     Item.fetch(@record.id) # warm cache
 
@@ -94,16 +113,91 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
     child.save!
   end
 
-  def test_unsupported_through_assocation
-    assert_raises IdentityCache::UnsupportedAssociationError, "caching through associations isn't supported" do
-      Item.has_many :deeply_through_associated_records, :through => :associated_records, foreign_key: 'associated_record_id', inverse_of: :item, :class_name => 'DeeplyAssociatedRecord'
-      Item.cache_has_many :deeply_through_associated_records, :embed => true
+  def test_fetch_association_does_not_allow_chaining_when_fetch_returns_array
+    IdentityCache.with_fetch_returns_relation(false) do
+      check = proc { assert_equal false, Item.fetch(@record.id).fetch_associated_records.respond_to?(:where) }
+      2.times { check.call } # for miss and hit
+      Item.transaction { check.call }
+    end
+  end
+
+  def test_never_set_inverse_association_on_cache_hit
+    Item.fetch(@record.id) # warm cache
+
+    item = IdentityCache.with_never_set_inverse_association do
+      Item.fetch(@record.id)
     end
+
+    associated_record = item.fetch_associated_records.to_a.first
+    assert item.object_id != associated_record.item.object_id
+  end
+
+  def test_deprecated_set_inverse_association_on_cache_hit
+    Item.fetch(@record.id) # warm cache
+
+    item = Item.fetch(@record.id)
+
+    associated_record = item.fetch_associated_records.to_a.first
+    assert_equal item.object_id, associated_record.item.object_id
   end
 
-  def test_cache_has_many_on_derived_model_raises
-    assert_raises(IdentityCache::DerivedModelError) do
-      StiRecordTypeA.cache_has_many :polymorphic_records, :inverse_name => :owner, :embed => true
+  def test_returned_records_should_be_readonly_on_cache_hit
+    IdentityCache.with_fetch_read_only_records do
+      Item.fetch(@record.id) # warm cache
+      record_from_cache_hit = Item.fetch(@record.id)
+      assert record_from_cache_hit.fetch_associated_records.all?(&:readonly?)
+    end
+  end
+
+  def test_returned_records_should_be_readonly_on_cache_miss
+    IdentityCache.with_fetch_read_only_records do
+      record_from_cache_miss = Item.fetch(@record.id)
+      assert record_from_cache_miss.fetch_associated_records.all?(&:readonly?)
+    end
+  end
+
+  def test_db_returned_records_should_never_be_readonly
+    IdentityCache.with_fetch_read_only_records do
+      record_from_db = Item.find(@record.id)
+      uncached_records = record_from_db.associated_records
+      assert uncached_records.none?(&:readonly?)
+      assert record_from_db.fetch_associated_records.all?(&:readonly?)
+      assert record_from_db.associated_records.none?(&:readonly?)
+    end
+  end
+
+  def test_returned_records_with_open_transactions_should_not_be_readonly
+    IdentityCache.with_fetch_read_only_records do
+      Item.transaction do
+        assert_equal IdentityCache.should_use_cache?, false
+        assert Item.fetch(@record.id).fetch_associated_records.none?(&:readonly?)
+      end
+    end
+  end
+
+  class CheckAssociationTest < IdentityCache::TestCase
+    def test_unsupported_through_assocation
+      assert_raises IdentityCache::UnsupportedAssociationError, "caching through associations isn't supported" do
+        Item.has_many :deeply_through_associated_records, :through => :associated_records, foreign_key: 'associated_record_id', inverse_of: :item, :class_name => 'DeeplyAssociatedRecord'
+        Item.cache_has_many :deeply_through_associated_records, :embed => true
+      end
+    end
+
+    def test_unsupported_joins_in_assocation_scope
+      scope = -> { joins(:associated_record).where(associated_records: { name: 'contrived example' }) }
+      Item.has_many :deeply_joined_associated_records, scope, inverse_of: :item, class_name: 'DeeplyAssociatedRecord'
+      Item.cache_has_many :deeply_joined_associated_records, :embed => true
+
+      message = "caching association Item.deeply_joined_associated_records scoped with a join isn't supported"
+      assert_raises IdentityCache::UnsupportedAssociationError, message do
+        Item.fetch(1)
+      end
+    end
+
+    def test_cache_has_many_on_derived_model_raises
+      assert_raises(IdentityCache::DerivedModelError) do
+        StiRecordTypeA.cache_has_many :polymorphic_records, :inverse_name => :owner, :embed => true
+      end
     end
   end
 end

data/test/denormalized_has_one_test.rb

@@ -120,4 +120,40 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
       StiRecordTypeA.cache_has_one :polymorphic_record, :inverse_name => :owner, :embed => true
     end
   end
+
+  def test_returned_record_should_be_readonly_on_cache_hit
+    IdentityCache.with_fetch_read_only_records do
+      Item.fetch_by_title('foo')
+      record_from_cache_hit = Item.fetch_by_title('foo')
+      assert record_from_cache_hit.fetch_associated.readonly?
+      refute record_from_cache_hit.associated.readonly?
+    end
+  end
+
+  def test_returned_record_should_be_readonly_on_cache_miss
+    IdentityCache.with_fetch_read_only_records do
+      assert IdentityCache.should_use_cache?
+      record_from_cache_miss = Item.fetch_by_title('foo')
+      assert record_from_cache_miss.fetch_associated.readonly?
+    end
+  end
+
+  def test_db_returned_record_should_never_be_readonly
+    IdentityCache.with_fetch_read_only_records do
+      record_from_db = Item.find_by_title('foo')
+      uncached_record = record_from_db.associated
+      refute uncached_record.readonly?
+      record_from_db.fetch_associated
+      refute uncached_record.readonly?
+    end
+  end
+
+  def test_returned_record_with_open_transactions_should_not_be_readonly
+    IdentityCache.with_fetch_read_only_records do
+      Item.transaction do
+        refute IdentityCache.should_use_cache?
+        refute Item.fetch_by_title('foo').fetch_associated.readonly?
+      end
+    end
+  end
 end

data/test/fetch_multi_test.rb

@@ -223,6 +223,48 @@ class FetchMultiTest < IdentityCache::TestCase
     end
   end
 
+  def test_fetch_multi_with_mixed_hits_and_misses_returns_only_readonly_records
+    IdentityCache.with_fetch_read_only_records do
+      cache_response = {}
+      cache_response[@bob_blob_key] = cache_response_for(@bob)
+      cache_response[@joe_blob_key] = nil
+      cache_response[@fred_blob_key] = cache_response_for(@fred)
+      fetch_multi = fetch_multi_stub(cache_response)
+
+      response = Item.fetch_multi(@bob.id, @joe.id, @fred.id)
+      assert fetch_multi.has_been_called_with?(@bob_blob_key, @joe_blob_key, @fred_blob_key)
+      assert_equal [@bob, @joe, @fred], response
+
+      assert response.all?(&:readonly?)
+    end
+  end
+
+  def test_fetch_multi_with_mixed_hits_and_misses_and_responses_in_the_wrong_order_returns_readonly
+    IdentityCache.with_fetch_read_only_records do
+      cache_response = {}
+      cache_response[@bob_blob_key] = nil
+      cache_response[@joe_blob_key] = nil
+      cache_response[@fred_blob_key] = cache_response_for(@fred)
+      fetch_multi = fetch_multi_stub(cache_response)
+
+      response = Item.fetch_multi(@bob.id, @joe.id, @fred.id)
+      assert fetch_multi.has_been_called_with?(@bob_blob_key, @joe_blob_key, @fred_blob_key)
+      assert_equal [@bob, @joe, @fred], response
+
+      assert response.all?(&:readonly?)
+    end
+  end
+
+  def test_fetch_multi_with_open_transactions_returns_non_readonly_records
+    IdentityCache.with_fetch_read_only_records do
+      Item.transaction do
+        assert_equal IdentityCache.should_use_cache?, false
+        IdentityCache.cache.expects(:fetch_multi).never
+        assert Item.fetch_multi(@bob.id, @joe.id, @fred.id).none?(&:readonly?)
+      end
+    end
+  end
+
   private
 
   def populate_only_fred

data/test/fetch_test.rb

@@ -212,4 +212,36 @@ class FetchTest < IdentityCache::TestCase
       StiRecordTypeA.fetch(1)
     end
   end
+
+  def test_returned_records_are_readonly_on_cache_hit
+    IdentityCache.with_fetch_read_only_records do
+      IdentityCache.cache.expects(:fetch).with(@blob_key).returns(@cached_value)
+      assert Item.fetch(1).readonly?
+    end
+  end
+
+  def test_returned_records_are_readonly_on_cache_miss
+    IdentityCache.with_fetch_read_only_records do
+      fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
+      Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
+
+      assert Item.exists_with_identity_cache?(1)
+      assert fetch.has_been_called_with?(@blob_key)
+      assert Item.fetch(1).readonly?
+    end
+  end
+
+  def test_returned_records_are_not_readonly_with_open_transactions
+    IdentityCache.with_fetch_read_only_records do
+
+      @record.transaction do
+        fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
+        Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
+
+        refute IdentityCache.should_use_cache?
+        refute fetch.has_been_called_with?(@blob_key)
+        refute Item.fetch(1).readonly?, "Fetched item was read-only"
+      end
+    end
+  end
 end

data/test/helpers/database_connection.rb

@@ -50,14 +50,15 @@ module DatabaseConnection
     'mysql2' => {
       'adapter'  => 'mysql2',
       'database' => 'identity_cache_test',
-      'host'     => '127.0.0.1',
+      'host'     => ENV['MYSQL_HOST'] || '127.0.0.1',
       'username' => 'root'
     },
     'postgresql' => {
       'adapter'  => 'postgresql',
       'database' => 'identity_cache_test',
-      'host'     => '127.0.0.1',
-      'username' => 'postgres'
+      'host'     => ENV['POSTGRES_HOST'] || '127.0.0.1',
+      'username' => 'postgres',
+      'prepared_statements' => false,
     }
   }
 end

data/test/index_cache_test.rb

@@ -143,13 +143,13 @@ class IndexCacheTest < IdentityCache::TestCase
 
   def test_cache_index_with_non_id_primary_key
     KeyedRecord.cache_index :value
-    fixture = KeyedRecord.create!(value: "a") { |r| r.hashed_key = 123 }
+    KeyedRecord.create!(value: "a") { |r| r.hashed_key = 123 }
     assert_equal [123], KeyedRecord.fetch_by_value('a').map(&:id)
   end
 
   def test_unique_cache_index_with_non_id_primary_key
     KeyedRecord.cache_index :value, unique: true
-    fixture = KeyedRecord.create!(value: "a") { |r| r.hashed_key = 123 }
+    KeyedRecord.create!(value: "a") { |r| r.hashed_key = 123 }
     assert_equal 123, KeyedRecord.fetch_by_value('a').id
   end
 

data/test/memoized_attributes_test.rb

@@ -0,0 +1,49 @@
+require "test_helper"
+
+class MemoizedAttributesTest < IdentityCache::TestCase
+  def test_memoization_should_not_break_dirty_tracking_with_empty_cache
+    item = Item.create!
+
+    IdentityCache.cache.with_memoization do
+      Item.fetch(item.id).title = "my title"
+      Item.fetch(item.id).update!(title: "my title")
+    end
+
+    assert_equal "my title", Item.find(item.id).title
+  end
+
+  def test_memoization_should_not_break_dirty_tracking_with_filled_cache
+    item = Item.create!
+
+    IdentityCache.cache.with_memoization do
+      Item.fetch(item.id)
+      Item.fetch(item.id).title = "my title"
+      Item.fetch(item.id).update!(title: "my title")
+    end
+
+    assert_equal "my title", Item.find(item.id).title
+  end
+
+  def test_memoization_with_fetch_multi_should_not_break_dirty_tracking_with_empty_cache
+    item = Item.create!
+
+    IdentityCache.cache.with_memoization do
+      Item.fetch_multi(item.id).first.title = "my title"
+      Item.fetch_multi(item.id).first.update!(title: "my title")
+    end
+
+    assert_equal "my title", Item.find(item.id).title
+  end
+
+  def test_memoization_with_fetch_multi_should_not_break_dirty_tracking_with_filled_cache
+    item = Item.create!
+
+    IdentityCache.cache.with_memoization do
+      Item.fetch_multi(item.id)
+      Item.fetch_multi(item.id).first.title = "my title"
+      Item.fetch_multi(item.id).first.update!(title: "my title")
+    end
+
+    assert_equal "my title", Item.find(item.id).title
+  end
+end

data/test/normalized_belongs_to_test.rb

@@ -60,4 +60,28 @@ class NormalizedBelongsToTest < IdentityCache::TestCase
 
     assert_equal @parent_record, PolymorphicRecord.first.fetch_owner
   end
+
+  def test_returned_record_should_be_readonly_on_cache_hit
+    IdentityCache.with_fetch_read_only_records do
+      @record.fetch_item # warm cache
+      assert @record.fetch_item.readonly?
+      refute @record.item.readonly?
+    end
+  end
+
+  def test_returned_record_should_be_readonly_on_cache_miss
+    IdentityCache.with_fetch_read_only_records do
+      assert @record.fetch_item.readonly?
+      refute @record.item.readonly?
+    end
+  end
+
+  def test_returned_record_with_open_transactions_should_not_be_readonly
+    IdentityCache.with_fetch_read_only_records do
+      Item.transaction do
+        refute IdentityCache.should_use_cache?
+        refute @record.fetch_item.readonly?
+      end
+    end
+  end
 end

data/test/normalized_has_many_test.rb

@@ -111,9 +111,10 @@ class NormalizedHasManyTest < IdentityCache::TestCase
   def test_fetching_the_association_should_delegate_to_the_normal_association_fetcher_if_any_transaction_are_open
     @record = Item.fetch(@record.id)
 
-    Item.expects(:fetch_multi).never
-    @record.transaction do
-      assert_equal [@baz, @bar], @record.fetch_associated_records
+    assert_memcache_operations(0) do
+      @record.transaction do
+        assert_equal [@baz, @bar], @record.fetch_associated_records
+      end
     end
   end
 
@@ -121,8 +122,9 @@ class NormalizedHasManyTest < IdentityCache::TestCase
     # Warm the ActiveRecord association
     @record.associated_records.to_a
 
-    Item.expects(:fetch_multi).never
-    assert_equal [@baz, @bar], @record.fetch_associated_records
+    assert_memcache_operations(0) do
+      assert_equal [@baz, @bar], @record.fetch_associated_records
+    end
   end
 
   def test_saving_a_child_record_shouldnt_expire_the_parents_blob_if_the_foreign_key_hasnt_changed
@@ -195,4 +197,26 @@ class NormalizedHasManyTest < IdentityCache::TestCase
     @not_cached.save!
   end
 
+  def test_fetch_association_does_not_allow_chaining_when_fetch_returns_array
+    IdentityCache.with_fetch_returns_relation(false) do
+      check = proc { assert_equal false, Item.fetch(@record.id).fetch_associated_records.respond_to?(:where) }
+      2.times { check.call } # for miss and hit
+      Item.transaction { check.call }
+    end
+  end
+
+  def test_returned_records_should_be_readonly_on_cache_hit
+    IdentityCache.with_fetch_read_only_records do
+      Item.fetch(@record.id) # warm cache
+      record_from_cache_hit = Item.fetch(@record.id)
+      record_from_cache_hit.fetch_associated_records.all?(&:readonly?)
+    end
+  end
+
+  def test_returned_records_should_be_readonly_on_cache_miss
+    IdentityCache.with_fetch_read_only_records do
+      record_from_cache_miss = Item.fetch(@record.id)
+      assert record_from_cache_miss.fetch_associated_records.all?(&:readonly?)
+    end
+  end
 end