record-cache 0.1.0

data/spec/lib/strategy/request_cache_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe RecordCache::Strategy::RequestCache do
+
+  it "should retrieve a record from the Request Cache" do
+    lambda{ Store.find(1) }.should miss_cache(Store)
+    lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
+  end
+
+  it "should retrieve the same record when the same query is used" do
+    @store_1 = Store.find(1)
+    @store_2 = Store.find(1)
+    @store_1.should == @store_2
+    @store_1.object_id.should == @store_2.object_id
+  end
+
+  context "logging" do
+    before(:each) do
+      Store.find(1)
+    end
+
+    it "should write hit to the debug log" do
+      mock(RecordCache::Base.logger).debug(/RequestCache hit for id=1\.L1|^(?!RequestCache)/).times(any_times)
+      Store.find(1)
+    end
+
+    it "should write miss to the debug log" do
+      mock(RecordCache::Base.logger).debug(/^RequestCache miss for id=2.L1|^(?!RequestCache)/).times(any_times)
+      Store.find(2)
+    end
+  end
+
+  context "record_change" do
+    before(:each) do
+      # cache query in request cache
+      @store1 = Store.find(1)
+      @store2 = Store.find(2)
+    end
+    
+    it "should remove all records from the cache for a specific model when one record is destroyed" do
+      lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
+      lambda{ Store.find(2) }.should hit_cache(Store).on(:request_cache).times(1)
+      @store1.destroy
+      lambda{ Store.find(2) }.should miss_cache(Store).on(:request_cache).times(1)
+    end
+
+    it "should remove all records from the cache for a specific model when one record is updated" do
+      lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
+      lambda{ Store.find(2) }.should hit_cache(Store).on(:request_cache).times(1)
+      @store1.name = "Store E"
+      @store1.save!
+      lambda{ Store.find(1) }.should miss_cache(Store).on(:request_cache).times(1)
+      lambda{ Store.find(2) }.should miss_cache(Store).on(:request_cache).times(1)
+    end
+
+    it "should remove all records from the cache for a specific model when one record is created" do
+      lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
+      lambda{ Store.find(2) }.should hit_cache(Store).on(:request_cache).times(1)
+      Store.create!(:name => "New Apple Store")
+      lambda{ Store.find(1) }.should miss_cache(Store).on(:request_cache).times(1)
+      lambda{ Store.find(2) }.should miss_cache(Store).on(:request_cache).times(1)
+    end
+
+  end
+
+  context "invalidate" do
+    before(:each) do
+      # cache query in request cache
+      @store1 = Store.find(1)
+      @store2 = Store.find(2)
+    end
+    
+    it "should remove all records from the cache when clear is explicitly called" do
+      lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
+      RecordCache::Strategy::RequestCache.clear
+      lambda{ Store.find(1) }.should miss_cache(Store).on(:request_cache).times(1)
+    end
+
+    it "should remove all records from the cache when invalidate is called" do
+      lambda{ Store.find(1) }.should hit_cache(Store).on(:request_cache).times(1)
+      Store.record_cache.invalidate(:request_cache, @store2)
+      lambda{ Store.find(1) }.should miss_cache(Store).on(:request_cache).times(1)
+    end
+  end
+end

data/spec/lib/version_store_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe RecordCache::VersionStore do
+  
+  before(:each) do
+    @version_store = RecordCache::Base.version_store
+    @version_store.store.write("key1", 1000)
+    @version_store.store.write("key2", 2000)
+  end
+  
+  it "should only accept ActiveSupport cache stores" do
+    lambda { RecordCache::VersionStore.new(Object.new) }.should raise_error("Must be an ActiveSupport::Cache::Store")
+  end
+
+  context "current" do
+    it "should retrieve the current version" do
+      @version_store.current("key1").should == 1000
+    end
+    
+    it "should retrieve nil for unknown keys" do
+      @version_store.current("unknown_key").should == 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}
+    end
+    
+    it "should return nil for unknown keys" do
+      @version_store.current_multi({:id1 => "key1", :key3 => "unknown_key"}).should == {: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}
+    end
+  end
+
+  context "renew" do
+    it "should renew the version" do
+      @version_store.current("key1").should == 1000
+      @version_store.renew("key1")
+      @version_store.current("key1").should_not == 1000
+    end
+
+    it "should renew the version for unknown keys" do
+      @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: renew key1: nil => \d+/)
+      @version_store.renew("key1")
+      stub(RecordCache::Base.logger).debug?{ false } # to prevent the ResettableVersionStore from logging in +after(:each)+
+    end
+  end
+
+  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)+
+    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
+    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
+    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)+
+    end
+  end
+
+end

data/spec/models/apple.rb

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

data/spec/models/banana.rb

@@ -0,0 +1,8 @@
+class Banana < ActiveRecord::Base
+  
+  cache_records :store => :local, :index => [:person_id]
+
+  belongs_to :store
+  belongs_to :person
+  
+end

data/spec/models/pear.rb

@@ -0,0 +1,6 @@
+class Pear < ActiveRecord::Base
+  
+  belongs_to :store
+  belongs_to :person
+  
+end

data/spec/models/person.rb

@@ -0,0 +1,11 @@
+class Person < ActiveRecord::Base
+  
+  cache_records :store => :shared, :key => "per"
+
+  has_many :apples  # cached with index on person_id
+  has_many :bananas # cached with index on person_id
+  has_many :pears   # not cached
+
+  has_and_belongs_to_many :stores
+
+end

data/spec/models/store.rb

@@ -0,0 +1,13 @@
+class Store < ActiveRecord::Base
+
+  cache_records :store => :local, :key => "st", :request_cache => true
+
+  belongs_to :owner, :class_name => "Person"
+
+  has_many :apples, :autosave => true  # cached with index on store
+  has_many :bananas # cached without index on store
+  has_many :pears   # not cached
+
+  has_and_belongs_to_many :customers, :class_name => "Person"
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir + "/../lib"
+$LOAD_PATH.unshift dir
+
+require "rubygems"
+require "test/unit"
+require "rspec"
+require 'rr'
+require 'database_cleaner'
+require "logger"
+require "record_cache"
+require "record_cache/test/resettable_version_store"
+
+# spec support files
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+
+# logging
+Dir.mkdir(dir + "/log") unless File.exists?(dir + "/log")
+ActiveRecord::Base.logger = Logger.new(dir + "/log/debug.log")
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+# SQL Lite
+ActiveRecord::Base.configurations = YAML::load(IO.read(dir + "/db/database.yml"))
+ActiveRecord::Base.establish_connection("sqlite3")
+
+# Initializers + Model + Data
+load(dir + "/initializers/record_cache.rb")
+load(dir + "/db/schema.rb")
+Dir["#{dir}/models/*.rb"].each {|f| load(f) }
+load(dir + "/db/seeds.rb")
+
+# Clear cache after each test
+RSpec.configure do |config|
+  config.mock_with :rr
+  
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+  
+  config.after(:each) do
+    DatabaseCleaner.clean
+    RecordCache::Base.version_store.reset!
+  end
+end

data/spec/support/after_commit.rb

@@ -0,0 +1,71 @@
+# @see http://outofti.me/post/4777884779/test-after-commit-hooks-with-transactional-fixtures
+module ActiveRecord
+  module ConnectionAdapters
+    module DatabaseStatements
+      #
+      # Run the normal transaction method; when it's done, check to see if there
+      # is exactly one open transaction. If so, that's the transactional
+      # fixtures transaction; from the model's standpoint, the completed
+      # transaction is the real deal. Send commit callbacks to models.
+      #
+      # If the transaction block raises a Rollback, we need to know, so we don't
+      # call the commit hooks. Other exceptions don't need to be explicitly
+      # accounted for since they will raise uncaught through this method and
+      # prevent the code after the hook from running.
+      #
+      def transaction_with_transactional_fixtures(options = {}, &block)
+        rolled_back = false
+
+        transaction_without_transactional_fixtures do
+          begin
+            yield
+          rescue Exception => exception
+            if exception.is_a?(ActiveRecord::Rollback)
+              rolled_back = true
+            else
+              puts "Exception in aftercommit: #{exception}"
+              puts exception.backtrace
+            end
+            raise exception
+          end
+        end
+
+        if !rolled_back && open_transactions == 1
+          commit_transaction_records(false)
+        end
+      end
+      alias_method_chain :transaction, :transactional_fixtures
+
+      #
+      # The @_current_transaction_records is an stack of arrays, each one
+      # containing the records associated with the corresponding transaction
+      # in the transaction stack. This is used by the
+      # `rollback_transaction_records` method (to only send a rollback hook to
+      # models attached to the transaction being rolled back) but is usually
+      # ignored by the `commit_transaction_records` method. Here we
+      # monkey-patch it to temporarily replace the array with only the records
+      # for the top-of-stack transaction, so the real
+      # `commit_transaction_records` method only sends callbacks to those.
+      #
+      def commit_transaction_records_with_transactional_fixtures(commit = true)
+        unless commit
+          real_current_transaction_records = @_current_transaction_records
+          @_current_transaction_records = @_current_transaction_records.pop
+        end
+
+        begin
+          @_current_transaction_records ||= []
+          commit_transaction_records_without_transactional_fixtures
+        rescue Exception => exception
+          puts "Error in aftercommit: #{exception}"
+          puts exception.backtrace
+        ensure
+          unless commit
+            @_current_transaction_records = real_current_transaction_records
+          end
+        end
+      end
+      alias_method_chain :commit_transaction_records, :transactional_fixtures
+    end
+  end
+end

data/spec/support/matchers/hit_cache_matcher.rb

@@ -0,0 +1,53 @@
+# Examples:
+#  1) lambda{ Person.find(22) }.should hit_cache(Person)
+#     _should have at least one hit in any of the cache strategies for the Person model_
+#
+#  2) lambda{ Person.find(22) }.should hit_cache(Person).on(:id)
+#     _should have at least one hit in the ID cache strategy for the Person model_
+#
+#  3) lambda{ Person.find_by_ids(22, 23, 24) }.should hit_cache(Person).on(:id).times(2)
+#     _should have exactly two hits in the :id cache strategy for the Person model_
+#
+#  4) lambda{ Person.find_by_ids(22, 23, 24) }.should hit_cache(Person).times(3)
+#     _should have exactly three hits in any of the cache strategies for the Person model_
+RSpec::Matchers.define :hit_cache do |model|
+
+  chain :on do |strategy|
+    @strategy = strategy
+  end
+
+  chain :times do |nr_of_hits|
+    @expected_nr_of_hits = nr_of_hits
+  end
+
+  match do |proc|
+    # reset statistics for the given model and start counting
+    RecordCache::Statistics.reset!(model)
+    RecordCache::Statistics.start
+    # call the given proc
+    proc.call
+    # collect statistics for the model
+    @stats = RecordCache::Statistics.find(model)
+    # check the nr of hits
+    @nr_of_hits = @strategy ? @stats[@strategy].hits : @stats.values.map{ |s| s.hits }.sum
+    # test nr of hits
+    @expected_nr_of_hits ? @nr_of_hits == @expected_nr_of_hits : @nr_of_hits > 0
+  end
+
+  failure_message_for_should do |proc|
+    prepare_message
+    "Expected #{@strategy_msg} for #{model.name} to be hit #{@times_msg}, but found #{@nr_of_hits}: #{@statistics_msg}"
+  end
+
+  failure_message_for_should_not do |proc|
+    prepare_message
+    "Expected #{@strategy_msg} for #{model.name} not to be hit #{@times_msg}, but found #{@nr_of_hits}: #{@statistics_msg}"
+  end
+
+  def prepare_message
+    @strategy_msg = @strategy ? "the #{@strategy} cache" : "any of the caches"
+    @times_msg = @expected_nr_of_hits ? (@expected_nr_of_hits == 1 ? "exactly once" : "exactly #{@expected_nr_of_hits} times") : "at least once"
+    @statistics_msg = @stats.map{|strategy, s| "#{strategy} => #{s.inspect}" }.join(", ")
+  end
+
+end 

data/spec/support/matchers/miss_cache_matcher.rb

@@ -0,0 +1,53 @@
+# Examples:
+#  1) lambda{ Person.find(22) }.should miss_cache(Person)
+#     _should have at least one miss in any of the cache strategies for the Person model_
+#
+#  2) lambda{ Person.find(22) }.should miss_cache(Person).on(:id)
+#     _should have at least one miss for the ID cache strategy for the Person model_
+#
+#  3) lambda{ Person.find_by_ids(22, 23, 24) }.should miss_cache(Person).on(:id).times(2)
+#     _should have exactly two misses in the :id cache strategy for the Person model_
+#
+#  4) lambda{ Person.find_by_ids(22, 23, 24) }.should miss_cache(Person).times(3)
+#     _should have exactly three misses in any of the cache strategies for the Person model_
+RSpec::Matchers.define :miss_cache do |model|
+
+  chain :on do |strategy|
+    @strategy = strategy
+  end
+
+  chain :times do |nr_of_misses|
+    @expected_nr_of_misses = nr_of_misses
+  end
+
+  match do |proc|
+    # reset statistics for the given model and start counting
+    RecordCache::Statistics.reset!(model)
+    RecordCache::Statistics.start
+    # call the given proc
+    proc.call
+    # collect statistics for the model
+    @stats = RecordCache::Statistics.find(model)
+    # check the nr of misses
+    @nr_of_misses = @strategy ? @stats[@strategy].misses : @stats.values.map{ |s| s.misses }.sum
+    # test nr of misses
+    @expected_nr_of_misses ? @nr_of_misses == @expected_nr_of_misses : @nr_of_misses > 0
+  end
+
+  failure_message_for_should do |proc|
+    prepare_message
+    "Expected #{@strategy_msg} for #{model.name} to be missed #{@times_msg}, but found #{@nr_of_misses}: #{@statistics_msg}"
+  end
+
+  failure_message_for_should_not do |proc|
+    prepare_message
+    "Expected #{@strategy_msg} for #{model.name} not to be missed #{@times_msg}, but found #{@nr_of_misses}: #{@statistics_msg}"
+  end
+
+  def prepare_message
+    @strategy_msg = @strategy ? "the #{@strategy} cache" : "any of the caches"
+    @times_msg = @expected_nr_of_misses ? (@expected_nr_of_misses == 1 ? "exactly once" : "exactly #{@expected_nr_of_misses} times") : "at least once"
+    @statistics_msg = @stats.map{|strategy, s| "#{strategy} => #{s.inspect}" }.join(", ")
+  end
+
+end 

data/spec/support/matchers/use_cache_matcher.rb

@@ -0,0 +1,53 @@
+# Examples:
+#  1) lambda{ Person.find(22) }.should use_cache(Person)
+#     _should perform at least one call (hit/miss) to any of the cache strategies for the Person model_
+#
+#  2) lambda{ Person.find(22) }.should use_cache(Person).on(:id)
+#     _should perform at least one call (hit/miss) to the ID cache strategy for the Person model_
+#
+#  3) lambda{ Person.find_by_ids(22, 23, 24) }.should use_cache(Person).on(:id).times(2)
+#     _should perform exactly two calls (hit/miss) to the :id cache strategy for the Person model_
+#
+#  4) lambda{ Person.find_by_ids(22, 23, 24) }.should use_cache(Person).times(3)
+#     _should perform exactly three calls (hit/miss) to any of the cache strategies for the Person model_
+RSpec::Matchers.define :use_cache do |model|
+
+  chain :on do |strategy|
+    @strategy = strategy
+  end
+
+  chain :times do |nr_of_calls|
+    @expected_nr_of_calls = nr_of_calls
+  end
+
+  match do |proc|
+    # reset statistics for the given model and start counting
+    RecordCache::Statistics.reset!(model)
+    RecordCache::Statistics.start
+    # call the given proc
+    proc.call
+    # collect statistics for the model
+    @stats = RecordCache::Statistics.find(model)
+    # check the nr of calls
+    @nr_of_calls = @strategy ? @stats[@strategy].calls : @stats.values.map{ |s| s.calls }.sum
+    # test nr of calls
+    @expected_nr_of_calls ? @nr_of_calls == @expected_nr_of_calls : @nr_of_calls > 0
+  end
+
+  failure_message_for_should do |proc|
+    prepare_message
+    "Expected #{@strategy_msg} for #{model.name} to be called #{@times_msg}, but found #{@nr_of_calls}: #{@statistics_msg}"
+  end
+
+  failure_message_for_should_not do |proc|
+    prepare_message
+    "Expected #{@strategy_msg} for #{model.name} not to be called #{@times_msg}, but found #{@nr_of_calls}: #{@statistics_msg}"
+  end
+
+  def prepare_message
+    @strategy_msg = @strategy ? "the #{@strategy} cache" : "any of the caches"
+    @times_msg = @expected_nr_of_calls ? (@expected_nr_of_calls == 1 ? "exactly once" : "exactly #{@expected_nr_of_calls} times") : "at least once"
+    @statistics_msg = @stats.map{|strategy, s| "#{strategy} => #{s.inspect}" }.join(", ")
+  end
+
+end