record-cache 0.1.2 → 0.1.3

data/spec/lib/strategy/util_spec.rb

@@ -1,61 +1,72 @@
-$KCODE = 'UTF8'
+# encoding: utf-8
 require 'spec_helper'
 
 describe RecordCache::Strategy::Util do
 
   it "should serialize a record (currently Active Record only)" do
-    subject.serialize(Banana.find(1)).should == {:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"}
+    expect(subject.serialize(Banana.find(1))).to eq({: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
-    subject.deserialize({:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"}).should == Banana.find(1)
+    expect(subject.deserialize({:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"})).to eq(Banana.find(1))
+  end
+
+  it "should call the after_finalize and after_find callbacks when deserializing a record" do
+    record = subject.deserialize({:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"})
+    expect(record.logs.sort).to eq(["after_find", "after_initialize"])
+  end
+
+  it "should not be a new record nor have changed attributes after deserializing a record" do
+    record = subject.deserialize({:a=>{"id"=>1}, :c=>"Banana"})
+    expect(record.new_record?).to be_falsey
+    expect(record.changed_attributes).to be_empty
   end
 
   context "filter" do
     it "should apply filter" do
       apples = Apple.where(:id => [1,2]).all
       subject.filter!(apples, :name => "Adams Apple 1")
-      apples.should == [Apple.find_by_name("Adams Apple 1")]
+      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
       apples = Apple.where(:id => [1,2]).all
       subject.filter!(apples, :name => "Adams Apple Pie")
-      apples.should be_empty
+      expect(apples).to be_empty
     end
 
     it "should filter on text" do
       apples = Apple.where(:id => [1,2]).all
       subject.filter!(apples, :name => "Adams Apple 1")
-      apples.should == [Apple.find_by_name("Adams Apple 1")]
+      expect(apples).to eq([Apple.find_by_name("Adams Apple 1")])
     end
 
     it "should filter on integers" do
       apples = Apple.where(:id => [1,2,8,9]).all
       subject.filter!(apples, :store_id => 2)
-      apples.map(&:id).sort.should == [8,9]
+      expect(apples.map(&:id).sort).to eq([8,9])
     end
 
     it "should filter on dates" do
       people = Person.where(:id => [1,2,3]).all
       subject.filter!(people, :birthday => Date.civil(1953,11,11))
-      people.size.should == 1
-      people.first.name.should == "Blue"
+      expect(people.size).to eq(1)
+      expect(people.first.name).to eq("Blue")
     end
 
     it "should filter on floats" do
       people = Person.where(:id => [1,2,3]).all
       subject.filter!(people, :height => 1.75)
-      people.size.should == 2
-      people.map(&:name).sort.should == ["Blue", "Cris"]
+      expect(people.size).to eq(2)
+      expect(people.map(&:name).sort).to eq(["Blue", "Cris"])
     end
 
     it "should filter on arrays" do
       apples = Apple.where(:id => [1,2,8,9])
       subject.filter!(apples, :store_id => [2, 4])
-      apples.map(&:id).sort.should == [8,9]
+      expect(apples.map(&:id).sort).to eq([8,9])
     end
-    
+
     it "should filter on multiple fields" do
       # make sure two apples exist with the same name
       apple = Apple.find(8)
@@ -64,9 +75,16 @@ describe RecordCache::Strategy::Util do
 
       apples = Apple.where(:id => [1,2,3,8,9,10]).all
       subject.filter!(apples, :store_id => [2, 4], :name => apple.name)
-      apples.size.should == 2
-      apples.map(&:name).should == [apple.name, apple.name]
-      apples.map(&:id).sort.should == [8,9]
+      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
+
+    it "should filter with more than 2 and conditions" do
+      # this construction leads to a arel object with 3 Equality Nodes within a single And Node
+      apples = Apple.where(:store_id => [1,2]).where(:store_id => 1, :person_id => nil).all
+      expect(apples.size).to eq(2)
+      expect(apples.map(&:id).sort).to eq([1,2])
     end
 
   end
@@ -75,138 +93,138 @@ describe RecordCache::Strategy::Util do
     it "should accept a Symbol as a sort order" do
       people = Person.where(:id => [1,2,3]).all
       subject.sort!(people, :name)
-      people.map(&:name).should == ["Adam", "Blue", "Cris"]
+      expect(people.map(&:name)).to eq(["Adam", "Blue", "Cris"])
     end
 
    it "should accept a single Array as a sort order" do
       people = Person.where(:id => [1,2,3]).all
       subject.sort!(people, [:name, false])
-      people.map(&:name).should == ["Cris", "Blue", "Adam"]
+      expect(people.map(&:name)).to eq(["Cris", "Blue", "Adam"])
     end
 
     it "should accept multiple Symbols as a sort order" do
       people = Person.where(:id => [2,3,4,5]).all
       subject.sort!(people, :height, :id)
-      people.map(&:height).should == [1.69, 1.75, 1.75, 1.91]
-      people.map(&:id).should == [4, 2, 3, 5]
+      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 accept a mix of Symbols and Arrays as a sort order" do
       people = Person.where(:id => [2,3,4,5]).all
       subject.sort!(people, [:height, false], :id)
-      people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
-      people.map(&:id).should == [5, 2, 3, 4]
+      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 accept multiple Arrays as a sort order" do
       people = Person.where(:id => [2,3,4,5]).all
       subject.sort!(people, [:height, false], [:id, false])
-      people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
-      people.map(&:id).should == [5, 3, 2, 4]
+      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 accept an Array with Arrays as a sort order (default used by record cache)" do
       people = Person.where(:id => [2,3,4,5]).all
       subject.sort!(people, [[:height, false], [:id, false]])
-      people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
-      people.map(&:id).should == [5, 3, 2, 4]
+      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 order nil first for ASC" do
       apples = Apple.where(:store_id => 1).all
       subject.sort!(apples, [:person_id, true])
-      apples.map(&:person_id).should == [nil, nil, 4, 4, 5]
+      expect(apples.map(&:person_id)).to eq([nil, nil, 4, 4, 5])
     end
 
     it "should order nil last for DESC" do
       apples = Apple.where(:store_id => 1).all
       subject.sort!(apples, [:person_id, false])
-      apples.map(&:person_id).should == [5, 4, 4, nil, nil]
+      expect(apples.map(&:person_id)).to eq([5, 4, 4, nil, nil])
     end
 
     it "should order ascending on text" do
       people = Person.where(:id => [1,2,3,4]).all
       subject.sort!(people, [:name, true])
-      people.map(&:name).should == ["Adam", "Blue", "Cris", "Fry"]
+      expect(people.map(&:name)).to eq(["Adam", "Blue", "Cris", "Fry"])
     end
 
     it "should order descending on text" do
       people = Person.where(:id => [1,2,3,4]).all
       subject.sort!(people, [:name, false])
-      people.map(&:name).should == ["Fry", "Cris", "Blue", "Adam"]
+      expect(people.map(&:name)).to eq(["Fry", "Cris", "Blue", "Adam"])
     end
 
     it "should order ascending on integers" do
       people = Person.where(:id => [4,2,1,3]).all
       subject.sort!(people, [:id, true])
-      people.map(&:id).should == [1,2,3,4]
+      expect(people.map(&:id)).to eq([1,2,3,4])
     end
 
     it "should order descending on integers" do
       people = Person.where(:id => [4,2,1,3]).all
       subject.sort!(people, [:id, false])
-      people.map(&:id).should == [4,3,2,1]
+      expect(people.map(&:id)).to eq([4,3,2,1])
     end
 
     it "should order ascending on dates" do
       people = Person.where(:id => [1,2,3,4]).all
       subject.sort!(people, [:birthday, true])
-      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.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 order descending on dates" do
       people = Person.where(:id => [1,2,3,4]).all
       subject.sort!(people, [:birthday, false])
-      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.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 order ascending on float" do
       people = Person.where(:id => [1,2,3,4]).all
       subject.sort!(people, [:height, true])
-      people.map(&:height).should == [1.69, 1.75, 1.75, 1.83]
+      expect(people.map(&:height)).to eq([1.69, 1.75, 1.75, 1.83])
     end
 
     it "should order descending on float" do
       people = Person.where(:id => [1,2,3,4]).all
       subject.sort!(people, [:height, false])
-      people.map(&:height).should == [1.83, 1.75, 1.75, 1.69]
+      expect(people.map(&:height)).to eq([1.83, 1.75, 1.75, 1.69])
     end
 
     it "should order on multiple fields (ASC + ASC)" do
       people = Person.where(:id => [2,3,4,5]).all
       subject.sort!(people, [:height, true], [:id, true])
-      people.map(&:height).should == [1.69, 1.75, 1.75, 1.91]
-      people.map(&:id).should == [4, 2, 3, 5]
+      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 order on multiple fields (ASC + DESC)" do
       people = Person.where(:id => [2,3,4,5]).all
       subject.sort!(people, [:height, true], [:id, false])
-      people.map(&:height).should == [1.69, 1.75, 1.75, 1.91]
-      people.map(&:id).should == [4, 3, 2, 5]
+      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 order on multiple fields (DESC + ASC)" do
       people = Person.where(:id => [2,3,4,5]).all
       subject.sort!(people, [:height, false], [:id, true])
-      people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
-      people.map(&:id).should == [5, 2, 3, 4]
+      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 order on multiple fields (DESC + DESC)" do
       people = Person.where(:id => [2,3,4,5]).all
       subject.sort!(people, [:height, false], [:id, false])
-      people.map(&:height).should == [1.91, 1.75, 1.75, 1.69]
-      people.map(&:id).should == [5, 3, 2, 4]
+      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
       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 => "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
@@ -218,10 +236,10 @@ describe RecordCache::Strategy::Util do
       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"]
       people = Person.where(:id => ids).all
       subject.sort!(people, [:name, true])
-      people.map(&:name).should == names_asc
+      expect(people.map(&:name)).to eq(names_asc)
 
       subject.sort!(people, [:name, false])
-      people.map(&:name).should == names_asc.reverse
+      expect(people.map(&:name)).to eq(names_asc.reverse)
     end
   end
 

data/spec/lib/version_store_spec.rb

@@ -9,95 +9,76 @@ describe RecordCache::VersionStore do
   end
   
   it "should only accept ActiveSupport cache stores" do
-    lambda { RecordCache::VersionStore.new(Object.new) }.should raise_error("Must be an ActiveSupport::Cache::Store")
+    expect{ RecordCache::VersionStore.new(Object.new) }.to raise_error("Store Object must respond to write")
   end
 
   context "current" do
     it "should retrieve the current version" do
-      @version_store.current("key1").should == 1000
+      expect(@version_store.current("key1")).to eq(1000)
     end
     
     it "should retrieve nil for unknown keys" do
-      @version_store.current("unknown_key").should == nil
+      expect(@version_store.current("unknown_key")).to be_nil
     end
   end
 
   context "current_multi" do
     it "should retrieve all versions" do
-      @version_store.current_multi({:id1 => "key1", :id2 => "key2"}).should == {:id1 => 1000, :id2 => 2000}
+      expect(@version_store.current_multi({:id1 => "key1", :id2 => "key2"})).to eq({:id1 => 1000, :id2 => 2000})
     end
     
     it "should return nil for unknown keys" do
-      @version_store.current_multi({:id1 => "key1", :key3 => "unknown_key"}).should == {:id1 => 1000, :key3 => nil}
+      expect(@version_store.current_multi({:id1 => "key1", :key3 => "unknown_key"})).to eq({:id1 => 1000, :key3 => nil})
     end
 
     it "should use read_multi on the underlying store" do
-      mock(@version_store.store).read_multi(/key[12]/, /key[12]/) { {"key1" => 5, "key2" => 6} }
-      @version_store.current_multi({:id1 => "key1", :id2 => "key2"}).should == {:id1 => 5, :id2 => 6}
+      allow(@version_store.store).to receive(:read_multi).with(/key[12]/, /key[12]/) { {"key1" => 5, "key2" => 6} }
+      expect(@version_store.current_multi({:id1 => "key1", :id2 => "key2"})).to eq({:id1 => 5, :id2 => 6})
     end
   end
 
   context "renew" do
     it "should renew the version" do
-      @version_store.current("key1").should == 1000
+      expect(@version_store.current("key1")).to eq(1000)
       @version_store.renew("key1")
-      @version_store.current("key1").should_not == 1000
+      expect(@version_store.current("key1")).to_not eq(1000)
     end
 
     it "should renew the version for unknown keys" do
-      @version_store.current("unknown_key").should == nil
+      expect(@version_store.current("unknown_key")).to be_nil
       @version_store.renew("unknown_key")
-      @version_store.current("unknown_key").should_not == nil
+      expect(@version_store.current("unknown_key")).to_not be_nil
     end
     
     it "should write to the debug log" do
-      mock(RecordCache::Base.logger).debug?{ true }
-      mock(RecordCache::Base.logger).debug(/Version Store: renew key1: nil => \d+/)
-      @version_store.renew("key1")
-      stub(RecordCache::Base.logger).debug?{ false } # to prevent the ResettableVersionStore from logging in +after(:each)+
+      expect{ @version_store.renew("key1") }.to log(:debug, /Version Store: renew key1: nil => \d+/)
     end
   end
 
+  # deprecated
   context "increment" do
-    it "should increment the version" do
-      @version_store.current("key1").should == 1000
-      @version_store.increment("key1")
-      @version_store.current("key1").should == 1001
-    end
-
-    it "should renew the version on increment for unknown keys" do
-      # do not use unknown_key as the version store retains the value after this spec
-      @version_store.current("unknown_key").should == nil
-      @version_store.renew("unknown_key")
-      @version_store.current("unknown_key").should_not == nil
-    end
 
     it "should write to the debug log" do
-      mock(RecordCache::Base.logger).debug?{ true }
-      mock(RecordCache::Base.logger).debug("Version Store: incremented key1: 1000 => 1001")
-      @version_store.increment("key1")
-      stub(RecordCache::Base.logger).debug?{ false } # to prevent the ResettableVersionStore from logging in +after(:each)+
+      expect{ @version_store.increment("key1") }.to log(:debug, /increment is deprecated, use renew instead/)
     end
+
   end
 
   context "delete" do
     it "should delete the version" do
-      @version_store.current("key1").should == 1000
-      @version_store.delete("key1").should == true
-      @version_store.current("key1").should == nil
+      expect(@version_store.current("key1")).to eq(1000)
+      expect(@version_store.delete("key1")).to be_truthy
+      expect(@version_store.current("key1")).to be_nil
     end
 
     it "should not raise an error when deleting the version for unknown keys" do
-      @version_store.current("unknown_key").should == nil
-      @version_store.delete("unknown_key").should == false
-      @version_store.current("unknown_key").should == nil
+      expect(@version_store.current("unknown_key")).to be_nil
+      expect(@version_store.delete("unknown_key")).to be_falsey
+      expect(@version_store.current("unknown_key")).to be_nil
     end
 
     it "should write to the debug log" do
-      mock(RecordCache::Base.logger).debug?{ true }
-      mock(RecordCache::Base.logger).debug("Version Store: deleted key1")
-      @version_store.delete("key1")
-      stub(RecordCache::Base.logger).debug?{ false } # to prevent the ResettableVersionStore from logging in +after(:each)+
+      expect{ @version_store.delete("key1") }.to log(:debug, %(Version Store: deleted key1))
     end
   end
 

data/spec/models/address.rb

@@ -0,0 +1,9 @@
+class Address < ActiveRecord::Base
+
+  cache_records :store => :shared, :key => "add", :index => [:store_id]
+
+  serialize :location, Hash
+
+  belongs_to :store
+
+end

data/spec/models/apple.rb

@@ -1,6 +1,6 @@
 class Apple < ActiveRecord::Base
   
-  cache_records :store => :shared, :key => "apl", :index => [:store_id, :person_id]
+  cache_records :store => :shared, :key => "apl", :index => [:store_id, :person_id], :ttl => 300
 
   belongs_to :store
   belongs_to :person

data/spec/models/banana.rb

@@ -1,8 +1,27 @@
 class Banana < ActiveRecord::Base
-  
+
   cache_records :store => :local, :index => [:person_id]
 
   belongs_to :store
   belongs_to :person
-  
+
+  after_initialize :do_after_initialize
+  after_find :do_after_find
+
+  def logs
+    @logs ||= []
+  end
+
+  private
+
+    def do_after_initialize
+      self.logs << "after_initialize"
+      true
+    end
+
+    def do_after_find
+      self.logs << "after_find"
+      true
+    end
+
 end