record-cache 0.1.3 → 0.1.4

data/spec/lib/strategy/unique_index_on_string_cache_spec.rb

@@ -1,168 +1,170 @@
 require "spec_helper"
 
-describe RecordCache::Strategy::UniqueIndexCache do
+RSpec.describe RecordCache::Strategy::UniqueIndexCache do
 
   it "should retrieve an Person from the cache" do
-    expect{ Person.find_by_name("Fry") }.to miss_cache(Person).on(:name).times(1)
-    expect{ Person.find_by_name("Fry") }.to hit_cache(Person).on(:name).times(1)
+    expect{ Person.find_by(name: "Fry") }.to miss_cache(Person).on(:name).times(1)
+    expect{ Person.find_by(name: "Fry") }.to hit_cache(Person).on(:name).times(1)
   end
 
   it "should retrieve cloned records" do
-    @fry_a = Person.find_by_name("Fry")
-    @fry_b = Person.find_by_name("Fry")
+    @fry_a = Person.find_by(name: "Fry")
+    @fry_b = Person.find_by(name: "Fry")
     expect(@fry_a).to eq(@fry_b)
     expect(@fry_a.object_id).to_not eq(@fry_b.object_id)
   end
 
   context "logging" do
     before(:each) do
-      Person.find_by_name("Fry")
+      Person.find_by(name: "Fry")
     end
 
     it "should write full hits to the debug log" do
-      expect{ Person.find_by_name("Fry") }.to log(:debug, %(UniqueIndexCache on 'Person.name' hit for ids "Fry"))
+      expect{ Person.find_by(name: "Fry") }.to log(:debug, %(UniqueIndexCache on 'Person.name' hit for ids "Fry"))
     end
 
     it "should write full miss to the debug log" do
-      expect{ Person.find_by_name("Chase") }.to log(:debug, %(UniqueIndexCache on 'Person.name' miss for ids "Chase"))
+      expect{ Person.find_by(name: "Chase") }.to log(:debug, %(UniqueIndexCache on 'Person.name' miss for ids "Chase"))
     end
 
     it "should write partial hits to the debug log" do
-      expect{ Person.where(:name => ["Fry", "Chase"]).all }.to log(:debug, %(UniqueIndexCache on 'Person.name' partial hit for ids ["Fry", "Chase"]: missing ["Chase"]))
+      expect{ Person.where(:name => ["Fry", "Chase"]).load }.to log(:debug, %(UniqueIndexCache on 'Person.name' partial hit for ids ["Fry", "Chase"]: missing ["Chase"]))
     end
   end
 
   context "cacheable?" do
     before(:each) do
       # fill cache
-      @fry = Person.find_by_name("Fry")
-      @chase = Person.find_by_name("Chase")
+      @fry = Person.find_by(name: "Fry")
+      @chase = Person.find_by(name: "Chase")
     end
 
     # @see https://github.com/orslumen/record-cache/issues/2
     it "should not use the cache when a lock is used" do
-      expect{ Person.lock("any_lock").where(:name => "Fry").all }.to_not hit_cache(Person)
+      pending("Any_lock is sqlite specific and I'm not aware of a mysql alternative") unless ActiveRecord::Base.connection.adapter_name == "SQLite"
+
+      expect{ Person.lock("any_lock").where(:name => "Fry").load }.to_not hit_cache(Person)
     end
 
     it "should use the cache when a single id is requested" do
-      expect{ Person.where(:name => "Fry").all }.to hit_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => "Fry").load }.to hit_cache(Person).on(:name).times(1)
     end
 
     it "should use the cache when a multiple ids are requested" do
-      expect{ Person.where(:name => ["Fry", "Chase"]).all }.to hit_cache(Person).on(:name).times(2)
+      expect{ Person.where(:name => ["Fry", "Chase"]).load }.to hit_cache(Person).on(:name).times(2)
     end
 
     it "should use the cache when a single id is requested and the limit is 1" do
-      expect{ Person.where(:name => "Fry").limit(1).all }.to hit_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => "Fry").limit(1).load }.to hit_cache(Person).on(:name).times(1)
     end
 
     it "should not use the cache when a single id is requested and the limit is > 1" do
-      expect{ Person.where(:name => "Fry").limit(2).all }.to_not use_cache(Person).on(:name)
+      expect{ Person.where(:name => "Fry").limit(2).load }.to_not use_cache(Person).on(:name)
     end
 
     it "should not use the cache when multiple ids are requested and the limit is 1" do
-      expect{ Person.where(:name => ["Fry", "Chase"]).limit(1).all }.to_not use_cache(Person).on(:name)
+      expect{ Person.where(:name => ["Fry", "Chase"]).limit(1).load }.to_not use_cache(Person).on(:name)
     end
 
     it "should use the cache when a single id is requested together with other where clauses" do
-      expect{ Person.where(:name => "Fry").where(:height => 1.67).all }.to hit_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => "Fry").where(:height => 1.67).load }.to hit_cache(Person).on(:name).times(1)
     end
 
     it "should use the cache when a multiple ids are requested together with other where clauses" do
-      expect{ Person.where(:name => ["Fry", "Chase"]).where(:height => 1.67).all }.to hit_cache(Person).on(:name).times(2)
+      expect{ Person.where(:name => ["Fry", "Chase"]).where(:height => 1.67).load }.to hit_cache(Person).on(:name).times(2)
     end
 
     it "should use the cache when a single id is requested together with (simple) sort clauses" do
-      expect{ Person.where(:name => "Fry").order("name ASC").all }.to hit_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => "Fry").order("name ASC").load }.to hit_cache(Person).on(:name).times(1)
     end
 
     it "should use the cache when a single id is requested together with (simple) case insensitive sort clauses" do
-      expect{ Person.where(:name => "Fry").order("name desc").all }.to hit_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => "Fry").order("name desc").load }.to hit_cache(Person).on(:name).times(1)
     end
 
     it "should use the cache when a single id is requested together with (simple) sort clauses with table prefix" do
-      expect{ Person.where(:name => "Fry").order("people.name desc").all }.to hit_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => "Fry").order("people.name desc").load }.to hit_cache(Person).on(:name).times(1)
     end
 
     it "should not use the cache when a single id is requested together with an unknown sort clause" do
-      expect{ Person.where(:name => "Fry").order("lower(people.name) desc").all }.to_not hit_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => "Fry").order("lower(people.name) desc").load }.to_not hit_cache(Person).on(:name).times(1)
     end
 
     it "should use the cache when a multiple ids are requested together with (simple) sort clauses" do
-      expect{ Person.where(:name => ["Fry", "Chase"]).order("name ASC").all }.to hit_cache(Person).on(:name).times(2)
+      expect{ Person.where(:name => ["Fry", "Chase"]).order("name ASC").load }.to hit_cache(Person).on(:name).times(2)
     end
   end
-  
+
   context "record_change" do
     before(:each) do
       # fill cache
-      @fry = Person.find_by_name("Fry")
-      @chase = Person.find_by_name("Chase")
+      @fry = Person.find_by(name: "Fry")
+      @chase = Person.find_by(name: "Chase")
     end
 
     it "should invalidate destroyed records" do
-      expect{ Person.where(:name => "Fry").all }.to hit_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => "Fry").load }.to hit_cache(Person).on(:name).times(1)
       @fry.destroy
-      expect{ @people = Person.where(:name => "Fry").all }.to miss_cache(Person).on(:name).times(1)
+      expect{ @people = Person.where(:name => "Fry").load }.to miss_cache(Person).on(:name).times(1)
       expect(@people).to be_empty
       # try again, to make sure the "missing record" is not cached
-      expect{ Person.where(:name => "Fry").all }.to miss_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => "Fry").load }.to miss_cache(Person).on(:name).times(1)
     end
 
     it "should add updated records directly to the cache" do
       @fry.height = 1.71
       @fry.save!
-      expect{ @person = Person.find_by_name("Fry") }.to hit_cache(Person).on(:name).times(1)
+      expect{ @person = Person.find_by(name: "Fry") }.to hit_cache(Person).on(:name).times(1)
       expect(@person.height).to eq(1.71)
     end
 
     it "should add created records directly to the cache" do
       Person.create!(:name => "Flower", :birthday => Date.civil(1990,07,29), :height => 1.80)
-      expect{ @person = Person.find_by_name("Flower") }.to hit_cache(Person).on(:name).times(1)
+      expect{ @person = Person.find_by(name: "Flower") }.to hit_cache(Person).on(:name).times(1)
       expect(@person.height).to eq(1.80)
     end
 
     it "should add updated records to the cache, also when multiple ids are queried" do
       @fry.height = 1.71
       @fry.save!
-      expect{ @people = Person.where(:name => ["Fry", "Chase"]).order("id ASC").all }.to hit_cache(Person).on(:name).times(2)
+      expect{ @people = Person.where(:name => ["Fry", "Chase"]).order("id ASC").load }.to hit_cache(Person).on(:name).times(2)
       expect(@people.map(&:height)).to eq([1.71, 1.91])
     end
-    
+
   end
-  
+
   context "invalidate" do
     before(:each) do
-      @fry = Person.find_by_name("Fry")
-      @chase = Person.find_by_name("Chase")
+      @fry = Person.find_by(name: "Fry")
+      @chase = Person.find_by(name: "Chase")
     end
 
     it "should invalidate single records" do
       Person.record_cache[:name].invalidate("Fry")
-      expect{ Person.find_by_name("Fry") }.to miss_cache(Person).on(:name).times(1)
+      expect{ Person.find_by(name: "Fry") }.to miss_cache(Person).on(:name).times(1)
     end
 
     it "should only miss the cache for the invalidated record when multiple ids are queried" do
       # miss on 1
       Person.record_cache[:name].invalidate("Fry")
-      expect{ Person.where(:name => ["Fry", "Chase"]).all }.to miss_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => ["Fry", "Chase"]).load }.to miss_cache(Person).on(:name).times(1)
       # hit on 2
       Person.record_cache[:name].invalidate("Fry")
-      expect{ Person.where(:name => ["Fry", "Chase"]).all }.to hit_cache(Person).on(:name).times(1)
+      expect{ Person.where(:name => ["Fry", "Chase"]).load }.to hit_cache(Person).on(:name).times(1)
       # nothing invalidated, both hit
-      expect{ Person.where(:name => ["Fry", "Chase"]).all }.to hit_cache(Person).on(:name).times(2)
+      expect{ Person.where(:name => ["Fry", "Chase"]).load }.to hit_cache(Person).on(:name).times(2)
     end
 
     it "should invalidate records when using update_all" do
-      Person.where(:id => ["Fry", "Chase", "Penny"]).all # fill id cache on all Adam Store apples
-      expect{ @people = Person.where(:name => ["Fry", "Chase", "Penny"]).order("name ASC").all }.to hit_cache(Person).on(:name).times(2)
+      Person.where(:id => ["Fry", "Chase", "Penny"]).load # fill id cache on all Adam Store apples
+      expect{ @people = Person.where(:name => ["Fry", "Chase", "Penny"]).order("name ASC").load }.to hit_cache(Person).on(:name).times(2)
       expect(@people.map(&:name)).to eq(["Chase", "Fry", "Penny"])
       # update 2 of the 3 People
       Person.where(:name => ["Fry", "Penny"]).update_all(:height => 1.21)
-      expect{ @people = Person.where(:name => ["Fry", "Chase", "Penny"]).order("height ASC").all }.to hit_cache(Person).on(:name).times(1)
+      expect{ @people = Person.where(:name => ["Fry", "Chase", "Penny"]).order("height ASC").load }.to hit_cache(Person).on(:name).times(1)
       expect(@people.map(&:height)).to eq([1.21, 1.21, 1.91])
     end
 
   end
-  
+
 end

data/spec/lib/strategy/util_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe RecordCache::Strategy::Util do
+RSpec.describe RecordCache::Strategy::Util do
 
   it "should serialize a record (currently Active Record only)" do
     expect(subject.serialize(Banana.find(1))).to eq({:a=>{"name"=>"Blue Banana 1", "id"=>1, "store_id"=>2, "person_id"=>4}, :c=>"Banana"})
@@ -24,47 +24,53 @@ describe RecordCache::Strategy::Util do
 
   context "filter" do
     it "should apply filter" do
-      apples = Apple.where(:id => [1,2]).all
-      subject.filter!(apples, :name => "Adams Apple 1")
-      expect(apples).to eq([Apple.find_by_name("Adams Apple 1")])
+      apples = Apple.where(id: [1, 2]).to_a
+      subject.filter!(apples, 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 = Apple.where(id: [1, 2])
+      subject.filter!(apples, name: "Adams Apple Pie")
       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")
-      expect(apples).to eq([Apple.find_by_name("Adams Apple 1")])
+      apples = Apple.where(id: [1, 2])
+      subject.filter!(apples, name: "Adams Apple 1")
+      expect(apples).to eq([Apple.find_by(name: "Adams Apple 1")])
+    end
+
+    it "should filter on text case insensitive" do
+      apples = Apple.where(id: [1, 2])
+      subject.filter!(apples, 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)
-      expect(apples.map(&:id).sort).to eq([8,9])
+      apples = Apple.where(id: [1, 2, 8, 9])
+      subject.filter!(apples, store_id: 2)
+      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 = Person.where(id: [1, 2, 3])
+      subject.filter!(people, birthday: Date.civil(1953, 11, 11))
       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 = Person.where(id: [1, 2, 3])
+      subject.filter!(people, height: 1.75)
       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])
+      apples = Apple.where(:id => [1, 2, 8, 9])
       subject.filter!(apples, :store_id => [2, 4])
-      expect(apples.map(&:id).sort).to eq([8,9])
+      expect(apples.map(&:id).sort).to eq([8, 9])
     end
 
     it "should filter on multiple fields" do
@@ -73,8 +79,8 @@ describe RecordCache::Strategy::Util do
       apple.name = Apple.find(9).name
       apple.save!
 
-      apples = Apple.where(:id => [1,2,3,8,9,10]).all
-      subject.filter!(apples, :store_id => [2, 4], :name => apple.name)
+      apples = Apple.where(id: [1, 2, 3, 8, 9, 10])
+      subject.filter!(apples, store_id: [2, 4], name: apple.name)
       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])
@@ -82,137 +88,137 @@ describe RecordCache::Strategy::Util do
 
     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
+      apples = Apple.where(store_id: [1,2]).where(store_id: 1, person_id: nil)
       expect(apples.size).to eq(2)
-      expect(apples.map(&:id).sort).to eq([1,2])
+      expect(apples.map(&:id).sort).to eq([1, 2])
     end
 
   end
 
   context "sort" do
     it "should accept a Symbol as a sort order" do
-      people = Person.where(:id => [1,2,3]).all
+      people = Person.where(:id => [1,2,3]).to_a
       subject.sort!(people, :name)
       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
+      people = Person.where(:id => [1,2,3]).to_a
       subject.sort!(people, [:name, false])
       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
+      people = Person.where(:id => [2,3,4,5]).to_a
       subject.sort!(people, :height, :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 accept a mix of Symbols and Arrays as a sort order" do
-      people = Person.where(:id => [2,3,4,5]).all
+      people = Person.where(:id => [2,3,4,5]).to_a
       subject.sort!(people, [:height, false], :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 accept multiple Arrays as a sort order" do
-      people = Person.where(:id => [2,3,4,5]).all
+      people = Person.where(:id => [2,3,4,5]).to_a
       subject.sort!(people, [:height, false], [:id, false])
       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
+      people = Person.where(:id => [2,3,4,5]).to_a
       subject.sort!(people, [[:height, false], [:id, false]])
       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
+      apples = Apple.where(:store_id => 1).to_a
       subject.sort!(apples, [:person_id, true])
       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
+      apples = Apple.where(:store_id => 1).to_a
       subject.sort!(apples, [:person_id, false])
       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
+      people = Person.where(:id => [1,2,3,4]).to_a
       subject.sort!(people, [:name, true])
       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
+      people = Person.where(:id => [1,2,3,4]).to_a
       subject.sort!(people, [:name, false])
       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
+      people = Person.where(:id => [4,2,1,3]).to_a
       subject.sort!(people, [:id, true])
       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
+      people = Person.where(:id => [4,2,1,3]).to_a
       subject.sort!(people, [:id, false])
       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
+      people = Person.where(:id => [1,2,3,4]).to_a
       subject.sort!(people, [:birthday, true])
       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
+      people = Person.where(:id => [1,2,3,4]).to_a
       subject.sort!(people, [:birthday, false])
       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
+      people = Person.where(:id => [1,2,3,4]).to_a
       subject.sort!(people, [:height, true])
       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
+      people = Person.where(:id => [1,2,3,4]).to_a
       subject.sort!(people, [:height, false])
       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
+      people = Person.where(:id => [2,3,4,5]).to_a
       subject.sort!(people, [:height, true], [:id, true])
       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
+      people = Person.where(:id => [2,3,4,5]).to_a
       subject.sort!(people, [:height, true], [:id, false])
       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
+      people = Person.where(:id => [2,3,4,5]).to_a
       subject.sort!(people, [:height, false], [:id, true])
       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
+      people = Person.where(:id => [2,3,4,5]).to_a
       subject.sort!(people, [:height, false], [:id, false])
       expect(people.map(&:height)).to eq([1.91, 1.75, 1.75, 1.69])
       expect(people.map(&:id)).to eq([5, 3, 2, 4])
@@ -234,7 +240,7 @@ describe RecordCache::Strategy::Util 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"]
-      people = Person.where(:id => ids).all
+      people = Person.where(:id => ids).to_a
       subject.sort!(people, [:name, true])
       expect(people.map(&:name)).to eq(names_asc)