record-cache 0.1.0

data/spec/db/seeds.rb

@@ -0,0 +1,40 @@
+ActiveRecord::Schema.define :version => 1 do
+  
+  # Make sure that at the beginning of the tests, NOTHING is known to Record Cache
+  RecordCache::Base.disable!
+  
+  @adam = Person.create!(:name => "Adam", :birthday => Date.civil(1975,03,20), :height => 1.83)
+  @blue = Person.create!(:name => "Blue", :birthday => Date.civil(1953,11,11), :height => 1.75)
+  @cris = Person.create!(:name => "Cris", :birthday => Date.civil(1975,03,20), :height => 1.75)
+
+  @adam_apples = Store.create!(:name => "Adams Apple Store", :owner => @adam)
+  @blue_fruits = Store.create!(:name => "Blue Fruits", :owner => @blue)
+  @cris_bananas = Store.create!(:name => "Chris Bananas", :owner => @cris)
+
+  @fry = Person.create!(:name => "Fry", :birthday => Date.civil(1985,01,20), :height => 1.69)
+  @chase = Person.create!(:name => "Chase", :birthday => Date.civil(1970,07,03), :height => 1.91)
+  @penny = Person.create!(:name => "Penny", :birthday => Date.civil(1958,04,16), :height => 1.61)
+
+  Apple.create!(:name => "Adams Apple 1", :store => @adam_apples)
+  Apple.create!(:name => "Adams Apple 2", :store => @adam_apples)
+  Apple.create!(:name => "Adams Apple 3", :store => @adam_apples, :person => @fry)
+  Apple.create!(:name => "Adams Apple 4", :store => @adam_apples, :person => @fry)
+  Apple.create!(:name => "Adams Apple 5", :store => @adam_apples, :person => @chase)
+  Apple.create!(:name => "Blue Apple 1", :store => @blue_fruits, :person => @fry)
+  Apple.create!(:name => "Blue Apple 2", :store => @blue_fruits, :person => @fry)
+  Apple.create!(:name => "Blue Apple 3", :store => @blue_fruits, :person => @chase)
+  Apple.create!(:name => "Blue Apple 4", :store => @blue_fruits, :person => @chase)
+
+  Banana.create!(:name => "Blue Banana 1", :store => @blue_fruits, :person => @fry)
+  Banana.create!(:name => "Blue Banana 2", :store => @blue_fruits, :person => @chase)
+  Banana.create!(:name => "Blue Banana 3", :store => @blue_fruits, :person => @chase)
+  Banana.create!(:name => "Cris Banana 1", :store => @cris_bananas, :person => @fry)
+  Banana.create!(:name => "Cris Banana 2", :store => @cris_bananas, :person => @chase)
+
+  Pear.create!(:name => "Blue Pear 1", :store => @blue_fruits)
+  Pear.create!(:name => "Blue Pear 2", :store => @blue_fruits, :person => @fry)
+  Pear.create!(:name => "Blue Pear 3", :store => @blue_fruits, :person => @chase)
+  Pear.create!(:name => "Blue Pear 4", :store => @blue_fruits, :person => @chase)
+
+  RecordCache::Base.enable
+end

data/spec/initializers/record_cache.rb

@@ -0,0 +1,14 @@
+# --- Version Store
+# All Workers that use the Record Cache should point to the same Version Store
+# E.g. a MemCached cluster or a Redis Store (defaults to Rails.cache)
+RecordCache::Base.version_store = ActiveSupport::Cache.lookup_store(:memory_store)
+
+# --- Record Stores
+# Register Cache Stores for the Records themselves
+# Note: A different Cache Store could be used per Model, but in most configurations the following 2 stores will suffice:
+
+# The :local store is used to keep records in Worker memory
+RecordCache::Base.register_store(:local, ActiveSupport::Cache.lookup_store(:memory_store))
+
+# The :shared store is used to share Records between multiple Workers
+RecordCache::Base.register_store(:shared, ActiveSupport::Cache.lookup_store(:memory_store))

data/spec/lib/dispatcher_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe RecordCache::Dispatcher do
+  before(:each) do
+    @apple_dispatcher = Apple.record_cache
+  end
+  
+  it "should raise an error when the same index is added twice" do
+    lambda { @apple_dispatcher.register(:store_id, RecordCache::Strategy::IdCache, nil, {}) }.should raise_error("Multiple record cache definitions found for 'store_id' on Apple")
+  end
+  
+  it "should return the Cache for the requested strategy" do
+    @apple_dispatcher[:id].class.should == RecordCache::Strategy::IdCache
+    @apple_dispatcher[:store_id].class.should == RecordCache::Strategy::IndexCache
+  end
+
+  it "should return nil for unknown requested strategies" do
+    @apple_dispatcher[:unknown].should == nil
+  end
+
+  it "should return cacheable? true if there is a cacheable strategy that accepts the query" do
+    query = RecordCache::Query.new
+    mock(@apple_dispatcher).first_cacheable_strategy(query) { Object.new }
+    @apple_dispatcher.cacheable?(query).should == true
+  end
+
+  context "fetch" do
+    it "should delegate fetch to the Request Cache if present" do
+      query = RecordCache::Query.new
+      mock(@apple_dispatcher[:request_cache]).fetch(query)
+      @apple_dispatcher.fetch(query)
+    end
+
+    it "should delegate fetch to the first cacheable strategy if Request Cache is not present" do
+      query = RecordCache::Query.new
+      banana_dispatcher = Banana.record_cache
+      banana_dispatcher[:request_cache].should == nil
+      mock(banana_dispatcher).first_cacheable_strategy(query) { mock(Object.new).fetch(query) }
+      banana_dispatcher.fetch(query)
+    end
+  end
+  
+  context "record_change" do
+    it "should dispatch record_change to all strategies" do
+      apple = Apple.first
+      [:id, :store_id, :person_id].each do |strategy|
+        mock(@apple_dispatcher[strategy]).record_change(apple, :create)
+      end
+      @apple_dispatcher.record_change(apple, :create)
+    end
+  
+    it "should not dispatch record_change for updates without changes" do
+      apple = Apple.first
+      [:request_cache, :id, :store_id, :person_id].each do |strategy|
+        mock(@apple_dispatcher[strategy]).record_change(anything, anything).times(0)
+      end
+      @apple_dispatcher.record_change(apple, :update)
+    end
+  end
+
+  context "invalidate" do
+    it "should default to the :id strategy" do
+      mock(@apple_dispatcher[:id]).invalidate(15)
+      @apple_dispatcher.invalidate(15)
+    end
+
+    it "should delegate to given strategy" do
+      mock(@apple_dispatcher[:id]).invalidate(15)
+      mock(@apple_dispatcher[:store_id]).invalidate(31)
+      @apple_dispatcher.invalidate(:id, 15)
+      @apple_dispatcher.invalidate(:store_id, 31)
+    end
+
+    it "should invalidate the request cache" do
+      store_dispatcher = Store.record_cache
+      mock(store_dispatcher[:request_cache]).invalidate(15)
+      store_dispatcher.invalidate(:id, 15)
+    end
+
+    it "should even invalidate the request cache if the given strategy is not known" do
+      store_dispatcher = Store.record_cache
+      mock(store_dispatcher[:request_cache]).invalidate(31)
+      store_dispatcher.invalidate(:unknown_id, 31)
+    end
+  end
+end

data/spec/lib/multi_read_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe RecordCache::MultiRead do
+
+  it "should not delegate to single reads when multi_read is supported" do
+    class MultiReadSupported
+      def read(key) "single" end
+      def read_multi(*keys) "multi" end
+    end
+    store = RecordCache::MultiRead.test(MultiReadSupported.new)
+    store.read_multi("key1", "key2").should == "multi"
+  end
+
+  it "should delegate to single reads when multi_read is explicitly disabled" do
+    class ExplicitlyDisabled
+      def read(key) "single" end
+      def read_multi(*keys) "multi" end
+    end
+    RecordCache::MultiRead.disable(ExplicitlyDisabled)
+    store = RecordCache::MultiRead.test(ExplicitlyDisabled.new)
+    store.read_multi("key1", "key2").should == {"key1" => "single", "key2" => "single"}
+  end
+
+  it "should delegate to single reads when multi_read throws an error" do
+    class MultiReadNotImplemented
+      def read(key) "single" end
+      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"}
+  end
+
+  it "should delegate to single reads when multi_read is undefined" do
+    class MultiReadNotDefined
+      def read(key) "single" end
+    end
+    store = RecordCache::MultiRead.test(MultiReadNotDefined.new)
+    store.read_multi("key1", "key2").should == {"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))
+  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)
+    end
+  end
+end

data/spec/lib/query_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+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 == {}
+    end
+
+    it "should fill wheres on instantiation" do
+      @query = RecordCache::Query.new({:id => 1})
+      @query.wheres.should == {: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}
+    end
+
+    context "where_ids" do
+      it "should return nil if the attribute is not defined" do
+        @query.where(:idx, 15)
+        @query.where_ids(:id).should == nil
+      end
+
+      it "should return nil if one the value is nil" do
+        @query.where(:id, nil)
+        @query.where_ids(:id).should == 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
+      end
+
+      it "should return nil if one of the values is nil" do
+        @query.where(:id, ["1", nil, "3"])
+        @query.where_ids(:id).should == nil
+      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]
+      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]
+      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]
+      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]
+      end
+      
+      it "should cache the array of integers" do
+        @query.where(:id, ["2", "4", "8"])
+        ids1 = @query.where_ids(:id)
+        ids2 = @query.where_ids(:id)
+        ids1.object_id.should == ids2.object_id
+      end
+    end
+
+    context "where_id" do
+      it "should return nil when multiple integers are provided" do
+        @query.where(:id, [2, 4, 8])
+        @query.where_id(:id).should == nil
+      end
+      
+      it "should return the id when a single integer is provided" do
+        @query.where(:id, 4)
+        @query.where_id(:id).should == 4
+      end
+
+      it "should return the id when a single string is provided" do
+        @query.where(:id, ["4"])
+        @query.where_id(:id).should == 4
+      end
+    end
+  end
+
+  context "sort" do
+    it "should be an empty array by default" do
+      @query.sort_orders.should == []
+    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] ]
+    end
+
+    it "should convert attribute to string" do
+      @query.order_by(:name, true)
+      @query.sort_orders.should == [ ["name", true] ]
+    end
+
+    it "should define sorted?" do
+      @query.sorted?.should == false
+      @query.order_by("name", true)
+      @query.sorted?.should == true
+    end
+  end
+  
+  context "limit" do
+    it "should be +nil+ by default" do
+      @query.limit.should == nil
+    end
+    
+    it "should keep track of limit" do
+      @query.limit = 4
+      @query.limit.should == 4
+    end
+
+    it "should convert limit to integer" do
+      @query.limit = "4"
+      @query.limit.should == 4
+    end
+  end
+  
+  context "utility" do
+    before(:each) do
+      @query.where(:name, "My name")
+      @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'
+    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'
+    end
+  end
+  
+end

data/spec/lib/statistics_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe RecordCache::Statistics do
+  before(:each) do
+    # remove active setting from other tests
+    RecordCache::Statistics.send(:remove_instance_variable, :@active) if RecordCache::Statistics.instance_variable_get(:@active)
+  end
+
+  context "active" do
+    it "should default to false" do
+      RecordCache::Statistics.active?.should == false
+    end
+
+    it "should be activated by start" do
+      RecordCache::Statistics.start
+      RecordCache::Statistics.active?.should == true
+    end
+
+    it "should be deactivated by stop" do
+      RecordCache::Statistics.start
+      RecordCache::Statistics.active?.should == true
+      RecordCache::Statistics.stop
+      RecordCache::Statistics.active?.should == false
+    end
+
+    it "should be toggleable" do
+      RecordCache::Statistics.toggle
+      RecordCache::Statistics.active?.should == true
+      RecordCache::Statistics.toggle
+      RecordCache::Statistics.active?.should == false
+    end
+  end
+  
+  context "find" do
+    it "should return {} for unknown base classes" do
+      class UnknownBase; end
+      RecordCache::Statistics.find(UnknownBase).should == {}
+    end
+
+    it "should create a new counter for unknown strategies" do
+      class UnknownBase; end
+      counter = RecordCache::Statistics.find(UnknownBase, :strategy)
+      counter.calls.should == 0
+    end
+
+    it "should retrieve all strategies if only the base is provided" do
+      class KnownBase; end
+      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
+    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
+    end
+  end
+  
+  context "reset!" do
+    before(:each) do
+      class BaseA; end
+      @counter_a1 = RecordCache::Statistics.find(BaseA, :strategy1)
+      @counter_a2 = RecordCache::Statistics.find(BaseA, :strategy2)
+      class BaseB; end
+      @counter_b1 = RecordCache::Statistics.find(BaseB, :strategy1)
+    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)
+      RecordCache::Statistics.reset!(BaseA)
+    end
+
+    it "should reset all counters" do
+      mock(@counter_a1).reset!
+      mock(@counter_a2).reset!
+      mock(@counter_b1).reset!
+      RecordCache::Statistics.reset!
+    end
+  end
+  
+  context "counter" do
+    before(:each) do
+      @counter = RecordCache::Statistics::Counter.new
+    end
+    
+    it "should be empty by default" do
+      [@counter.calls, @counter.hits, @counter.misses].should == [0, 0, 0]
+    end
+    
+    it "should delegate active? to RecordCache::Statistics" do
+      mock(RecordCache::Statistics).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]
+    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]
+    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]
+    end
+
+    it "should provide 0.0 percentage for empty counter" do
+      @counter.percentage.should == 0.0
+    end
+
+    it "should provide percentage" do
+      @counter.add(4, 3)
+      @counter.percentage.should == 75.0
+      @counter.add(1, 1)
+      @counter.percentage.should == 80.0
+      @counter.add(5, 2)
+      @counter.percentage.should == 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)"
+    end
+  end
+end