identity_cache 0.4.1 → 1.1.0

data/test/cache_invalidation_test.rb

@@ -1,139 +0,0 @@
-require "test_helper"
-
-class CacheInvalidationTest < IdentityCache::TestCase
-  def setup
-    super
-
-    @record = Item.new(:title => 'foo')
-    @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]
-    @record.reload
-  end
-
-  def test_reload_invalidate_cached_ids
-    Item.cache_has_many :associated_records, :embed => :ids
-
-    variable_name = "@#{@record.class.send(:embedded_associations)[:associated_records][:ids_variable_name]}"
-
-    @record.fetch_associated_record_ids
-    assert_equal [@baz.id, @bar.id], @record.instance_variable_get(variable_name)
-
-    @record.reload
-    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)
-  end
-
-  def test_reload_invalidate_cached_objects
-    Item.cache_has_many :associated_records, :embed => :ids
-
-    variable_name = "@#{@record.class.send(:embedded_associations)[:associated_records][:records_variable_name]}"
-
-    @record.fetch_associated_records
-    assert_equal [@baz, @bar], @record.instance_variable_get(variable_name)
-
-    @record.reload
-    assert_equal false, @record.instance_variable_defined?(variable_name)
-
-    @record.fetch_associated_records
-    assert_equal [@baz, @bar], @record.instance_variable_get(variable_name)
-  end
-
-  def test_after_a_reload_the_cache_perform_as_expected
-    Item.cache_has_many :associated_records, :embed => :ids
-
-    assert_equal [@baz, @bar], @record.fetch_associated_records
-    assert_equal [@baz, @bar], @record.associated_records
-
-    @baz.destroy
-    @record.reload
-
-    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
-    Item.cache_has_many :associated_records, :embed => true
-    ItemTwo.cache_has_many :associated_records, :embed => true
-
-    baz = AssociatedRecord.new(:name => 'baz')
-
-    record1 = Item.new(:title => 'foo')
-    record1.associated_records << baz
-    record1.save!
-
-    record2 = ItemTwo.new(:title => 'bar')
-    record2.associated_records << baz
-    record2.save!
-
-    record1.class.fetch(record1.id)
-    record2.class.fetch(record2.id)
-
-    expected_keys = [
-      record1.primary_cache_index_key,
-      record2.primary_cache_index_key,
-    ]
-
-    expected_keys.each do |expected_key|
-      assert IdentityCache.cache.fetch(expected_key) { nil }
-    end
-
-    baz.save!
-
-    expected_keys.each do |expected_key|
-      refute IdentityCache.cache.fetch(expected_key) { nil }
-    end
-  end
-
-  def test_cache_invalidation_expire_properly_if_child_is_embed_in_multiple_parents_with_ids
-    Item.cache_has_many :associated_records, :embed => :ids
-    ItemTwo.cache_has_many :associated_records, :embed => :ids
-
-    baz = AssociatedRecord.new(:name => 'baz')
-
-    record1 = Item.new(:title => 'foo')
-    record1.save
-
-    record2 = ItemTwo.new(:title => 'bar')
-    record2.save
-
-    record1.class.fetch(record1.id)
-    record2.class.fetch(record2.id)
-
-    expected_keys = [
-      record1.primary_cache_index_key,
-      record2.primary_cache_index_key,
-    ]
-
-    expected_keys.each do |expected_key|
-      assert IdentityCache.cache.fetch(expected_key) { nil }
-    end
-
-    baz.item = record1
-    baz.item_two = record2
-    baz.save!
-
-    expected_keys.each do |expected_key|
-      refute IdentityCache.cache.fetch(expected_key) { nil }
-    end
-  end
-
-  def test_dedup_cache_invalidation_of_records_embedded_twice_through_different_associations
-    Item.cache_has_many :associated_records, embed: true
-    AssociatedRecord.cache_has_many :deeply_associated_records, embed: true
-    Item.cache_has_many :deeply_associated_records, embed: true
-
-    deeply_associated_record = DeeplyAssociatedRecord.new(name: 'deep', item_id: @record.id)
-    @record.associated_records[0].deeply_associated_records << deeply_associated_record
-    deeply_associated_record.reload
-
-    Item.any_instance.expects(:expire_primary_index).once
-
-    deeply_associated_record.name = "deep2"
-    deeply_associated_record.save!
-  end
-end

data/test/deeply_nested_associated_record_test.rb

@@ -1,19 +0,0 @@
-require "test_helper"
-
-class DeeplyNestedAssociatedRecordHasOneTest < IdentityCache::TestCase
-  def test_deeply_nested_models_can_cache_has_one_associations
-    assert_nothing_raised do
-      PolymorphicRecord.include(IdentityCache::WithoutPrimaryIndex)
-      Deeply::Nested::AssociatedRecord.has_one :polymorphic_record, as: 'owner'
-      Deeply::Nested::AssociatedRecord.cache_has_one :polymorphic_record, inverse_name: :owner
-    end
-  end
-
-  def test_deeply_nested_models_can_cache_has_many_associations
-    assert_nothing_raised do
-      PolymorphicRecord.include(IdentityCache)
-      Deeply::Nested::AssociatedRecord.has_many :polymorphic_records, as: 'owner'
-      Deeply::Nested::AssociatedRecord.cache_has_many :polymorphic_records, inverse_name: :owner
-    end
-  end
-end

data/test/denormalized_has_many_test.rb

@@ -1,211 +0,0 @@
-require "test_helper"
-
-class DenormalizedHasManyTest < IdentityCache::TestCase
-  def setup
-    super
-    PolymorphicRecord.include(IdentityCache::WithoutPrimaryIndex)
-    Item.cache_has_many :associated_records, :embed => true
-
-    @record = Item.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_should_come_back_with_association_array
-    record_from_db = Item.find(@record.id)
-    assert_equal Array, record_from_db.fetch_associated_records.class
-  end
-
-  def test_uncached_record_from_the_db_will_use_normal_association
-    expected = @record.associated_records
-    record_from_db = Item.find(@record.id)
-
-    Item.any_instance.expects(:association).with(: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_array
-    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
-
-  def test_on_cache_hit_record_should_come_back_with_cached_association
-    Item.fetch(@record.id) # warm cache
-
-    record_from_cache_hit = Item.fetch(@record.id)
-    assert_equal @record, record_from_cache_hit
-
-    expected = @record.associated_records
-
-    assoc = mock()
-    assoc.expects(:klass).returns(Item)
-    Item.any_instance.expects(:association).with(:associated_records).returns(assoc).once
-
-    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 = Item.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
-    Item.fetch(@record.id)
-    key = @record.primary_cache_index_key
-    assert_not_nil IdentityCache.cache.fetch(key)
-
-    IdentityCache.cache.expects(:delete).with(@record.associated_records.first.primary_cache_index_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 = Item.create!
-    new_key = @new_record.primary_cache_index_key
-
-    IdentityCache.cache.expects(:delete).with(@associatated_record.primary_cache_index_key)
-    IdentityCache.cache.expects(:delete).with(old_key)
-    IdentityCache.cache.expects(:delete).with(new_key)
-    @associatated_record.item = @new_record
-    @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_caches }
-  end
-
-  def test_cache_without_guessable_inverse_name_raises
-    assert_raises IdentityCache::InverseAssociationError do
-      Item.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
-      Item.cache_has_many :polymorphic_records, :inverse_name => :owner, :embed => true
-    end
-  end
-
-  def test_cache_uses_inverse_of_on_association
-    Item.has_many :invertable_association, :inverse_of => :owner, :class_name => 'PolymorphicRecord', :as => "owner"
-    Item.cache_has_many :invertable_association, :embed => true
-  end
-
-  def test_saving_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.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_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_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
-
-  def test_respect_should_use_cache_from_embedded_records
-    Item.fetch(@record.id)
-    AssociatedRecord.stubs(:should_use_cache?).returns(false)
-
-    assert_memcache_operations(1) do
-      assert_queries(1) do
-        Item.fetch(@record.id).fetch_associated_records
-      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

@@ -1,160 +0,0 @@
-require "test_helper"
-
-class DenormalizedHasOneTest < IdentityCache::TestCase
-  def setup
-    super
-    PolymorphicRecord.include(IdentityCache::WithoutPrimaryIndex)
-    Item.cache_has_one :associated
-    Item.cache_index :title, :unique => true
-    @record = Item.new(:title => 'foo')
-    @record.associated = AssociatedRecord.new(:name => 'bar')
-    @record.save
-
-    @record.reload
-  end
-
-  def test_on_cache_miss_record_should_embed_associated_object
-    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
-
-    record_from_cache_miss = Item.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
-    assert fetch.has_been_called_with?(@record.attribute_cache_key_for_attribute_and_current_values(:id, [:title], true))
-    assert fetch.has_been_called_with?(@record.primary_cache_index_key)
-  end
-
-  def test_on_cache_miss_record_should_embed_nil_object
-
-    @record.associated = nil
-    @record.save!
-    @record.reload
-    Item.expects(:resolve_cache_miss).with(@record.id).once.returns(@record)
-
-    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
-
-    record_from_cache_miss = Item.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
-    assert fetch.has_been_called_with?(@record.attribute_cache_key_for_attribute_and_current_values(:id, [:title], true))
-    assert fetch.has_been_called_with?(@record.primary_cache_index_key)
-  end
-
-  def test_on_record_from_the_db_will_use_normal_association
-    record_from_db = Item.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
-    Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
-    Item.fetch_by_title('foo')
-
-    record_from_cache_hit = Item.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.associated = nil
-    @record.save!
-    @record.reload
-
-    Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
-    Item.fetch_by_title('foo')
-
-    record_from_cache_hit = Item.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
-    Item.fetch_by_title('foo')
-    key = @record.primary_cache_index_key
-    assert_not_nil IdentityCache.cache.fetch(key)
-
-    IdentityCache.cache.expects(:delete).at_least(1).with(key)
-    IdentityCache.cache.expects(:delete).with(@record.associated.primary_cache_index_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_caches }
-  end
-
-  def test_cache_without_guessable_inverse_name_raises
-    assert_raises IdentityCache::InverseAssociationError do
-      Item.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
-      Item.cache_has_one :polymorphic_record, :inverse_name => :owner, :embed => true
-    end
-  end
-
-  def test_unsupported_through_assocation
-    assert_raises IdentityCache::UnsupportedAssociationError, "caching through associations isn't supported" do
-      Item.has_one :deeply_associated, :through => :associated, :class_name => 'DeeplyAssociatedRecord'
-      Item.cache_has_one :deeply_associated, :embed => true
-    end
-  end
-
-  def test_cache_has_one_on_derived_model_raises
-    assert_raises(IdentityCache::DerivedModelError) do
-      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