identity_cache 0.5.1 → 1.0.0

data/Gemfile.rails42

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-gemspec
-
-gem 'activerecord', '~> 4.2.0'
-gem 'activesupport', '~> 4.2.0'
-gem 'mysql2', '~> 0.3.13'

data/Gemfile.rails50

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-gemspec
-
-gem 'activerecord', '~> 5.0.0'
-gem 'activesupport', '~> 5.0.0'
-gem 'mysql2', '>= 0.3.18', '< 0.5'

data/test/attribute_cache_test.rb

@@ -1,110 +0,0 @@
-require "test_helper"
-
-class AttributeCacheTest < IdentityCache::TestCase
-  NAMESPACE = IdentityCache::CacheKeyGeneration::DEFAULT_NAMESPACE
-
-  def setup
-    super
-    AssociatedRecord.cache_attribute :name
-
-    @parent = Item.create!(:title => 'bob')
-    @record = @parent.associated_records.create!(:name => 'foo')
-    @name_attribute_key = "#{NAMESPACE}attr:AssociatedRecord:name:id:#{cache_hash(@record.id.to_s)}"
-    IdentityCache.cache.clear
-  end
-
-  def test_attribute_values_are_fetched_and_returned_on_cache_misses
-    fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
-
-    assert_queries(1) do
-      assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
-    end
-    assert fetch.has_been_called_with?(@name_attribute_key)
-  end
-
-  def test_attribute_values_are_returned_on_cache_hits
-    assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
-
-    assert_queries(0) do
-      assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
-    end
-  end
-
-  def test_nil_is_stored_in_the_cache_on_cache_misses
-    assert_nil AssociatedRecord.fetch_name_by_id(2)
-
-    assert_queries(0) do
-      assert_nil AssociatedRecord.fetch_name_by_id(2)
-    end
-  end
-
-  def test_cached_attribute_values_are_expired_from_the_cache_when_an_existing_record_is_saved
-    assert_queries(1) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
-    assert_queries(0) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
-
-    @record.save!
-
-    assert_queries(1) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
-  end
-
-  def test_cached_attribute_values_are_expired_from_the_cache_when_an_existing_record_with_changed_attributes_is_saved
-    assert_queries(1) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
-    assert_queries(0) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
-
-    @record.name = 'bar'
-    @record.save!
-
-    assert_queries(1) { assert_equal 'bar', AssociatedRecord.fetch_name_by_id(1) }
-  end
-
-  def test_cached_attribute_values_are_expired_from_the_cache_when_an_existing_record_is_destroyed
-    assert_queries(1) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
-    assert_queries(0) { assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1) }
-
-    @record.destroy
-
-    assert_queries(1) { assert_nil AssociatedRecord.fetch_name_by_id(1) }
-  end
-
-  def test_cached_attribute_values_are_expired_from_the_cache_when_a_new_record_is_saved
-    new_id = 2
-    assert_queries(1) { assert_nil AssociatedRecord.fetch_name_by_id(new_id) }
-    assert_queries(0) { assert_nil AssociatedRecord.fetch_name_by_id(new_id) }
-
-    @parent.associated_records.create(:name => 'bar')
-
-    assert_queries(1) { assert_equal 'bar', AssociatedRecord.fetch_name_by_id(new_id) }
-  end
-
-  def test_fetching_by_attribute_delegates_to_block_if_transactions_are_open
-    IdentityCache.cache.expects(:read).never
-
-    @record.transaction do
-      assert_queries(1) do
-        assert_equal 'foo', AssociatedRecord.fetch_name_by_id(1)
-      end
-    end
-  end
-
-  def test_previously_stored_cached_nils_are_busted_by_new_record_saves
-    assert_nil AssociatedRecord.fetch_name_by_id(2)
-    AssociatedRecord.create(:name => "Jim")
-    assert_equal "Jim", AssociatedRecord.fetch_name_by_id(2)
-  end
-
-  def test_cache_attribute_on_derived_model_raises
-    assert_raises(IdentityCache::DerivedModelError) do
-      StiRecordTypeA.cache_attribute :name
-    end
-  end
-
-  def test_cache_attribute_respects_should_use_cache
-    AssociatedRecord.stubs(:should_use_cache?).returns(false)
-
-    assert_queries(1) do
-      assert_memcache_operations(0) do
-        AssociatedRecord.fetch_name_by_id(@record.id)
-      end
-    end
-  end
-end

data/test/cache_fetch_includes_test.rb

@@ -1,46 +0,0 @@
-require "test_helper"
-
-class CacheFetchIncludesTest < IdentityCache::TestCase
-  def setup
-    super
-  end
-
-  def test_cached_embedded_has_manys_are_included_in_includes
-    Item.send(:cache_has_many, :associated_records, :embed => true)
-    assert_equal [:associated_records], Item.send(:cache_fetch_includes)
-  end
-
-  def test_cached_nonembedded_has_manys_are_included_in_includes
-    Item.send(:cache_has_many, :associated_records, :embed => :ids)
-    assert_equal [], Item.send(:cache_fetch_includes)
-  end
-
-  def test_cached_has_ones_are_included_in_includes
-    Item.send(:cache_has_one, :associated)
-    assert_equal [:associated], Item.send(:cache_fetch_includes)
-  end
-
-  def test_cached_nonembedded_belongs_tos_are_not_included_in_includes
-    Item.send(:cache_belongs_to, :item)
-    assert_equal [], Item.send(:cache_fetch_includes)
-  end
-
-  def test_cached_child_associations_are_included_in_includes
-    Item.send(:cache_has_many, :associated_records, :embed => true)
-    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => true)
-    assert_equal [{:associated_records => [:deeply_associated_records]}], Item.send(:cache_fetch_includes)
-  end
-
-  def test_multiple_cached_associations_and_child_associations_are_included_in_includes
-    Item.send(:cache_has_many, :associated_records, :embed => true)
-    PolymorphicRecord.send(:include, IdentityCache::WithoutPrimaryIndex)
-    Item.send(:cache_has_many, :polymorphic_records, {:inverse_name => :owner, :embed => true})
-    Item.send(:cache_has_one, :associated, :embed => true)
-    AssociatedRecord.send(:cache_has_many, :deeply_associated_records, :embed => true)
-    assert_equal [
-      {:associated_records => [:deeply_associated_records]},
-      :polymorphic_records,
-      {:associated => [:deeply_associated_records]}
-    ],  Item.send(:cache_fetch_includes)
-  end
-end

data/test/cache_hash_test.rb

@@ -1,14 +0,0 @@
-require 'test_helper'
-
-class CacheHashTest < IdentityCache::TestCase
-
-  def test_memcache_hash
-    3.times do
-      random_str = Array.new(200){rand(36).to_s(36)}.join
-      hash_val = IdentityCache.memcache_hash(random_str)
-      assert hash_val
-      assert_kind_of Numeric, hash_val
-      assert_equal 0, (hash_val >> 64)
-    end
-  end
-end

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,214 +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
-    IdentityCache.never_set_inverse_association = false
-    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
-  ensure
-    IdentityCache.never_set_inverse_association = true
-  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