1 files changed, 127 insertions, 76 deletions

diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index d84653e4c9..29b2deea26 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -1,22 +1,45 @@
 require "cases/helper"
-require 'models/topic'
-require 'models/task'
-require 'models/category'
-require 'models/post'
-require 'rack'
+require "models/topic"
+require "models/task"
+require "models/category"
+require "models/post"
+require "rack"
 
 class QueryCacheTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
   fixtures :tasks, :topics, :categories, :posts, :categories_posts
 
-  teardown do
+  class ShouldNotHaveExceptionsLogger < ActiveRecord::LogSubscriber
+    attr_reader :logger
+
+    def initialize
+      super
+      @logger = ::Logger.new File::NULL
+      @exception = false
+    end
+
+    def exception?
+      @exception
+    end
+
+    def sql(event)
+      super
+    rescue
+      @exception = true
+    end
+  end
+
+  def teardown
     Task.connection.clear_query_cache
     ActiveRecord::Base.connection.disable_query_cache!
+    super
   end
 
   def test_exceptional_middleware_clears_and_disables_cache_on_error
-    assert !ActiveRecord::Base.connection.query_cache_enabled, 'cache off'
+    assert !ActiveRecord::Base.connection.query_cache_enabled, "cache off"
 
-    mw = ActiveRecord::QueryCache.new lambda { |env|
+    mw = middleware { |env|
       Task.find 1
       Task.find 1
       assert_equal 1, ActiveRecord::Base.connection.query_cache.length
@@ -25,44 +48,55 @@ class QueryCacheTest < ActiveRecord::TestCase
     assert_raises(RuntimeError) { mw.call({}) }
 
     assert_equal 0, ActiveRecord::Base.connection.query_cache.length
-    assert !ActiveRecord::Base.connection.query_cache_enabled, 'cache off'
+    assert !ActiveRecord::Base.connection.query_cache_enabled, "cache off"
   end
 
-  def test_exceptional_middleware_leaves_enabled_cache_alone
-    ActiveRecord::Base.connection.enable_query_cache!
+  def test_exceptional_middleware_cleans_up_correct_cache
+    connection = ActiveRecord::Base.connection
+    called = false
 
-    mw = ActiveRecord::QueryCache.new lambda { |env|
-      raise "lol borked"
+    mw = middleware { |env|
+      Task.find 1
+      Task.find 1
+      assert_equal 1, connection.query_cache.length
+
+      # Checkin connection early
+      ActiveRecord::Base.clear_active_connections!
+      # Make sure ActiveRecord::Base.connection doesn't checkout the same connection
+      ActiveRecord::Base.connection_pool.remove(connection)
+
+      called = true
     }
-    assert_raises(RuntimeError) { mw.call({}) }
+    mw.call({})
 
-    assert ActiveRecord::Base.connection.query_cache_enabled, 'cache on'
+    assert called
+    assert_equal 0, connection.query_cache.length
+    assert !connection.query_cache_enabled, "cache off"
   end
 
-  def test_exceptional_middleware_assigns_original_connection_id_on_error
-    connection_id = ActiveRecord::Base.connection_id
+  def test_exceptional_middleware_leaves_enabled_cache_alone
+    ActiveRecord::Base.connection.enable_query_cache!
 
-    mw = ActiveRecord::QueryCache.new lambda { |env|
-      ActiveRecord::Base.connection_id = self.object_id
+    mw = middleware { |env|
       raise "lol borked"
     }
     assert_raises(RuntimeError) { mw.call({}) }
 
-    assert_equal connection_id, ActiveRecord::Base.connection_id
+    assert ActiveRecord::Base.connection.query_cache_enabled, "cache on"
   end
 
   def test_middleware_delegates
     called = false
-    mw = ActiveRecord::QueryCache.new lambda { |env|
+    mw = middleware { |env|
       called = true
       [200, {}, nil]
     }
     mw.call({})
-    assert called, 'middleware should delegate'
+    assert called, "middleware should delegate"
   end
 
   def test_middleware_caches
-    mw = ActiveRecord::QueryCache.new lambda { |env|
+    mw = middleware { |env|
       Task.find 1
       Task.find 1
       assert_equal 1, ActiveRecord::Base.connection.query_cache.length
@@ -72,52 +106,15 @@ class QueryCacheTest < ActiveRecord::TestCase
   end
 
   def test_cache_enabled_during_call
-    assert !ActiveRecord::Base.connection.query_cache_enabled, 'cache off'
+    assert !ActiveRecord::Base.connection.query_cache_enabled, "cache off"
 
-    mw = ActiveRecord::QueryCache.new lambda { |env|
-      assert ActiveRecord::Base.connection.query_cache_enabled, 'cache on'
+    mw = middleware { |env|
+      assert ActiveRecord::Base.connection.query_cache_enabled, "cache on"
       [200, {}, nil]
     }
     mw.call({})
   end
 
-  def test_cache_on_during_body_write
-    streaming = Class.new do
-      def each
-        yield ActiveRecord::Base.connection.query_cache_enabled
-      end
-    end
-
-    mw = ActiveRecord::QueryCache.new lambda { |env|
-      [200, {}, streaming.new]
-    }
-    body = mw.call({}).last
-    body.each { |x| assert x, 'cache should be on' }
-    body.close
-    assert !ActiveRecord::Base.connection.query_cache_enabled, 'cache disabled'
-  end
-
-  def test_cache_off_after_close
-    mw = ActiveRecord::QueryCache.new lambda { |env| [200, {}, nil] }
-    body = mw.call({}).last
-
-    assert ActiveRecord::Base.connection.query_cache_enabled, 'cache enabled'
-    body.close
-    assert !ActiveRecord::Base.connection.query_cache_enabled, 'cache disabled'
-  end
-
-  def test_cache_clear_after_close
-    mw = ActiveRecord::QueryCache.new lambda { |env|
-      Post.first
-      [200, {}, nil]
-    }
-    body = mw.call({}).last
-
-    assert !ActiveRecord::Base.connection.query_cache.empty?, 'cache not empty'
-    body.close
-    assert ActiveRecord::Base.connection.query_cache.empty?, 'cache should be empty'
-  end
-
   def test_cache_passing_a_relation
     post = Post.first
     Post.cache do
@@ -168,9 +165,21 @@ class QueryCacheTest < ActiveRecord::TestCase
     end
   end
 
+  def test_cache_does_not_raise_exceptions
+    logger = ShouldNotHaveExceptionsLogger.new
+    subscriber = ActiveSupport::Notifications.subscribe "sql.active_record", logger
+
+    ActiveRecord::Base.cache do
+      assert_queries(1) { Task.find(1); Task.find(1) }
+    end
+
+    assert_not_predicate logger, :exception?
+  ensure
+    ActiveSupport::Notifications.unsubscribe subscriber
+  end
+
   def test_cache_is_flat
     Task.cache do
-      Topic.columns # don't count this query
       assert_queries(1) { Topic.find(1); Topic.find(1); }
     end
 
@@ -181,13 +190,12 @@ class QueryCacheTest < ActiveRecord::TestCase
 
   def test_cache_does_not_wrap_string_results_in_arrays
     Task.cache do
-      # Oracle adapter returns count() as Fixnum or Float
+      # Oracle adapter returns count() as Integer or Float
       if current_adapter?(:OracleAdapter)
         assert_kind_of Numeric, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
       elsif current_adapter?(:SQLite3Adapter, :Mysql2Adapter, :PostgreSQLAdapter)
         # Future versions of the sqlite3 adapter will return numeric
-        assert_instance_of Fixnum,
-         Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
+        assert_instance_of 0.class, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
       else
         assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
       end
@@ -213,37 +221,80 @@ class QueryCacheTest < ActiveRecord::TestCase
     ActiveRecord::Base.configurations = conf
   end
 
+  def test_cache_is_not_available_when_using_a_not_connected_connection
+    spec_name = Task.connection_specification_name
+    conf = ActiveRecord::Base.configurations["arunit"].merge("name" => "test2")
+    ActiveRecord::Base.connection_handler.establish_connection(conf)
+    Task.connection_specification_name = "test2"
+    refute Task.connected?
+
+    Task.cache do
+      Task.connection # warmup postgresql connection setup queries
+      assert_queries(2) { Task.find(1); Task.find(1) }
+    end
+  ensure
+    ActiveRecord::Base.connection_handler.remove_connection(Task.connection_specification_name)
+    Task.connection_specification_name = spec_name
+  end
+
   def test_query_cache_doesnt_leak_cached_results_of_rolled_back_queries
     ActiveRecord::Base.connection.enable_query_cache!
     post = Post.first
 
     Post.transaction do
-      post.update_attributes(title: 'rollback')
-      assert_equal 1, Post.where(title: 'rollback').to_a.count
+      post.update_attributes(title: "rollback")
+      assert_equal 1, Post.where(title: "rollback").to_a.count
       raise ActiveRecord::Rollback
     end
 
-    assert_equal 0, Post.where(title: 'rollback').to_a.count
+    assert_equal 0, Post.where(title: "rollback").to_a.count
 
     ActiveRecord::Base.connection.uncached do
-      assert_equal 0, Post.where(title: 'rollback').to_a.count
+      assert_equal 0, Post.where(title: "rollback").to_a.count
     end
 
     begin
       Post.transaction do
-        post.update_attributes(title: 'rollback')
-        assert_equal 1, Post.where(title: 'rollback').to_a.count
-        raise 'broken'
+        post.update_attributes(title: "rollback")
+        assert_equal 1, Post.where(title: "rollback").to_a.count
+        raise "broken"
       end
     rescue Exception
     end
 
-    assert_equal 0, Post.where(title: 'rollback').to_a.count
+    assert_equal 0, Post.where(title: "rollback").to_a.count
 
     ActiveRecord::Base.connection.uncached do
-      assert_equal 0, Post.where(title: 'rollback').to_a.count
+      assert_equal 0, Post.where(title: "rollback").to_a.count
     end
   end
+
+  def test_query_cached_even_when_types_are_reset
+    Task.cache do
+      # Warm the cache
+      Task.find(1)
+
+      Task.connection.type_map.clear
+
+      # Preload the type cache again (so we don't have those queries issued during our assertions)
+      Task.connection.send(:initialize_type_map, Task.connection.type_map)
+
+      # Clear places where type information is cached
+      Task.reset_column_information
+      Task.initialize_find_by_cache
+
+      assert_queries(0) do
+        Task.find(1)
+      end
+    end
+  end
+
+  private
+    def middleware(&app)
+      executor = Class.new(ActiveSupport::Executor)
+      ActiveRecord::QueryCache.install_executor_hooks executor
+      lambda { |env| executor.wrap { app.call(env) } }
+    end
 end
 
 class QueryCacheExpiryTest < ActiveRecord::TestCase