record-cache 0.1.2 → 0.1.3

data/spec/lib/multi_read_spec.rb

@@ -8,7 +8,7 @@ describe RecordCache::MultiRead do
       def read_multi(*keys) "multi" end
     end
     store = RecordCache::MultiRead.test(MultiReadSupported.new)
-    store.read_multi("key1", "key2").should == "multi"
+    expect(store.read_multi("key1", "key2")).to eq("multi")
   end
 
   it "should delegate to single reads when multi_read is explicitly disabled" do
@@ -18,7 +18,7 @@ describe RecordCache::MultiRead do
     end
     RecordCache::MultiRead.disable(ExplicitlyDisabled)
     store = RecordCache::MultiRead.test(ExplicitlyDisabled.new)
-    store.read_multi("key1", "key2").should == {"key1" => "single", "key2" => "single"}
+    expect(store.read_multi("key1", "key2")).to eq({"key1" => "single", "key2" => "single"})
   end
 
   it "should delegate to single reads when multi_read throws an error" do
@@ -27,7 +27,7 @@ describe RecordCache::MultiRead do
       def read_multi(*keys) raise NotImplementedError.new("multiread not implemented") end
     end
     store = RecordCache::MultiRead.test(MultiReadNotImplemented.new)
-    store.read_multi("key1", "key2").should == {"key1" => "single", "key2" => "single"}
+    expect(store.read_multi("key1", "key2")).to eq({"key1" => "single", "key2" => "single"})
   end
 
   it "should delegate to single reads when multi_read is undefined" do
@@ -35,17 +35,17 @@ describe RecordCache::MultiRead do
       def read(key) "single" end
     end
     store = RecordCache::MultiRead.test(MultiReadNotDefined.new)
-    store.read_multi("key1", "key2").should == {"key1" => "single", "key2" => "single"}
+    expect(store.read_multi("key1", "key2")).to eq({"key1" => "single", "key2" => "single"})
   end
 
   it "should have tested the Version Store" do
-    RecordCache::MultiRead.instance_variable_get(:@tested).should include(RecordCache::Base.version_store.instance_variable_get(:@store))
+    expect(RecordCache::MultiRead.instance_variable_get(:@tested)).to include(RecordCache::Base.version_store.instance_variable_get(:@store))
   end
 
   it "should have tested all Record Stores" do
     tested_stores = RecordCache::MultiRead.instance_variable_get(:@tested)
     RecordCache::Base.stores.values.each do |record_store|
-      tested_stores.should include(record_store)
+      expect(tested_stores).to include(record_store)
     end
   end
 end

data/spec/lib/query_spec.rb

@@ -4,145 +4,145 @@ describe RecordCache::Query do
   before(:each) do
     @query = RecordCache::Query.new
   end
-  
+
   context "wheres" do
     it "should be an empty hash by default" do
-      @query.wheres.should == {}
+      expect(@query.wheres).to eq({})
     end
 
     it "should fill wheres on instantiation" do
       @query = RecordCache::Query.new({:id => 1})
-      @query.wheres.should == {:id => 1}
+      expect(@query.wheres).to eq({:id => 1})
     end
 
     it "should keep track of where clauses" do
       @query.where(:name, "My name")
       @query.where(:id, [1, 2, 3])
       @query.where(:height, 1.75)
-      @query.wheres.should == {:name => "My name", :id => [1, 2, 3], :height => 1.75}
+      expect(@query.wheres).to eq({:name => "My name", :id => [1, 2, 3], :height => 1.75})
     end
 
-    context "where_ids" do
+    context "where_values" do
       it "should return nil if the attribute is not defined" do
         @query.where(:idx, 15)
-        @query.where_ids(:id).should == nil
+        expect(@query.where_values(:id)).to be_nil
       end
 
       it "should return nil if one the value is nil" do
         @query.where(:id, nil)
-        @query.where_ids(:id).should == nil
+        expect(@query.where_values(:id)).to be_nil
       end
 
       it "should return nil if one of the values is < 1" do
         @query.where(:id, [2, 0, 8])
-        @query.where_ids(:id).should == nil
+        expect(@query.where_values(:id)).to be_nil
       end
 
-      it "should return nil if one of the values is nil" do
+      it "should return remove nil from the values" do
         @query.where(:id, ["1", nil, "3"])
-        @query.where_ids(:id).should == nil
+        expect(@query.where_values(:id)).to eq([1,3])
       end
 
       it "should retrieve an array of integers when a single integer is provided" do
         @query.where(:id, 15)
-        @query.where_ids(:id).should == [15]
+        expect(@query.where_values(:id)).to eq([15])
       end
-  
+
       it "should retrieve an array of integers when a multiple integers are provided" do
         @query.where(:id, [2, 4, 8])
-        @query.where_ids(:id).should == [2, 4, 8]
+        expect(@query.where_values(:id)).to eq([2, 4, 8])
       end
-      
+
       it "should retrieve an array of integers when a single string is provided" do
         @query.where(:id, "15")
-        @query.where_ids(:id).should == [15]
+        expect(@query.where_values(:id)).to eq([15])
       end
-  
+
       it "should retrieve an array of integers when a multiple strings are provided" do
         @query.where(:id, ["2", "4", "8"])
-        @query.where_ids(:id).should == [2, 4, 8]
+        expect(@query.where_values(:id)).to eq([2, 4, 8])
       end
-      
-      it "should cache the array of integers" do
+
+      it "should cache the array of values" do
         @query.where(:id, ["2", "4", "8"])
-        ids1 = @query.where_ids(:id)
-        ids2 = @query.where_ids(:id)
-        ids1.object_id.should == ids2.object_id
+        ids1 = @query.where_values(:id)
+        ids2 = @query.where_values(:id)
+        expect(ids1.object_id).to eq(ids2.object_id)
       end
     end
 
-    context "where_id" do
+    context "where_value" do
       it "should return nil when multiple integers are provided" do
         @query.where(:id, [2, 4, 8])
-        @query.where_id(:id).should == nil
+        expect(@query.where_value(:id)).to be_nil
       end
-      
+
       it "should return the id when a single integer is provided" do
         @query.where(:id, 4)
-        @query.where_id(:id).should == 4
+        expect(@query.where_value(:id)).to eq(4)
       end
 
       it "should return the id when a single string is provided" do
         @query.where(:id, ["4"])
-        @query.where_id(:id).should == 4
+        expect(@query.where_value(:id)).to eq(4)
       end
     end
   end
 
   context "sort" do
     it "should be an empty array by default" do
-      @query.sort_orders.should == []
+      expect(@query.sort_orders).to be_empty
     end
 
     it "should keep track of sort orders" do
       @query.order_by("name", true)
       @query.order_by("id", false)
-      @query.sort_orders.should == [ ["name", true], ["id", false] ]
+      expect(@query.sort_orders).to eq([ ["name", true], ["id", false] ])
     end
 
     it "should convert attribute to string" do
       @query.order_by(:name, true)
-      @query.sort_orders.should == [ ["name", true] ]
+      expect(@query.sort_orders).to eq([ ["name", true] ])
     end
 
     it "should define sorted?" do
-      @query.sorted?.should == false
+      expect(@query.sorted?).to eq(false)
       @query.order_by("name", true)
-      @query.sorted?.should == true
+      expect(@query.sorted?).to eq(true)
     end
   end
-  
+
   context "limit" do
     it "should be +nil+ by default" do
-      @query.limit.should == nil
+      expect(@query.limit).to be_nil
     end
-    
+
     it "should keep track of limit" do
       @query.limit = 4
-      @query.limit.should == 4
+      expect(@query.limit).to eq(4)
     end
 
     it "should convert limit to integer" do
       @query.limit = "4"
-      @query.limit.should == 4
+      expect(@query.limit).to eq(4)
     end
   end
-  
+
   context "utility" do
     before(:each) do
-      @query.where(:name, "My name")
+      @query.where(:name, "My name & co")
       @query.where(:id, [1, 2, 3])
       @query.order_by("name", true)
       @query.limit = "4"
     end
-    
+
     it "should generate a unique key for (request) caching purposes" do
-      @query.cache_key.should == 'name="My name"&id=[1, 2, 3].name=AL4'
+      expect(@query.cache_key).to eq('4+name?name="My name & co"&id=[1, 2, 3]')
     end
 
     it "should generate a pretty formatted query" do
-      @query.to_s.should == 'SELECT name = "My name" AND id = [1, 2, 3] ORDER_BY name ASC LIMIT 4'
+      expect(@query.to_s).to eq('SELECT name = "My name & co" AND id = [1, 2, 3] ORDER_BY name ASC LIMIT 4')
     end
   end
-  
+
 end

data/spec/lib/statistics_spec.rb

@@ -8,39 +8,39 @@ describe RecordCache::Statistics do
 
   context "active" do
     it "should default to false" do
-      RecordCache::Statistics.active?.should == false
+      expect(RecordCache::Statistics.active?).to be_falsey
     end
 
     it "should be activated by start" do
       RecordCache::Statistics.start
-      RecordCache::Statistics.active?.should == true
+      expect(RecordCache::Statistics.active?).to be_truthy
     end
 
     it "should be deactivated by stop" do
       RecordCache::Statistics.start
-      RecordCache::Statistics.active?.should == true
+      expect(RecordCache::Statistics.active?).to be_truthy
       RecordCache::Statistics.stop
-      RecordCache::Statistics.active?.should == false
+      expect(RecordCache::Statistics.active?).to be_falsey
     end
 
     it "should be toggleable" do
       RecordCache::Statistics.toggle
-      RecordCache::Statistics.active?.should == true
+      expect(RecordCache::Statistics.active?).to be_truthy
       RecordCache::Statistics.toggle
-      RecordCache::Statistics.active?.should == false
+      expect(RecordCache::Statistics.active?).to be_falsey
     end
   end
   
   context "find" do
     it "should return {} for unknown base classes" do
       class UnknownBase; end
-      RecordCache::Statistics.find(UnknownBase).should == {}
+      expect(RecordCache::Statistics.find(UnknownBase)).to eq({})
     end
 
     it "should create a new counter for unknown strategies" do
       class UnknownBase; end
       counter = RecordCache::Statistics.find(UnknownBase, :strategy)
-      counter.calls.should == 0
+      expect(counter.calls).to eq(0)
     end
 
     it "should retrieve all strategies if only the base is provided" do
@@ -48,15 +48,15 @@ describe RecordCache::Statistics do
       counter1 = RecordCache::Statistics.find(KnownBase, :strategy1)
       counter2 = RecordCache::Statistics.find(KnownBase, :strategy2)
       counters = RecordCache::Statistics.find(KnownBase)
-      counters.size.should == 2
-      counters[:strategy1].should == counter1
-      counters[:strategy2].should == counter2
+      expect(counters.size).to eq(2)
+      expect(counters[:strategy1]).to eq(counter1)
+      expect(counters[:strategy2]).to eq(counter2)
     end
 
     it "should retrieve the counter for an existing strategy" do
       class KnownBase; end
       counter1 = RecordCache::Statistics.find(KnownBase, :strategy1)
-      RecordCache::Statistics.find(KnownBase, :strategy1).should == counter1
+      expect(RecordCache::Statistics.find(KnownBase, :strategy1)).to eq(counter1)
     end
   end
   
@@ -70,16 +70,16 @@ describe RecordCache::Statistics do
     end
     
     it "should reset all counters for a specific base" do
-      mock(@counter_a1).reset!
-      mock(@counter_a2).reset!
-      mock(@counter_b1).reset!.times(0)
+      expect(@counter_a1).to receive(:reset!)
+      expect(@counter_a2).to receive(:reset!)
+      expect(@counter_b1).to_not receive(:reset!)
       RecordCache::Statistics.reset!(BaseA)
     end
 
     it "should reset all counters" do
-      mock(@counter_a1).reset!
-      mock(@counter_a2).reset!
-      mock(@counter_b1).reset!
+      expect(@counter_a1).to receive(:reset!)
+      expect(@counter_a2).to receive(:reset!)
+      expect(@counter_b1).to receive(:reset!)
       RecordCache::Statistics.reset!
     end
   end
@@ -90,51 +90,51 @@ describe RecordCache::Statistics do
     end
     
     it "should be empty by default" do
-      [@counter.calls, @counter.hits, @counter.misses].should == [0, 0, 0]
+      expect([@counter.calls, @counter.hits, @counter.misses]).to eq([0, 0, 0])
     end
     
     it "should delegate active? to RecordCache::Statistics" do
-      mock(RecordCache::Statistics).active?
+      expect(RecordCache::Statistics).to receive(:active?)
       @counter.active?
     end
     
     it "should add hits and misses" do
       @counter.add(4, 3)
-      [@counter.calls, @counter.hits, @counter.misses].should == [1, 3, 1]
+      expect([@counter.calls, @counter.hits, @counter.misses]).to eq([1, 3, 1])
     end
 
     it "should sum added hits and misses" do
       @counter.add(4, 3)
       @counter.add(1, 1)
       @counter.add(3, 2)
-      [@counter.calls, @counter.hits, @counter.misses].should == [3, 6, 2]
+      expect([@counter.calls, @counter.hits, @counter.misses]).to eq([3, 6, 2])
     end
 
     it "should reset! hits and misses" do
       @counter.add(4, 3)
       @counter.add(1, 1)
       @counter.reset!
-      [@counter.calls, @counter.hits, @counter.misses].should == [0, 0, 0]
+      expect([@counter.calls, @counter.hits, @counter.misses]).to eq([0, 0, 0])
     end
 
     it "should provide 0.0 percentage for empty counter" do
-      @counter.percentage.should == 0.0
+      expect(@counter.percentage).to eq(0.0)
     end
 
     it "should provide percentage" do
       @counter.add(4, 3)
-      @counter.percentage.should == 75.0
+      expect(@counter.percentage).to eq(75.0)
       @counter.add(1, 1)
-      @counter.percentage.should == 80.0
+      expect(@counter.percentage).to eq(80.0)
       @counter.add(5, 2)
-      @counter.percentage.should == 60.0
+      expect(@counter.percentage).to eq(60.0)
     end
 
     it "should pretty print on inspect" do
       @counter.add(4, 3)
       @counter.add(1, 1)
       @counter.add(5, 2)
-      @counter.inspect.should == "60.0% (6/10)"
+      expect(@counter.inspect).to eq("60.0% (6/10)")
     end
   end
 end

data/spec/lib/strategy/base_spec.rb

@@ -1,75 +1,90 @@
-$KCODE = 'UTF8'
+# encoding: utf-8
 require 'spec_helper'
 
 describe RecordCache::Strategy::Base do
-  
+
+  it "should force implementation of self.parse method" do
+    module RecordCache
+      module Strategy
+        class MissingParseCache < Base
+        end
+      end
+    end
+    expect{ RecordCache::Strategy::MissingParseCache.parse(1,2,3) }.to raise_error(NotImplementedError)
+  end
+
   it "should provide easy access to the Version Store" do
-    Apple.record_cache[:id].send(:version_store).should == RecordCache::Base.version_store
+    expect(Apple.record_cache[:id].send(:version_store)).to eq(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]
+    expect(Apple.record_cache[:id].send(:record_store)).to eq(RecordCache::Base.stores[:shared])
+    expect(Banana.record_cache[:id].send(:record_store)).to eq(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)
+    expect(Apple.record_cache[:person_id].send(:statistics)).to eq(RecordCache::Statistics.find(Apple, :person_id))
+    expect(Banana.record_cache[:id].send(:statistics)).to eq(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"
+    expect(Apple.record_cache[:id].send(:cache_key, 1)).to eq("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"
+    expect(Banana.record_cache[:id].send(:cache_key, 1)).to eq("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"
+    expect(Banana.record_cache[:id].send(:versioned_key, "rc/Banana/1", 2312423)).to eq("rc/Banana/1v2312423")
+  end
+
+  it "should provide the version_opts" do
+    expect(Apple.record_cache[:id].send(:version_opts)).to eq({:ttl => 300})
+    expect(Banana.record_cache[:id].send(:version_opts)).to eq({})
   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")]
+      expect{ @apples = Apple.where(:id => [1,2]).where(:name => "Adams Apple 1").all }.to use_cache(Apple).on(:id)
+      expect(@apples).to eq([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")]
+      expect{ @apples = Apple.where(:store_id => 1).where(:name => "Adams Apple 1").all }.to use_cache(Apple).on(:store_id)
+      expect(@apples).to eq([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 == []
+      expect{ @apples = Apple.where(:store_id => 1).where(:name => "Adams Apple Pie").all }.to use_cache(Apple).on(:store_id)
+      expect(@apples).to be_empty
     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")]
+      expect{ @apples = Apple.where(:id => [1,2]).where(:name => "Adams Apple 1").all }.to use_cache(Apple).on(:id)
+      expect(@apples).to eq([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]
+      expect{ @apples = Apple.where(:id => [1,2,8,9]).where(:store_id => 2).all }.to use_cache(Apple).on(:id)
+      expect(@apples.map(&:id).sort).to eq([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"
+      expect{ @people = Person.where(:id => [1,2,3]).where(:birthday => Date.civil(1953,11,11)).all }.to use_cache(Person).on(:id)
+      expect(@people.size).to eq(1)
+      expect(@people.first.name).to eq("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"]
+      expect{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).all }.to use_cache(Person).on(:id)
+      expect(@people.size).to eq(2)
+      expect(@people.map(&:name).sort).to eq(["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]
+      expect{ @apples = Apple.where(:id => [1,2,8,9]).where(:store_id => [2, 4]).all }.to use_cache(Apple).on(:id)
+      expect(@apples.map(&:id).sort).to eq([8,9])
     end
     
     it "should filter on multiple fields" do
@@ -78,102 +93,102 @@ describe RecordCache::Strategy::Base do
       @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]
+      expect{ @apples = Apple.where(:id => [1,2,3,8,9,10]).where(:store_id => 2).where(:name => @apple.name).all }.to use_cache(Apple).on(:id)
+      expect(@apples.size).to eq(2)
+      expect(@apples.map(&:name)).to eq([@apple.name, @apple.name])
+      expect(@apples.map(&:id).sort).to eq([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"]
+      expect{ @people = Person.where(:id => [1,2,3]).order("name DESC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:name)).to eq(["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]
+      expect{ @apples = Apple.where(:store_id => 1).order("person_id ASC").all }.to use_cache(Apple).on(:store_id)
+      expect(@apples.map(&:person_id)).to eq([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]
+      expect{ @apples = Apple.where(:store_id => 1).order("person_id").all }.to use_cache(Apple).on(:store_id)
+      expect(@apples.map(&:person_id)).to eq([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]
+      expect{ @apples = Apple.where(:store_id => 1).order("person_id ASC").all }.to use_cache(Apple).on(:store_id)
+      expect(@apples.map(&:person_id)).to eq([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]
+      expect{ @apples = Apple.where(:store_id => 1).order("person_id DESC").all }.to use_cache(Apple).on(:store_id)
+      expect(@apples.map(&:person_id)).to eq([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"]
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("name ASC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:name)).to eq(["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"]
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("name DESC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:name)).to eq(["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]
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("id ASC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:id)).to eq([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]
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("id DESC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:id)).to eq([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)]
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("birthday ASC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:birthday)).to eq([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)]
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("birthday DESC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:birthday)).to eq([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]
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("height ASC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:height)).to eq([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]
+      expect{ @people = Person.where(:id => [1,2,3,4]).order("height DESC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:height)).to eq([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]
+      expect{ @people = Person.where(:id => [2,3,4,5]).order("height ASC, id ASC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:height)).to eq([1.69, 1.75, 1.75, 1.91])
+      expect(@people.map(&:id)).to eq([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]
+      expect{ @people = Person.where(:id => [2,3,4,5]).order("height ASC, id DESC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:height)).to eq([1.69, 1.75, 1.75, 1.91])
+      expect(@people.map(&:id)).to eq([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]
+      expect{ @people = Person.where(:id => [2,3,4,5]).order("height DESC, id ASC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:height)).to eq([1.91, 1.75, 1.75, 1.69])
+      expect(@people.map(&:id)).to eq([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]
+      expect{ @people = Person.where(:id => [2,3,4,5]).order("height DESC, id DESC").all }.to use_cache(Person).on(:id)
+      expect(@people.map(&:height)).to eq([1.91, 1.75, 1.75, 1.69])
+      expect(@people.map(&:id)).to eq([5, 3, 2, 4])
     end
     
     it "should use mysql style collation" do
@@ -192,42 +207,38 @@ describe RecordCache::Strategy::Base do
       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
+      expect{ @people = Person.where(:id => ids).order("name ASC").all }.to hit_cache(Person).on(:id).times(ids.size)
+      expect(@people.map(&:name)).to eq(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
+      expect{ @people = Person.where(:id => ids).order("name DESC").all }.to hit_cache(Person).on(:id).times(ids.size)
+      expect(@people.map(&:name)).to eq(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"]
+    expect{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).order("name DESC").all }.to use_cache(Person).on(:id)
+    expect(@people.size).to eq(2)
+    expect(@people.map(&:name)).to eq(["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"]
+    expect{ @people = Person.where(:id => [1,2,3]).where(:height => 1.75).order("name").all }.to hit_cache(Person).on(:id).times(3)
+    expect(@people.map(&:name)).to eq(["Blue", "Cris"])
   end
   
   context "NotImplementedError" do
     before(:each) do
-      @invalid_strategy = RecordCache::Strategy::Base.new(Object, nil, nil, "key")
+      @invalid_strategy = RecordCache::Strategy::Base.new(Object, nil, nil, {:key => "key"})
     end
 
     it "should require record_change to be implemented" do
-      lambda { @invalid_strategy.record_change(Object.new, 1) }.should raise_error(NotImplementedError)
+      expect{ @invalid_strategy.record_change(Object.new, 1) }.to 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)
+      expect{ @invalid_strategy.cacheable?(RecordCache::Query.new) }.to raise_error(NotImplementedError)
     end
 
     it "should fetch_records to be implemented" do
-      lambda { @invalid_strategy.fetch(RecordCache::Query.new) }.should raise_error(NotImplementedError)
+      expect{ @invalid_strategy.fetch(RecordCache::Query.new) }.to raise_error(NotImplementedError)
     end
   end
 end