active_record_cache 1.0.3

data/README.rdoc

@@ -0,0 +1,57 @@
+=  Active Record Cache
+
+This gem provides a caching layer to ActiveRecord models that can be activated in a variety of ways and scopes. The cache strategy that is implemented will only work when querying for records by their primary key, so it is not applicable to all situations, but does provide good support for the most common use case.
+
+== Usage
+
+To enable caching on a model, simply add a call to +use_record_cache+ to the class definition:
+
+  class MyModel < ActiveRecord::Base
+    use_record_cache
+  end
+  
+To use the cache, simple add +from_cache+ to a finder chain:
+
+  MyModel.where(:id => params[:id]).from_cache
+
+To make matter easier to use the cache, you can also set a default for a model:
+
+  class MyModel < ActiveRecord::Base
+    use_record_cache :default => true
+  end
+
+You can use the +from_database+ method on you model finders to force a query to hit the database:
+
+  MyModel.where(:id => params[:id]).from_database
+  
+You can also set the default behavior for using the cache on a model within a block:
+
+  ActiveRecordCache.set_defaults(MyModel => true) do
+    # This will use the cache
+    MyModel.where(:id => params[:id])
+  end
+
+  ActiveRecordCache.set_defaults(MyModel => false) do
+    # This will not use the cache
+    MyModel.where(:id => params[:id])
+  end
+
+This last behavior is also available as a Rack handler:
+
+  Rails.configuration.middleware.use(ActiveRecordCache::DefaultsHandler, MyModel => true)
+
+By default, Rails.cache will be used for caching records, but you can specify any implementation of ActiveSupport::Cache::Store you wish.
+
+== Constraints
+
+* Only queries specifically instructed to use the cache will use the cache. This value can be made the default behavior for models where you always want to use the cache.
+
+* Only queries by primary key will hit the cache. Queries may be by more that one primary key.
+
+* Queries can only use the limit and at most one order by statement. Order by statements must be by a single column and can be either in ascending or descending order. Using any other statements in the finder like joins or select will result in the cache being bypassed.
+
+* Records will be returned as read only so that they cannot be saved back to the database when they come through the cache. This is a safety measure to prevent stale data from being used to update the database.
+
+== Expiring
+
+Entries will be expired from the cache whenever they are updated or destroyed. Entries can also be given a time to live with an :expires_in option on either the cache or on the +use_record_cache+ method call. Note that if you don't use a shared cache among all accessors of the record, the records could become out of sync with the database and even among app servers.

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'rake'
+
+desc 'Default: run unit tests'
+task :default => :test
+
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+  desc 'Run the unit tests'
+  RSpec::Core::RakeTask.new(:test)
+rescue LoadError
+  task :test do
+    raise "You must have rspec 2.0 installed to run the tests"
+  end
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "active_record_cache"
+    gem.summary = %Q{This gem adds a caching layer to ActiveRecord models when finding them by a numeric primary key.}
+    gem.description = %Q{This gem adds a caching layer to ActiveRecord models when finding them by a numeric primary key.}
+    gem.authors = ["Brian Durand"]
+    gem.email = ["mdobrota@tribune.com", "ddpr@tribune.com"]
+    gem.files = FileList["lib/**/*", "spec/**/*", "bin/**/*", "example/**/*" "README.rdoc", "Rakefile", "License.txt"].to_a
+    gem.has_rdoc = true
+    gem.rdoc_options << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+    gem.extra_rdoc_files = ["README.rdoc"]
+    gem.add_dependency('activerecord', "~>3.0.5")
+    gem.add_dependency('tribune-sort_by_field', "~>1.0.1")
+    gem.add_development_dependency('rspec', '>= 2.0.0')
+    gem.add_development_dependency('sqlite3')
+  end
+  Jeweler::RubygemsDotOrgTasks.new
+rescue LoadError
+end

data/lib/active_record_cache/defaults_handler.rb

@@ -0,0 +1,15 @@
+module ActiveRecordCache
+  # Rack handler that sets the default for classes if they will use the cache for queries.
+  class DefaultsHandler
+    def initialize(app, options)
+      @app = app
+      @options = options
+    end
+    
+    def call(env)
+      ActiveRecordCache.enable_by_default_on(@options) do
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/active_record_cache/record_cache.rb

@@ -0,0 +1,80 @@
+module ActiveRecordCache
+  class RecordCache  
+    attr_reader :cache, :expires_in
+      
+    def initialize(klass, options = {})
+      @klass = klass
+      @cache = options[:cache] || ActiveRecordCache.cache
+      @expires_in = options[:expires_in] || @cache.options[:expires_in]
+      @preload = options[:preload]
+      @default = (options[:default].nil? ? false : !!options[:default])
+    end
+    
+    def read(ids)
+      ids = ids.first if ids.is_a?(Array) && ids.size == 1
+      if ids.is_a?(Array)
+        keys = []
+        id_key_map = {}
+        ids.each do |id|
+          key = cache_key(id)
+          keys << key
+          id_key_map[id] = key
+        end
+        record_map = @cache.read_multi(*keys)
+        missing_ids = ids.reject{|id| record_map[id_key_map[id]]}
+        unless missing_ids.empty?
+          finder.where(@klass.primary_key => missing_ids).each do |record|
+            key = id_key_map[record.id]
+            record_map[key] = record
+            @cache.write(key, record, :expires_in => @expires_in)
+          end
+        end
+        
+        records = []
+        ids.each do |id|
+          record = record_map[id_key_map[id]]
+          records << record if record
+        end
+        records
+      else
+        [self[ids]]
+      end
+    end
+    
+    # Get a value from the cache by primary key.
+    def [](id)
+      @cache.fetch(cache_key(id), :expires_in => @expires_in) do
+        finder.where(@klass.primary_key => id).first
+      end
+    end
+    
+    # Remove an entry from the cache.
+    def expire(id)
+      @cache.delete(cache_key(id))
+    end
+    
+    # Generate a cache key for a record.
+    def cache_key(id)
+      "#{@klass.model_name.cache_key}/#{id}"
+    end
+    
+    # Get the default value for whether the cache is enabled or not.
+    def default
+      defaults = Thread.current[:active_record_cache_defaults]
+      if defaults && defaults.include?(@klass.name)
+        defaults[@klass.name]
+      else
+        @default
+      end
+    end
+    
+    private
+    
+    # Return a Relation for finding records to put in the cache.
+    def finder
+      relation = @klass.from_database.readonly
+      relation = relation.preload(@preload) if @preload
+      relation
+    end
+  end
+end

data/lib/active_record_cache/relation_extension.rb

@@ -0,0 +1,104 @@
+module ActiveRecordCache
+  module RelationExtension
+    extend ActiveSupport::Concern
+    
+    SIMPLE_ORDER_BY = /^([a-z][a-z0-9_]*)( ?((asc|desc)(ending)?)?)$/i
+    
+    included do
+      alias_method_chain :to_a, :record_cache
+      alias_method_chain :merge, :record_cache
+      attr_accessor :query_from_cache_value
+    end
+    
+    # Calling +from_database+ on a Relation will force the query to bypass the cache.
+    def from_database
+      relation = clone
+      relation.query_from_cache_value = false
+      relation
+    end
+    
+    # Calling +from_database+ on a Relation will force the query to bypass the cache.
+    def from_cache
+      relation = clone
+      relation.query_from_cache_value = true
+      relation
+    end
+    
+    # Override the to_a method to look in the cache.
+    def to_a_with_record_cache #:nodoc:
+      if !loaded? && cacheable_query?
+        ids = get_where_ids
+        unless ids.blank?
+          records = klass.record_cache.read(ids)
+          records = records[0, limit_value.to_i] if limit_value
+          records = records.sort_by_field(order_values.first) unless order_values.empty?
+          if logger && logger.debug?
+            logger.debug("  #{klass.name} LOAD FROM RECORD CACHE #{to_sql}")
+          end
+          @records = records
+          @loaded = true
+        end
+      end
+      to_a_without_record_cache
+    end
+    
+    # Override the merge function so that the query_from_cache_value gets merged.
+    def merge_with_record_cache(relation) #:nodoc:
+      merged_relation = merge_without_record_cache(relation)
+      merged_relation.query_from_cache_value = relation.query_from_cache_value
+      merged_relation
+    end
+    
+    private
+    
+    # Return true if the query is cacheable. Queries are only cacheable if there is at most one where clause and that
+    # clause searches only by one or more id's. The query must also not do any joins, offsets, or groupings. Any order
+    # clause must be a simple order by one of the columns.
+    def cacheable_query?
+      return false unless klass.respond_to?(:record_cache)
+      from_cache = (query_from_cache_value.nil? ? klass.record_cache.default : query_from_cache_value)
+      return false unless from_cache
+      return false unless where_values.size == (klass.finder_needs_type_condition? ? 2 : 1)
+      return false unless order_values.blank? || (order_values.size == 1 && order_values.first.to_s.match(SIMPLE_ORDER_BY))
+      select_col = select_values.first
+      select_col = select_col.name if select_col && select_col.respond_to?(:name)
+      select_star = select_values.blank? || (select_values.size == 1 && select_col == "*")
+      return false unless select_star
+      return false unless group_values.blank? && includes_values.blank? && eager_load_values.blank? && preload_values.blank? && joins_values.blank? && having_values.blank? && offset_value.blank?
+      return false unless from_value.blank? && lock_value.blank?
+      true
+    end
+    
+    # Get the primary key values used in the query. This will only return a value if the query
+    # had exactly one where clause by primary key.
+    def get_where_ids
+      where_hash = where_values_hash.with_indifferent_access
+      if where_hash.size == (klass.finder_needs_type_condition? ? 2 : 1)
+        bind_index = 0
+        Array(where_hash[klass.primary_key]).collect do |id|
+          if id == "?"
+            bind_val = bind_values[bind_index]
+            id = bind_val.last if bind_val
+            bind_index += 1
+          end
+          begin
+            Integer(id)
+          rescue ArgumentError
+            return nil
+          end
+        end
+      elsif where_hash.empty? && (!defined?(bind_values) || bind_values.empty?)
+        sql = where_values.first
+        if sql.is_a?(String)
+          pk_column = "#{klass.connection.quote_table_name(klass.table_name)}.#{klass.connection.quote_column_name(klass.primary_key)}"
+          pattern = Regexp.new("^\\s*\\(?\\s*#{Regexp.escape(pk_column)}(\\s*(=\\s*(\\d+))|(\\s+IN\\s+\\(([\\d\\s,]+)\\)))\\s*\\)?\\s*$", true)
+          if sql.match(pattern)
+            single_id = $~[3].to_i if $~[3]
+            multiple_ids = $~[5].split(',').collect{|n| n.to_i} if $~[5]
+            single_id || multiple_ids
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record_cache.rb

@@ -0,0 +1,75 @@
+require 'active_record'
+require 'active_support/all'
+require 'sort_by_field'
+
+module ActiveRecordCache
+  extend ActiveSupport::Concern
+  
+  autoload :DefaultsHandler, File.expand_path("../active_record_cache/defaults_handler.rb", __FILE__)
+  autoload :RecordCache, File.expand_path("../active_record_cache/record_cache.rb", __FILE__)
+  autoload :RelationExtension, File.expand_path("../active_record_cache/relation_extension.rb", __FILE__)
+
+  included do
+    # Expire the cache entry both after updates and destroys to ensure it is consistent within a transaction.
+    after_destroy :expire_cache_entry
+    after_update :expire_cache_entry
+    
+    # Expire the cache again after a transaction to ensure it is consistent after database changes are committed.
+    after_commit :expire_cache_entry
+    after_rollback :expire_cache_entry
+  end
+  
+  class << self
+    # Get the default cache used by models. Defaults to Rails.cache.
+    def cache
+      unless defined?(@cache)
+        @cache = Rails.cache if defined?(Rails.cache)
+      end
+      @cache
+    end
+  
+    # Set the default cache used by models.
+    def cache=(value)
+      @cache = value
+    end
+    
+    # Set the default for classes if they should use the cache or not for the duration of a block.
+    # The options hash should be a hash of {class_name => (true|false)}.
+    def enable_by_default_on(options)
+      current_defaults = Thread.current[:active_record_cache_defaults]
+      begin
+        defaults = current_defaults ? current_defaults.dup : {}
+        Thread.current[:active_record_cache_defaults] = defaults
+        options.each do |klass, default|
+          defaults[klass.is_a?(Class) ? klass.name : klass.to_s] = !!default
+        end
+        yield
+      ensure
+        Thread.current[:active_record_cache_defaults] = current_defaults
+      end
+    end
+  end
+  
+  # Expire the record out of the cache.
+  def expire_cache_entry
+    self.class.expire_cache_entry(id)
+  end
+  
+  module ClassMethods
+    # Call this method to add a cache to a model. The options allowed are:
+    # * :cache - the ActiveSupport::Cache::Store instance to use. By default it will use Rails.cache.
+    # * :expires_in - the number of seconds until cache entries will be automatically refreshed (defaults to 1 hour)
+    def use_record_cache(options = {})
+      class_attribute :record_cache, :instance_reader => false, :instance_writer => false
+      self.record_cache = RecordCache.new(self, options)
+      scope :from_database, scoped.from_database
+      scope :from_cache, scoped.from_cache
+    end
+    
+    def expire_cache_entry(id)
+      self.record_cache.expire(id)
+    end
+  end
+end
+
+ActiveRecord::Relation.send(:include, ActiveRecordCache::RelationExtension) unless ActiveRecord::Relation.include?(ActiveRecordCache::RelationExtension)

data/spec/active_record_cache_spec.rb

@@ -0,0 +1,274 @@
+require 'spec_helper'
+
+describe ActiveRecordCache do
+  before :each do
+    Rails.cache.clear
+    MY_CACHE.clear
+    ActiveRecordCache::Tester.destroy_all
+    ActiveRecordCache::Test.destroy_all
+    ActiveRecordCache::SubTest.destroy_all
+    ActiveRecordCache::NoCacheTester.destroy_all
+    ActiveRecordCache::TesterNoCacheDefault.destroy_all
+  end
+  
+  let(:test_1){ ActiveRecordCache::Test.create(:name => "test_1") }
+  let(:test_2){ ActiveRecordCache::Test.create(:name => "test_2") }
+  let(:test_3){ ActiveRecordCache::Test.create(:name => "test_3") }
+  let(:subtest_1){ ActiveRecordCache::SubTest.create(:name => "subtest_1") }
+  let(:subtest_2){ ActiveRecordCache::SubTest.create(:name => "subtest_2") }
+  let(:tester_1){ ActiveRecordCache::Tester.create!(:name => "tester_1", :test => test_1) }
+  let(:tester_2){ ActiveRecordCache::Tester.create!(:name => "tester_2", :test => test_1) }
+  let(:tester_3){ ActiveRecordCache::Tester.create!(:name => "tester_3", :test => test_2) }
+  let(:tester_4){ ActiveRecordCache::Tester.create!(:name => "tester_4", :test => test_2) }
+  let(:no_cache_tester_1){ ActiveRecordCache::NoCacheTester.create!(:name => "no_cache_tester_1") }
+  let(:no_cache_tester_2){ ActiveRecordCache::NoCacheTester.create!(:name => "no_cache_tester_2") }
+  let(:no_cache_default_tester_1){ ActiveRecordCache::TesterNoCacheDefault.create!(:name => "no_cache_default_tester_1") }
+  let(:no_cache_default_tester_2){ ActiveRecordCache::TesterNoCacheDefault.create!(:name => "no_cache_default_tester_2") }
+  
+  it "should have a cache that defaults to Rails.cache" do
+    ActiveRecordCache.cache.should == Rails.cache
+    begin
+      my_cache = ActiveSupport::Cache::MemoryStore.new
+      ActiveRecordCache.cache = my_cache
+      ActiveRecordCache.cache.should == my_cache
+    ensure
+      ActiveRecordCache.cache = Rails.cache
+    end
+  end
+  
+  context "injecting behavior into a model" do
+    it "should be able to add caching to a model" do
+      ActiveRecordCache::Tester.record_cache.cache.should == Rails.cache
+    end
+    
+    it "should be able to specify the cache to use" do
+      ActiveRecordCache::Test.record_cache.cache.should == MY_CACHE
+    end
+    
+    it "should be able to specify the number of seconds until entries expire" do
+      ActiveRecordCache::Tester.record_cache.expires_in.should == nil
+      ActiveRecordCache::Test.record_cache.expires_in.should == 30
+    end
+    
+    it "should have a scope to find from the database" do
+      scope = ActiveRecordCache::Tester.from_database
+      scope.should be_a(ActiveRecord::Relation)
+      scope.query_from_cache_value.should == false
+    end
+    
+    it "should have a scope to find from the cache" do
+      scope = ActiveRecordCache::TesterNoCacheDefault.from_cache
+      scope.should be_a(ActiveRecord::Relation)
+      scope.query_from_cache_value.should == true
+    end
+    
+    it "should be able to expire a cache entry" do
+      key = ActiveRecordCache::Tester.record_cache.cache_key(1)
+      Rails.cache.write(key, "boo")
+      Rails.cache.read(key).should == "boo"
+      ActiveRecordCache::Tester.expire_cache_entry(1)
+      Rails.cache.exist?(key).should == false
+    end
+    
+    it "should expire an entry when a record is destroyed" do
+      key = ActiveRecordCache::Tester.record_cache.cache_key(tester_1.id)
+      Rails.cache.write(key, "boo")
+      Rails.cache.exist?(key).should == true
+      tester_1.destroy
+      Rails.cache.exist?(key).should == false
+    end
+    
+    it "should expire an entry when a record is updated" do
+      key = ActiveRecordCache::Tester.record_cache.cache_key(tester_1.id)
+      Rails.cache.write(key, "boo")
+      Rails.cache.exist?(key).should == true
+      tester_1.update_attribute(:name, "new value")
+      Rails.cache.exist?(key).should == false
+    end
+    
+    it "should inherit caching" do
+      ActiveRecordCache::SubTest.record_cache.should == ActiveRecordCache::Test.record_cache
+    end
+  end
+  
+  context "default behavior" do
+    it "should not use the cache by default" do
+      ActiveRecordCache::TesterNoCacheDefault.find(no_cache_default_tester_1.id).should == no_cache_default_tester_1
+      Rails.cache.should be_empty
+    end
+    
+    it "should use the cache if the default is set to true" do
+      ActiveRecordCache::Tester.find(tester_1.id).should == tester_1
+      Rails.cache.size.should == 1
+    end
+    
+    it "should be able to set the defaults in a block" do
+      ActiveRecordCache::Tester.record_cache.default.should == true
+      ActiveRecordCache::Test.record_cache.default.should == true
+      ActiveRecordCache::TesterNoCacheDefault.record_cache.default.should == false
+      
+      ActiveRecordCache.enable_by_default_on(ActiveRecordCache::Tester => false, "ActiveRecordCache::TesterNoCacheDefault" => true) do
+        ActiveRecordCache::Tester.record_cache.default.should == false
+        ActiveRecordCache::Test.record_cache.default.should == true
+        ActiveRecordCache::TesterNoCacheDefault.record_cache.default.should == true
+        
+        ActiveRecordCache.enable_by_default_on(ActiveRecordCache::Test => false, "ActiveRecordCache::Tester" => true) do
+          ActiveRecordCache::Tester.record_cache.default.should == true
+          ActiveRecordCache::Test.record_cache.default.should == false
+          ActiveRecordCache::TesterNoCacheDefault.record_cache.default.should == true
+        end
+        
+        ActiveRecordCache::Tester.record_cache.default.should == false
+        ActiveRecordCache::Test.record_cache.default.should == true
+        ActiveRecordCache::TesterNoCacheDefault.record_cache.default.should == true
+      end
+      
+      ActiveRecordCache::Tester.record_cache.default.should == true
+      ActiveRecordCache::Test.record_cache.default.should == true
+      ActiveRecordCache::TesterNoCacheDefault.record_cache.default.should == false
+    end
+  end
+  
+  context "caching" do
+    before :each do
+      test_1
+      test_2
+      test_3
+      subtest_1
+      subtest_2
+      tester_1
+      tester_2
+      tester_3
+      tester_4
+      no_cache_tester_1
+      no_cache_tester_2
+    end
+    
+    it "should lazy load a single record into the cache" do
+      ActiveRecordCache::Tester.find(tester_1.id).should == tester_1
+      ActiveRecordCache::Tester.connection.should_not_receive(:select)
+      ActiveRecordCache::Tester.find(tester_1.id).should == tester_1
+      ActiveRecordCache::Tester.find(tester_1.id.to_s).should == tester_1
+      ActiveRecordCache::Tester.find_by_id(tester_1.id).should == tester_1
+      ActiveRecordCache::Tester.where(:id => tester_1.id).should == [tester_1]
+      ActiveRecordCache::Tester.where("id" => tester_1.id.to_s).should == [tester_1]
+      c = ActiveRecordCache::Tester.connection
+      sql = "#{c.quote_table_name(ActiveRecordCache::Tester.table_name)}.#{c.quote_column_name('id')} = #{tester_1.id}"
+      ActiveRecordCache::Tester.where(sql).should == [tester_1]
+    end
+    
+    it "should lazy load multiple records into the cache" do
+      ActiveRecordCache::Tester.find(tester_1.id, tester_2.id).sort_by_field(:name).should == [tester_1, tester_2]
+      ActiveRecordCache::Tester.connection.should_not_receive(:select)
+      ActiveRecordCache::Tester.find(tester_1.id, tester_2.id).sort_by_field(:name).should == [tester_1, tester_2]
+      ActiveRecordCache::Tester.find_all_by_id([tester_1.id, tester_2.id]).sort_by_field(:name).should == [tester_1, tester_2]
+      ActiveRecordCache::Tester.where(:id => [tester_1.id, tester_2.id]).should == [tester_1, tester_2]
+      ActiveRecordCache::Tester.where("id" => [tester_1.id.to_s, tester_2.id.to_s]).should == [tester_1, tester_2]
+      c = ActiveRecordCache::Tester.connection
+      sql = "#{c.quote_table_name(ActiveRecordCache::Tester.table_name)}.#{c.quote_column_name('id')} IN (#{tester_1.id}, #{tester_2.id})"
+      ActiveRecordCache::Tester.where(sql).should == [tester_1, tester_2]
+    end
+    
+    it "should only load records not already in the cache from the database" do
+      ActiveRecordCache::Tester.find(tester_1.id).should == tester_1
+      key = ActiveRecordCache::Tester.record_cache.cache_key(tester_1.id)
+      first_cache_entry = Rails.cache[key]
+      ActiveRecordCache::Tester.find(tester_1.id, tester_2.id).sort_by_field(:name).should == [tester_1, tester_2]
+      Rails.cache[key].object_id.should == first_cache_entry.object_id
+      Rails.cache.size.should == 2
+    end
+    
+    it "should cache when limit is set" do
+      found = ActiveRecordCache::Tester.where(:id => [tester_1.id, tester_2.id]).limit(1).first
+      [tester_1, tester_2].should include(found)
+      Rails.cache.size.should == 2
+    end
+    
+    it "should cache when ordering is by a single column" do
+      found = ActiveRecordCache::Tester.where(:id => [tester_1.id, tester_2.id]).order(:name).should == [tester_1, tester_2]
+      Rails.cache.size.should == 2
+    end
+    
+    it "should cache when ordering is by a single column with a direction" do
+      found = ActiveRecordCache::Tester.where(:id => [tester_1.id, tester_2.id]).order("name DESC").should == [tester_2, tester_1]
+      Rails.cache.size.should == 2
+    end
+    
+    it "should cache when loading belongs_to associations" do
+      records = ActiveRecordCache::Tester.where(:id => [tester_1.id, tester_2.id, tester_3.id]).order(:name).preload(:test)
+      records.should == [tester_1, tester_2, tester_3]
+      ActiveRecordCache::Test.connection.should_not_receive(:select)
+      records.all?{|r| r.test_association_loaded? }.should == true
+      ActiveRecordCache::Test.find(tester_1.test_id).should == test_1
+      ActiveRecordCache::Test.find(tester_2.test_id).should == test_1
+      ActiveRecordCache::Test.find(tester_3.test_id).should == test_2
+    end
+    
+    it "should preload specified associations" do
+      tester_1.no_cache_testers.create(:name => "relation_1")
+      tester_1.no_cache_testers.create(:name => "relation_2")
+      record = ActiveRecordCache::Tester.find(tester_1.id)
+      record.no_cache_testers.loaded?.should == true
+    end
+    
+    it "should cache when using polymorphic tables" do
+      ActiveRecordCache::SubTest.find(subtest_1.id).should == subtest_1
+      ActiveRecordCache::SubTest.connection.should_not_receive(:select)
+      ActiveRecordCache::SubTest.where(:id => subtest_1.id).should == [subtest_1]
+    end
+    
+    it "should not cache when force loading from the database" do
+      ActiveRecordCache::Tester.from_database.where(:id => tester_1.id).should == [tester_1]
+      Rails.cache.should be_empty
+    end
+    
+    it "should not cache when there are multiple elements to a where clause hash" do
+      ActiveRecordCache::Tester.from_database.where(:id => tester_1.id, :name => "tester_1").should == [tester_1]
+      ActiveRecordCache::Tester.from_database.where(:id => tester_1.id).where(:name => "tester_1").should == [tester_1]
+      Rails.cache.should be_empty
+    end
+    
+    it "should not cache when there are mulitple clauses in a sql string where clause" do
+      c = ActiveRecordCache::Tester.connection
+      sql = "#{c.quote_table_name(ActiveRecordCache::Tester.table_name)}.#{c.quote_column_name('id')} = #{tester_1.id} AND name = 'tester_1'"
+      ActiveRecordCache::Tester.from_database.where(sql).should == [tester_1]
+      Rails.cache.should be_empty
+    end
+    
+    it "should not cache when ordering is more complex than a single column with a direction" do
+      ActiveRecordCache::Tester.where(:id => [tester_1.id, tester_2.id]).order(:name).order(:id).should == [tester_1, tester_2]
+      ActiveRecordCache::Tester.where(:id => [tester_1.id, tester_2.id]).order("name, id").should == [tester_1, tester_2]
+      Rails.cache.should be_empty
+    end
+    
+    it "should not cache with offset is set" do
+      ActiveRecordCache::Tester.where(:id => [tester_1.id, tester_2.id]).order(:name).offset(1).should == [tester_2]
+      Rails.cache.should be_empty
+    end
+    
+    it "should not cache when joins are used" do
+      ActiveRecordCache::Tester.where(:id => tester_1.id).joins(:test).should == [tester_1]
+      Rails.cache.should be_empty
+    end
+    
+    it "should not cache when select is used" do
+      ActiveRecordCache::Tester.where(:id => tester_1.id).select(:id).should == [tester_1]
+      Rails.cache.should be_empty
+    end
+    
+    it "should not cache when from is used" do
+      ActiveRecordCache::Tester.where(:id => tester_1.id).from(ActiveRecordCache::Tester.table_name).should == [tester_1]
+      Rails.cache.should be_empty
+    end
+    
+    it "should not cache when grouping is used" do
+      ActiveRecordCache::Tester.where(:id => tester_1.id).group(:name).should == [tester_1]
+      Rails.cache.should be_empty
+    end
+    
+    it "should not cache when having is used" do
+      ActiveRecordCache::Tester.where(:id => tester_1.id).group(:name).having(:name => "tester_1").should == [tester_1]
+      Rails.cache.should be_empty
+    end
+  end
+end

data/spec/defaults_handler_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe ActiveRecordCache::DefaultsHandler do
+  it "should set the defaults for classes withing a rack request" do
+    ActiveRecordCache::Tester.record_cache.default.should == true
+    ActiveRecordCache::Test.record_cache.default.should == true
+    ActiveRecordCache::TesterNoCacheDefault.record_cache.default.should == false
+    app = lambda{|env| [200, {:tester => ActiveRecordCache::Tester.record_cache.default, :test => ActiveRecordCache::Test.record_cache.default, :no_cache => ActiveRecordCache::TesterNoCacheDefault.record_cache.default}, env.inspect]}
+    handler = ActiveRecordCache::DefaultsHandler.new(app, ActiveRecordCache::Tester => false, "ActiveRecordCache::TesterNoCacheDefault" => true)
+    env = {"hello" => "world"}
+    handler.call(env).should == [200, {:tester => false, :test => true, :no_cache => true}, env.inspect]
+  end
+end