identity_cache 0.5.1 → 1.0.0

data/test/helpers/update_serialization_format.rb

@@ -1,27 +0,0 @@
-$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
-
-require 'logger'
-require 'active_record'
-require 'memcached_store'
-require 'active_support/cache/memcached_store'
-require_relative 'serialization_format'
-require_relative 'database_connection'
-require_relative 'active_record_objects'
-require 'identity_cache'
-
-include SerializationFormat
-include ActiveRecordObjects
-
-DatabaseConnection.setup
-DatabaseConnection.drop_tables
-DatabaseConnection.create_tables
-IdentityCache.logger = Logger.new(nil)
-IdentityCache.cache_backend = ActiveSupport::Cache::MemcachedStore.new(
-  "#{ENV["MEMCACHED_HOST"] || "localhost"}:11211",
-  :support_cas => true,
-)
-setup_models
-File.open(serialized_record_file, 'w') {|file| serialize(serialized_record, file) }
-puts "Serialized record to #{serialized_record_file}"
-IdentityCache.cache.clear
-teardown_models

data/test/identity_cache_test.rb

@@ -1,29 +0,0 @@
-require "test_helper"
-
-class IdentityCacheTest < IdentityCache::TestCase
-
-  class BadModelBase < ActiveRecord::Base
-    include IdentityCache
-  end
-
-  class BadModel < BadModelBase
-  end
-
-  def test_identity_cache_raises_if_loaded_twice
-    assert_raises(IdentityCache::AlreadyIncludedError) do
-      BadModel.class_eval do
-        include IdentityCache
-      end
-    end
-  end
-
-  def test_should_use_cache_outside_transaction
-    assert_equal true, IdentityCache.should_use_cache?
-  end
-
-  def test_should_use_cache_in_transaction
-    ActiveRecord::Base.transaction do
-      assert_equal false, IdentityCache.should_use_cache?
-    end
-  end
-end

data/test/index_cache_test.rb

@@ -1,161 +0,0 @@
-require "test_helper"
-
-class IndexCacheTest < IdentityCache::TestCase
-  NAMESPACE = IdentityCache::CacheKeyGeneration::DEFAULT_NAMESPACE
-
-  def setup
-    super
-    @record = Item.new
-    @record.id = 1
-    @record.title = 'bob'
-  end
-
-  def test_fetch_with_garbage_input
-    Item.cache_index :title, :id
-
-    assert_queries(1) do
-      assert_equal [], Item.fetch_by_title_and_id('garbage', 'garbage')
-    end
-  end
-
-  def test_fetch_with_unique_adds_limit_clause
-    Item.cache_index :title, :id, :unique => true
-
-    Item.connection.expects(:exec_query)
-      .with(regexp_matches(/ LIMIT 1\Z/i), any_parameters)
-      .returns(ActiveRecord::Result.new([], []))
-
-    assert_nil Item.fetch_by_title_and_id('title', '2')
-  end
-
-  def test_unique_index_caches_nil
-    Item.cache_index :title, :unique => true
-    assert_nil Item.fetch_by_title('bob')
-    assert_equal IdentityCache::CACHED_NIL, backend.read(cache_key(unique: true))
-  end
-
-  def test_unique_index_expired_by_new_record
-    Item.cache_index :title, :unique => true
-    IdentityCache.cache.write(cache_key(unique: true), IdentityCache::CACHED_NIL)
-    @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(cache_key(unique: true))
-  end
-
-  def test_unique_index_filled_on_fetch_by
-    Item.cache_index :title, :unique => true
-    @record.save!
-    assert_equal @record, Item.fetch_by_title('bob')
-    assert_equal @record.id, backend.read(cache_key(unique: true))
-  end
-
-  def test_unique_index_expired_by_updated_record
-    Item.cache_index :title, :unique => true
-    @record.save!
-    old_cache_key = cache_key(unique: true)
-    IdentityCache.cache.write(old_cache_key, @record.id)
-
-    @record.title = 'robert'
-    new_cache_key = cache_key(unique: true)
-    IdentityCache.cache.write(new_cache_key, IdentityCache::CACHED_NIL)
-    @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(old_cache_key)
-    assert_equal IdentityCache::DELETED, backend.read(new_cache_key)
-  end
-
-  def test_non_unique_index_caches_empty_result
-    Item.cache_index :title
-    assert_equal [], Item.fetch_by_title('bob')
-    assert_equal [], backend.read(cache_key)
-  end
-
-  def test_non_unique_index_expired_by_new_record
-    Item.cache_index :title
-    IdentityCache.cache.write(cache_key, [])
-    @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(cache_key)
-  end
-
-  def test_non_unique_index_filled_on_fetch_by
-    Item.cache_index :title
-    @record.save!
-    assert_equal [@record], Item.fetch_by_title('bob')
-    assert_equal [@record.id], backend.read(cache_key)
-  end
-
-  def test_non_unique_index_fetches_multiple_records
-    Item.cache_index :title
-    @record.save!
-    record2 = Item.create(:title => 'bob') { |item| item.id = 2 }
-
-    assert_equal [@record, record2], Item.fetch_by_title('bob')
-    assert_equal [1, 2], backend.read(cache_key)
-  end
-
-  def test_non_unique_index_expired_by_updating_record
-    Item.cache_index :title
-    @record.save!
-    old_cache_key = cache_key
-    IdentityCache.cache.write(old_cache_key, [@record.id])
-
-    @record.title = 'robert'
-    new_cache_key = cache_key
-    IdentityCache.cache.write(new_cache_key, [])
-    @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(old_cache_key)
-    assert_equal IdentityCache::DELETED, backend.read(new_cache_key)
-  end
-
-  def test_non_unique_index_expired_by_destroying_record
-    Item.cache_index :title
-    @record.save!
-    IdentityCache.cache.write(cache_key, [@record.id])
-    @record.destroy
-    assert_equal IdentityCache::DELETED, backend.read(cache_key)
-  end
-
-  def test_set_table_name_cache_fetch
-    Item.cache_index :title
-    Item.table_name = 'items2'
-    @record.save!
-    assert_equal [@record], Item.fetch_by_title('bob')
-    assert_equal [@record.id], backend.read(cache_key)
-  end
-
-  def test_fetch_by_index_raises_when_called_on_a_scope
-    Item.cache_index :title
-    assert_raises(IdentityCache::UnsupportedScopeError) do
-      Item.where(updated_at: nil).fetch_by_title('bob')
-    end
-  end
-
-  def test_fetch_by_unique_index_raises_when_called_on_a_scope
-    Item.cache_index :title, :id, :unique => true
-    assert_raises(IdentityCache::UnsupportedScopeError) do
-      Item.where(updated_at: nil).fetch_by_title_and_id('bob', 2)
-    end
-  end
-
-  def test_cache_index_on_derived_model_raises
-    assert_raises(IdentityCache::DerivedModelError) do
-      StiRecordTypeA.cache_index :name, :id
-    end
-  end
-
-  def test_cache_index_with_non_id_primary_key
-    KeyedRecord.cache_index :value
-    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
-    KeyedRecord.create!(value: "a") { |r| r.hashed_key = 123 }
-    assert_equal 123, KeyedRecord.fetch_by_value('a').id
-  end
-
-  private
-
-  def cache_key(unique: false)
-    "#{NAMESPACE}attr#{unique ? '' : 's'}:Item:id:title:#{cache_hash(@record.title)}"
-  end
-end

data/test/memoized_attributes_test.rb

@@ -1,59 +0,0 @@
-require "test_helper"
-
-class MemoizedAttributesTest < IdentityCache::TestCase
-  def setup
-    IdentityCache.fetch_read_only_records = false
-    super
-  end
-
-  def teardown
-    super
-    IdentityCache.fetch_read_only_records = true
-  end
-
-  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/memoized_cache_proxy_test.rb

@@ -1,107 +0,0 @@
-require "test_helper"
-
-class MemoizedCacheProxyTest < IdentityCache::TestCase
-  def test_changing_default_cache
-    IdentityCache.cache_backend = ActiveSupport::Cache::MemoryStore.new
-    IdentityCache.cache.write('foo', 'bar')
-    assert_equal 'bar', IdentityCache.cache.fetch('foo')
-  end
-
-  def test_fetch_multi_with_fallback_fetcher
-    IdentityCache.cache_backend = backend = ActiveSupport::Cache::MemoryStore.new
-    IdentityCache.cache.write('foo', 'bar')
-    backend.expects(:write).with('bar', 'baz')
-    yielded = nil
-    assert_equal({'foo' => 'bar', 'bar' => 'baz'}, IdentityCache.cache.fetch_multi('foo', 'bar') {|_| yielded = ['baz'] })
-    assert_equal ['baz'], yielded
-  end
-
-  def test_fetch_should_short_circuit_on_memoized_values
-    fetcher.expects(:fetch).never
-
-    IdentityCache.cache.with_memoization do
-      IdentityCache.cache.write('foo', 'bar')
-      assert_equal 'bar', IdentityCache.cache.fetch('foo')
-    end
-  end
-
-  def test_fetch_should_short_circuit_on_falsy_memoized_values
-    fetcher.expects(:fetch).never
-
-    IdentityCache.cache.with_memoization do
-      IdentityCache.cache.write('foo', nil)
-      assert_nil IdentityCache.cache.fetch('foo')
-      IdentityCache.cache.write('bar', false)
-      assert_equal false, IdentityCache.cache.fetch('bar')
-    end
-  end
-
-  def test_fetch_should_try_memcached_on_not_memoized_values
-    fetcher.expects(:fetch).with('foo').returns('bar')
-
-    IdentityCache.cache.with_memoization do
-      assert_equal 'bar', IdentityCache.cache.fetch('foo')
-    end
-  end
-
-  def test_write_should_memoize_values
-    fetcher.expects(:fetch).never
-    fetcher.expects(:write).with('foo', 'bar')
-
-    IdentityCache.cache.with_memoization do
-      IdentityCache.cache.write('foo', 'bar')
-      assert_equal 'bar', IdentityCache.cache.fetch('foo')
-    end
-  end
-
-  def test_fetch_should_memoize_values
-    backend.write('foo', 'bar')
-
-    IdentityCache.cache.with_memoization do
-      assert_equal 'bar', IdentityCache.cache.fetch('foo')
-      backend.delete('foo')
-      assert_equal 'bar', IdentityCache.cache.fetch('foo')
-    end
-  end
-
-  def test_fetch_multi_should_memoize_values
-    expected_hash = {'foo' => 'bar', 'fooz' => IdentityCache::CACHED_NIL}
-
-    backend.write('foo', 'bar')
-
-    IdentityCache.cache.with_memoization do
-      assert_equal(expected_hash, IdentityCache.cache.fetch_multi('foo', 'fooz') {|_| [IdentityCache::CACHED_NIL] })
-      assert_equal(expected_hash, IdentityCache.cache.memoized_key_values)
-      backend.delete('foo')
-      backend.write('fooz', 'baz')
-      assert_equal(expected_hash, IdentityCache.cache.fetch_multi('foo', 'fooz'))
-    end
-  end
-
-  def test_fetch_multi_with_partially_memoized_should_read_missing_keys_from_memcache
-    IdentityCache.cache.write('foo', 'bar')
-    @backend.write('fooz', 'baz')
-
-    IdentityCache.cache.with_memoization do
-      assert_equal({'foo' => 'bar', 'fooz' => 'baz'}, IdentityCache.cache.fetch_multi('foo', 'fooz'))
-    end
-  end
-
-  def test_fetch_multi_with_blank_values_should_not_hit_the_cache_engine
-    @backend.expects(:fetch_multi).never
-
-    IdentityCache.cache.with_memoization do
-      IdentityCache.cache.write('foo', [])
-      IdentityCache.cache.write('bar', false)
-      IdentityCache.cache.write('baz', {})
-      assert_equal({'foo' => [], 'bar' => false, 'baz' => {}}, IdentityCache.cache.fetch_multi('foo', 'bar', 'baz'))
-    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', @backend.fetch('foo')
-  end
-end

data/test/normalized_belongs_to_test.rb

@@ -1,107 +0,0 @@
-require "test_helper"
-
-class NormalizedBelongsToTest < IdentityCache::TestCase
-  def setup
-    super
-    AssociatedRecord.cache_belongs_to :item, :embed => false
-
-    @parent_record = Item.new(:title => 'foo')
-    @parent_record.associated_records << AssociatedRecord.new(:name => 'bar')
-    @parent_record.save
-    @parent_record.reload
-    @record = @parent_record.associated_records.first
-    # Reset association cache, so we remove the inverse of in memory reference
-    @record.association(:item).reset
-  end
-
-  def test_fetching_the_association_should_delegate_to_the_normal_association_fetcher_if_any_transactions_are_open
-    Item.expects(:fetch_by_id).never
-    @record.transaction do
-      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.item
-
-    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
-    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_an_instance_variable_so_that_successive_accesses_are_cached
-    Item.expects(:fetch_by_id).with(@parent_record.id).returns(@parent_record)
-    assert_equal @parent_record, @record.fetch_item
-    assert_equal false, @record.association(:item).loaded?
-    assert_equal @parent_record, @record.fetch_item
-  end
-
-  def test_fetching_the_association_should_cache_nil_and_not_raise_if_the_record_cant_be_found
-    Item.expects(:fetch_by_id).with(@parent_record.id).returns(nil)
-    assert_nil @record.fetch_item # miss
-    assert_nil @record.fetch_item # hit
-  end
-
-  def test_cache_belongs_to_on_derived_model_raises
-    assert_raises(IdentityCache::DerivedModelError) do
-      StiRecordTypeA.cache_belongs_to :item, :embed => false
-    end
-  end
-
-  def test_fetching_polymorphic_belongs_to_association
-    PolymorphicRecord.include IdentityCache
-    PolymorphicRecord.cache_belongs_to :owner
-    PolymorphicRecord.create!(owner: @parent_record)
-
-    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_db_returned_record_should_never_be_readonly
-    IdentityCache.with_fetch_read_only_records do
-      uncached_record = @record.item
-      refute uncached_record.readonly?
-      @record.fetch_item
-      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 @record.fetch_item.readonly?
-      end
-    end
-  end
-
-  def test_respects_should_use_cache_on_parent
-    @record.reload
-    @parent_record.class.stubs(:should_use_cache?).returns(false)
-
-    assert_queries(1) do
-      assert_memcache_operations(0) do
-        @record.fetch_item
-      end
-    end
-  end
-end