ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

data/test/cases/query_cache_test.rb

@@ -1,16 +1,62 @@
+# frozen_string_literal: true
+
 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, :events
+
+    def initialize
+      super
+      @logger = ::Logger.new File::NULL
+      @exception = false
+      @events = []
+    end
+
+    def exception?
+      @exception
+    end
+
+    def sql(event)
+      @events << event
+      super
+    rescue
+      @exception = true
+    end
+  end
+
+  def teardown
     Task.connection.clear_query_cache
     ActiveRecord::Base.connection.disable_query_cache!
+    super
+  end
+
+  def test_writes_should_always_clear_cache
+    assert_cache :off
+
+    mw = middleware { |env|
+      Post.first
+      query_cache = ActiveRecord::Base.connection.query_cache
+      assert_equal 1, query_cache.length, query_cache.keys
+      Post.connection.uncached do
+        # should clear the cache
+        Post.create!(title: "a new post", body: "and a body")
+      end
+      query_cache = ActiveRecord::Base.connection.query_cache
+      assert_equal 0, query_cache.length, query_cache.keys
+    }
+    mw.call({})
+
+    assert_cache :off
   end
 
   def test_exceptional_middleware_clears_and_disables_cache_on_error
@@ -19,7 +65,8 @@ class QueryCacheTest < ActiveRecord::TestCase
     mw = middleware { |env|
       Task.find 1
       Task.find 1
-      assert_equal 1, ActiveRecord::Base.connection.query_cache.length
+      query_cache = ActiveRecord::Base.connection.query_cache
+      assert_equal 1, query_cache.length, query_cache.keys
       raise "lol borked"
     }
     assert_raises(RuntimeError) { mw.call({}) }
@@ -27,101 +74,249 @@ class QueryCacheTest < ActiveRecord::TestCase
     assert_cache :off
   end
 
-  private def with_temporary_connection_pool
-    old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
-    new_pool = ActiveRecord::ConnectionAdapters::ConnectionPool.new ActiveRecord::Base.connection_pool.spec
-    ActiveRecord::Base.connection_handler.send(:owner_to_pool)["primary"] = new_pool
+  def test_query_cache_is_applied_to_legacy_connections_in_all_handlers
+    old_value = ActiveRecord::Base.legacy_connection_handling
+    ActiveRecord::Base.legacy_connection_handling = true
+
+    ActiveRecord::Base.connection_handlers = {
+      writing: ActiveRecord::Base.default_connection_handler,
+      reading: ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+    }
 
-    yield
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config)
+    end
+
+    mw = middleware { |env|
+      reading_handler = ActiveRecord::Base.connection_handlers[:reading]
+      ro_pool = reading_handler.connection_pool_list
+      ro_conn = ro_pool.first.connection
+      assert_predicate ActiveRecord::Base.connection, :query_cache_enabled
+      assert_predicate ro_conn, :query_cache_enabled
+    }
+
+    mw.call({})
   ensure
-    ActiveRecord::Base.connection_handler.send(:owner_to_pool)["primary"] = old_pool
+    clean_up_legacy_connection_handlers
+    ActiveRecord::Base.legacy_connection_handling = old_value
   end
 
-  def test_query_cache_across_threads
-    with_temporary_connection_pool do
-      begin
-        if in_memory_db?
-          # Separate connections to an in-memory database create an entirely new database,
-          # with an empty schema etc, so we just stub out this schema on the fly.
-          ActiveRecord::Base.connection_pool.with_connection do |connection|
-            connection.create_table :tasks do |t|
-              t.datetime :starting
-              t.datetime :ending
-            end
-          end
-          ActiveRecord::FixtureSet.create_fixtures(self.class.fixture_path, ["tasks"], {}, ActiveRecord::Base)
-        end
+  def test_query_cache_is_applied_to_all_connections
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config)
+    end
 
-        ActiveRecord::Base.connection_pool.connections.each do |conn|
-          assert_cache :off, conn
-        end
+    mw = middleware { |env|
+      rw_conn = ActiveRecord::Base.connection_handler.connection_pool_list(:writing).first.connection
+      assert_predicate rw_conn, :query_cache_enabled
 
-        assert !ActiveRecord::Base.connection.nil?
-        assert_cache :off
+      ro_conn = ActiveRecord::Base.connection_handler.connection_pool_list(:reading).first.connection
+      assert_predicate ActiveRecord::Base.connection, :query_cache_enabled
+      assert_predicate ro_conn, :query_cache_enabled
+    }
 
-        middleware {
-          assert_cache :clean
+    mw.call({})
+  ensure
+    clean_up_connection_handler
+  end
 
-          Task.find 1
-          assert_cache :dirty
+  if Process.respond_to?(:fork) && !in_memory_db?
+    def test_query_cache_with_multiple_handlers_and_forked_processes_legacy_handling
+      old_value = ActiveRecord::Base.legacy_connection_handling
+      ActiveRecord::Base.legacy_connection_handling = true
+      ActiveRecord::Base.connection_handlers = {
+        writing: ActiveRecord::Base.default_connection_handler,
+        reading: ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+      }
+
+      ActiveRecord::Base.connected_to(role: :reading) do
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        ActiveRecord::Base.establish_connection(db_config)
+      end
 
-          thread_1_connection = ActiveRecord::Base.connection
-          ActiveRecord::Base.clear_active_connections!
-          assert_cache :off, thread_1_connection
+      rd, wr = IO.pipe
+      rd.binmode
+      wr.binmode
 
-          started = Concurrent::Event.new
-          checked = Concurrent::Event.new
+      pid = fork {
+        rd.close
+        status = 0
 
-          thread_2_connection = nil
-          thread = Thread.new {
-            thread_2_connection = ActiveRecord::Base.connection
+        middleware { |env|
+          begin
+            assert_cache :clean
 
-            assert_equal thread_2_connection, thread_1_connection
-            assert_cache :off
+            # first request dirties cache
+            ActiveRecord::Base.connected_to(role: :reading) do
+              Post.first
+              assert_cache :dirty
+            end
 
-            middleware {
+            # should clear the cache
+            Post.create!(title: "a new post", body: "and a body")
+
+            # fails because cache is still dirty
+            ActiveRecord::Base.connected_to(role: :reading) do
               assert_cache :clean
+              Post.first
+            end
 
-              Task.find 1
-              assert_cache :dirty
+          rescue Minitest::Assertion => e
+            wr.write Marshal.dump e
+            status = 1
+          end
+        }.call({})
+
+        wr.close
+        exit!(status)
+      }
+
+      wr.close
+
+      Process.waitpid pid
+      if !$?.success?
+        raise Marshal.load(rd.read)
+      else
+        assert_predicate $?, :success?
+      end
 
-              started.set
-              checked.wait
+      rd.close
+    ensure
+      clean_up_legacy_connection_handlers
+      ActiveRecord::Base.legacy_connection_handling = old_value
+    end
+
+    def test_query_cache_with_forked_processes
+      ActiveRecord::Base.connected_to(role: :reading) do
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        ActiveRecord::Base.establish_connection(db_config)
+      end
 
-              ActiveRecord::Base.clear_active_connections!
-            }.call({})
-          }
+      rd, wr = IO.pipe
+      rd.binmode
+      wr.binmode
 
-          started.wait
+      pid = fork {
+        rd.close
+        status = 0
+
+        middleware { |env|
+          begin
+            assert_cache :clean
+
+            # first request dirties cache
+            ActiveRecord::Base.connected_to(role: :reading) do
+              Post.first
+              assert_cache :dirty
+            end
 
-          thread_1_connection = ActiveRecord::Base.connection
-          assert_not_equal thread_1_connection, thread_2_connection
-          assert_cache :dirty, thread_2_connection
-          checked.set
-          thread.join
+            # should clear the cache
+            Post.create!(title: "a new post", body: "and a body")
 
-          assert_cache :off, thread_2_connection
+            # fails because cache is still dirty
+            ActiveRecord::Base.connected_to(role: :reading) do
+              assert_cache :clean
+              Post.first
+            end
+
+          rescue Minitest::Assertion => e
+            wr.write Marshal.dump e
+            status = 1
+          end
         }.call({})
 
-        ActiveRecord::Base.connection_pool.connections.each do |conn|
-          assert_cache :off, conn
-        end
-      ensure
-        ActiveRecord::Base.clear_all_connections!
+        wr.close
+        exit!(status)
+      }
+
+      wr.close
+
+      Process.waitpid pid
+      if !$?.success?
+        raise Marshal.load(rd.read)
+      else
+        assert_predicate $?, :success?
       end
+
+      rd.close
+    ensure
+      clean_up_connection_handler
     end
   end
 
-  def test_exceptional_middleware_assigns_original_connection_id_on_error
-    connection_id = ActiveRecord::Base.connection_id
+  def test_query_cache_across_threads
+    with_temporary_connection_pool do
+      if in_memory_db?
+        # Separate connections to an in-memory database create an entirely new database,
+        # with an empty schema etc, so we just stub out this schema on the fly.
+        ActiveRecord::Base.connection_pool.with_connection do |connection|
+          connection.create_table :tasks do |t|
+            t.datetime :starting
+            t.datetime :ending
+          end
+        end
+        ActiveRecord::FixtureSet.create_fixtures(self.class.fixture_path, ["tasks"], {}, ActiveRecord::Base)
+      end
 
-    mw = middleware { |env|
-      ActiveRecord::Base.connection_id = self.object_id
-      raise "lol borked"
-    }
-    assert_raises(RuntimeError) { mw.call({}) }
+      ActiveRecord::Base.connection_pool.connections.each do |conn|
+        assert_cache :off, conn
+      end
+
+      assert_not_predicate ActiveRecord::Base.connection, :nil?
+      assert_cache :off
+
+      middleware {
+        assert_cache :clean
+
+        Task.find 1
+        assert_cache :dirty
+
+        thread_1_connection = ActiveRecord::Base.connection
+        ActiveRecord::Base.clear_active_connections!
+        assert_cache :off, thread_1_connection
+
+        started = Concurrent::Event.new
+        checked = Concurrent::Event.new
 
-    assert_equal connection_id, ActiveRecord::Base.connection_id
+        thread_2_connection = nil
+        thread = Thread.new {
+          thread_2_connection = ActiveRecord::Base.connection
+
+          assert_equal thread_2_connection, thread_1_connection
+          assert_cache :off
+
+          middleware {
+            assert_cache :clean
+
+            Task.find 1
+            assert_cache :dirty
+
+            started.set
+            checked.wait
+
+            ActiveRecord::Base.clear_active_connections!
+          }.call({})
+        }
+
+        started.wait
+
+        thread_1_connection = ActiveRecord::Base.connection
+        assert_not_equal thread_1_connection, thread_2_connection
+        assert_cache :dirty, thread_2_connection
+        checked.set
+        thread.join
+
+        assert_cache :off, thread_2_connection
+      }.call({})
+
+      ActiveRecord::Base.connection_pool.connections.each do |conn|
+        assert_cache :off, conn
+      end
+    ensure
+      ActiveRecord::Base.connection_pool.disconnect!
+    end
   end
 
   def test_middleware_delegates
@@ -131,14 +326,15 @@ class QueryCacheTest < ActiveRecord::TestCase
       [200, {}, nil]
     }
     mw.call({})
-    assert called, 'middleware should delegate'
+    assert called, "middleware should delegate"
   end
 
   def test_middleware_caches
     mw = middleware { |env|
       Task.find 1
       Task.find 1
-      assert_equal 1, ActiveRecord::Base.connection.query_cache.length
+      query_cache = ActiveRecord::Base.connection.query_cache
+      assert_equal 1, query_cache.length, query_cache.keys
       [200, {}, nil]
     }
     mw.call({})
@@ -183,7 +379,7 @@ class QueryCacheTest < ActiveRecord::TestCase
       Task.cache do
         assert_queries(2) { Task.find(1); Task.find(2) }
       end
-      assert_queries(0) { Task.find(1); Task.find(1); Task.find(2) }
+      assert_no_queries { Task.find(1); Task.find(1); Task.find(2) }
     end
   end
 
@@ -193,6 +389,52 @@ class QueryCacheTest < ActiveRecord::TestCase
     end
   end
 
+  def test_exists_queries_with_cache
+    Post.cache do
+      assert_queries(1) { Post.exists?; Post.exists? }
+    end
+  end
+
+  def test_select_all_with_cache
+    Post.cache do
+      assert_queries(1) do
+        2.times { Post.connection.select_all(Post.all) }
+      end
+    end
+  end
+
+  def test_select_one_with_cache
+    Post.cache do
+      assert_queries(1) do
+        2.times { Post.connection.select_one(Post.all) }
+      end
+    end
+  end
+
+  def test_select_value_with_cache
+    Post.cache do
+      assert_queries(1) do
+        2.times { Post.connection.select_value(Post.all) }
+      end
+    end
+  end
+
+  def test_select_values_with_cache
+    Post.cache do
+      assert_queries(1) do
+        2.times { Post.connection.select_values(Post.all) }
+      end
+    end
+  end
+
+  def test_select_rows_with_cache
+    Post.cache do
+      assert_queries(1) do
+        2.times { Post.connection.select_rows(Post.all) }
+      end
+    end
+  end
+
   def test_query_cache_dups_results_correctly
     Task.cache do
       now  = Time.now.utc
@@ -204,9 +446,55 @@ class QueryCacheTest < ActiveRecord::TestCase
     end
   end
 
+  def test_cache_notifications_can_be_overridden
+    logger = ShouldNotHaveExceptionsLogger.new
+    subscriber = ActiveSupport::Notifications.subscribe "sql.active_record", logger
+
+    connection = ActiveRecord::Base.connection.dup
+
+    def connection.cache_notification_info(sql, name, binds)
+      super.merge(neat: true)
+    end
+
+    connection.cache do
+      connection.select_all "select 1 from SYSIBM.DUAL"
+      connection.select_all "select 1 from SYSIBM.DUAL"
+    end
+
+    assert_equal true, logger.events.last.payload[:neat]
+  ensure
+    ActiveSupport::Notifications.unsubscribe subscriber
+  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_query_cache_does_not_allow_sql_key_mutation
+    subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
+      payload[:sql].downcase!
+    end
+
+    assert_raises FrozenError do
+      ActiveRecord::Base.cache do
+        assert_queries(1) { Task.find(1); Task.find(1) }
+      end
+    end
+  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
 
@@ -215,17 +503,9 @@ class QueryCacheTest < ActiveRecord::TestCase
     end
   end
 
-  def test_cache_does_not_wrap_string_results_in_arrays
+  def test_cache_does_not_wrap_results_in_arrays
     Task.cache do
-      # 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 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
+      assert_equal 2, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
     end
   end
 
@@ -250,20 +530,35 @@ class QueryCacheTest < ActiveRecord::TestCase
 
   def test_cache_is_available_when_using_a_not_connected_connection
     skip "In-Memory DB can't test for using a not connected connection" if in_memory_db?
-    with_temporary_connection_pool do
-      spec_name = Task.connection_specification_name
-      resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(ActiveRecord::Base.configurations)
-      ActiveRecord::Base.connection_handler.establish_connection(resolver.spec(:arunit, "test2"))
-      Task.connection_specification_name = "test2"
-      refute Task.connected?
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").dup
+    db_config.owner_name = "test2"
+    ActiveRecord::Base.connection_handler.establish_connection(db_config)
+    assert_not_predicate Task, :connected?
 
-      Task.cache do
-        begin
-          assert_queries(1) { Task.find(1); Task.find(1) }
-        ensure
-          ActiveRecord::Base.connection_handler.remove_connection(Task.connection_specification_name)
-          Task.connection_specification_name = spec_name
-        end
+    Task.cache do
+      assert_queries(1) { Task.find(1); Task.find(1) }
+    ensure
+      ActiveRecord::Base.connection_handler.remove_connection_pool(db_config.owner_name)
+    end
+  end
+
+  def test_query_cache_executes_new_queries_within_block
+    ActiveRecord::Base.connection.enable_query_cache!
+
+    # Warm up the cache by running the query
+    assert_queries(1) do
+      assert_equal 0, Post.where(title: "test").to_a.count
+    end
+
+    # Check that if the same query is run again, no queries are executed
+    assert_no_queries do
+      assert_equal 0, Post.where(title: "test").to_a.count
+    end
+
+    ActiveRecord::Base.connection.uncached do
+      # Check that new query is executed, avoiding the cache
+      assert_queries(1) do
+        assert_equal 0, Post.where(title: "test").to_a.count
       end
     end
   end
@@ -273,75 +568,199 @@ class QueryCacheTest < ActiveRecord::TestCase
     post = Post.first
 
     Post.transaction do
-      post.update_attributes(title: 'rollback')
-      assert_equal 1, Post.where(title: 'rollback').to_a.count
+      post.update(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(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_cache_does_not_establish_connection_if_unconnected
-    with_temporary_connection_pool do
-      ActiveRecord::Base.clear_active_connections!
-      refute ActiveRecord::Base.connection_handler.active_connections? # sanity check
+  def test_query_cached_even_when_types_are_reset
+    Task.cache do
+      # Warm the cache
+      Task.find(1)
 
-      middleware {
-        refute ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in setup"
-      }.call({})
+      # Preload the type cache again (so we don't have those queries issued during our assertions)
+      Task.connection.send(:reload_type_map)
 
-      refute ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in cleanup"
+      # Clear places where type information is cached
+      Task.reset_column_information
+      Task.initialize_find_by_cache
+      Task.define_attribute_methods
+
+      assert_no_queries do
+        Task.find(1)
+      end
     end
   end
 
+  def test_query_cache_does_not_establish_connection_if_unconnected
+    ActiveRecord::Base.clear_active_connections!
+    assert_not ActiveRecord::Base.connection_handler.active_connections? # sanity check
+
+    middleware {
+      assert_not ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in setup"
+    }.call({})
+
+    assert_not ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in cleanup"
+  end
+
   def test_query_cache_is_enabled_on_connections_established_after_middleware_runs
-    with_temporary_connection_pool do
-      ActiveRecord::Base.clear_active_connections!
-      refute ActiveRecord::Base.connection_handler.active_connections? # sanity check
+    ActiveRecord::Base.clear_active_connections!
+    assert_not ActiveRecord::Base.connection_handler.active_connections? # sanity check
 
-      middleware {
-        assert ActiveRecord::Base.connection.query_cache_enabled, "QueryCache did not get lazily enabled"
-      }.call({})
-    end
+    middleware {
+      assert_predicate ActiveRecord::Base.connection, :query_cache_enabled
+    }.call({})
+    assert_not_predicate ActiveRecord::Base.connection, :query_cache_enabled
   end
 
   def test_query_caching_is_local_to_the_current_thread
-    with_temporary_connection_pool do
-      ActiveRecord::Base.clear_active_connections!
+    ActiveRecord::Base.clear_active_connections!
 
-      middleware {
-        assert ActiveRecord::Base.connection_pool.query_cache_enabled
-        assert ActiveRecord::Base.connection.query_cache_enabled
+    middleware {
+      assert ActiveRecord::Base.connection_pool.query_cache_enabled
+      assert ActiveRecord::Base.connection.query_cache_enabled
 
-        Thread.new {
-          refute ActiveRecord::Base.connection_pool.query_cache_enabled
-          refute ActiveRecord::Base.connection.query_cache_enabled
-        }.join
-      }.call({})
+      Thread.new {
+        assert_not ActiveRecord::Base.connection_pool.query_cache_enabled
+        assert_not ActiveRecord::Base.connection.query_cache_enabled
+      }.join
+    }.call({})
+  end
+
+  def test_query_cache_is_enabled_on_all_connection_pools
+    middleware {
+      ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
+        assert pool.query_cache_enabled
+        assert pool.connection.query_cache_enabled
+      end
+    }.call({})
+  end
 
+  def test_clear_query_cache_is_called_on_all_legacy_connections
+    skip "with in memory db, reading role won't be able to see database on writing role" if in_memory_db?
+    old_value = ActiveRecord::Base.legacy_connection_handling
+    ActiveRecord::Base.legacy_connection_handling = true
+
+    ActiveRecord::Base.connection_handlers = {
+      writing: ActiveRecord::Base.default_connection_handler,
+      reading: ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+    }
+
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config)
     end
+
+    mw = middleware { |env|
+      ActiveRecord::Base.connected_to(role: :reading) do
+        @topic = Topic.first
+      end
+
+      assert @topic
+
+      ActiveRecord::Base.connected_to(role: :writing) do
+        @topic.title = "It doesn't have to be crazy at work"
+        @topic.save!
+      end
+
+      assert_equal "It doesn't have to be crazy at work", @topic.title
+
+      ActiveRecord::Base.connected_to(role: :reading) do
+        @topic = Topic.first
+        assert_equal "It doesn't have to be crazy at work", @topic.title
+      end
+    }
+
+    mw.call({})
+  ensure
+    unless in_memory_db?
+      clean_up_legacy_connection_handlers
+      ActiveRecord::Base.legacy_connection_handling = old_value
+    end
+  end
+
+  def test_clear_query_cache_is_called_on_all_connections
+    skip "with in memory db, reading role won't be able to see database on writing role" if in_memory_db?
+
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config)
+    end
+
+    mw = middleware { |env|
+      ActiveRecord::Base.connected_to(role: :reading) do
+        @topic = Topic.first
+      end
+
+      assert @topic
+
+      ActiveRecord::Base.connected_to(role: :writing) do
+        @topic.title = "It doesn't have to be crazy at work"
+        @topic.save!
+      end
+
+      assert_equal "It doesn't have to be crazy at work", @topic.title
+
+      ActiveRecord::Base.connected_to(role: :reading) do
+        @topic = Topic.first
+        assert_equal "It doesn't have to be crazy at work", @topic.title
+      end
+    }
+
+    mw.call({})
+  ensure
+    clean_up_connection_handler
+  end
+
+  test "query cache is enabled in threads with shared connection" do
+    ActiveRecord::Base.connection_pool.lock_thread = true
+
+    assert_cache :off
+
+    thread_a = Thread.new do
+      middleware { |env|
+        assert_cache :clean
+        [200, {}, nil]
+      }.call({})
+    end
+
+    thread_a.join
+
+    ActiveRecord::Base.connection_pool.lock_thread = false
   end
 
   private
+    def with_temporary_connection_pool
+      pool_config = ActiveRecord::Base.connection_handler.send(:owner_to_pool_manager).fetch("ActiveRecord::Base").get_pool_config(ActiveRecord::Base.writing_role, :default)
+      new_pool = ActiveRecord::ConnectionAdapters::ConnectionPool.new(pool_config)
+
+      pool_config.stub(:pool, new_pool) do
+        yield
+      end
+    end
+
     def middleware(&app)
       executor = Class.new(ActiveSupport::Executor)
       ActiveRecord::QueryCache.install_executor_hooks executor
@@ -351,14 +770,14 @@ class QueryCacheTest < ActiveRecord::TestCase
     def assert_cache(state, connection = ActiveRecord::Base.connection)
       case state
       when :off
-        assert !connection.query_cache_enabled, "cache should be off"
+        assert_not connection.query_cache_enabled, "cache should be off"
         assert connection.query_cache.empty?, "cache should be empty"
       when :clean
         assert connection.query_cache_enabled, "cache should be on"
         assert connection.query_cache.empty?, "cache should be empty"
       when :dirty
         assert connection.query_cache_enabled, "cache should be on"
-        assert !connection.query_cache.empty?, "cache should be dirty"
+        assert_not connection.query_cache.empty?, "cache should be dirty"
       else
         raise "unknown state"
       end
@@ -368,6 +787,10 @@ end
 class QueryCacheExpiryTest < ActiveRecord::TestCase
   fixtures :tasks, :posts, :categories, :categories_posts
 
+  def teardown
+    Task.connection.clear_query_cache
+  end
+
   def test_cache_gets_cleared_after_migration
     # warm the cache
     Post.find(1)
@@ -382,19 +805,19 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
 
   def test_find
     assert_called(Task.connection, :clear_query_cache) do
-      assert !Task.connection.query_cache_enabled
+      assert_not Task.connection.query_cache_enabled
       Task.cache do
         assert Task.connection.query_cache_enabled
         Task.find(1)
 
         Task.uncached do
-          assert !Task.connection.query_cache_enabled
+          assert_not Task.connection.query_cache_enabled
           Task.find(1)
         end
 
         assert Task.connection.query_cache_enabled
       end
-      assert !Task.connection.query_cache_enabled
+      assert_not Task.connection.query_cache_enabled
     end
   end
 
@@ -424,6 +847,40 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
     end
   end
 
+  def test_insert_all
+    skip unless supports_insert_on_duplicate_skip?
+
+    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
+      Task.cache { Task.insert({ starting: Time.now }) }
+    end
+
+    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
+      Task.cache { Task.insert_all([{ starting: Time.now }]) }
+    end
+  end
+
+  def test_insert_all_bang
+    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
+      Task.cache { Task.insert!({ starting: Time.now }) }
+    end
+
+    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
+      Task.cache { Task.insert_all!([{ starting: Time.now }]) }
+    end
+  end
+
+  def test_upsert_all
+    skip unless supports_insert_on_duplicate_update?
+
+    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
+      Task.cache { Task.upsert({ starting: Time.now }) }
+    end
+
+    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
+      Task.cache { Task.upsert_all([{ starting: Time.now }]) }
+    end
+  end
+
   def test_cache_is_expired_by_habtm_update
     assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
       ActiveRecord::Base.cache do
@@ -438,9 +895,21 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
     assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
       ActiveRecord::Base.cache do
         p = Post.find(1)
-        assert p.categories.any?
+        assert_predicate p.categories, :any?
         p.categories.delete_all
       end
     end
   end
+
+  test "threads use the same connection" do
+    @connection_1 = ActiveRecord::Base.connection.object_id
+
+    thread_a = Thread.new do
+      @connection_2 = ActiveRecord::Base.connection.object_id
+    end
+
+    thread_a.join
+
+    assert_equal @connection_1, @connection_2
+  end
 end