djmaze-arid_cache 1.1.0

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+root_path = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$LOAD_PATH.unshift(File.join(root_path, '/test/lib')) # add test/lib to the load path
+
+require 'bundler/setup'
+Bundler.require
+
+require 'spec/autorun'
+require 'mock_rails'
+require 'blueprint'
+
+WillPaginate.enable_activerecord
+AridCache.init_rails
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+Spec::Runner.configure do |config|
+  include ActiveRecordQueryMatchers
+  config.mock_with :mocha
+
+  config.before(:all) do
+    Sham.reset(:before_all)
+  end
+
+  config.before(:each) do
+    Sham.reset(:before_each)
+    full_example_description = "#{self.class.description} #{@method_name}"
+    RAILS_DEFAULT_LOGGER.info("\n\n#{full_example_description}\n#{'-' * (full_example_description.length)}")
+  end
+end

data/spec/support/ar_query.rb

@@ -0,0 +1,128 @@
+module ActiveRecordQueryMatchers
+
+  class ArQuery  #:nodoc:
+    cattr_accessor :executed
+
+    @@recording_queries = false
+    def self.recording_queries?
+      @@recording_queries
+    end
+
+    def initialize(expected, &block)
+      @expected = expected
+      @block = block
+    end
+
+    def matches?(given_proc)
+      @eval_block = false
+      @eval_error = nil
+      ArQuery.executed = []
+      @@recording_queries = true
+
+      given_proc.call
+
+      if @expected.is_a?(Fixnum)
+        @actual = ArQuery.executed.length
+        @matched = @actual == @expected
+      else
+        @actual = ArQuery.executed.detect { |sql| @expected === sql }
+        @matched = !@actual.nil?
+      end
+
+      eval_block if @block && @matched && !negative_expectation?
+
+    ensure
+      ArQuery.executed = nil
+      @@recording_queries = false
+      return @matched && @eval_error.nil?
+    end
+
+    def eval_block
+      @eval_block = true
+      begin
+        @block[ArQuery.executed]
+      rescue Exception => err
+        @eval_error = err
+      end
+    end
+
+    def failure_message_for_should
+      if @eval_error
+        @eval_error.message
+      elsif @expected.is_a?(Fixnum)
+        "expected #{@expected}, got #{@actual}"
+      else
+        "expected to execute a query with pattern #{@expected.inspect}, but it wasn't"
+      end
+    end
+
+    def failure_message_for_should_not
+      if @expected.is_a?(Fixnum)
+        "did not expect #{@expected}"
+      else
+        "did not expect to execute a query with pattern #{@expected.inspect}, but it was executed"
+      end
+    end
+
+    def description
+      if @expected.is_a?(Fixnum)
+        @expected == 1 ? "execute 1 query" : "execute #{@expected} queries"
+      else
+        "execute query with pattern #{@expected.inspect}"
+      end
+    end
+
+    # Copied from raise_error
+    def negative_expectation?
+      @negative_expectation ||= !caller.first(3).find { |s| s =~ /should_not/ }.nil?
+    end
+
+  end
+
+  unless defined?(IGNORED_SQL)
+    # From active_record/test/cases/helper.rb :
+    ActiveRecord::Base.connection.class.class_eval do
+      IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/]
+      def execute_with_query_record(sql, name = nil, &block)
+        if ArQuery.recording_queries?
+          ArQuery.executed << sql unless IGNORED_SQL.any? { |ignore| sql =~ ignore }
+        end
+        execute_without_query_record(sql, name, &block)
+      end
+      alias_method_chain :execute, :query_record
+    end
+  end
+
+  # :call-seq:
+  #   response.should query
+  #   response.should query(expected)
+  #   response.should query(expected) { |sql| ... }
+  #   response.should_not query
+  #   response.should_not query(expected)
+  #
+  # Accepts a Fixnum or a Regexp as argument.
+  #
+  # With no args, matches if exactly 1 query is executed.
+  # With a Fixnum arg, matches if the number of queries executed equals the given number.
+  # With a Regexp arg, matches if any query is executed with the given pattern.
+  #
+  # Pass an optional block to perform extra verifications of the queries matched.
+  # The argument of the block will receive an array of query strings that were executed.
+  #
+  # == Examples
+  #
+  #   lambda { @object.posts }.should query
+  #   lambda { @object.valid? }.should query(0)
+  #   lambda { @object.save }.should query(3)
+  #   lambda { @object.line_items }.should query(/SELECT DISTINCT/)
+  #   lambda { @object.line_items }.should query(1) { |sql| sql[0].should =~ /SELECT DISTINCT/ }
+  #
+  #   lambda { @object.posts }.should_not query
+  #   lambda { @object.valid? }.should_not query(0)
+  #   lambda { @object.save }.should_not query(3)
+  #   lambda { @object.line_items }.should_not query(/SELECT DISTINCT/)
+  #
+  def query(expected = 1, &block)
+    ArQuery.new(expected, &block)
+  end
+end

data/spec/support/custom_methods.rb

@@ -0,0 +1,7 @@
+class String
+  
+  def json_to_hash
+    HashWithIndifferentAccess.new JSON.parse(self)
+  end
+  
+end

data/spec/support/matchers.rb

@@ -0,0 +1,33 @@
+Spec::Matchers.define :include_keys do |*expected|
+  
+  match do |actual|
+    check_all_present(actual, expected) == []
+  end
+
+  failure_message_for_should do |actual|
+    "expected key #{check_all_present(actual, expected).first} but did not see it in #{actual.keys.map(&:to_sym)}"
+   end
+
+   def check_all_present actual, expected
+     keys_we_have = actual.keys.map(&:to_sym)
+     expected = [expected] unless expected.is_a?(Array)
+     remainder = expected.map(&:to_sym) - keys_we_have
+   end
+end
+
+Spec::Matchers.define :match_object do |object, *expected_matching_keys|
+
+  match do |actual|
+    check_specified_keys_match(actual, object, expected_matching_keys) == []
+  end
+
+  failure_message_for_should do |actual|
+    offending_key = check_specified_keys_match(actual, object, expected_matching_keys).first
+    "expected match for #{offending_key} but it did not. Expected: #{object.send(offending_key).inspect} but got #{actual[offending_key].inspect}"
+  end
+
+  def check_specified_keys_match actual, object, expected_matches
+    expected_matches = [expected_matches] unless expected_matches.is_a?(Array)
+    expected_matches.map(&:to_sym).map { |key| key unless (object.send(key) == actual[key]) }.compact
+  end
+end

data/test/arid_cache_test.rb

@@ -0,0 +1,414 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class AridCacheTest < ActiveSupport::TestCase
+  def setup
+    FileUtils.rm_r(Rails.cache.cache_path) if File.exists?(Rails.cache.cache_path)
+    @user = User.first
+  end
+
+  test "initializes needed objects" do
+    assert_instance_of AridCache::Store, AridCache.store
+    assert_same AridCache::CacheProxy, AridCache.cache
+  end
+
+  test "should respond to methods" do
+    assert User.respond_to?(:clear_caches)
+    assert @user.respond_to?(:clear_caches)
+    assert_instance_of AridCache::Store, AridCache.store
+    assert_same AridCache::CacheProxy, AridCache.cache
+  end
+
+  test "should not clobber model methods" do
+    assert_respond_to @user, :name
+    assert_respond_to Company.first, :name
+    assert_nothing_raised { @user.name }
+    assert_nothing_raised { Company.first.name }
+  end
+
+  test "should not clobber method_missing" do
+    assert_nothing_raised { @user.is_high? }
+    assert @user.is_high?
+  end
+
+  test "should not clobber respond_to?" do
+    assert @user.respond_to?(:respond_not_overridden)
+  end
+
+  test "should raise an error on invalid dynamic caches" do
+    assert_raises ArgumentError do
+      @user.cached_invalid_companies
+    end
+  end
+
+  test "should create dynamic caches given valid arguments" do
+    assert_nothing_raised { @user.cached_companies }
+  end
+
+  test "counts queries correctly" do
+    assert_queries(1) { User.all }
+  end
+
+  test "returns valid results" do
+    @one = @user.cached_companies
+    assert_equal @user.companies, @one
+    assert_equal @user.companies.count, @one.size
+  end
+
+  test "paginates results" do
+    results = @user.cached_companies(:page => 1, :per_page => 3, :order => 'name desc')
+    assert_kind_of WillPaginate::Collection, results
+    assert_equal 3, results.size
+    assert_equal @user.companies.count, results.total_entries
+    assert_equal 1, results.current_page
+  end
+
+  test "should work for different pages" do
+    results = @user.cached_companies(:page => 2, :per_page => 3)
+    assert_kind_of WillPaginate::Collection, results
+    assert results.size <= 3
+    assert_equal @user.companies.count, results.total_entries
+    assert_equal 2, results.current_page
+  end
+
+  test "ignores random parameters" do
+    result = @user.cached_companies(:invalid => :params, 'random' => 'values', :user_id => 3)
+    assert_equal @user.companies, result
+  end
+
+  test "passes on options to find" do
+    actual = @user.cached_companies(:order => 'users.id DESC', :include => [:owner])
+    expected = @user.companies
+    assert_equal expected, actual
+    assert_equal expected.first, actual.first
+  end
+
+  test "caches the count when it gets records" do
+    assert_queries(1) do
+      @user.cached_companies
+      @user.cached_companies_count
+    end
+  end
+
+  test "gets the count only if it's requested first" do
+    count = @user.companies.count
+    assert_queries(1) do
+      assert_equal count, @user.cached_companies_count
+      assert_equal count, @user.cached_companies_count
+    end
+    assert_queries(1) do
+      assert_equal count, @user.cached_companies.size
+      assert_equal count, @user.cached_companies_count
+    end
+  end
+
+  test "applies limit and offset" do
+    result = @user.cached_limit_companies do
+      companies
+    end
+    limit_two_result = @user.cached_limit_companies(:limit => 2)
+    assert_equal 2, limit_two_result.size
+    assert_equal result[0, 2], limit_two_result
+
+    limit_three_result = @user.cached_limit_companies(:limit => 3)
+    assert_equal 3, limit_three_result.size
+    assert_equal result[0, 3], limit_three_result
+
+    limit_two_offset_one_result = @user.cached_limit_companies(:limit => 2, :offset => 1)
+    assert_equal 2, limit_two_offset_one_result.size
+    assert_equal result[1, 2], limit_two_offset_one_result
+
+    offset_one_result = @user.cached_limit_companies(:offset => 1)
+    assert_equal result.size-1, offset_one_result.size
+    assert_equal result[1, result.size], offset_one_result
+
+    assert_equal @user.companies.all(:limit => 2, :offset => 1), @user.cached_limit_companies(:limit => 2, :offset => 1)
+    assert_equal @user.companies.size, @user.cached_limit_companies.size
+
+    # Careful of this Rails bug: https://rails.lighthouseapp.com/projects/8994/tickets/1349-named-scope-with-group-by-bug
+    User.cached_successful_limit_companies do
+      User.successful.all
+    end
+    assert_equal 2, User.cached_successful_limit_companies(:limit => 2).size
+    assert_equal 3, User.cached_successful_limit_companies(:limit => 3).size
+    assert_equal User.successful.all(:limit => 2, :offset => 1), User.cached_successful_limit_companies(:limit => 2, :offset => 1)
+    assert_equal User.successful.all.size, User.cached_successful_limit_companies.size
+  end
+
+  test "should requery the database for limits with order" do
+    @user.cached_companies # prime the cache
+    assert_equal @user.companies.find(:all, :limit => 3, :order => 'name DESC'), @user.cached_companies(:limit => 3, :order => 'name DESC')
+    assert_equal @user.companies.find(:all, :limit => 3, :order => 'name ASC'), @user.cached_companies(:limit => 3, :order => 'name ASC')
+  end
+
+  test "should activate will paginate" do
+    assert_nothing_raised do
+      User.paginate(:page => 1)
+    end
+  end
+
+  test "should requery the database for paginate with order" do
+    @user.cached_companies # prime the cache
+    assert_equal @user.companies.paginate(:page => 1, :per_page => 3, :order => 'name DESC'), @user.cached_companies(:page => 1, :per_page => 3, :order => 'name DESC')
+    assert_equal @user.companies.paginate(:page => 1, :per_page => 3, :order => 'name ASC'), @user.cached_companies(:page => 1, :per_page => 3, :order => 'name ASC')
+  end
+
+  test "pagination should not result in an extra query" do
+    assert_queries(1) do
+      @user.cached_big_companies(:page => 1)
+    end
+    assert_queries(1) do
+      User.cached_companies(:page => 1)
+    end
+  end
+
+  test "should support a 'force' option" do
+    # ActiveRecord caches the result of the proc, so we need to
+    # use different instances of the user to test the force option.
+    uncached_user = User.first
+    companies = @user.companies
+    size = companies.size
+    assert_queries(1) do
+      assert_equal companies, @user.cached_companies
+      assert_equal size, @user.cached_companies_count
+      assert_equal size, uncached_user.cached_companies_count
+    end
+    assert_queries(2) do
+      assert_equal companies, uncached_user.cached_companies(:force => true)
+      assert_equal size, uncached_user.cached_companies_count(:force => true)
+    end
+  end
+
+  test "should handle various different model instances" do
+    one = User.first
+    two = User.first :offset => 1
+    assert_not_same one, two
+    assert_equal one.companies, one.cached_companies
+    assert_equal two.companies, two.cached_companies
+  end
+
+  test "should handle arrays of non-active record instances" do
+    assert_equal @user.pet_names, @user.cached_pet_names
+    assert_equal @user.pet_names, @user.cached_pet_names
+    assert_equal @user.pet_names.count, @user.cached_pet_names_count
+  end
+
+  test "should empty the Rails cache" do
+    @user.cached_companies
+    User.cached_companies
+    assert Rails.cache.exist?(@user.arid_cache_key('companies'))
+    assert Rails.cache.exist?(User.arid_cache_key('companies'))
+    User.clear_caches
+    assert !Rails.cache.exist?(@user.arid_cache_key('companies'))
+    assert !Rails.cache.exist?(User.arid_cache_key('companies'))
+  end
+
+  test "should support expiring caches" do
+    # The first query should put the count in the cache.  The second query
+    # should read the count from the cache.  The third query should
+    # reload the cache.
+    assert_queries(2) do
+      User.cached_companies_count(:expires_in => 1.second)
+      User.cached_companies_count(:expires_in => 1.second)
+      sleep(1)
+      User.cached_companies_count(:expires_in => 1.second)
+    end
+  end
+
+  test "should support an auto-expire option" do
+    assert_match %r[users/#{@user.id}-companies], @user.arid_cache_key('companies')
+    assert_equal @user.arid_cache_key('companies'), @user.arid_cache_key('companies', :auto_expire => false)
+    assert_match %r[users/#{@user.id}-\d{14}-companies], @user.arid_cache_key('companies', :auto_expire => true)
+
+    # It doesn't apply to class caches, but shouldn't affect it either
+    assert_equal User.arid_cache_key('companies'), User.arid_cache_key('companies', :auto_expire => true)
+  end
+
+  test "should turn off auto-expire by default" do
+    assert_queries(2) do
+      @user.cached_companies_count
+      @user.touch
+      @user.cached_companies_count
+    end
+  end
+
+  test "should reload auto-expired caches" do
+    assert_queries(2) do
+      @user.cached_companies_count(:auto_expire => true)
+      @user.cached_companies_count(:auto_expire => true)
+      @user.updated_at = Time.now + 1.seconds
+      @user.cached_companies_count(:auto_expire => true)
+      @user.cached_companies_count(:auto_expire => true)
+    end
+  end
+
+  test "should support configuring instance caches" do
+    User.instance_caches { best_companies { companies } }
+    assert_equal @user.companies, @user.cached_best_companies
+  end
+
+  test "instance caches should work on all instances of the class" do
+    User.instance_caches { best_companies { companies } }
+    assert_equal @user.cached_best_companies, User.first.cached_best_companies
+  end
+
+  test "should support configuring class caches" do
+    User.class_caches { successful_users { successful } }
+    assert_equal User.successful, User.cached_successful_users
+  end
+
+  test "should create valid store keys" do
+    assert_equal 'user-key', AridCache.store.send(:class_store_key, User, 'key')
+    assert_equal 'users-key', AridCache.store.send(:instance_store_key, User, 'key')
+    assert_equal AridCache.store.send(:instance_store_key, User, 'key'), AridCache.store.send(:object_store_key, @user, 'key')
+    assert_equal AridCache.store.send(:class_store_key, User, 'key'), AridCache.store.send(:object_store_key, User, 'key')
+  end
+
+  test "configuring caches should not perform any queries" do
+    User.instance_caches do
+      best_companies { companies }
+    end
+    User.class_caches do
+      best_companies(:order => 'name DESC') { companies.find(:all, :order => 'name DESC') }
+    end
+  end
+
+  test "should support options in the cache configuration" do
+    User.instance_caches(:auto_expire => true) do
+      expires_in = 1.second
+      best_companies(:expires_in => expires_in) { companies }
+    end
+    assert_queries(2) do
+      @user.cached_best_companies_count
+      @user.updated_at = Time.now + 1.seconds
+      @user.cached_best_companies_count
+      @user.cached_best_companies_count
+    end
+    User.class_caches do
+      most_successful(:order => 'name DESC') { successful.find(:all, :order => 'name DESC') }
+    end
+    # Call it twice to ensure that on the second call the order is applied when retrieving the
+    # records by id
+    assert_equal User.successful.find(:all, :order => 'name DESC'), User.cached_most_successful
+    assert_equal User.successful.find(:all, :order => 'name DESC'), User.cached_most_successful
+  end
+
+  test "should not raise an error if all cached ids cannot be found" do
+    @user.cached_companies
+    key = @user.arid_cache_key('companies')
+    cached_result = Rails.cache.read(key)
+    cached_result.ids.push(24342234, 243234132)
+    Rails.cache.write(key, cached_result)
+    assert_nothing_raised { @user.cached_companies }
+    assert_equal @user.cached_companies, @user.companies
+  end
+
+  test "should not raise an error if all cached ids cannot be found while paginating" do
+    @user.cached_companies
+    key = @user.arid_cache_key('companies')
+    cached_result = Rails.cache.read(key)
+    cached_result.ids.push(24342234, 243234132)
+    Rails.cache.write(key, cached_result)
+    assert_nothing_raised { @user.cached_companies(:page => 1, :order => 'name DESC') }
+    assert_equal @user.cached_companies(:page => 1, :order => 'name DESC'), @user.companies.paginate(:page => 1, :order => 'name DESC')
+  end
+
+  test "should handle empty collections" do
+    @user.cached_empty_collection { [] }
+    assert_nothing_raised { @user.cached_empty_collection }
+    assert_nothing_raised { @user.cached_empty_collection }
+  end
+
+  test "should return proper paginate results when we include order" do
+    total = @user.companies.count
+    assert_queries(2) do
+      @user.cached_companies
+      page = @user.cached_companies(:page => 2, :per_page => 3, :order => 'name desc') # call again to get cached results
+      assert_equal total,          page.total_entries
+      assert_equal 2,              page.current_page
+      assert_equal (total/3.0).ceil, page.total_pages
+    end
+  end
+
+  test "should support calling store methods directly with a block" do
+    assert_nothing_raised do
+      AridCache.cache.new(@user, 'my-fancy-key') do
+        companies
+      end.fetch
+    end
+    assert_equal @user.companies.all(:order => 'name DESC'), AridCache.cache.new(@user, 'my-fancy-key', :order => 'name DESC') { companies }.fetch
+  end
+
+  test "empty user relation should be empty" do
+    assert_equal [], @user.empty_user_relations
+  end
+
+  test "should not query the database for ids when the list is empty" do
+    assert_queries(1) do
+      @user.cached_empty_user_relations
+      result = @user.cached_empty_user_relations
+      assert_kind_of Array, result
+    end
+  end
+
+  test "should not query the database for ids when the list is empty and we are paginating" do
+    assert_queries(1) do
+      @user.cached_empty_user_relations(:page => 1)
+      result = @user.cached_empty_user_relations(:page => 1)
+      assert_kind_of WillPaginate::Collection, result
+    end
+  end
+
+  test "should not query the database for ids when the list is empty and we are applying limits etc" do
+    assert_queries(1) do
+      @user.cached_empty_user_relations(:limit => 10)
+      result = @user.cached_empty_user_relations(:limit => 10)
+      assert_kind_of Array, result
+    end
+  end
+
+  test "should identify the MySQL2 adapter as a MySQL database" do
+    original_adapter_name = ::ActiveRecord::Base.connection.adapter_name
+    ::ActiveRecord::Base.connection.instance_eval { def adapter_name; "Mysql2"; end }
+    assert_equal "Mysql2", ::ActiveRecord::Base.connection.adapter_name
+    assert_equal true, ::ActiveRecord::Base.is_mysql_adapter?
+
+    # Restore it otherwise the other tests break
+    ::ActiveRecord::Base.connection.instance_eval { def adapter_name; "SQLite3"; end }
+    assert_equal "SQLite3", ::ActiveRecord::Base.connection.adapter_name
+    ::ActiveRecord::Base.is_mysql_adapter = nil
+    assert_equal false, ::ActiveRecord::Base.is_mysql_adapter?
+  end
+
+  #
+  # Tests requiring manual verification by looking at the SQL logs.
+  # TODO move these to a separate class.
+  #
+
+  test "should preserve original ordering" do
+    # TODO.  This one is hard to test because SQL usually keeps the same ordering
+    # and it's difficult to make it do otherwise.  Best to just inspect the queries
+    # in the log.
+    @user.cached_companies
+    @user.cached_companies
+  end
+
+  test "should paginate collections in memory" do
+    # TODO.  Tough to test because we can't just count queries
+    # have to look at the SQL in the logs for this one.
+    @user.cached_companies(:page => 2, :per_page => 3)
+    @user.cached_companies(:page => 1, :per_page => 3)
+  end
+
+  protected
+
+    def assert_queries(num = 1)
+      $query_count = 0
+      yield
+    ensure
+      assert_equal num, $query_count, "#{$query_count} instead of #{num} queries were executed."
+    end
+
+    def assert_no_queries(&block)
+      assert_queries(0, &block)
+    end
+end