identity_cache 0.0.1

data/lib/identity_cache/version.rb

@@ -0,0 +1,3 @@
+module IdentityCache
+  VERSION = "0.0.1"
+end

data/lib/memoized_cache_proxy.rb

@@ -0,0 +1,71 @@
+require 'monitor'
+
+module IdentityCache
+  class MemoizedCacheProxy
+    attr_writer :memcache
+
+    def initialize(memcache = nil)
+      @memcache = memcache || Rails.cache
+      @key_value_maps = Hash.new {|h, k| h[k] = {} }
+    end
+
+    def memoized_key_values
+      @key_value_maps[Thread.current.object_id]
+    end
+
+    def with_memoization(&block)
+      Thread.current[:memoizing_idc] = true
+      yield
+    ensure
+      clear_memoization
+      Thread.current[:memoizing_idc] = false
+    end
+
+    def write(key, value)
+      memoized_key_values[key] = value if memoizing?
+      @memcache.write(key, value)
+    end
+
+    def read(key)
+      if memoizing?
+        memoized_key_values[key] ||= @memcache.read(key)
+      else
+        @memcache.read(key)
+      end
+    end
+
+    def delete(key)
+      memoized_key_values.delete(key) if memoizing?
+      @memcache.delete(key)
+    end
+
+    def read_multi(*keys)
+      hash = {}
+
+      if memoizing?
+        keys.reduce({}) do |hash, key|
+          hash[key] = memoized_key_values[key] if memoized_key_values[key].present?
+          hash
+        end
+      end
+
+      missing_keys = keys - hash.keys
+      hash.merge(@memcache.read_multi(*missing_keys))
+    end
+
+    def clear
+      clear_memoization
+      @memcache.clear
+    end
+
+    private
+
+    def clear_memoization
+      @key_value_maps.delete(Thread.current.object_id)
+    end
+
+    def memoizing?
+      Thread.current[:memoizing_idc]
+    end
+  end
+end

data/test/attribute_cache_test.rb

@@ -0,0 +1,73 @@
+require "test_helper"
+
+class AttributeCacheTest < IdentityCache::TestCase
+  def setup
+    super
+    AssociatedRecord.cache_attribute :name
+    AssociatedRecord.cache_attribute :record, :by => [:id, :name]
+
+    @parent = Record.create!(:title => 'bob')
+    @record = @parent.associated_records.create!(:name => 'foo')
+    @name_attribute_key = "IDC:attribute:AssociatedRecord:name:id:#{cache_hash(@record.id.to_s)}"
+    @blob_key = "IDC:blob:AssociatedRecord:#{cache_hash("id:integer,name:string,record_id:integer")}:1"
+  end
+
+  def test_attribute_values_are_returned_on_cache_hits
+    IdentityCache.cache.expects(:read).with(@name_attribute_key).returns('foo')
+    assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+  end
+
+  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')
+    assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+  end
+
+  def test_attribute_values_are_stored_in_the_cache_on_cache_misses
+
+    # Cache miss, so
+    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')
+
+    # And write it back to the cache
+    IdentityCache.cache.expects(:write).with(@name_attribute_key, 'foo').returns(nil)
+
+    assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+  end
+
+  def test_cached_attribute_values_are_expired_from_the_cache_when_an_existing_record_is_saved
+    IdentityCache.cache.expects(:delete).with(@name_attribute_key)
+    IdentityCache.cache.expects(:delete).with(@blob_key)
+    @record.save!
+  end
+
+  def test_cached_attribute_values_are_expired_from_the_cache_when_an_existing_record_with_changed_attributes_is_saved
+    IdentityCache.cache.expects(:delete).with(@name_attribute_key)
+    IdentityCache.cache.expects(:delete).with(@blob_key)
+    @record.name = 'bar'
+    @record.save!
+  end
+
+  def test_cached_attribute_values_are_expired_from_the_cache_when_an_existing_record_is_destroyed
+    IdentityCache.cache.expects(:delete).with(@name_attribute_key)
+    IdentityCache.cache.expects(:delete).with(@blob_key)
+    @record.destroy
+  end
+
+  def test_cached_attribute_values_are_expired_from_the_cache_when_a_new_record_is_saved
+    IdentityCache.cache.expects(:delete).with("IDC:blob:AssociatedRecord:#{cache_hash("id:integer,name:string,record_id:integer")}:2")
+    @parent.associated_records.create(:name => 'bar')
+  end
+
+  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.transaction do
+      assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
+    end
+  end
+end

data/test/denormalized_has_many_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+class DenormalizedHasManyTest < IdentityCache::TestCase
+  def setup
+    super
+    Record.cache_has_many :associated_records, :embed => true
+
+    @record = Record.new(:title => 'foo')
+    @record.associated_records << AssociatedRecord.new(:name => 'bar')
+    @record.associated_records << AssociatedRecord.new(:name => 'baz')
+    @record.save
+    @record.reload
+  end
+
+  def test_uncached_record_from_the_db_will_use_normal_association
+    expected = @record.associated_records
+    record_from_db = Record.find(@record.id)
+
+    Record.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
+
+    record_from_cache_hit = Record.fetch(@record.id)
+    assert_equal @record, record_from_cache_hit
+
+    expected = @record.associated_records
+    Record.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)
+    expected = @record.associated_records
+
+    assert_equal @record, record_from_cache_miss
+    assert_equal expected, record_from_cache_miss.fetch_associated_records
+  end
+
+  def test_changes_in_associated_records_should_expire_the_parents_cache
+    Record.fetch(@record.id)
+    key = @record.primary_cache_index_key
+    assert_not_nil IdentityCache.cache.read(key)
+
+    IdentityCache.cache.expects(:delete).with(key)
+    @record.associated_records.first.save
+  end
+
+  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_key = @new_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.save!
+  end
+
+  def test_cached_associations_after_commit_hook_will_not_fail_on_undefined_parent_association
+    ar = AssociatedRecord.new
+    ar.save
+    assert_nothing_raised { ar.expire_parent_cache }
+  end
+
+  def test_cache_without_guessable_inverse_name_raises
+    assert_raises IdentityCache::InverseAssociationError do
+      Record.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
+    end
+  end
+
+  def test_touching_associated_records_should_expire_itself_and_the_parents_cache
+    child = @record.associated_records.first
+    IdentityCache.cache.expects(:delete).with(child.primary_cache_index_key).once
+    IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key)
+    child.touch
+  end
+end

data/test/denormalized_has_one_test.rb

@@ -0,0 +1,99 @@
+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')
+    @record.associated = AssociatedRecord.new(:name => 'bar')
+    @record.save
+
+    @record.reload
+  end
+
+  def test_on_cache_miss_record_should_embed_associated_object
+    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')
+
+    assert_equal @record, record_from_cache_miss
+    assert_not_nil @record.fetch_associated
+    assert_equal @record.associated, record_from_cache_miss.fetch_associated
+  end
+
+  def test_on_cache_miss_record_should_embed_nil_object
+    @record.expects(:associated => nil)
+    Record.expects(:find_by_id).with(@record.id, :include => Record.cache_fetch_includes).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.expects(:associated).never
+
+    assert_equal @record, record_from_cache_miss
+    5.times do
+      assert_nil record_from_cache_miss.fetch_associated
+    end
+  end
+
+  def test_on_record_from_the_db_will_use_normal_association
+    record_from_db = Record.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_from_cache_hit = Record.fetch_by_title('foo')
+    expected = @record.associated
+
+    assert_equal @record, record_from_cache_hit
+    assert_equal expected, record_from_cache_hit.fetch_associated
+  end
+
+  def test_on_cache_hit_record_should_come_back_with_cached_nil_association
+    @record.expects(:associated => nil)
+    Record.expects(:find_by_id).with(1, :include => Record.cache_fetch_includes).once.returns(@record)
+    Record.fetch_by_title('foo')
+
+    record_from_cache_hit = Record.fetch_by_title('foo')
+    record_from_cache_hit.expects(:associated).never
+
+    assert_equal @record, record_from_cache_hit
+    5.times do
+      assert_nil record_from_cache_hit.fetch_associated
+    end
+  end
+
+  def test_changes_in_associated_record_should_expire_the_parents_cache
+    Record.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)
+    @record.associated.save
+  end
+
+  def test_cached_associations_after_commit_hook_will_not_fail_on_undefined_parent_association
+    ar = AssociatedRecord.new
+    ar.save
+    assert_nothing_raised { ar.expire_parent_cache }
+  end
+
+  def test_cache_without_guessable_inverse_name_raises
+    assert_raises IdentityCache::InverseAssociationError do
+      Record.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
+    end
+  end
+end

data/test/fetch_multi_test.rb

@@ -0,0 +1,144 @@
+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,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"
+  end
+
+  def test_fetch_multi_with_no_records
+    assert_equal [], Record.fetch_multi
+  end
+
+  def test_fetch_multi_with_all_hits
+    cache_response = {}
+    cache_response[@bob_blob_key] = @bob
+    cache_response[@joe_blob_key] = @joe
+    cache_response[@fred_blob_key] = @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)
+  end
+
+  def test_fetch_multi_with_all_misses
+    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)
+    assert_equal [@bob, @joe, @fred], Record.fetch_multi(@bob.id, @joe.id, @fred.id)
+  end
+
+  def test_fetch_multi_with_mixed_hits_and_misses
+    cache_response = {}
+    cache_response[@bob_blob_key] = @bob
+    cache_response[@joe_blob_key] = nil
+    cache_response[@fred_blob_key] = @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)
+  end
+
+  def test_fetch_multi_with_mixed_hits_and_misses_and_responses_in_the_wrong_order
+    cache_response = {}
+    cache_response[@bob_blob_key] = nil
+    cache_response[@joe_blob_key] = nil
+    cache_response[@fred_blob_key] = @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)
+  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)
+  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)
+  end
+
+
+  def test_fetch_multi_works_with_nils
+    cache_result = {1 => IdentityCache::CACHED_NIL, 2 => IdentityCache::CACHED_NIL}
+    fetch_result = {1 => nil, 2 => nil}
+
+    IdentityCache.cache.expects(:read_multi).with(1,2).times(2).returns({1 => nil, 2 => nil}, cache_result)
+    IdentityCache.cache.expects(:write).with(1, IdentityCache::CACHED_NIL).once
+    IdentityCache.cache.expects(:write).with(2, IdentityCache::CACHED_NIL).once
+
+    results = IdentityCache.fetch_multi(1,2) do |keys|
+      [nil, nil]
+    end
+    assert_equal fetch_result, results
+
+    results = IdentityCache.fetch_multi(1,2) do |keys|
+      flunk "Contents should have been fetched from cache successfully"
+    end
+
+    assert_equal fetch_result, results
+  end
+
+  def test_fetch_multi_duplicate_ids
+    assert_equal [@joe, @bob, @joe], Record.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)
+    IdentityCache.cache.expects(:read_multi).never
+    assert_equal [@bob, @joe, @fred], Record.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)
+  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)
+  end
+
+  def test_fetch_multi_includes_cached_associations
+    Record.send(:cache_has_many, :associated_records, :embed => true)
+    Record.send(:cache_has_one, :associated)
+
+    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_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 populate_only_fred
+    @cache_response = {}
+    @cache_response[@bob_blob_key] = nil
+    @cache_response[@joe_blob_key] = nil
+    @cache_response[@tenth_blob_key] = nil
+    @cache_response[@fred_blob_key] = @fred
+  end
+end