record-cache 0.1.2 → 0.1.3

data/spec/lib/strategy/full_table_cache_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe RecordCache::Strategy::FullTableCache do
+
+  it "should retrieve a Language from the cache" do
+    expect{ Language.where(:locale => 'en-US').all }.to miss_cache(Language).on(:full_table).times(1)
+    expect{ Language.where(:locale => 'en-US').all }.to hit_cache(Language).on(:full_table).times(1)
+  end
+
+  it "should retrieve all Languages from cache" do
+    expect{ Language.all }.to miss_cache(Language).on(:full_table).times(1)
+    expect{ Language.all }.to hit_cache(Language).on(:full_table).times(1)
+    expect(Language.all.map(&:locale).sort).to eq(%w(du-NL en-GB en-US hu))
+  end
+
+  context "logging" do
+    it "should write hit to the debug log" do
+      Language.all
+      expect{ Language.all }.to log(:debug, "FullTableCache hit for model Language")
+    end
+
+    it "should write miss to the debug log" do
+      expect{ Language.all }.to log(:debug, "FullTableCache miss for model Language")
+    end
+  end
+
+  context "cacheable?" do
+    it "should always return true" do
+      expect(Language.record_cache[:full_table].cacheable?("any query")).to be_truthy
+    end
+  end
+  
+  context "record_change" do
+    before(:each) do
+      @Languages = Language.all
+    end
+
+    it "should invalidate the cache when a record is added" do
+      expect{ Language.where(:locale => 'en-US').all }.to hit_cache(Language).on(:full_table).times(1)
+      Language.create!(:name => 'Deutsch', :locale => 'de')
+      expect{ Language.where(:locale => 'en-US').all }.to miss_cache(Language).on(:full_table).times(1)
+    end
+
+    it "should invalidate the cache when any record is deleted" do
+      expect{ Language.where(:locale => 'en-US').all }.to hit_cache(Language).on(:full_table).times(1)
+      Language.where(:locale => 'hu').first.destroy
+      expect{ Language.where(:locale => 'en-US').all }.to miss_cache(Language).on(:full_table).times(1)
+    end
+
+    it "should invalidate the cache when any record is modified" do
+      expect{ Language.where(:locale => 'en-US').all }.to hit_cache(Language).on(:full_table).times(1)
+      hungarian = Language.where(:locale => 'hu').first
+      hungarian.name = 'Magyar (Magyarorszag)'
+      hungarian.save!
+      expect{ Language.where(:locale => 'en-US').all }.to miss_cache(Language).on(:full_table).times(1)
+    end
+  end
+  
+  context "invalidate" do
+
+    it "should invalidate the full cache" do
+      Language.record_cache[:full_table].invalidate(-10) # any id
+      expect{ Language.where(:locale => 'en-US').all }.to miss_cache(Language).on(:full_table).times(1)
+    end
+
+  end
+
+end

data/spec/lib/strategy/index_cache_spec.rb

@@ -4,18 +4,18 @@ 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.")
+      expect{ Apple.send(:cache_records, :index => :unknown_column) }.to 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.")
+      expect{ Apple.send(:cache_records, :index => :name) }.to 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)
+    expect{ @apples = Apple.where(:store_id => 1).all }.to miss_cache(Apple).on(:store_id).times(1)
+    expect{ Apple.where(:store_id => 1).all }.to hit_cache(Apple).on(:store_id).times(1)
+    expect{ Apple.where(:store_id => 1).all }.to hit_cache(Apple).on(:id).times(@apples.size)
   end
 
   context "logging" do
@@ -24,13 +24,11 @@ describe RecordCache::Strategy::IndexCache do
     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
+      expect{ Apple.where(:store_id => 1).all }.to log(:debug, /IndexCache hit for rc\/apl\/store_id=1v\d+: found 5 ids/)
     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
+      expect{ Apple.where(:store_id => 2).all }.to log(:debug, /IndexCache miss for rc\/apl\/store_id=2v\d+: found no ids/)
     end
   end
 
@@ -41,24 +39,25 @@ describe RecordCache::Strategy::IndexCache do
     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)
+      expect{ Apple.where(:store_id => 1).all }.to 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)
+      expect{ Apple.where(:store_id => 1).where(:name => "applegate").all }.to 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)
+      expect{ Apple.where(:store_id => 1).order("name ASC").all }.to 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)
+    #Allow limit == 1 by filtering records after cache hit.  Needed for has_one
+    it "should not hit the cache for a single index id with limit > 0" do
+      expect{ Apple.where(:store_id => 1).limit(2).all }.to_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)
+      expect{ Apple.where(:store_id => 1).where(:id => 1).all }.to_not hit_cache(Apple).on(:store_id)
     end
   end
   
@@ -77,14 +76,14 @@ describe RecordCache::Strategy::IndexCache do
         @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)
+          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to 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)
+          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to 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]
+        expect(@apples.size).to eq(@store1_apples.size - 1)
+        expect(@apples.map(&:id)).to eq(@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)
+        expect{ Apple.where(:store_id => 1).all }.to 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
@@ -94,14 +93,14 @@ describe RecordCache::Strategy::IndexCache do
         @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)
+          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to 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)
+          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to 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]
+        expect(@apples.size).to eq(@store1_apples.size + 1)
+        expect(@apples.map(&:id)).to eq(@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)
+        expect{ Apple.where(:store_id => 1).all }.to 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
@@ -114,19 +113,19 @@ describe RecordCache::Strategy::IndexCache do
         @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)
+          expect{ @apples1 = Apple.where(:store_id => 1).order('id ASC').all }.to hit_cache(Apple).on(:store_id).times(1)
+          expect{ @apples2 = Apple.where(:store_id => 2).order('id ASC').all }.to 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)
+          expect{ @apples1 = Apple.where(:store_id => 1).order('id ASC').all }.to miss_cache(Apple).on(:store_id).times(1)
+          expect{ @apples2 = Apple.where(:store_id => 2).order('id ASC').all }.to 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)
+        expect(@apples1.size).to eq(@store1_apples.size - 1)
+        expect(@apples2.size).to eq(@store2_apples.size + 1)
+        expect(@apples1.map(&:id)).to eq(@store1_apples.map(&:id) - [@apple_moved_from_store1_to_store2.id])
+        expect(@apples2.map(&:id)).to eq([@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)
+        expect{ Apple.where(:store_id => 1).all }.to hit_cache(Apple).on(:store_id).times(1)
+        expect{ Apple.where(:store_id => 2).all }.to 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
@@ -142,28 +141,28 @@ describe RecordCache::Strategy::IndexCache do
         @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)
+        expect{ @apples_s1 = Apple.where(:store_id => 1).order('id ASC').all }.to hit_cache(Apple).on(:store_id).times(1)
+        expect{ @apples_s2 = Apple.where(:store_id => 2).order('id ASC').all }.to 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)
+          expect{ @apples_p1 = Apple.where(:person_id => 4).order('id ASC').all }.to hit_cache(Apple).on(:person_id).times(1)
+          expect{ @apples_p2 = Apple.where(:person_id => 5).order('id ASC').all }.to 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)
+          expect{ @apples_p1 = Apple.where(:person_id => 4).order('id ASC').all }.to miss_cache(Apple).on(:person_id).times(1)
+          expect{ @apples_p2 = Apple.where(:person_id => 5).order('id ASC').all }.to 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
+        expect(@apples_s1.size).to eq(@store1_apples.size - 1)
+        expect(@apples_s2.size).to eq(@store2_apples.size + 1)
+        expect(@apples_p1.size).to eq(@person4_apples.size + 1)
+        expect(@apples_p2.size).to eq(@person5_apples.size - 1)
+        expect(@apples_s1.map(&:id)).to eq(@store1_apples.map(&:id) - [@apple_moved_from_s1to2_p5to4.id])
+        expect(@apples_s2.map(&:id)).to eq([@apple_moved_from_s1to2_p5to4.id] + @store2_apples.map(&:id))
+        expect(@apples_p1.map(&:id)).to eq(([@apple_moved_from_s1to2_p5to4.id] + @person4_apples.map(&:id)).sort)
+        expect(@apples_p2.map(&:id)).to eq( (@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)
+        expect{ Apple.where(:store_id => 1).all }.to hit_cache(Apple).on(:store_id).times(1)
+        expect{ Apple.where(:store_id => 2).all }.to hit_cache(Apple).on(:store_id).times(1)
+        expect{ Apple.where(:person_id => 4).all }.to hit_cache(Apple).on(:person_id).times(1)
+        expect{ Apple.where(:person_id => 5).all }.to hit_cache(Apple).on(:person_id).times(1)
       end
     end
 
@@ -171,14 +170,14 @@ describe RecordCache::Strategy::IndexCache 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)
+      expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to 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)
+      expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to hit_cache(Apple).on(:store_id).times(1)
     end
   end
   
@@ -186,37 +185,81 @@ describe RecordCache::Strategy::IndexCache do
     before(:each) do
       @store1_apples = Apple.where(:store_id => 1).all
       @store2_apples = Apple.where(:store_id => 2).all
+      @address_1 = Address.where(:store_id => 1).all
+      @address_2 = Address.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)
+      expect{ Apple.where(:store_id => 1).all }.to 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
+      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..."
+      # 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)
+      expect{ @apples_1 = Apple.where(:store_id => 1).all }.to miss_cache(Apple).on(:store_id).times(1)
+      expect{ @apples_2 = Apple.where(:store_id => 2).all }.to miss_cache(Apple).on(:store_id).times(1)
+      expect(@apples_1.map(&:id).sort).to eq(@store1_apples[1..-1].sort)
+      expect(@apples_2.map(&:id).sort).to eq(@store2_apples[1..-1].sort)
     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)
+      expect{ Apple.where(:store_id => 1).first }.to 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
+      expect{ @apples_1 = Apple.where(:store_id => 1).all }.to miss_cache(Apple).on(:store_id).times(1)
+      expect(@apples_1.map(&:id).sort).to eq(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 == []
+      expect{ @apples_2 = Apple.where(:store_id => 2).all }.to hit_cache(Apple).on(:store_id).times(1)
+      expect(@apples_2).to eq([])
+    end
+
+    it "should invalidate reflection indexes when a has_one relation is updated" do
+      # assign different address to store 2
+      expect{ Address.where(:store_id => 1).limit(1).first }.to hit_cache(Address).on(:store_id).times(1)
+      store2 = Store.find(2)
+      store2_address = store2.address
+      Address.where(:store_id => 1).first.id == 1
+      store1 = Store.find(1)
+      store1.address = store2_address
+      store1.save!
+      Address.where(:store_id => 1).first.id == 2
+      # address for Store 1 should be the address that was for Store 2 (cache invalidated)
+      expect{ @address_1 = Address.where(:store_id => 1).first }.to hit_cache(Address).on(:store_id).times(1)
+      expect(@address_1.id).to eq(store2_address.id)
+      # there are no address in Store 2 anymore (incremental cache update, as address for store 2 was saved separately)
+      expect{ @address_2 = Address.where(:store_id => 2).first }.to hit_cache(Address).on(:store_id).times(1)
+      expect(@address_2).to be_nil
+    end
+
+    # see https://github.com/orslumen/record-cache/issues/19
+    it "should work with serialized object" do
+      address = Address.find(3) # not from cache
+      address = Address.find(3) # from cache
+      expect(address.location[:latitue]).to eq(27.175015)
+      expect(address.location[:dms_lat]).to eq(%(27\u00B0 10' 30.0540" N))
+      address.name = 'updated name'
+      address.save!
+    end
+  end
+
+  context 'subclassing' do
+    it "should delegate cache updates to the base class" do
+      class RedDelicious < Apple; end
+      apple = Apple.find(1)
+      delicious = RedDelicious.find(1)
+      store_id = apple.store_id
+      delicious.store_id = 100
+      delicious.save
+      apple = Apple.find(1)
+      expect(apple.store_id).to_not eq(store_id)
+      apple.store_id = store_id
+      apple.save
     end
   end
 

data/spec/lib/strategy/query_cache_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+# This describes the behaviour as expected when ActiveRecord::QueryCache is
+# enabled. ActiveRecord::QueryCache is enabled by default in rails via a
+# middleware. During the scope of a request that cache is used.
+#
+# In console mode (or within e.g. a cron job) QueryCache isn't enabled.
+# You can still take advantage of this cache by executing
+#
+#   ActiveRecord::Base.cache do
+#     # your queries
+#   end
+#
+# Be aware that though that during the execution of the block if updates
+# happen to records by another process, while you have already got
+# references to that records in QueryCache, that you won't see the changes
+# made by the other process.
+describe "QueryCache" do
+
+  it "should retrieve a record from the QueryCache" do
+    ActiveRecord::Base.cache do
+      expect{ Store.find(1) }.to miss_cache(Store).on(:id).times(1)
+      second_lookup = expect{ Store.find(1) }
+      second_lookup.to miss_cache(Store).times(0)
+      second_lookup.to hit_cache(Store).on(:id).times(0)
+    end
+  end
+
+  it "should maintain object identity when the same query is used" do
+    ActiveRecord::Base.cache do
+      @store_1 = Store.find(1)
+      @store_2 = Store.find(1)
+      expect(@store_1).to eq(@store_2)
+      expect(@store_1.object_id).to eq(@store_2.object_id)
+    end
+  end
+
+  context "record_change" do
+    it "should clear the query cache completely when a record is created" do
+      ActiveRecord::Base.cache do
+        init_query_cache
+        expect{ Store.find(2) }.to hit_cache(Store).times(0)
+        expect{ Apple.find(1) }.to hit_cache(Apple).times(0)
+        Store.create!(:name => "New Apple Store")
+        expect{ Store.find(2) }.to hit_cache(Store).times(1)
+        expect{ Apple.find(1) }.to hit_cache(Apple).times(1)
+      end
+    end
+
+    it "should clear the query cache completely when a record is updated" do
+      ActiveRecord::Base.cache do
+        init_query_cache
+        expect{ Store.find(2) }.to hit_cache(Store).times(0)
+        expect{ Apple.find(1) }.to hit_cache(Apple).times(0)
+        @store1.name = "Store E"
+        @store1.save!
+        expect{ Store.find(2) }.to hit_cache(Store).times(1)
+        expect{ Apple.find(1) }.to hit_cache(Apple).times(1)
+      end
+    end
+
+    it "should clear the query cache completely when a record is destroyed" do
+      ActiveRecord::Base.cache do
+        init_query_cache
+        expect{ Store.find(2) }.to hit_cache(Store).times(0)
+        expect{ Apple.find(1) }.to hit_cache(Apple).times(0)
+        @store1.destroy
+        expect{ Store.find(2) }.to hit_cache(Store).times(1)
+        expect{ Apple.find(1) }.to hit_cache(Apple).times(1)
+      end
+    end
+  end
+
+  private
+
+    # Cache a few objects in QueryCache to test with
+    def init_query_cache
+      @store1 = Store.find(1)
+      @store2 = Store.find(2)
+      @apple1 = Apple.find(1)
+    end
+
+end