identity_cache 0.4.1 → 1.1.0

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

data/test/normalized_has_many_test.rb

@@ -1,231 +0,0 @@
-require "test_helper"
-
-class NormalizedHasManyTest < IdentityCache::TestCase
-  def setup
-    super
-    Item.cache_has_many :associated_records, :embed => :ids
-
-    @record = Item.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', item_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 = Item.fetch(@record.id)
-    assert_equal [2, 1], fetched_record.cached_associated_record_ids
-    assert_equal false, fetched_record.associated_records.loaded?
-  end
-
-  def test_batch_fetching_of_association_for_multiple_parent_records
-    record2 = Item.new(:title => 'two')
-    record2.associated_records << AssociatedRecord.new(:name => 'a')
-    record2.associated_records << AssociatedRecord.new(:name => 'b')
-    record2.save!
-
-    fetched_records = assert_queries(2) do
-      Item.fetch_multi(@record.id, record2.id)
-    end
-    assert_equal [[2, 1], [4, 3]], fetched_records.map(&:cached_associated_record_ids)
-    assert_equal false, fetched_records.any?{ |record| record.associated_records.loaded? }
-  end
-
-  def test_batch_fetching_of_deeply_associated_records
-    Item.has_many :denormalized_associated_records, class_name: 'AssociatedRecord'
-    Item.cache_has_many :denormalized_associated_records, embed: true
-    AssociatedRecord.cache_has_many :deeply_associated_records, embed: :ids
-    @record.associated_records[0].deeply_associated_records << DeeplyAssociatedRecord.new(:name => 'deep1')
-    @record.associated_records[1].deeply_associated_records << DeeplyAssociatedRecord.new(:name => 'deep2')
-    @record.associated_records.each(&:save!)
-
-    fetched_records = assert_queries(4) do
-      Item.fetch(@record.id)
-    end
-    assert_no_queries do
-      assert_equal [[1], [2]], fetched_records.fetch_denormalized_associated_records.map(&:cached_deeply_associated_record_ids)
-      assert_equal false, fetched_records.fetch_denormalized_associated_records.any?{ |record| record.deeply_associated_records.loaded? }
-    end
-  end
-
-  def test_batch_fetching_stops_with_nil_parent
-    Item.cache_has_one :associated, embed: true
-    AssociatedRecord.cache_has_many :deeply_associated_records, embed: :ids
-    AssociatedRecord.delete_all
-
-    fetched_records = assert_queries(3) do
-      Item.fetch(@record.id)
-    end
-    assert_no_queries do
-      assert_equal @record, fetched_records
-      assert_nil fetched_records.fetch_associated
-    end
-  end
-
-  def test_fetching_associated_ids_will_populate_the_value_if_the_record_isnt_from_the_cache
-    assert_equal [2, 1], @record.fetch_associated_record_ids
-  end
-
-  def test_fetching_associated_ids_will_use_the_cached_value_if_the_record_is_from_the_cache
-    @record = Item.fetch(@record.id)
-    assert_queries(0) do
-      assert_equal [2, 1], @record.fetch_associated_record_ids
-    end
-  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_record_on_a_cache_hit_should_not_issue_any_queries
-    # Populate the cache
-    @record = Item.fetch(@record.id)
-    @record.fetch_associated_records
-    assert_queries(0) do
-      @record = Item.fetch(@record.id)
-      assert_equal [@baz, @bar], @record.fetch_associated_records
-    end
-  end
-
-  def test_fetching_the_association_from_a_identity_cached_record_should_not_re_fetch_the_association_ids
-    @record = Item.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 = Item.fetch(@record.id)
-
-    assert_memcache_operations(0) do
-      @record.transaction do
-        assert_equal [@baz, @bar], @record.fetch_associated_records
-      end
-    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
-
-    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
-    IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key).never
-    IdentityCache.cache.expects(:delete).with(@baz.primary_cache_index_key)
-    @baz.name = 'foo'
-    @baz.save!
-    assert_equal [@baz.id, @bar.id], Item.fetch(@record.id).cached_associated_record_ids
-    assert_equal [@baz, @bar], Item.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
-    IdentityCache.cache.expects(:delete).with(@bar.primary_cache_index_key[0...-1] + '3')
-    @qux = @record.associated_records.create!(:name => 'qux')
-    assert_equal [@qux, @baz, @bar], Item.fetch(@record.id).fetch_associated_records
-  end
-
-  def test_saving_a_child_record_should_expire_the_new_and_old_parents_cache_blob
-    @new_record = Item.create
-    @baz.item = @new_record
-
-    IdentityCache.cache.expects(:delete).with(@record.primary_cache_index_key).once
-    IdentityCache.cache.expects(:delete).with(@new_record.primary_cache_index_key).once
-    IdentityCache.cache.expects(:delete).with(@baz.primary_cache_index_key).once
-
-    @baz.save!
-
-    assert_equal [@bar.id], Item.fetch(@record.id).cached_associated_record_ids
-    assert_equal [@bar], Item.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 = Item.create
-    @baz.item_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
-      IdentityCache.cache.expects(:delete).with(@baz.primary_cache_index_key).once
-
-      @baz.save!
-      @baz.reload
-    end
-
-    assert_equal [@bar.id], Item.fetch(@record.id).cached_associated_record_ids
-    assert_equal [@bar], Item.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
-    IdentityCache.cache.expects(:delete).with(@baz.primary_cache_index_key).once
-    @baz.destroy
-    assert_equal [@bar], @record.reload.fetch_associated_records
-  end
-
-  def test_saving_a_child_record_should_expire_only_itself
-    IdentityCache.cache.expects(:delete).with(@baz.primary_cache_index_key).once
-    @baz.save!
-  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.name = 'Changed'
-    @not_cached.save!
-  end
-
-  def test_fetch_association_does_not_allow_chaining
-    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
-
-  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
-
-  def test_respects_should_use_cache_on_association
-    @record.reload
-    AssociatedRecord.stubs(:should_use_cache?).returns(false)
-
-    assert_queries(1) do
-      assert_memcache_operations(0) do
-        @record.fetch_associated_records
-      end
-    end
-  end
-end

data/test/normalized_has_one_test.rb

@@ -1,9 +0,0 @@
-require "test_helper"
-
-class NormalizedHasOneTest < IdentityCache::TestCase
-  def test_not_implemented_error
-    assert_raises(NotImplementedError) do
-      Item.cache_has_one :associated, :embed => false
-    end
-  end
-end