ibm_db 3.0.4 → 5.0.4

data/test/cases/query_cache_test.rb

@@ -14,9 +14,9 @@ class QueryCacheTest < ActiveRecord::TestCase
   end
 
   def test_exceptional_middleware_clears_and_disables_cache_on_error
-    assert !ActiveRecord::Base.connection.query_cache_enabled, 'cache off'
+    assert_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
@@ -24,25 +24,98 @@ 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_cache :off
   end
 
-  def test_exceptional_middleware_leaves_enabled_cache_alone
-    ActiveRecord::Base.connection.enable_query_cache!
+  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
 
-    mw = ActiveRecord::QueryCache.new lambda { |env|
-      raise "lol borked"
-    }
-    assert_raises(RuntimeError) { mw.call({}) }
+    yield
+  ensure
+    ActiveRecord::Base.connection_handler.send(:owner_to_pool)["primary"] = old_pool
+  end
 
-    assert ActiveRecord::Base.connection.query_cache_enabled, 'cache on'
+  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
+
+        ActiveRecord::Base.connection_pool.connections.each do |conn|
+          assert_cache :off, conn
+        end
+
+        assert !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
+
+          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.clear_all_connections!
+      end
+    end
   end
 
   def test_exceptional_middleware_assigns_original_connection_id_on_error
     connection_id = ActiveRecord::Base.connection_id
 
-    mw = ActiveRecord::QueryCache.new lambda { |env|
+    mw = middleware { |env|
       ActiveRecord::Base.connection_id = self.object_id
       raise "lol borked"
     }
@@ -53,7 +126,7 @@ class QueryCacheTest < ActiveRecord::TestCase
 
   def test_middleware_delegates
     called = false
-    mw = ActiveRecord::QueryCache.new lambda { |env|
+    mw = middleware { |env|
       called = true
       [200, {}, nil]
     }
@@ -62,7 +135,7 @@ class QueryCacheTest < ActiveRecord::TestCase
   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 +145,15 @@ class QueryCacheTest < ActiveRecord::TestCase
   end
 
   def test_cache_enabled_during_call
-    assert !ActiveRecord::Base.connection.query_cache_enabled, 'cache off'
+    assert_cache :off
 
-    mw = ActiveRecord::QueryCache.new lambda { |env|
-      assert ActiveRecord::Base.connection.query_cache_enabled, 'cache on'
+    mw = middleware { |env|
+      assert_cache :clean
       [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
@@ -181,19 +217,14 @@ 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)
+      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")
-      else        		
-		if current_adapter?(:DB2Adapter)
-			assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-		else
-			assert_instance_of Fixnum, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-		end
+        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
     end
   end
@@ -217,6 +248,26 @@ class QueryCacheTest < ActiveRecord::TestCase
     ActiveRecord::Base.configurations = conf
   end
 
+  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?
+
+      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
+      end
+    end
+  end
+
   def test_query_cache_doesnt_leak_cached_results_of_rolled_back_queries
     ActiveRecord::Base.connection.enable_query_cache!
     post = Post.first
@@ -248,6 +299,70 @@ class QueryCacheTest < ActiveRecord::TestCase
       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
+
+      middleware {
+        refute ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in setup"
+      }.call({})
+
+      refute ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in cleanup"
+    end
+  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
+
+      middleware {
+        assert ActiveRecord::Base.connection.query_cache_enabled, "QueryCache did not get lazily enabled"
+      }.call({})
+    end
+  end
+
+  def test_query_caching_is_local_to_the_current_thread
+    with_temporary_connection_pool do
+      ActiveRecord::Base.clear_active_connections!
+
+      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({})
+
+    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
+
+    def assert_cache(state, connection = ActiveRecord::Base.connection)
+      case state
+      when :off
+        assert !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"
+      else
+        raise "unknown state"
+      end
+    end
 end
 
 class QueryCacheExpiryTest < ActiveRecord::TestCase
@@ -266,61 +381,66 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
   end
 
   def test_find
-    Task.connection.expects(:clear_query_cache).times(1)
+    assert_called(Task.connection, :clear_query_cache) do
+      assert !Task.connection.query_cache_enabled
+      Task.cache do
+        assert Task.connection.query_cache_enabled
+        Task.find(1)
 
-    assert !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
+          Task.find(1)
+        end
 
-      Task.uncached do
-        assert !Task.connection.query_cache_enabled
-        Task.find(1)
+        assert Task.connection.query_cache_enabled
       end
-
-      assert Task.connection.query_cache_enabled
+      assert !Task.connection.query_cache_enabled
     end
-    assert !Task.connection.query_cache_enabled
   end
 
   def test_update
-    Task.connection.expects(:clear_query_cache).times(2)
-    Task.cache do
-      task = Task.find(1)
-      task.starting = Time.now.utc
-      task.save!
+    assert_called(Task.connection, :clear_query_cache, times: 2) do
+      Task.cache do
+        task = Task.find(1)
+        task.starting = Time.now.utc
+        task.save!
+      end
     end
   end
 
   def test_destroy
-    Task.connection.expects(:clear_query_cache).times(2)
-    Task.cache do
-      Task.find(1).destroy
+    assert_called(Task.connection, :clear_query_cache, times: 2) do
+      Task.cache do
+        Task.find(1).destroy
+      end
     end
   end
 
   def test_insert
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-    Task.cache do
-      Task.create!
+    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
+      Task.cache do
+        Task.create!
+      end
     end
   end
 
   def test_cache_is_expired_by_habtm_update
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-    ActiveRecord::Base.cache do
-      c = Category.first
-      p = Post.first
-      p.categories << c
+    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
+      ActiveRecord::Base.cache do
+        c = Category.first
+        p = Post.first
+        p.categories << c
+      end
     end
   end
 
   def test_cache_is_expired_by_habtm_delete
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-    ActiveRecord::Base.cache do
-      p = Post.find(1)
-      assert p.categories.any?
-      p.categories.delete_all
+    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
+      ActiveRecord::Base.cache do
+        p = Post.find(1)
+        assert p.categories.any?
+        p.categories.delete_all
+      end
     end
   end
 end

data/test/cases/quoting_test.rb

@@ -44,30 +44,63 @@ module ActiveRecord
         assert_equal t.to_s(:db), @quoter.quoted_date(t)
       end
 
-      def test_quoted_time_utc
+      def test_quoted_timestamp_utc
         with_timezone_config default: :utc do
-          t = Time.now
+          t = Time.now.change(usec: 0)
           assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
         end
       end
 
-      def test_quoted_time_local
+      def test_quoted_timestamp_local
         with_timezone_config default: :local do
-          t = Time.now
+          t = Time.now.change(usec: 0)
           assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
         end
       end
 
-      def test_quoted_time_crazy
+      def test_quoted_timestamp_crazy
         with_timezone_config default: :asdfasdf do
-          t = Time.now
+          t = Time.now.change(usec: 0)
           assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
         end
       end
 
+      def test_quoted_time_utc
+        with_timezone_config default: :utc do
+          t = Time.now.change(usec: 0)
+
+          expected = t.getutc.change(year: 2000, month: 1, day: 1)
+          expected = expected.to_s(:db).sub("2000-01-01 ", "")
+
+          assert_equal expected, @quoter.quoted_time(t)
+        end
+      end
+
+      def test_quoted_time_local
+        with_timezone_config default: :local do
+          t = Time.now.change(usec: 0)
+
+          expected = t.change(year: 2000, month: 1, day: 1)
+          expected = expected.getlocal.to_s(:db).sub("2000-01-01 ", "")
+
+          assert_equal expected, @quoter.quoted_time(t)
+        end
+      end
+
+      def test_quoted_time_crazy
+        with_timezone_config default: :asdfasdf do
+          t = Time.now.change(usec: 0)
+
+          expected = t.change(year: 2000, month: 1, day: 1)
+          expected = expected.getlocal.to_s(:db).sub("2000-01-01 ", "")
+
+          assert_equal expected, @quoter.quoted_time(t)
+        end
+      end
+
       def test_quoted_datetime_utc
         with_timezone_config default: :utc do
-          t = DateTime.now
+          t = Time.now.change(usec: 0).to_datetime
           assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
         end
       end
@@ -76,7 +109,7 @@ module ActiveRecord
       # DateTime doesn't define getlocal, so make sure it does nothing
       def test_quoted_datetime_local
         with_timezone_config default: :local do
-          t = DateTime.now
+          t = Time.now.change(usec: 0).to_datetime
           assert_equal t.to_s(:db), @quoter.quoted_date(t)
         end
       end
@@ -102,9 +135,9 @@ module ActiveRecord
         assert_equal float.to_s, @quoter.quote(float, nil)
       end
 
-      def test_quote_fixnum
-        fixnum = 1
-        assert_equal fixnum.to_s, @quoter.quote(fixnum, nil)
+      def test_quote_integer
+        integer = 1
+        assert_equal integer.to_s, @quoter.quote(integer, nil)
       end
 
       def test_quote_bignum
@@ -125,14 +158,11 @@ module ActiveRecord
       end
 
       def test_crazy_object
-        crazy = Class.new.new
-        expected = "'#{YAML.dump(crazy)}'"
-        assert_equal expected, @quoter.quote(crazy, nil)
-      end
-
-      def test_crazy_object_calls_quote_string
-        crazy = Class.new { def initialize; @lol = 'lo\l' end }.new
-        assert_match "lo\\\\l", @quoter.quote(crazy, nil)
+        crazy = Object.new
+        e = assert_raises(TypeError) do
+          @quoter.quote(crazy, nil)
+        end
+        assert_equal "can't quote Object", e.message
       end
 
       def test_quote_string_no_column
@@ -152,5 +182,21 @@ module ActiveRecord
         assert_equal "1800", @quoter.quote(30.minutes)
       end
     end
+
+    class QuoteBooleanTest < ActiveRecord::TestCase
+      def setup
+        @connection = ActiveRecord::Base.connection
+      end
+
+      def test_quote_returns_frozen_string
+        assert_predicate @connection.quote(true), :frozen?
+        assert_predicate @connection.quote(false), :frozen?
+      end
+
+      def test_type_cast_returns_frozen_value
+        assert_predicate @connection.type_cast(true), :frozen?
+        assert_predicate @connection.type_cast(false), :frozen?
+      end
+    end
   end
 end