identity_cache 0.0.1

data/test/fetch_test.rb

@@ -0,0 +1,108 @@
+require "test_helper"
+
+class FetchTest < IdentityCache::TestCase
+  def setup
+    super
+    Record.cache_index :title, :unique => true
+    Record.cache_index :id, :title, :unique => true
+
+    @record = Record.new
+    @record.id = 1
+    @record.title = 'bob'
+    @blob_key = "IDC:blob:Record:#{cache_hash("created_at:datetime,id:integer,title:string,updated_at:datetime")}:1"
+    @index_key = "IDC:index:Record:title:#{cache_hash('bob')}"
+  end
+
+
+  def test_fetch_cache_hit
+    IdentityCache.cache.expects(:read).with(@blob_key).returns(@record)
+
+    assert_equal @record, Record.fetch(1)
+  end
+
+  def test_exists_with_identity_cache_when_cache_hit
+    IdentityCache.cache.expects(:read).with(@blob_key).returns(@record)
+
+    assert Record.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)
+
+    assert Record.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)
+
+    assert !Record.exists_with_identity_cache?(1)
+  end
+
+  def test_fetch_miss
+    Record.expects(:find_by_id).with(1, :include => []).returns(@record)
+
+    IdentityCache.cache.expects(:read).with(@blob_key).returns(nil)
+    IdentityCache.cache.expects(:write).with(@blob_key, @record)
+
+    assert_equal @record, Record.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)
+  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) }
+  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 IdentityCache::CACHED_NIL, IdentityCache.cache.read(key)
+
+    @record.save!
+    assert_nil IdentityCache.cache.read(key)
+  end
+
+  def test_fetch_by_title_hit
+    # Read record with title bob
+    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)
+
+    # cache sql result
+    IdentityCache.cache.expects(:write).with(@index_key, 1)
+
+    # got id, do memcache lookup on that, hit -> done
+    IdentityCache.cache.expects(:read).with(@blob_key).returns(@record)
+
+    assert_equal @record, Record.fetch_by_title('bob')
+  end
+
+  def test_fetch_by_title_stores_idcnil
+    Record.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, Record.fetch_by_title('bob') # returns cached nil
+    assert_equal nil, Record.fetch_by_title('bob') # returns cached nil
+  end
+
+  def test_fetch_by_bang_method
+    Record.connection.expects(:select_value).returns(nil)
+    assert_raises ActiveRecord::RecordNotFound do
+      Record.fetch_by_title!('bob')
+    end
+  end
+end

data/test/helpers/cache.rb

@@ -0,0 +1,60 @@
+module Rails
+  class Cache
+
+    def initialize
+      @cache = {}
+    end
+
+    def fetch(e)
+      if @cache.key?(e)
+        return read(e)
+      else
+        a = yield
+        write(e,a)
+        return a
+      end
+    end
+
+    def clear
+      @cache.clear
+    end
+
+    def write(a,b)
+      @cache[a] = b
+    end
+
+    def delete(a)
+      @cache.delete(a)
+    end
+
+    def read(a)
+      @cache[a]
+    end
+
+    def read_multi(*keys)
+      keys.reduce({}) do |hash, key|
+        hash[key] = @cache[key]
+        hash
+      end
+    end
+  end
+
+  def self.cache
+    @@cache ||= Cache.new
+  end
+
+  class Logger
+    def info(string)
+    end
+
+    def debug(string)
+    end
+
+    def error(string)
+    end
+  end
+
+  def self.logger
+    @logger = Logger.new
+  end
+end

data/test/helpers/database_connection.rb

@@ -0,0 +1,41 @@
+module DatabaseConnection
+  def self.setup
+    ActiveRecord::Base.establish_connection(DATABASE_CONFIG)
+    ActiveRecord::Base.connection
+  rescue
+    ActiveRecord::Base.establish_connection(DATABASE_CONFIG.merge('database' => nil))
+    ActiveRecord::Base.connection.create_database(DATABASE_CONFIG['database'])
+    ActiveRecord::Base.establish_connection(DATABASE_CONFIG)
+  end
+
+  def self.drop_tables
+    TABLES.keys.each do |table|
+      ActiveRecord::Base.connection.drop_table(table) if ActiveRecord::Base.connection.table_exists?(table)
+    end
+  end
+
+  def self.create_tables
+    TABLES.each do |table, fields|
+      ActiveRecord::Base.connection.create_table(table) do |t|
+        fields.each do |column_type, *args|
+          t.send(column_type, *args)
+        end
+      end
+    end
+  end
+
+  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]],
+    :not_cached_records         => [[:string, :name], [:integer, :record_id]],
+    :records                    => [[:string, :title], [:timestamps]]
+  }
+
+  DATABASE_CONFIG = {
+    'adapter'  => 'mysql2',
+    'database' => 'identity_cache_test',
+    'host'     => '127.0.0.1',
+    'username' => 'root'
+  }
+end

data/test/identity_cache_test.rb

@@ -0,0 +1,17 @@
+require "test_helper"
+
+class IdentityCacheTest < IdentityCache::TestCase
+
+  class BadModel < ActiveRecord::Base
+  end
+
+  def test_identity_cache_raises_if_loaded_twice
+    assert_raises(IdentityCache::AlreadyIncludedError) do
+      BadModel.class_eval do
+        include IdentityCache
+        include IdentityCache
+      end
+    end
+  end
+
+end

data/test/index_cache_test.rb

@@ -0,0 +1,96 @@
+require "test_helper"
+
+class ExpirationTest < IdentityCache::TestCase
+  def setup
+    super
+    @record = Record.new
+    @record.id = 1
+    @record.title = 'bob'
+    @cache_key = "IDC:index:Record: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')
+    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
+    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
+    @record.save!
+    assert_equal @record, Record.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
+    @record.save!
+    IdentityCache.cache.write(@cache_key, @record.id)
+
+    @record.title = 'robert'
+    new_cache_key = "IDC:index:Record: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')
+    assert_equal [], IdentityCache.cache.read(@cache_key)
+  end
+
+  def test_non_unique_index_expired_by_new_record
+    Record.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
+    @record.save!
+    assert_equal [@record], Record.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
+    @record.save!
+    record2 = Record.create(:id => 2, :title => 'bob')
+
+    assert_equal [@record, record2], Record.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
+    @record.save!
+    IdentityCache.cache.write(@cache_key, [@record.id])
+
+    @record.title = 'robert'
+    new_cache_key = "IDC:index:Record:title:#{cache_hash(@record.title)}"
+    IdentityCache.cache.write(new_cache_key, [])
+    @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_expired_by_destroying_record
+    Record.cache_index :title
+    @record.save!
+    IdentityCache.cache.write(@cache_key, [@record.id])
+    @record.destroy
+    assert_equal nil, IdentityCache.cache.read(@cache_key)
+  end
+
+end

data/test/memoized_cache_proxy_test.rb

@@ -0,0 +1,60 @@
+require "test_helper"
+
+class MemoizedCacheProxyTest < IdentityCache::TestCase
+  def setup
+    super
+    IdentityCache.cache_backend = Rails.cache
+  end
+
+  def test_chaging_default_cache
+    IdentityCache.cache_backend = ActiveSupport::Cache::MemoryStore.new
+    IdentityCache.cache.write('foo', 'bar')
+    assert_equal 'bar', IdentityCache.cache.read('foo')
+  end
+
+  def test_read_should_short_circuit_on_memoized_values
+    Rails.cache.expects(:read).never
+
+    IdentityCache.cache.with_memoization do
+      IdentityCache.cache.write('foo', 'bar')
+      assert_equal 'bar', IdentityCache.cache.read('foo')
+    end
+  end
+
+  def test_read_should_try_memcached_on_not_memoized_values
+    Rails.cache.expects(:read).with('foo').returns('bar')
+
+    IdentityCache.cache.with_memoization do
+      assert_equal 'bar', IdentityCache.cache.read('foo')
+    end
+  end
+
+  def test_write_should_memoize_values
+    Rails.cache.expects(:read).never
+    Rails.cache.expects(:write).with('foo', 'bar')
+
+
+    IdentityCache.cache.with_memoization do
+      IdentityCache.cache.write('foo', 'bar')
+      assert_equal 'bar', IdentityCache.cache.read('foo')
+    end
+  end
+
+  def test_read_multi_with_partially_memoized_should_read_missing_keys_from_memcache
+    IdentityCache.cache.write('foo', 'bar')
+    Rails.cache.write('fooz', 'baz')
+
+    IdentityCache.cache.with_memoization do
+      assert_equal({'foo' => 'bar', 'fooz' => 'baz'}, IdentityCache.cache.read_multi('foo', 'fooz'))
+    end
+  end
+
+  def test_with_memoization_should_not_clear_rails_cache_when_the_block_ends
+    IdentityCache.cache.with_memoization do
+      IdentityCache.cache.write('foo', 'bar')
+    end
+
+    assert_equal 'bar', Rails.cache.read('foo')
+  end
+
+end

data/test/normalized_belongs_to_test.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+
+class NormalizedBelongsToTest < IdentityCache::TestCase
+  def setup
+    super
+    AssociatedRecord.cache_belongs_to :record, :embed => false
+
+    @parent_record = Record.new(:title => 'foo')
+    @parent_record.associated_records << AssociatedRecord.new(:name => 'bar')
+    @parent_record.save
+    @parent_record.reload
+    @record = @parent_record.associated_records.first
+  end
+
+  def test_fetching_the_association_should_delegate_to_the_normal_association_fetcher_if_any_transactions_are_open
+    Record.expects(:fetch_by_id).never
+    @record.transaction do
+      assert_equal @parent_record, @record.fetch_record
+    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.expects(:fetch_by_id).never
+    assert_equal @parent_record, @record.fetch_record
+  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
+  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
+  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
+  end
+end

data/test/normalized_has_many_test.rb

@@ -0,0 +1,125 @@
+require "test_helper"
+
+class NormalizedHasManyTest < IdentityCache::TestCase
+  def setup
+    super
+    Record.cache_has_many :associated_records, :embed => false
+
+    @record = Record.new(:title => 'foo')
+    @record.not_cached_records << NotCachedRecord.new(:name => 'NoCache')
+    @record.associated_records << AssociatedRecord.new(:name => 'bar')
+    @record.associated_records << AssociatedRecord.new(:name => 'baz')
+    @record.save
+    @record.reload
+    @baz, @bar  = @record.associated_records[0], @record.associated_records[1]
+    @not_cached = @record.not_cached_records.first
+  end
+
+  def test_a_records_list_of_associated_ids_on_the_parent_record_retains_association_sort_order
+    assert_equal [2, 1], @record.associated_record_ids
+
+    AssociatedRecord.create(name: 'foo', record_id: @record.id)
+    @record.reload
+    assert_equal [3, 2, 1], @record.associated_record_ids
+  end
+
+  def test_defining_a_denormalized_has_many_cache_caches_the_list_of_associated_ids_on_the_parent_record_during_cache_miss
+    fetched_record = Record.fetch(@record.id)
+    assert_equal [2, 1], fetched_record.cached_associated_record_ids
+  end
+
+  def test_the_cached_the_list_of_associated_ids_on_the_parent_record_should_not_be_populated_by_default
+    assert_nil @record.cached_associated_record_ids
+  end
+
+  def test_fetching_the_association_should_fetch_each_record_by_id
+    assert_equal [@baz, @bar], @record.fetch_associated_records
+  end
+
+  def test_fetching_the_association_from_a_identity_cached_record_should_not_re_fetch_the_association_ids
+    @record = Record.fetch(@record.id)
+    @record.expects(:associated_record_ids).never
+    assert_equal [@baz, @bar], @record.fetch_associated_records
+  end
+
+  def test_fetching_the_association_should_delegate_to_the_normal_association_fetcher_if_any_transaction_are_open
+    @record = Record.fetch(@record.id)
+
+    Record.expects(:fetch_multi).never
+    @record.transaction do
+      assert_equal [@baz, @bar], @record.fetch_associated_records
+    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.associated_records.to_a
+
+    Record.expects(:fetch_multi).never
+    assert_equal [@baz, @bar], @record.fetch_associated_records
+  end
+
+  def test_saving_a_child_record_shouldnt_expire_the_parents_blob_if_the_foreign_key_hasnt_changed
+    IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key).never
+    @baz.name = 'foo'
+    @baz.save!
+    assert_equal [@baz.id, @bar.id], Record.fetch(@record.id).cached_associated_record_ids
+    assert_equal [@baz, @bar], Record.fetch(@record.id).fetch_associated_records
+  end
+
+  def test_creating_a_child_record_should_expire_the_parents_cache_blob
+    IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key).once
+    @qux = @record.associated_records.create!(:name => 'qux')
+    assert_equal [@qux, @baz, @bar], Record.fetch(@record.id).fetch_associated_records
+  end
+  
+  def test_saving_a_child_record_should_expire_the_new_and_old_parents_cache_blob
+    @new_record = Record.create
+    @baz.record_id = @new_record.id
+
+    IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key).once
+    IdentityCache.cache.expects(:delete).with(@new_record.primary_cache_index_key).once
+
+    @baz.save!
+
+    assert_equal [@bar.id], Record.fetch(@record.id).cached_associated_record_ids
+    assert_equal [@bar], Record.fetch(@record.id).fetch_associated_records
+  end
+
+  def test_saving_a_child_record_in_a_transaction_should_expire_the_new_and_old_parents_cache_blob
+    @new_record = Record.create
+    @baz.record_id = @new_record.id
+
+    @baz.transaction do
+      IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key).once
+      IdentityCache.cache.expects(:delete).with(@new_record.primary_cache_index_key).once
+
+      @baz.save!
+      @baz.reload
+    end
+
+    assert_equal [@bar.id], Record.fetch(@record.id).cached_associated_record_ids
+    assert_equal [@bar], Record.fetch(@record.id).fetch_associated_records
+  end
+
+  def test_destroying_a_child_record_should_expire_the_parents_cache_blob
+    IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key).once
+    @baz.destroy
+    assert_equal [@bar], @record.reload.fetch_associated_records
+  end
+
+  def test_touching_a_child_record_should_expire_only_itself
+    IdentityCache.cache.expects(:delete).with(@baz.primary_cache_index_key).once
+    @baz.touch
+  end
+
+  def test_touching_child_with_touch_true_on_parent_expires_parent
+    IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key).once
+    @not_cached.touch
+  end
+
+  def test_saving_child_with_touch_true_on_parent_expires_parent
+    IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key).once
+    @not_cached.save
+  end
+end