active_record_cache 1.0.3

data/spec/record_cache_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe ActiveRecordCache::RecordCache do
+  let(:cache){ ActiveSupport::Cache::MemoryStore.new(:expires_in => 60) }
+  let(:record_cache){ ActiveRecordCache::RecordCache.new(ActiveRecordCache::Tester, :cache => cache, :expires_in => 120) }
+  let(:tester_1){ ActiveRecordCache::Tester.create!(:name => "tester_1") }
+  let(:tester_2){ ActiveRecordCache::Tester.create!(:name => "tester_2") }
+  let(:tester_3){ ActiveRecordCache::Tester.create!(:name => "tester_3") }
+  
+  before :each do
+    Rails.cache.clear
+    ActiveRecordCache::Tester.destroy_all
+    tester_1
+    tester_2
+    tester_3
+  end
+  
+  it "should have an underlying cache" do
+    record_cache.cache.should == cache
+  end
+  
+  it "should have an expires_in time" do
+    record_cache.expires_in.should == 120
+  end
+  
+  it "should default the expires_in time to the cache's default" do
+    record_cache = ActiveRecordCache::RecordCache.new(ActiveRecordCache::Tester, :cache => cache)
+    record_cache.expires_in.should == 60
+  end
+  
+  it "should read a single value" do
+    record_cache[tester_1.id].should == tester_1
+  end
+  
+  it "should read a single value using the read method" do
+    record_cache.read(tester_1.id).should == [tester_1]
+  end
+  
+  it "should read multiple values" do
+    record_cache.read([tester_1.id, tester_2.id]).sort_by_field(:name).should == [tester_1, tester_2]
+  end
+  
+  it "should get a cache key for a record id" do
+    record_cache.cache_key(1).should == "active_record_cache/testers/1"
+  end
+  
+  it "should expire an id from the cache" do
+    record_cache[tester_1.id]
+    cache.size.should == 1
+    record_cache.expire(tester_1.id)
+    cache.should be_empty
+  end
+end

data/spec/relation_extension_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe ActiveRecordCache::RelationExtension do
+  context "forcing database queries" do
+    let(:relation){ ActiveRecordCache::Tester.unscoped }
+
+    it "should add an attribute indicating if the relation should always be read from the database" do
+      relation.query_from_cache_value.should == nil
+      relation.from_database.query_from_cache_value.should == false
+      relation.from_cache.query_from_cache_value.should == true
+    end
+    
+    it "should merge the force database read value when merging with another relation" do
+      relation.from_database.where(:id => 1).query_from_cache_value.should == false
+      relation.where(:id => 1).from_cache.query_from_cache_value.should == true
+    end
+  end
+  
+  context "using the cache" do
+    let(:tester_1){ ActiveRecordCache::Tester.create!(:name => "tester_1") }
+    
+    before :each do
+      tester_1
+    end
+    
+    it "should not use the cache if the relation is already loaded" do
+      relation = ActiveRecordCache::Tester.where(:id => tester_1.id)
+      relation.to_a
+      relation.loaded?.should == true
+      Rails.cache.size.should == 1
+      Rails.cache.clear
+      relation.to_a
+      Rails.cache.should be_empty
+    end
+    
+    it "should not get records from the cache when the class does not support caching" do
+      relation = ActiveRecordCache::NoCacheTester.scoped
+      relation.to_a
+      Rails.cache.should be_empty
+    end
+    
+    it "should not get records from the cache when it is not a cacheable query" do
+      relation = ActiveRecordCache::Tester.where(:id => tester_1.id, :name => tester_1.name)
+      relation.to_a
+      Rails.cache.should be_empty
+    end
+    
+    it "should not get records from the cache when the query is forcing a database read" do
+      relation = ActiveRecordCache::Tester.where(:id => tester_1.id).from_database
+      relation.to_a
+      Rails.cache.should be_empty
+    end
+    
+    it "should get records from the cache when the class supports caching, it is a cacheable query, and the query is not forcing a database read" do
+      relation = ActiveRecordCache::Tester.where(:id => tester_1.id)
+      relation.to_a
+      Rails.cache.size.should == 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,118 @@
+require 'rubygems'
+require 'sqlite3'
+
+active_record_version = ENV['ACTIVE_RECORD_VERSION'] || "~>3.0.0"
+gem 'activerecord', active_record_version
+gem 'activesupport', active_record_version
+require 'active_record'
+puts "Testing against #{ActiveRecord::VERSION::STRING}"
+
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+rescue LoadError
+  # simplecov not installed
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'active_record_cache'))
+
+MY_CACHE = ActiveSupport::Cache::MemoryStore.new
+
+module Rails
+  def self.cache
+    unless defined?(@cache)
+      @cache = ActiveSupport::Cache::MemoryStore.new
+    end
+    @cache
+  end
+end
+
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+
+
+module ActiveRecordCache
+  class Tester < ActiveRecord::Base
+    include ActiveRecordCache
+    use_record_cache :preload => :no_cache_testers, :default => true
+    
+    belongs_to :test
+    has_many :no_cache_testers
+    
+    def self.create_table
+      connection.create_table(table_name) do |t|
+        t.string :name
+        t.integer :test_id
+      end
+    end
+    
+    def test_association_loaded?
+      if respond_to?(:association)
+        association(:test).loaded?
+      else
+        self.loaded_test?
+      end
+    end
+  end
+  
+  class Test < ActiveRecord::Base
+    include ActiveRecordCache
+    use_record_cache :cache => MY_CACHE, :expires_in => 30, :default => true
+    
+    def self.create_table
+      connection.create_table(table_name) do |t|
+        t.string :name
+        t.string :type
+      end
+    end
+  end
+  
+  class SubTest < Test
+  end
+  
+  class TesterNoCacheDefault < ActiveRecord::Base
+    include ActiveRecordCache
+    use_record_cache :preload => :no_cache_testers
+    
+    def self.create_table
+      connection.create_table(table_name) do |t|
+        t.string :name
+      end
+    end
+  end
+  
+  class NoCacheTester < ActiveRecord::Base
+    
+    def self.create_table
+      connection.create_table(table_name) do |t|
+        t.string :name
+        t.integer :tester_id
+      end
+    end
+  end
+  
+  # Used for testing with MemoryStore.
+  module CachePeek
+    def size
+      @data.size
+    end
+    
+    def empty?
+      size == 0
+    end
+    
+    def [](key)
+      @data[key]
+    end
+  end
+  
+  ActiveSupport::Cache::MemoryStore.send(:include, CachePeek)
+end
+
+ActiveRecordCache::Tester.create_table
+ActiveRecordCache::Test.create_table
+ActiveRecordCache::NoCacheTester.create_table
+ActiveRecordCache::TesterNoCacheDefault.create_table

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: active_record_cache
+version: !ruby/object:Gem::Version
+  version: 1.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Brian Durand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70234670478240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *70234670478240
+- !ruby/object:Gem::Dependency
+  name: tribune-sort_by_field
+  requirement: &70234670476760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70234670476760
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70234670475540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70234670475540
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70234670474060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70234670474060
+description: This gem adds a caching layer to ActiveRecord models when finding them
+  by a numeric primary key.
+email:
+- mdobrota@tribune.com
+- ddpr@tribune.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- License.txt
+- Rakefile
+- lib/active_record_cache.rb
+- lib/active_record_cache/defaults_handler.rb
+- lib/active_record_cache/record_cache.rb
+- lib/active_record_cache/relation_extension.rb
+- spec/active_record_cache_spec.rb
+- spec/defaults_handler_spec.rb
+- spec/record_cache_spec.rb
+- spec/relation_extension_spec.rb
+- spec/spec_helper.rb
+- README.rdoc
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options:
+- --line-numbers
+- --inline-source
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: This gem adds a caching layer to ActiveRecord models when finding them by
+  a numeric primary key.
+test_files: []