record-cache 0.1.3 → 0.1.4

data/spec/lib/strategy/full_table_cache_spec.rb

@@ -1,26 +1,26 @@
 require 'spec_helper'
 
-describe RecordCache::Strategy::FullTableCache do
+RSpec.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)
+    expect { Language.where(:locale => 'en-US').load }.to miss_cache(Language).on(:full_table).times(1)
+    expect { Language.where(:locale => 'en-US').load }.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.load }.to miss_cache(Language).on(:full_table).times(1)
+    expect { Language.all.load }.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")
+      Language.all.load
+      expect { Language.all.load }.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")
+      expect{ Language.all.load }.to log(:debug, "FullTableCache miss for model Language")
     end
   end
 
@@ -29,38 +29,38 @@ describe RecordCache::Strategy::FullTableCache 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
+      @Languages = Language.all.load
     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)
+      expect{ Language.where(:locale => 'en-US').load }.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)
+      expect{ Language.where(:locale => 'en-US').load }.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)
+      expect{ Language.where(:locale => 'en-US').load }.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)
+      expect{ Language.where(:locale => 'en-US').load }.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)
+      expect{ Language.where(:locale => 'en-US').load }.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)
+      expect{ Language.where(:locale => 'en-US').load }.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)
+      expect{ Language.where(:locale => 'en-US').load }.to miss_cache(Language).on(:full_table).times(1)
     end
 
   end

data/spec/lib/strategy/index_cache_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RecordCache::Strategy::IndexCache do
+RSpec.describe RecordCache::Strategy::IndexCache do
 
   context "initialize" do
     it "should only accept index cache on DB columns" do
@@ -13,58 +13,64 @@ describe RecordCache::Strategy::IndexCache do
   end
 
   it "should use the id cache to retrieve the actual records" do
-    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)
+    expect{ @apples = Apple.where(:store_id => 1).load }.to miss_cache(Apple).on(:store_id).times(1)
+    expect{ Apple.where(:store_id => 1).load }.to hit_cache(Apple).on(:store_id).times(1)
+    expect{ Apple.where(:store_id => 1).load }.to hit_cache(Apple).on(:id).times(@apples.size)
+  end
+
+  it "should find cached records through relationship" do
+    store = Store.first
+    expect{ @apple = store.apples.find(3) }.to use_cache(Apple).on(:id).times(1)
+    expect(@apple.name).to eq("Adams Apple 3")
   end
 
   context "logging" do
     before(:each) do
-      Apple.where(:store_id => 1).all
+      Apple.where(:store_id => 1).load
     end
 
     it "should write hit to the debug log" do
-      expect{ Apple.where(:store_id => 1).all }.to log(:debug, /IndexCache hit for rc\/apl\/store_id=1v\d+: found 5 ids/)
+      expect{ Apple.where(:store_id => 1).load }.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
-      expect{ Apple.where(:store_id => 2).all }.to log(:debug, /IndexCache miss for rc\/apl\/store_id=2v\d+: found no ids/)
+      expect{ Apple.where(:store_id => 2).load }.to log(:debug, /IndexCache miss for rc\/apl\/store_id=2v\d+: found no ids/)
     end
   end
 
   context "cacheable?" do
     before(:each) do
-      @store1_apples = Apple.where(:store_id => 1).all
-      @store2_apples = Apple.where(:store_id => 2).all
+      @store1_apples = Apple.where(:store_id => 1).load
+      @store2_apples = Apple.where(:store_id => 2).load
     end
 
     it "should hit the cache for a single index id" do
-      expect{ Apple.where(:store_id => 1).all }.to hit_cache(Apple).on(:store_id).times(1)
+      expect{ Apple.where(:store_id => 1).load }.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
-      expect{ Apple.where(:store_id => 1).where(:name => "applegate").all }.to hit_cache(Apple).on(:store_id).times(1)
+      expect{ Apple.where(:store_id => 1).where(:name => "applegate").load }.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
-      expect{ Apple.where(:store_id => 1).order("name ASC").all }.to hit_cache(Apple).on(:store_id).times(1)
+      expect{ Apple.where(:store_id => 1).order("name ASC").load }.to hit_cache(Apple).on(:store_id).times(1)
     end
 
     #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)
+      expect{ Apple.where(:store_id => 1).limit(2).load }.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
-      expect{ Apple.where(:store_id => 1).where(:id => 1).all }.to_not hit_cache(Apple).on(:store_id)
+      expect{ Apple.where(:store_id => 1).where(:id => 1).load }.to_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
+      @store1_apples = Apple.where(:store_id => 1).order('id ASC').to_a
+      @store2_apples = Apple.where(:store_id => 2).order('id ASC').to_a
     end
 
     [false, true].each do |fresh|
@@ -76,14 +82,14 @@ describe RecordCache::Strategy::IndexCache do
         @destroyed.destroy
         # check the cache hit/miss on the index that contained that apple
         if fresh
-          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to hit_cache(Apple).on(:store_id).times(1)
+          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').load }.to hit_cache(Apple).on(:store_id).times(1)
         else
-          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to miss_cache(Apple).on(:store_id).times(1)
+          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').load }.to miss_cache(Apple).on(:store_id).times(1)
         end
         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
-        expect{ Apple.where(:store_id => 1).all }.to hit_cache(Apple).on(:store_id).times(1)
+        expect{ Apple.where(:store_id => 1).load }.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
@@ -93,14 +99,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
-          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to hit_cache(Apple).on(:store_id).times(1)
+          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').load }.to hit_cache(Apple).on(:store_id).times(1)
         else
-          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to miss_cache(Apple).on(:store_id).times(1)
+          expect{ @apples = Apple.where(:store_id => 1).order('id ASC').load }.to miss_cache(Apple).on(:store_id).times(1)
         end
         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
-        expect{ Apple.where(:store_id => 1).all }.to hit_cache(Apple).on(:store_id).times(1)
+        expect{ Apple.where(:store_id => 1).load }.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
@@ -113,25 +119,25 @@ 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
-          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)
+          expect{ @apples1 = Apple.where(:store_id => 1).order('id ASC').load }.to hit_cache(Apple).on(:store_id).times(1)
+          expect{ @apples2 = Apple.where(:store_id => 2).order('id ASC').load }.to hit_cache(Apple).on(:store_id).times(1)
         else
-          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)
+          expect{ @apples1 = Apple.where(:store_id => 1).order('id ASC').load }.to miss_cache(Apple).on(:store_id).times(1)
+          expect{ @apples2 = Apple.where(:store_id => 2).order('id ASC').load }.to miss_cache(Apple).on(:store_id).times(1)
         end
         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
-        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(:store_id => 1).load }.to hit_cache(Apple).on(:store_id).times(1)
+        expect{ Apple.where(:store_id => 2).load }.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
         # 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
+        @person4_apples = Apple.where(:person_id => 4).to_a # Fry's Apples
+        @person5_apples = Apple.where(:person_id => 5).to_a # 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
@@ -141,14 +147,14 @@ 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
-        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)
+        expect{ @apples_s1 = Apple.where(:store_id => 1).order('id ASC').load }.to hit_cache(Apple).on(:store_id).times(1)
+        expect{ @apples_s2 = Apple.where(:store_id => 2).order('id ASC').load }.to hit_cache(Apple).on(:store_id).times(1)
         if fresh
-          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)
+          expect{ @apples_p1 = Apple.where(:person_id => 4).order('id ASC').load }.to hit_cache(Apple).on(:person_id).times(1)
+          expect{ @apples_p2 = Apple.where(:person_id => 5).order('id ASC').load }.to hit_cache(Apple).on(:person_id).times(1)
         else
-          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)
+          expect{ @apples_p1 = Apple.where(:person_id => 4).order('id ASC').load }.to miss_cache(Apple).on(:person_id).times(1)
+          expect{ @apples_p2 = Apple.where(:person_id => 5).order('id ASC').load }.to miss_cache(Apple).on(:person_id).times(1)
         end
         expect(@apples_s1.size).to eq(@store1_apples.size - 1)
         expect(@apples_s2.size).to eq(@store2_apples.size + 1)
@@ -159,10 +165,10 @@ describe RecordCache::Strategy::IndexCache do
         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
-        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)
+        expect{ Apple.where(:store_id => 1).load }.to hit_cache(Apple).on(:store_id).times(1)
+        expect{ Apple.where(:store_id => 2).load }.to hit_cache(Apple).on(:store_id).times(1)
+        expect{ Apple.where(:person_id => 4).load }.to hit_cache(Apple).on(:person_id).times(1)
+        expect{ Apple.where(:person_id => 5).load }.to hit_cache(Apple).on(:person_id).times(1)
       end
     end
 
@@ -170,36 +176,36 @@ describe RecordCache::Strategy::IndexCache do
       # destroy an apple of store 2
       @store2_apples.first.destroy
       # index of apples of store 1 are not affected
-      expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to hit_cache(Apple).on(:store_id).times(1)
+      expect{ @apples = Apple.where(:store_id => 1).order('id ASC').load }.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
-      expect{ @apples = Apple.where(:store_id => 1).order('id ASC').all }.to hit_cache(Apple).on(:store_id).times(1)
+      expect{ @apples = Apple.where(:store_id => 1).order('id ASC').load }.to 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
-      @address_1 = Address.where(:store_id => 1).all
-      @address_2 = Address.where(:store_id => 2).all
+      @store1_apples = Apple.where(:store_id => 1).to_a
+      @store2_apples = Apple.where(:store_id => 2).to_a
+      @address_1 = Address.where(:store_id => 1).to_a
+      @address_2 = Address.where(:store_id => 2).to_a
     end
 
     it "should invalidate single index" do
       Apple.record_cache[:store_id].invalidate(1)
-      expect{ Apple.where(:store_id => 1).all }.to miss_cache(Apple).on(:store_id).times(1)
+      expect{ Apple.where(:store_id => 1).load }.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..."
       # 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 = Apple.where(:store_id => 1).load }.to miss_cache(Apple).on(:store_id).times(1)
+      expect{ @apples_2 = Apple.where(:store_id => 2).load }.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
@@ -212,10 +218,10 @@ describe RecordCache::Strategy::IndexCache do
       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)
-      expect{ @apples_1 = Apple.where(:store_id => 1).all }.to miss_cache(Apple).on(:store_id).times(1)
+      expect{ @apples_1 = Apple.where(:store_id => 1).load }.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)
-      expect{ @apples_2 = Apple.where(:store_id => 2).all }.to hit_cache(Apple).on(:store_id).times(1)
+      expect{ @apples_2 = Apple.where(:store_id => 2).load }.to hit_cache(Apple).on(:store_id).times(1)
       expect(@apples_2).to eq([])
     end
 

data/spec/lib/strategy/query_cache_spec.rb

@@ -15,7 +15,7 @@ require 'spec_helper'
 # 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
+RSpec.describe "QueryCache" do
 
   it "should retrieve a record from the QueryCache" do
     ActiveRecord::Base.cache do

data/spec/lib/strategy/unique_index_on_id_cache_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RecordCache::Strategy::UniqueIndexCache do
+RSpec.describe RecordCache::Strategy::UniqueIndexCache do
 
   it "should retrieve an Apple from the cache" do
     expect{ Apple.find(1) }.to miss_cache(Apple).on(:id).times(1)
@@ -40,9 +40,9 @@ describe RecordCache::Strategy::UniqueIndexCache do
     it "should write full miss to the debug log" do
       expect{ Apple.find(2) }.to log(:debug, %(UniqueIndexCache on 'Apple.id' miss for ids 2))
     end
-    
+
     it "should write partial hits to the debug log" do
-      expect{ Apple.where(:id => [1,2]).all }.to log(:debug, %(UniqueIndexCache on 'Apple.id' partial hit for ids [1, 2]: missing [2]))
+      expect{ Apple.where(:id => [1,2]).load }.to log(:debug, %(UniqueIndexCache on 'Apple.id' partial hit for ids [1, 2]: missing [2]))
     end
   end
 
@@ -55,50 +55,60 @@ describe RecordCache::Strategy::UniqueIndexCache do
 
     # @see https://github.com/orslumen/record-cache/issues/2
     it "should not use the cache when a lock is used" do
-      expect{ Apple.lock("any_lock").where(:id => 1).all }.to_not hit_cache(Apple)
+      pending("Any_lock is sqlite specific and I'm not aware of a mysql alternative") unless ActiveRecord::Base.connection.adapter_name == "SQLite"
+
+      expect{ Apple.lock("any_lock").where(:id => 1).load }.to_not hit_cache(Apple)
     end
 
     it "should use the cache when a single id is requested" do
-      expect{ Apple.where(:id => 1).all }.to hit_cache(Apple).on(:id).times(1)
+      expect{ Apple.where(:id => 1).load }.to hit_cache(Apple).on(:id).times(1)
     end
 
     it "should use the cache when a multiple ids are requested" do
-      expect{ Apple.where(:id => [1, 2]).all }.to hit_cache(Apple).on(:id).times(2)
+      expect{ Apple.where(:id => [1, 2]).load }.to 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
-      expect{ Apple.where(:id => 1).limit(1).all }.to hit_cache(Apple).on(:id).times(1)
+      expect{ Apple.where(:id => 1).limit(1).load }.to 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
-      expect{ Apple.where(:id => 1).limit(2).all }.to_not use_cache(Apple).on(:id)
+      expect{ Apple.where(:id => 1).limit(2).load }.to_not use_cache(Apple).on(:id)
     end
 
     it "should not use the cache when multiple ids are requested and the limit is 1" do
-      expect{ Apple.where(:id => [1, 2]).limit(1).all }.to_not use_cache(Apple).on(:id)
+      expect{ Apple.where(:id => [1, 2]).limit(1).load }.to_not use_cache(Apple).on(:id)
     end
 
     it "should use the cache when a single id is requested together with other where clauses" do
-      expect{ Apple.where(:id => 1).where(:name => "Adams Apple x").all }.to hit_cache(Apple).on(:id).times(1)
+      expect{ Apple.where(:id => 1).where(:name => "Adams Apple x").load }.to 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
-      expect{ Apple.where(:id => [1,2]).where(:name => "Adams Apple x").all }.to hit_cache(Apple).on(:id).times(2)
+      expect{ Apple.where(:id => [1,2]).where(:name => "Adams Apple x").load }.to 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
-      expect{ Apple.where(:id => 1).order("name ASC").all }.to hit_cache(Apple).on(:id).times(1)
+      expect{ Apple.where(:id => 1).order("name ASC").load }.to 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
-      expect{ Apple.where(:id => [1,2]).order("name ASC").all }.to hit_cache(Apple).on(:id).times(2)
+      expect{ Apple.where(:id => [1,2]).order("name ASC").load }.to hit_cache(Apple).on(:id).times(2)
     end
 
     it "should not use the cache when a join clause is used" do
-      expect{ Apple.where(:id => [1,2]).joins(:store).all }.to_not use_cache(Apple).on(:id)
+      expect{ Apple.where(:id => [1,2]).joins(:store).load }.to_not use_cache(Apple).on(:id)
+    end
+
+    it "should not use the cache when distinct is used in a select" do
+      expect{ Apple.select('distinct person_id').where(:id => [1, 2]).load }.not_to hit_cache(Apple).on(:id)
+    end
+
+    it "should not use the cache when distinct is used in a select" do
+      expect{ Apple.select('distinct person_id').where(:id => [1, 2]).load }.not_to hit_cache(Apple).on(:id)
     end
   end
-  
+
   context "record_change" do
     before(:each) do
       # fill cache
@@ -107,12 +117,12 @@ describe RecordCache::Strategy::UniqueIndexCache do
     end
 
     it "should invalidate destroyed records" do
-      expect{ Apple.where(:id => 1).all }.to hit_cache(Apple).on(:id).times(1)
+      expect{ Apple.where(:id => 1).load }.to hit_cache(Apple).on(:id).times(1)
       @apple1.destroy
-      expect{ @apples = Apple.where(:id => 1).all }.to miss_cache(Apple).on(:id).times(1)
+      expect{ @apples = Apple.where(:id => 1).load }.to miss_cache(Apple).on(:id).times(1)
       expect(@apples).to be_empty
       # try again, to make sure the "missing record" is not cached
-      expect{ Apple.where(:id => 1).all }.to miss_cache(Apple).on(:id).times(1)
+      expect{ Apple.where(:id => 1).load }.to miss_cache(Apple).on(:id).times(1)
     end
 
     it "should add updated records directly to the cache" do
@@ -131,12 +141,12 @@ describe RecordCache::Strategy::UniqueIndexCache do
     it "should add updated records to the cache, also when multiple ids are queried" do
       @apple1.name = "Applejuice"
       @apple1.save!
-      expect{ @apples = Apple.where(:id => [1, 2]).order('id ASC').all }.to hit_cache(Apple).on(:id).times(2)
+      expect{ @apples = Apple.where(:id => [1, 2]).order('id ASC').load }.to hit_cache(Apple).on(:id).times(2)
       expect(@apples.map(&:name)).to eq(["Applejuice", "Adams Apple 2"])
     end
 
   end
-  
+
   context "invalidate" do
     before(:each) do
       @apple1 = Apple.find(1)
@@ -151,27 +161,27 @@ describe RecordCache::Strategy::UniqueIndexCache do
     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)
-      expect{ Apple.where(:id => [1, 2]).all }.to miss_cache(Apple).on(:id).times(1)
+      expect{ Apple.where(:id => [1, 2]).load }.to miss_cache(Apple).on(:id).times(1)
       # hit on 2
       Apple.record_cache[:id].invalidate(1)
-      expect{ Apple.where(:id => [1, 2]).all }.to hit_cache(Apple).on(:id).times(1)
+      expect{ Apple.where(:id => [1, 2]).load }.to hit_cache(Apple).on(:id).times(1)
       # nothing invalidated, both hit
-      expect{ Apple.where(:id => [1, 2]).all }.to hit_cache(Apple).on(:id).times(2)
+      expect{ Apple.where(:id => [1, 2]).load }.to 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
-      expect{ @apples = Apple.where(:id => [1, 2, 3, 4, 5]).order('id ASC').all }.to hit_cache(Apple).on(:id).times(5)
+      Apple.where(:id => [3,4,5]).load # fill id cache on all Adam Store apples
+      expect{ @apples = Apple.where(:id => [1, 2, 3, 4, 5]).order('id ASC').load }.to hit_cache(Apple).on(:id).times(5)
       expect(@apples.map(&:name)).to eq(["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")
-      expect{ @apples = Apple.where(:id => [1, 2, 3, 4, 5]).order('id ASC').all }.to hit_cache(Apple).on(:id).times(2)
+      expect{ @apples = Apple.where(:id => [1, 2, 3, 4, 5]).order('id ASC').load }.to hit_cache(Apple).on(:id).times(2)
       expect(@apples.map(&:name)).to eq(["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
-      expect{ Apple.where(:store_id => 1).all }.to hit_cache(Apple).on(:id).times(2)
+      expect{ Apple.where(:store_id => 1).load }.to 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
@@ -288,30 +298,32 @@ describe RecordCache::Strategy::UniqueIndexCache do
       end
     end
 
-    it "should not update the cache for the rolled back inner transaction" do
-      pending "rails calls after_commit on records that are in a transaction that is rolled back"
-
-      apple1, apple2 = nil
+    # does not work for Rails 3.0
+    unless ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
+      it "should not update the cache for the rolled back inner transaction" do
+        apple1, apple2 = nil
 
-      ActiveRecord::Base.transaction do
-        apple1 = Apple.find(1)
-        apple1.name = "Committed Apple 1"
-        apple1.save!
+        ActiveRecord::Base.transaction do
+          apple1 = Apple.find(1)
+          apple1.name = "Committed Apple 1"
+          apple1.save!
 
-        ActiveRecord::Base.transaction(requires_new: true) do
-          apple2 = Apple.find(2)
-          apple2.name = "Rollback Apple 2"
-          apple2.save!
+          ActiveRecord::Base.transaction(requires_new: true) do
+            apple2 = Apple.find(2)
+            apple2.name = "Rollback Apple 2"
+            apple2.save!
 
-          raise ActiveRecord::Rollback, "oops"
+            raise ActiveRecord::Rollback, "oops"
+          end
         end
-      end
 
-      expect{ apple1 = Apple.find(1) }.to use_cache(Apple).on(:id)
-      expect(apple1.name).to eq("Committed Apple 1")
+        expect{ apple1 = Apple.find(1) }.to use_cache(Apple).on(:id)
+        expect(apple1.name).to eq("Committed Apple 1")
 
-      expect{ apple2 = Apple.find(2) }.to use_cache(Apple).on(:id)
-      expect(apple2.name).to eq("Adams Apple 2")
+        expect{ apple2 = Apple.find(2) }.to use_cache(Apple).on(:id)
+        expect(apple2.name).to eq("Adams Apple 2")
+      end
     end
+
   end
 end