record-cache 0.1.0

data/spec/lib/strategy/base_spec.rb

@@ -0,0 +1,241 @@
+$KCODE = 'UTF8'
+require 'spec_helper'
+
+describe RecordCache::Strategy::Base do
+  
+  it "should provide easy access to the Version Store" do
+    Apple.record_cache[:id].send(:version_store).should == RecordCache::Base.version_store
+  end
+
+  it "should provide easy access to the Record Store" do
+    Apple.record_cache[:id].send(:record_store).should == RecordCache::Base.stores[:shared]
+    Banana.record_cache[:id].send(:record_store).should == RecordCache::Base.stores[:local]
+  end
+
+  it "should provide easy access to the statistics" do
+    Apple.record_cache[:person_id].send(:statistics).should == RecordCache::Statistics.find(Apple, :person_id)
+    Banana.record_cache[:id].send(:statistics).should == RecordCache::Statistics.find(Banana, :id)
+  end
+
+  it "should retrieve the cache key based on the :key option" do
+    Apple.record_cache[:id].send(:cache_key, 1).should == "rc/apl/1"
+  end
+
+  it "should retrieve the cache key based on the model name" do
+    Banana.record_cache[:id].send(:cache_key, 1).should == "rc/Banana/1"
+  end
+
+  it "should define the versioned key" do
+    Banana.record_cache[:id].send(:versioned_key, "rc/Banana/1", 2312423).should == "rc/Banana/1v2312423"
+  end
+
+  it "should serialize a record (currently Active Record only)" do
+    Banana.record_cache[:id].send(:serialize, Banana.find(1)).should == {:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"}
+  end
+
+  it "should deserialize a record (currently Active Record only)" do
+    Banana.record_cache[:id].send(:deserialize, {:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"}).should == Banana.find(1)
+  end
+
+  context "filter" do
+    it "should apply filter on :id cache hits" do
+      lambda{ @apples = Apple.where(:id => [1,2]).where(:name => "Adams Apple 1").all }.should use_cache(Apple).on(:id)
+      @apples.should == [Apple.find_by_name("Adams Apple 1")]
+    end
+    
+    it "should apply filter on index cache hits" do
+      lambda{ @apples = Apple.where(:store_id => 1).where(:name => "Adams Apple 1").all }.should use_cache(Apple).on(:store_id)
+      @apples.should == [Apple.find_by_name("Adams Apple 1")]
+    end
+
+    it "should return empty array when filter does not match any record" do
+      lambda{ @apples = Apple.where(:store_id => 1).where(:name => "Adams Apple Pie").all }.should use_cache(Apple).on(:store_id)
+      @apples.should == []
+    end
+
+    it "should filter on text" do
+      lambda{ @apples = Apple.where(:id => [1,2]).where(:name => "Adams Apple 1").all }.should use_cache(Apple).on(:id)
+      @apples.should == [Apple.find_by_name("Adams Apple 1")]
+    end
+
+    it "should filter on integers" do
+      lambda{ @apples = Apple.where(:id => [1,2,8,9]).where(:store_id => 2).all }.should use_cache(Apple).on(:id)
+      @apples.map(&:id).sort.should == [8,9]
+    end
+
+    it "should filter on dates" do
+      lambda{ @people = Person.where(:id => [1,2,3]).where(:birthday => Date.civil(1953,11,11)).all }.should use_cache(Person).on(:id)
+      @people.size.should == 1
+      @people.first.name.should == "Blue"
+    end
+
+    it "should filter on floats" do
+      lambda{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).all }.should use_cache(Person).on(:id)
+      @people.size.should == 2
+      @people.map(&:name).sort.should == ["Blue", "Cris"]
+    end
+
+    it "should filter on arrays" do
+      lambda{ @apples = Apple.where(:id => [1,2,8,9]).where(:store_id => [2, 4]).all }.should use_cache(Apple).on(:id)
+      @apples.map(&:id).sort.should == [8,9]
+    end
+    
+    it "should filter on multiple fields" do
+      # make sure two apples exist with the same name
+      @apple = Apple.find(8)
+      @apple.name = Apple.find(9).name
+      @apple.save!
+
+      lambda{ @apples = Apple.where(:id => [1,2,3,8,9,10]).where(:store_id => 2).where(:name => @apple.name).all }.should use_cache(Apple).on(:id)
+      @apples.size.should == 2
+      @apples.map(&:name).should == [@apple.name, @apple.name]
+      @apples.map(&:id).sort.should == [8,9]
+    end
+
+  end
+
+  context "sort" do
+    it "should apply sort on :id cache hits" do
+      lambda{ @people = Person.where(:id => [1,2,3]).order("name DESC").all }.should use_cache(Person).on(:id)
+      @people.map(&:name).should == ["Cris", "Blue", "Adam"]
+    end
+
+    it "should apply sort on index cache hits" do
+      lambda{ @apples = Apple.where(:store_id => 1).order("person_id ASC").all }.should use_cache(Apple).on(:store_id)
+      @apples.map(&:person_id).should == [nil, nil, 4, 4, 5]
+    end
+    
+    it "should default to ASC" do
+      lambda{ @apples = Apple.where(:store_id => 1).order("person_id").all }.should use_cache(Apple).on(:store_id)
+      @apples.map(&:person_id).should == [nil, nil, 4, 4, 5]
+    end
+
+    it "should apply sort nil first for ASC" do
+      lambda{ @apples = Apple.where(:store_id => 1).order("person_id ASC").all }.should use_cache(Apple).on(:store_id)
+      @apples.map(&:person_id).should == [nil, nil, 4, 4, 5]
+    end
+
+    it "should apply sort nil last for DESC" do
+      lambda{ @apples = Apple.where(:store_id => 1).order("person_id DESC").all }.should use_cache(Apple).on(:store_id)
+      @apples.map(&:person_id).should == [5, 4, 4, nil, nil]
+    end
+
+    it "should sort ascending on text" do
+      lambda{ @people = Person.where(:id => [1,2,3,4]).order("name ASC").all }.should use_cache(Person).on(:id)
+      @people.map(&:name).should == ["Adam", "Blue", "Cris", "Fry"]
+    end
+
+    it "should sort descending on text" do
+      lambda{ @people = Person.where(:id => [1,2,3,4]).order("name DESC").all }.should use_cache(Person).on(:id)
+      @people.map(&:name).should == ["Fry", "Cris", "Blue", "Adam"]
+    end
+
+    it "should sort ascending on integers" do
+      lambda{ @people = Person.where(:id => [1,2,3,4]).order("id ASC").all }.should use_cache(Person).on(:id)
+      @people.map(&:id).should == [1,2,3,4]
+    end
+
+    it "should sort descending on integers" do
+      lambda{ @people = Person.where(:id => [1,2,3,4]).order("id DESC").all }.should use_cache(Person).on(:id)
+      @people.map(&:id).should == [4,3,2,1]
+    end
+
+    it "should sort ascending on dates" do
+      lambda{ @people = Person.where(:id => [1,2,3,4]).order("birthday ASC").all }.should use_cache(Person).on(:id)
+      @people.map(&:birthday).should == [Date.civil(1953,11,11), Date.civil(1975,03,20), Date.civil(1975,03,20), Date.civil(1985,01,20)]
+    end
+
+    it "should sort descending on dates" do
+      lambda{ @people = Person.where(:id => [1,2,3,4]).order("birthday DESC").all }.should use_cache(Person).on(:id)
+      @people.map(&:birthday).should == [Date.civil(1985,01,20), Date.civil(1975,03,20), Date.civil(1975,03,20), Date.civil(1953,11,11)]
+    end
+
+    it "should sort ascending on float" do
+      lambda{ @people = Person.where(:id => [1,2,3,4]).order("height ASC").all }.should use_cache(Person).on(:id)
+      @people.map(&:height).should == [1.69, 1.75, 1.75, 1.83]
+    end
+
+    it "should sort descending on float" do
+      lambda{ @people = Person.where(:id => [1,2,3,4]).order("height DESC").all }.should use_cache(Person).on(:id)
+      @people.map(&:height).should == [1.83, 1.75, 1.75, 1.69]
+    end
+
+    it "should sort on multiple fields (ASC + ASC)" do
+      lambda{ @people = Person.where(:id => [2,3,4,5]).order("height ASC, id ASC").all }.should use_cache(Person).on(:id)
+      @people.map(&:height).should == [1.69, 1.75, 1.75, 1.91]
+      @people.map(&:id).should == [4, 2, 3, 5]
+    end
+
+    it "should sort on multiple fields (ASC + DESC)" do
+      lambda{ @people = Person.where(:id => [2,3,4,5]).order("height ASC, id DESC").all }.should use_cache(Person).on(:id)
+      @people.map(&:height).should == [1.69, 1.75, 1.75, 1.91]
+      @people.map(&:id).should == [4, 3, 2, 5]
+    end
+
+    it "should sort on multiple fields (DESC + ASC)" do
+      lambda{ @people = Person.where(:id => [2,3,4,5]).order("height DESC, id ASC").all }.should use_cache(Person).on(:id)
+      @people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
+      @people.map(&:id).should == [5, 2, 3, 4]
+    end
+
+    it "should sort on multiple fields (DESC + DESC)" do
+      lambda{ @people = Person.where(:id => [2,3,4,5]).order("height DESC, id DESC").all }.should use_cache(Person).on(:id)
+      @people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
+      @people.map(&:id).should == [5, 3, 2, 4]
+    end
+    
+    it "should use mysql style collation" do
+      ids = []
+      ids << Person.create!(:name => "ċedriĉ 3").id # latin other special
+      ids << Person.create!(:name => "a cedric").id # first in ascending order
+      ids << Person.create!(:name => "čedriĉ 4").id # latin another special
+      ids << Person.create!(:name => "ćedriĉ Last").id # latin special lowercase
+      ids << Person.create!(:name => "sedric 1").id # second to last latin in ascending order 
+      ids << Person.create!(:name => "Cedric 2").id # ascii uppercase
+      ids << Person.create!(:name => "čedriĉ คฉ Almost last cedric").id # latin special, with non-latin
+      ids << Person.create!(:name => "Sedric 2").id # last latin in ascending order
+      ids << Person.create!(:name => "1 cedric").id # numbers before characters
+      ids << Person.create!(:name => "cedric 1").id # ascii lowercase
+      ids << Person.create!(:name => "คฉ Really last").id # non-latin characters last in ascending order
+      ids << Person.create!(:name => "čedriĉ ꜩ Last").id # latin special, with latin non-collateable
+
+      names_asc = ["1 cedric", "a cedric", "cedric 1", "Cedric 2", "ċedriĉ 3", "čedriĉ 4", "ćedriĉ Last", "čedriĉ คฉ Almost last cedric", "čedriĉ ꜩ Last", "sedric 1", "Sedric 2",  "คฉ Really last"]
+      lambda{ @people = Person.where(:id => ids).order("name ASC").all }.should hit_cache(Person).on(:id).times(ids.size)
+      @people.map(&:name).should == names_asc
+
+      lambda{ @people = Person.where(:id => ids).order("name DESC").all }.should hit_cache(Person).on(:id).times(ids.size)
+      @people.map(&:name).should == names_asc.reverse
+    end
+  end
+
+  it "should combine filter and sort" do
+    lambda{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).order("name DESC").all }.should use_cache(Person).on(:id)
+    @people.size.should == 2
+    @people.map(&:name).should == ["Cris", "Blue"]
+
+    lambda{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).order("name").all }.should hit_cache(Person).on(:id).times(3)
+    @people.map(&:name).should == ["Blue", "Cris"]
+  end
+  
+  context "NotImplementedError" do
+    before(:each) do
+      @invalid_strategy = RecordCache::Strategy::Base.new(Object, nil, nil, "key")
+    end
+
+    it "should require record_change to be implemented" do
+      lambda { @invalid_strategy.record_change(Object.new, 1) }.should raise_error(NotImplementedError)
+    end
+
+    it "should require cacheable? to be implemented" do
+      lambda { @invalid_strategy.cacheable?(RecordCache::Query.new) }.should raise_error(NotImplementedError)
+    end
+
+    it "should require invalidate to be implemented" do
+      lambda { @invalid_strategy.invalidate(1) }.should raise_error(NotImplementedError)
+    end
+
+    it "should fetch_records to be implemented" do
+      lambda { @invalid_strategy.fetch(RecordCache::Query.new) }.should raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/lib/strategy/id_cache_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe RecordCache::Strategy::IdCache do
+
+  it "should retrieve an Apple from the cache" do
+    lambda{ Apple.find(1) }.should miss_cache(Apple).on(:id).times(1)
+    lambda{ Apple.find(1) }.should hit_cache(Apple).on(:id).times(1)
+  end
+
+  it "should retrieve cloned records" do
+    @apple_1a = Apple.find(1)
+    @apple_1b = Apple.find(1)
+    @apple_1a.should == @apple_1b
+    @apple_1a.object_id.should_not == @apple_1b.object_id
+  end
+
+  context "logging" do
+    before(:each) do
+      Apple.find(1)
+    end
+
+    it "should write full hits to the debug log" do
+      mock(RecordCache::Base.logger).debug(/IdCache hit for ids 1|^(?!IdCache)/).times(any_times)
+      Apple.find(1)
+    end
+
+    it "should write full miss to the debug log" do
+      mock(RecordCache::Base.logger).debug(/IdCache miss for ids 2|^(?!IdCache)/).times(any_times)
+      Apple.find(2)
+    end
+    
+    it "should write partial hits to the debug log" do
+      mock(RecordCache::Base.logger).debug(/IdCache partial hit for ids \[1, 2\]: missing \[2\]|^(?!IdCache)/).times(any_times)
+      Apple.where(:id => [1,2]).all
+    end
+  end
+
+  context "cacheable?" do
+    before(:each) do
+      # fill cache
+      @apple1 = Apple.find(1)
+      @apple2 = Apple.find(2)
+    end
+
+    it "should use the cache when a single id is requested" do
+      lambda{ Apple.where(:id => 1).all }.should hit_cache(Apple).on(:id).times(1)
+    end
+
+    it "should use the cache when a multiple ids are requested" do
+      lambda{ Apple.where(:id => [1, 2]).all }.should hit_cache(Apple).on(:id).times(2)
+    end
+
+    it "should use the cache when a single id is requested and the limit is 1" do
+      lambda{ Apple.where(:id => 1).limit(1).all }.should hit_cache(Apple).on(:id).times(1)
+    end
+
+    it "should not use the cache when a single id is requested and the limit is > 1" do
+      lambda{ Apple.where(:id => 1).limit(2).all }.should_not use_cache(Apple).on(:id)
+    end
+
+    it "should not use the cache when multiple ids are requested and the limit is 1" do
+      lambda{ Apple.where(:id => [1, 2]).limit(1).all }.should_not use_cache(Apple).on(:id)
+    end
+
+    it "should use the cache when a single id is requested together with other where clauses" do
+      lambda{ Apple.where(:id => 1).where(:name => "Adams Apple x").all }.should hit_cache(Apple).on(:id).times(1)
+    end
+
+    it "should use the cache when a multiple ids are requested together with other where clauses" do
+      lambda{ Apple.where(:id => [1,2]).where(:name => "Adams Apple x").all }.should hit_cache(Apple).on(:id).times(2)
+    end
+
+    it "should use the cache when a single id is requested together with (simple) sort clauses" do
+      lambda{ Apple.where(:id => 1).order("name ASC").all }.should hit_cache(Apple).on(:id).times(1)
+    end
+
+    it "should use the cache when a multiple ids are requested together with (simple) sort clauses" do
+      lambda{ Apple.where(:id => [1,2]).order("name ASC").all }.should hit_cache(Apple).on(:id).times(2)
+    end
+  end
+  
+  context "record_change" do
+    before(:each) do
+      # fill cache
+      @apple1 = Apple.find(1)
+      @apple2 = Apple.find(2)
+    end
+
+    it "should invalidate destroyed records" do
+      lambda{ Apple.where(:id => 1).all }.should hit_cache(Apple).on(:id).times(1)
+      @apple1.destroy
+      lambda{ @apples = Apple.where(:id => 1).all }.should miss_cache(Apple).on(:id).times(1)
+      @apples.should == []
+      # try again, to make sure the "missing record" is not cached
+      lambda{ Apple.where(:id => 1).all }.should miss_cache(Apple).on(:id).times(1)
+    end
+
+    it "should add updated records directly to the cache" do
+      @apple1.name = "Applejuice"
+      @apple1.save!
+      lambda{ @apple = Apple.find(1) }.should hit_cache(Apple).on(:id).times(1)
+      @apple.name.should == "Applejuice"
+    end
+
+    it "should add created records directly to the cache" do
+      @new_apple = Apple.create!(:name => "Fresh Apple", :store_id => 1)
+      lambda{ @apple = Apple.find(@new_apple.id) }.should hit_cache(Apple).on(:id).times(1)
+      @apple.name.should == "Fresh Apple"
+    end
+
+    it "should add updated records to the cache, also when multiple ids are queried" do
+      @apple1.name = "Applejuice"
+      @apple1.save!
+      lambda{ @apples = Apple.where(:id => [1, 2]).order('id ASC').all }.should hit_cache(Apple).on(:id).times(2)
+      @apples.map(&:name).should == ["Applejuice", "Adams Apple 2"]
+    end
+    
+  end
+  
+  context "invalidate" do
+    before(:each) do
+      @apple1 = Apple.find(1)
+      @apple2 = Apple.find(2)
+    end
+
+    it "should invalidate single records" do
+      Apple.record_cache[:id].invalidate(1)
+      lambda{ Apple.find(1) }.should miss_cache(Apple).on(:id).times(1)
+    end
+
+    it "should only miss the cache for the invalidated record when multiple ids are queried" do
+      # miss on 1
+      Apple.record_cache[:id].invalidate(1)
+      lambda{ Apple.where(:id => [1, 2]).all }.should miss_cache(Apple).on(:id).times(1)
+      # hit on 2
+      Apple.record_cache[:id].invalidate(1)
+      lambda{ Apple.where(:id => [1, 2]).all }.should hit_cache(Apple).on(:id).times(1)
+      # nothing invalidated, both hit
+      lambda{ Apple.where(:id => [1, 2]).all }.should hit_cache(Apple).on(:id).times(2)
+    end
+
+    it "should invalidate records when using update_all" do
+      Apple.where(:id => [3,4,5]).all # fill id cache on all Adam Store apples
+      lambda{ @apples = Apple.where(:id => [1, 2, 3, 4, 5]).order('id ASC').all }.should hit_cache(Apple).on(:id).times(5)
+      @apples.map(&:name).should == ["Adams Apple 1", "Adams Apple 2", "Adams Apple 3", "Adams Apple 4", "Adams Apple 5"]
+      # update 3 of the 5 apples in the Adam Store
+      Apple.where(:id => [1,2,3]).update_all(:name => "Uniform Apple")
+      lambda{ @apples = Apple.where(:id => [1, 2, 3, 4, 5]).order('id ASC').all }.should hit_cache(Apple).on(:id).times(2)
+      @apples.map(&:name).should == ["Uniform Apple", "Uniform Apple", "Uniform Apple", "Adams Apple 4", "Adams Apple 5"]
+    end
+
+    it "should invalidate reflection indexes when a has_many relation is updated" do
+      # assign different apples to store 2
+      lambda{ Apple.where(:store_id => 1).all }.should hit_cache(Apple).on(:id).times(2)
+      store2_apple_ids = Apple.where(:store_id => 2).map(&:id)
+      store1 = Store.find(1)
+      store1.apple_ids = store2_apple_ids
+      store1.save!
+      # the apples that used to belong to store 2 are now in store 1 (incremental update)
+      lambda{ @apple1 = Apple.find(store2_apple_ids.first) }.should hit_cache(Apple).on(:id).times(1)
+      @apple1.store_id.should == 1
+      # the apples that used to belong to store 1 are now homeless (cache invalidated)
+      lambda{ @homeless_apple = Apple.find(1) }.should miss_cache(Apple).on(:id).times(1)
+      @homeless_apple.store_id.should == nil
+    end
+  end
+
+end

data/spec/lib/strategy/index_cache_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+
+describe RecordCache::Strategy::IndexCache do
+
+  context "initialize" do
+    it "should only accept index cache on DB columns" do
+      lambda { Apple.send(:cache_records, :index => :unknown_column) }.should raise_error("No column found for index 'unknown_column' on Apple.")
+    end
+  
+    it "should only accept index cache on integer columns" do
+      lambda { Apple.send(:cache_records, :index => :name) }.should raise_error("Incorrect type (expected integer, found string) for index 'name' on Apple.")
+    end
+  end
+
+  it "should use the id cache to retrieve the actual records" do
+    lambda { @apples = Apple.where(:store_id => 1).all }.should miss_cache(Apple).on(:store_id).times(1)
+    lambda { Apple.where(:store_id => 1).all }.should hit_cache(Apple).on(:store_id).times(1)
+    lambda { Apple.where(:store_id => 1).all }.should hit_cache(Apple).on(:id).times(@apples.size)
+  end
+
+  context "logging" do
+    before(:each) do
+      Apple.where(:store_id => 1).all
+    end
+
+    it "should write hit to the debug log" do
+      mock(RecordCache::Base.logger).debug(/IndexCache hit for rc\/apl\/store_id=1v\d+: found 5 ids|^(?!IndexCache)/).times(any_times)
+      Apple.where(:store_id => 1).all
+    end
+
+    it "should write miss to the debug log" do
+      mock(RecordCache::Base.logger).debug(/IndexCache miss for rc\/apl\/store_id=2v\d+: found no ids|^(?!IndexCache)/).times(any_times)
+      Apple.where(:store_id => 2).all
+    end
+  end
+
+  context "cacheable?" do
+    before(:each) do
+      @store1_apples = Apple.where(:store_id => 1).all
+      @store2_apples = Apple.where(:store_id => 2).all
+    end
+
+    it "should hit the cache for a single index id" do
+      lambda { Apple.where(:store_id => 1).all }.should hit_cache(Apple).on(:store_id).times(1)
+    end
+
+    it "should hit the cache for a single index id with other where clauses" do
+      lambda { Apple.where(:store_id => 1).where(:name => "applegate").all }.should hit_cache(Apple).on(:store_id).times(1)
+    end
+
+    it "should hit the cache for a single index id with (simple) sort clauses" do
+      lambda { Apple.where(:store_id => 1).order("name ASC").all }.should hit_cache(Apple).on(:store_id).times(1)
+    end
+
+    it "should not hit the cache for a single index id with limit" do
+      lambda { Apple.where(:store_id => 1).limit(1).all }.should_not hit_cache(Apple).on(:store_id)
+    end
+
+    it "should not hit the cache when an :id where clause is defined" do
+      # this query should make use of the :id cache, which is faster
+      lambda { Apple.where(:store_id => 1).where(:id => 1).all }.should_not hit_cache(Apple).on(:store_id)
+    end
+  end
+  
+  context "record_change" do
+    before(:each) do
+      @store1_apples = Apple.where(:store_id => 1).order('id ASC').all
+      @store2_apples = Apple.where(:store_id => 2).order('id ASC').all
+    end
+
+    [false, true].each do |fresh|
+      it "should #{fresh ? 'update' : 'invalidate'} the index when a record in the index is destroyed and the current index is #{fresh ? '' : 'not '}fresh" do
+        # make sure the index is no longer fresh
+        Apple.record_cache.invalidate(:store_id, 1) unless fresh
+        # destroy an apple
+        @destroyed = @store1_apples.last
+        @destroyed.destroy
+        # check the cache hit/miss on the index that contained that apple
+        if fresh
+          lambda { @apples = Apple.where(:store_id => 1).order('id ASC').all }.should hit_cache(Apple).on(:store_id).times(1)
+        else
+          lambda { @apples = Apple.where(:store_id => 1).order('id ASC').all }.should miss_cache(Apple).on(:store_id).times(1)
+        end
+        @apples.size.should == @store1_apples.size - 1
+        @apples.map(&:id).should == @store1_apples.map(&:id) - [@destroyed.id]
+        # and the index should be cached again
+        lambda { Apple.where(:store_id => 1).all }.should hit_cache(Apple).on(:store_id).times(1)
+      end
+
+      it "should #{fresh ? 'update' : 'invalidate'} the index when a record in the index is created and the current index is #{fresh ? '' : 'not '}fresh" do
+        # make sure the index is no longer fresh
+        Apple.record_cache.invalidate(:store_id, 1) unless fresh
+        # create an apple
+        @new_apple_in_store1 = Apple.create!(:name => "Fresh Apple", :store_id => 1)
+        # check the cache hit/miss on the index that contains that apple
+        if fresh
+          lambda { @apples = Apple.where(:store_id => 1).order('id ASC').all }.should hit_cache(Apple).on(:store_id).times(1)
+        else
+          lambda { @apples = Apple.where(:store_id => 1).order('id ASC').all }.should miss_cache(Apple).on(:store_id).times(1)
+        end
+        @apples.size.should == @store1_apples.size + 1
+        @apples.map(&:id).should == @store1_apples.map(&:id) + [@new_apple_in_store1.id]
+        # and the index should be cached again
+        lambda { Apple.where(:store_id => 1).all }.should hit_cache(Apple).on(:store_id).times(1)
+      end
+
+      it "should #{fresh ? 'update' : 'invalidate'} two indexes when the indexed value is updated and the current index is #{fresh ? '' : 'not '}fresh" do
+        # make sure both indexes are no longer fresh
+        Apple.record_cache.invalidate(:store_id, 1) unless fresh
+        Apple.record_cache.invalidate(:store_id, 2) unless fresh
+        # move one apple from store 1 to store 2
+        @apple_moved_from_store1_to_store2 = @store1_apples.last
+        @apple_moved_from_store1_to_store2.store_id = 2
+        @apple_moved_from_store1_to_store2.save!
+        # check the cache hit/miss on the indexes that contained/contains that apple
+        if fresh
+          lambda { @apples1 = Apple.where(:store_id => 1).order('id ASC').all }.should hit_cache(Apple).on(:store_id).times(1)
+          lambda { @apples2 = Apple.where(:store_id => 2).order('id ASC').all }.should hit_cache(Apple).on(:store_id).times(1)
+        else
+          lambda { @apples1 = Apple.where(:store_id => 1).order('id ASC').all }.should miss_cache(Apple).on(:store_id).times(1)
+          lambda { @apples2 = Apple.where(:store_id => 2).order('id ASC').all }.should miss_cache(Apple).on(:store_id).times(1)
+        end
+        @apples1.size.should == @store1_apples.size - 1
+        @apples2.size.should == @store2_apples.size + 1
+        @apples1.map(&:id).should == @store1_apples.map(&:id) - [@apple_moved_from_store1_to_store2.id]
+        @apples2.map(&:id).should == [@apple_moved_from_store1_to_store2.id] + @store2_apples.map(&:id)
+        # and the index should be cached again
+        lambda { Apple.where(:store_id => 1).all }.should hit_cache(Apple).on(:store_id).times(1)
+        lambda { Apple.where(:store_id => 2).all }.should hit_cache(Apple).on(:store_id).times(1)
+      end
+
+      it "should #{fresh ? 'update' : 'invalidate'} multiple indexes when several values on different indexed attributes are updated at once and one of the indexes is #{fresh ? '' : 'not '}fresh" do
+        # find the apples for person 1 and 5 (Chase)
+        @person4_apples = Apple.where(:person_id => 4).all # Fry's Apples
+        @person5_apples = Apple.where(:person_id => 5).all # Chases' Apples
+        # make sure person indexes are no longer fresh
+        Apple.record_cache.invalidate(:person_id, 4) unless fresh
+        Apple.record_cache.invalidate(:person_id, 5) unless fresh
+        # move one apple from store 1 to store 2
+        @apple_moved_from_s1to2_p5to4 = @store1_apples.last # the last apple belongs to person Chase (id 5)
+        @apple_moved_from_s1to2_p5to4.store_id = 2
+        @apple_moved_from_s1to2_p5to4.person_id = 4
+        @apple_moved_from_s1to2_p5to4.save!
+        # check the cache hit/miss on the indexes that contained/contains that apple
+        lambda { @apples_s1 = Apple.where(:store_id => 1).order('id ASC').all }.should hit_cache(Apple).on(:store_id).times(1)
+        lambda { @apples_s2 = Apple.where(:store_id => 2).order('id ASC').all }.should hit_cache(Apple).on(:store_id).times(1)
+        if fresh
+          lambda { @apples_p1 = Apple.where(:person_id => 4).order('id ASC').all }.should hit_cache(Apple).on(:person_id).times(1)
+          lambda { @apples_p2 = Apple.where(:person_id => 5).order('id ASC').all }.should hit_cache(Apple).on(:person_id).times(1)
+        else
+          lambda { @apples_p1 = Apple.where(:person_id => 4).order('id ASC').all }.should miss_cache(Apple).on(:person_id).times(1)
+          lambda { @apples_p2 = Apple.where(:person_id => 5).order('id ASC').all }.should miss_cache(Apple).on(:person_id).times(1)
+        end
+        @apples_s1.size.should == @store1_apples.size - 1
+        @apples_s2.size.should == @store2_apples.size + 1
+        @apples_p1.size.should == @person4_apples.size + 1
+        @apples_p2.size.should == @person5_apples.size - 1
+        @apples_s1.map(&:id).should == @store1_apples.map(&:id) - [@apple_moved_from_s1to2_p5to4.id]
+        @apples_s2.map(&:id).should == [@apple_moved_from_s1to2_p5to4.id] + @store2_apples.map(&:id)
+        @apples_p1.map(&:id).should == ([@apple_moved_from_s1to2_p5to4.id] + @person4_apples.map(&:id)).sort
+        @apples_p2.map(&:id).should ==  (@person5_apples.map(&:id) - [@apple_moved_from_s1to2_p5to4.id]).sort
+        # and the index should be cached again
+        lambda { Apple.where(:store_id => 1).all }.should hit_cache(Apple).on(:store_id).times(1)
+        lambda { Apple.where(:store_id => 2).all }.should hit_cache(Apple).on(:store_id).times(1)
+        lambda { Apple.where(:person_id => 4).all }.should hit_cache(Apple).on(:person_id).times(1)
+        lambda { Apple.where(:person_id => 5).all }.should hit_cache(Apple).on(:person_id).times(1)
+      end
+    end
+
+    it "should leave the index alone when a record outside the index is destroyed" do
+      # destroy an apple of store 2
+      @store2_apples.first.destroy
+      # index of apples of store 1 are not affected
+      lambda { @apples = Apple.where(:store_id => 1).order('id ASC').all }.should hit_cache(Apple).on(:store_id).times(1)
+    end
+
+    it "should leave the index alone when a record outside the index is created" do
+      # create an apple for store 2
+      Apple.create!(:name => "Fresh Apple", :store_id => 2)
+      # index of apples of store 1 are not affected
+      lambda { @apples = Apple.where(:store_id => 1).order('id ASC').all }.should hit_cache(Apple).on(:store_id).times(1)
+    end
+  end
+  
+  context "invalidate" do
+    before(:each) do
+      @store1_apples = Apple.where(:store_id => 1).all
+      @store2_apples = Apple.where(:store_id => 2).all
+    end
+
+    it "should invalidate single index" do
+      Apple.record_cache[:store_id].invalidate(1)
+      lambda{ Apple.where(:store_id => 1).all }.should miss_cache(Apple).on(:store_id).times(1)
+    end
+
+    it "should invalidate indexes when using update_all" do
+      pending "is there a performant way to invalidate index caches within update_all? only the new value is available, so we should query the old values..." do
+        # update 2 apples for index values store 1 and store 2
+        Apple.where(:id => [@store1_apples.first.id, @store2_apples.first.id]).update_all(:store_id => 3)
+        lambda{ @apples_1 = Apple.where(:store_id => 1).all }.should miss_cache(Apple).on(:store_id).times(1)
+        lambda{ @apples_2 = Apple.where(:store_id => 2).all }.should miss_cache(Apple).on(:store_id).times(1)
+        @apples_1.map(&:id).sort.should == @store1_apples[1..-1].sort
+        @apples_2.map(&:id).sort.should == @store2_apples[1..-1].sort
+      end
+    end
+
+    it "should invalidate reflection indexes when a has_many relation is updated" do
+      # assign different apples to store 2
+      lambda{ Apple.where(:store_id => 1).all }.should hit_cache(Apple).on(:store_id).times(1)
+      store2_apple_ids = @store2_apples.map(&:id).sort
+      store1 = Store.find(1)
+      store1.apple_ids = store2_apple_ids
+      store1.save!
+      # apples in Store 1 should be all (only) the apples that were in Store 2 (cache invalidated)
+      lambda{ @apples_1 = Apple.where(:store_id => 1).all }.should miss_cache(Apple).on(:store_id).times(1)
+      @apples_1.map(&:id).sort.should == store2_apple_ids
+      # there are no apples in Store 2 anymore (incremental cache update, as each apples in store 2 was saved separately)
+      lambda{ @apples_2 = Apple.where(:store_id => 2).all }.should hit_cache(Apple).on(:store_id).times(1)
+      @apples_2.should == []
+    end
+  end
+
+end