identity_cache 0.2.5 → 0.3.0

data/test/deeply_nested_associated_record_test.rb

@@ -10,6 +10,7 @@ class DeeplyNestedAssociatedRecordHasOneTest < IdentityCache::TestCase
 
   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

data/test/denormalized_has_many_test.rb

@@ -82,10 +82,28 @@ class DenormalizedHasManyTest < IdentityCache::TestCase
     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_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_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

data/test/denormalized_has_one_test.rb

@@ -20,7 +20,7 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
     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.secondary_cache_index_key_for_current_values([:title]))
+    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
 
@@ -29,7 +29,6 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
     @record.associated = nil
     @record.save!
     @record.reload
-    @record.send(:populate_association_caches)
     Item.expects(:resolve_cache_miss).with(@record.id).once.returns(@record)
 
     fetch = Spy.on(IdentityCache.cache, :fetch).and_call_through
@@ -41,7 +40,7 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
     5.times do
       assert_nil record_from_cache_miss.fetch_associated
     end
-    assert fetch.has_been_called_with?(@record.secondary_cache_index_key_for_current_values([:title]))
+    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
 
@@ -53,7 +52,6 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
   end
 
   def test_on_cache_hit_record_should_come_back_with_cached_association
-    @record.send(:populate_association_caches)
     Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
     Item.fetch_by_title('foo')
 
@@ -69,7 +67,6 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
     @record.save!
     @record.reload
 
-    @record.send(:populate_association_caches)
     Item.expects(:resolve_cache_miss).with(1).once.returns(@record)
     Item.fetch_by_title('foo')
 
@@ -110,4 +107,17 @@ class DenormalizedHasOneTest < IdentityCache::TestCase
       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
 end

data/test/fetch_multi_test.rb

@@ -121,6 +121,18 @@ class FetchMultiTest < IdentityCache::TestCase
     assert_equal [@joe, @bob, @joe], Item.fetch_multi(@joe.id, @bob.id, @joe.id)
   end
 
+  def test_fetch_multi_with_duplicate_ids_hits_backend_once_per_id
+    cache_response = {
+      @joe_blob_key => cache_response_for(@joe),
+      @bob_blob_key => cache_response_for(@bob),
+    }
+
+    fetcher.expects(:fetch_multi).with([@joe_blob_key, @bob_blob_key]).returns(cache_response)
+    result = Item.fetch_multi(@joe.id, @bob.id, @joe.id)
+
+    assert_equal [@joe, @bob, @joe], result
+  end
+
   def test_fetch_multi_with_open_transactions_hits_the_database
     Item.connection.expects(:open_transactions).at_least_once.returns(1)
     fetcher.expects(:fetch_multi).never
@@ -199,6 +211,18 @@ class FetchMultiTest < IdentityCache::TestCase
     assert_equal cache_response_for(Item.find(@bob.id)), backend.read(@bob.primary_cache_index_key)
   end
 
+  def test_fetch_multi_raises_when_called_on_a_scope
+    assert_raises(IdentityCache::UnsupportedScopeError) do
+      Item.where(updated_at: nil).fetch_multi(@bob.id, @joe.id, @fred.id)
+    end
+  end
+
+  def test_fetch_multi_on_derived_model_raises
+    assert_raises(IdentityCache::DerivedModelError) do
+      StiRecordTypeA.fetch_multi(1, 2)
+    end
+  end
+
   private
 
   def populate_only_fred
@@ -210,9 +234,7 @@ class FetchMultiTest < IdentityCache::TestCase
   end
 
   def cache_response_for(record)
-    coder = {:class => record.class}
-    record.encode_with(coder)
-    coder
+    {class: record.class, attributes: record.attributes_before_type_cast}
   end
 
   def with_batch_size(size)

data/test/fetch_test.rb

@@ -11,17 +11,12 @@ class FetchTest < IdentityCache::TestCase
     @record = Item.new
     @record.id = 1
     @record.title = 'bob'
-    @cached_value = {:class => @record.class}
-    @record.encode_with(@cached_value)
+    @cached_value = {class: @record.class, attributes: @record.attributes_before_type_cast}
     @blob_key = "#{NAMESPACE}blob:Item:#{cache_hash("created_at:datetime,id:integer,item_id:integer,title:string,updated_at:datetime")}:1"
-    @index_key = "#{NAMESPACE}index:Item:title:#{cache_hash('bob')}"
+    @index_key = "#{NAMESPACE}attr:Item:id:title:#{cache_hash('bob')}"
   end
 
   def test_fetch_with_garbage_input
-    Item.connection.expects(:exec_query)
-      .with(Item.where(id: 0).limit(1).to_sql, any_parameters)
-      .returns(ActiveRecord::Result.new([], []))
-
     assert_equal nil, Item.fetch_by_id('garbage')
   end
 
@@ -199,4 +194,22 @@ class FetchTest < IdentityCache::TestCase
 
     assert_equal false, ActiveRecord::Base.connection_handler.active_connections?
   end
+
+  def test_fetch_raises_when_called_on_a_scope
+    assert_raises(IdentityCache::UnsupportedScopeError) do
+      Item.where(updated_at: nil).fetch(1)
+    end
+  end
+
+  def test_fetch_by_raises_when_called_on_a_scope
+    assert_raises(IdentityCache::UnsupportedScopeError) do
+      Item.where(updated_at: nil).fetch_by_id(1)
+    end
+  end
+
+  def test_fetch_on_derived_model_raises
+    assert_raises(IdentityCache::DerivedModelError) do
+      StiRecordTypeA.fetch(1)
+    end
+  end
 end

data/test/helpers/active_record_objects.rb

@@ -76,6 +76,14 @@ module ActiveRecordObjects
       include IdentityCache
       self.primary_key = "hashed_key"
     }
+
+    Object.send :const_set, 'StiRecord', Class.new(base) {
+      include IdentityCache
+      has_many :polymorphic_records, :as => 'owner'
+    }
+
+    Object.send :const_set, 'StiRecordTypeA', Class.new(StiRecord) {
+    }
   end
 
   def teardown_models
@@ -89,6 +97,8 @@ module ActiveRecordObjects
     Object.send :remove_const, 'Item'
     Object.send :remove_const, 'ItemTwo'
     Object.send :remove_const, 'KeyedRecord'
+    Object.send :remove_const, 'StiRecord'
+    Object.send :remove_const, 'StiRecordTypeA'
     Deeply::Nested.send :remove_const, 'AssociatedRecord'
     Deeply.send :remove_const, 'Nested'
     Object.send :remove_const, 'Deeply'

data/test/helpers/database_connection.rb

@@ -1,6 +1,10 @@
 module DatabaseConnection
+  def self.db_name
+    ENV.fetch('DB', 'mysql2')
+  end
+
   def self.setup
-    db_config = ENV['DATABASE_URL'] || DEFAULT_CONFIG[ENV.fetch('DB', 'mysql2')]
+    db_config = ENV['DATABASE_URL'] || DEFAULT_CONFIG[db_name]
     begin
       ActiveRecord::Base.establish_connection(db_config)
       ActiveRecord::Base.connection
@@ -39,6 +43,7 @@ module DatabaseConnection
     :items                         => [[:integer, :item_id], [:string, :title], [:timestamps, null: true]],
     :items2                        => [[:integer, :item_id], [:string, :title], [:timestamps, null: true]],
     :keyed_records                 => [[:string, :value], :primary_key => "hashed_key"],
+    :sti_records                   => [[:string, :type], [:string, :name]],
   }
 
   DEFAULT_CONFIG = {

data/test/helpers/serialization_format.rb

@@ -24,7 +24,7 @@ module SerializationFormat
   end
 
   def serialized_record_file
-    File.expand_path("../../fixtures/serialized_record", __FILE__)
+    File.expand_path("../../fixtures/serialized_record.#{DatabaseConnection.db_name}", __FILE__)
   end
 
   def serialize(record, anIO = nil)

data/test/index_cache_test.rb

@@ -8,17 +8,14 @@ class IndexCacheTest < IdentityCache::TestCase
     @record = Item.new
     @record.id = 1
     @record.title = 'bob'
-    @cache_key = "#{NAMESPACE}index:Item:title:#{cache_hash(@record.title)}"
   end
 
-  def test_fetch_with_garbage_input_should_use_properly_typed_sql
+  def test_fetch_with_garbage_input
     Item.cache_index :title, :id
 
-    Item.connection.expects(:exec_query)
-      .with(Item.select(:id).where(title: 'garbage', id: 0).to_sql, any_parameters)
-      .returns(ActiveRecord::Result.new([], []))
-
-    assert_equal [], Item.fetch_by_title_and_id('garbage', 'garbage')
+    assert_queries(1) do
+      assert_equal [], Item.fetch_by_title_and_id('garbage', 'garbage')
+    end
   end
 
   def test_fetch_with_unique_adds_limit_clause
@@ -34,54 +31,55 @@ class IndexCacheTest < IdentityCache::TestCase
   def test_unique_index_caches_nil
     Item.cache_index :title, :unique => true
     assert_equal nil, Item.fetch_by_title('bob')
-    assert_equal IdentityCache::CACHED_NIL, backend.read(@cache_key)
+    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, IdentityCache::CACHED_NIL)
+    IdentityCache.cache.write(cache_key(unique: true), IdentityCache::CACHED_NIL)
     @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(@cache_key)
+    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)
+    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!
-    IdentityCache.cache.write(@cache_key, @record.id)
+    old_cache_key = cache_key(unique: true)
+    IdentityCache.cache.write(old_cache_key, @record.id)
 
     @record.title = 'robert'
-    new_cache_key = "#{NAMESPACE}index:Item:title:#{cache_hash(@record.title)}"
+    new_cache_key = cache_key(unique: true)
     IdentityCache.cache.write(new_cache_key, IdentityCache::CACHED_NIL)
     @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(@cache_key)
+    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)
+    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, [])
+    IdentityCache.cache.write(cache_key, [])
     @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(@cache_key)
+    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)
+    assert_equal [@record.id], backend.read(cache_key)
   end
 
   def test_non_unique_index_fetches_multiple_records
@@ -90,28 +88,29 @@ class IndexCacheTest < IdentityCache::TestCase
     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)
+    assert_equal [1, 2], backend.read(cache_key)
   end
 
   def test_non_unique_index_expired_by_updating_record
     Item.cache_index :title
     @record.save!
-    IdentityCache.cache.write(@cache_key, [@record.id])
+    old_cache_key = cache_key
+    IdentityCache.cache.write(old_cache_key, [@record.id])
 
     @record.title = 'robert'
-    new_cache_key = "#{NAMESPACE}index:Item:title:#{cache_hash(@record.title)}"
+    new_cache_key = cache_key
     IdentityCache.cache.write(new_cache_key, [])
     @record.save!
-    assert_equal IdentityCache::DELETED, backend.read(@cache_key)
+    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])
+    IdentityCache.cache.write(cache_key, [@record.id])
     @record.destroy
-    assert_equal IdentityCache::DELETED, backend.read(@cache_key)
+    assert_equal IdentityCache::DELETED, backend.read(cache_key)
   end
 
   def test_set_table_name_cache_fetch
@@ -119,6 +118,32 @@ class IndexCacheTest < IdentityCache::TestCase
     Item.table_name = 'items2'
     @record.save!
     assert_equal [@record], Item.fetch_by_title('bob')
-    assert_equal [@record.id], backend.read(@cache_key)
+    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
+
+  private
+
+  def cache_key(unique: false)
+    "#{NAMESPACE}attr#{unique ? '' : 's'}:Item:id:title:#{cache_hash(@record.title)}"
   end
 end

data/test/normalized_belongs_to_test.rb

@@ -34,15 +34,30 @@ class NormalizedBelongsToTest < IdentityCache::TestCase
     assert_equal @parent_record, @record.fetch_item
   end
 
-  def test_fetching_the_association_should_assign_the_result_to_the_association_so_that_successive_accesses_are_cached
+  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)
-    @record.fetch_item
-    assert @record.association(:item).loaded?
-    assert_equal @parent_record, @record.item
+    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_shouldnt_raise_if_the_record_cant_be_found
+  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_equal nil, @record.fetch_item
+    assert_equal nil, @record.fetch_item # miss
+    assert_equal 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
 end

data/test/normalized_has_many_test.rb

@@ -29,6 +29,50 @@ class NormalizedHasManyTest < IdentityCache::TestCase
     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