ibm_db 3.0.4 → 5.0.4

data/test/cases/connection_adapters/connection_specification_test.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   module ConnectionAdapters
     class ConnectionSpecificationTest < ActiveRecord::TestCase
       def test_dup_deep_copy_config
-        spec = ConnectionSpecification.new({ :a => :b }, "bar")
+        spec = ConnectionSpecification.new("primary", { :a => :b }, "bar")
         assert_not_equal(spec.config.object_id, spec.dup.config.object_id)
       end
     end

data/test/cases/connection_adapters/merge_and_resolve_default_url_config_test.rb

@@ -51,34 +51,6 @@ module ActiveRecord
         assert_equal expected, actual
       end
 
-      def test_resolver_with_database_uri_and_and_current_env_string_key
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        config   = { "default_env" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = assert_deprecated { resolve_spec("default_env", config) }
-        expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
-        assert_equal expected, actual
-      end
-
-      def test_resolver_with_database_uri_and_and_current_env_string_key_and_rails_env
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        ENV['RAILS_ENV'] = "foo"
-
-        config   = { "not_production" => {"adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = assert_deprecated { resolve_spec("foo", config) }
-        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost" }
-        assert_equal expected, actual
-      end
-
-      def test_resolver_with_database_uri_and_and_current_env_string_key_and_rack_env
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        ENV['RACK_ENV'] = "foo"
-
-        config   = { "not_production" => {"adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = assert_deprecated { resolve_spec("foo", config) }
-        expected = { "adapter" => "postgresql", "database" => "foo", "host" => "localhost" }
-        assert_equal expected, actual
-      end
-
       def test_resolver_with_database_uri_and_known_key
         ENV['DATABASE_URL'] = "postgres://localhost/foo"
         config   = { "production" => { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost" } }
@@ -95,16 +67,6 @@ module ActiveRecord
         end
       end
 
-      def test_resolver_with_database_uri_and_unknown_string_key
-        ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
-        assert_deprecated do
-          assert_raises AdapterNotSpecified do
-           resolve_spec("production", config)
-          end
-        end
-      end
-
       def test_resolver_with_database_uri_and_supplied_url
         ENV['DATABASE_URL'] = "not-postgres://not-localhost/not_foo"
         config   = { "production" => {  "adapter" => "also_not_postgres", "database" => "also_not_foo" } }

data/test/cases/connection_adapters/mysql_type_lookup_test.rb

@@ -1,6 +1,6 @@
 require "cases/helper"
 
-if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+if current_adapter?(:Mysql2Adapter)
 module ActiveRecord
   module ConnectionAdapters
     class MysqlTypeLookupTest < ActiveRecord::TestCase
@@ -22,6 +22,10 @@ module ActiveRecord
         assert_lookup_type :string, "SET('one', 'two', 'three')"
       end
 
+      def test_set_type_with_value_matching_other_type
+        assert_lookup_type :string, "SET('unicode', '8bit', 'none', 'time')"
+      end
+
       def test_enum_type_with_value_matching_other_type
         assert_lookup_type :string, "ENUM('unicode', '8bit', 'none')"
       end

data/test/cases/connection_adapters/schema_cache_test.rb

@@ -29,7 +29,7 @@ module ActiveRecord
       def test_clearing
         @cache.columns('posts')
         @cache.columns_hash('posts')
-        @cache.tables('posts')
+        @cache.data_sources('posts')
         @cache.primary_keys('posts')
 
         @cache.clear!
@@ -40,17 +40,22 @@ module ActiveRecord
       def test_dump_and_load
         @cache.columns('posts')
         @cache.columns_hash('posts')
-        @cache.tables('posts')
+        @cache.data_sources('posts')
         @cache.primary_keys('posts')
 
         @cache = Marshal.load(Marshal.dump(@cache))
 
         assert_equal 11, @cache.columns('posts').size
         assert_equal 11, @cache.columns_hash('posts').size
-        assert @cache.tables('posts')
+        assert @cache.data_sources('posts')
         assert_equal 'id', @cache.primary_keys('posts')
       end
 
+      def test_table_methods_deprecation
+        assert_deprecated { assert @cache.table_exists?('posts') }
+        assert_deprecated { assert @cache.tables('posts') }
+        assert_deprecated { @cache.clear_table_cache!('posts') }
+      end
     end
   end
 end

data/test/cases/connection_adapters/type_lookup_test.rb

@@ -1,6 +1,6 @@
 require "cases/helper"
 
-unless current_adapter?(:PostgreSQLAdapter) # PostgreSQL does not use type strigns for lookup
+unless current_adapter?(:PostgreSQLAdapter) # PostgreSQL does not use type strings for lookup
 module ActiveRecord
   module ConnectionAdapters
     class TypeLookupTest < ActiveRecord::TestCase
@@ -89,12 +89,20 @@ module ActiveRecord
       end
 
       def test_decimal_without_scale
-        types = %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0) number(2) number(2,0)}
-        types.each do |type|
-          cast_type = @connection.type_map.lookup(type)
-
-          assert_equal :decimal, cast_type.type
-          assert_equal 2, cast_type.type_cast_from_user(2.1)
+        if current_adapter?(:OracleAdapter)
+          {
+            decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0)},
+            integer: %w{number(2) number(2,0)}
+          }
+        else
+          { decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0) number(2) number(2,0)} }
+        end.each do |expected_type, types|
+          types.each do |type|
+            cast_type = @connection.type_map.lookup(type)
+
+            assert_equal expected_type, cast_type.type
+            assert_equal 2, cast_type.cast(2.1)
+          end
         end
       end
 

data/test/cases/connection_management_test.rb

@@ -4,6 +4,8 @@ require "rack"
 module ActiveRecord
   module ConnectionAdapters
     class ConnectionManagementTest < ActiveRecord::TestCase
+      self.use_transactional_tests = false
+
       class App
         attr_reader :calls
         def initialize
@@ -19,48 +21,20 @@ module ActiveRecord
       def setup
         @env = {}
         @app = App.new
-        @management = ConnectionManagement.new(@app)
+        @management = middleware(@app)
 
         # make sure we have an active connection
         assert ActiveRecord::Base.connection
         assert ActiveRecord::Base.connection_handler.active_connections?
       end
 
-      if Process.respond_to?(:fork)
-        def test_connection_pool_per_pid
-          object_id = ActiveRecord::Base.connection.object_id
-
-          rd, wr = IO.pipe
-          rd.binmode
-          wr.binmode
-
-          pid = fork {
-            rd.close
-            wr.write Marshal.dump ActiveRecord::Base.connection.object_id
-            wr.close
-            exit!
-          }
-
-          wr.close
-
-          Process.waitpid pid
-          assert_not_equal object_id, Marshal.load(rd.read)
-          rd.close
-        end
-      end
-
       def test_app_delegation
-        manager = ConnectionManagement.new(@app)
+        manager = middleware(@app)
 
         manager.call @env
         assert_equal [@env], @app.calls
       end
 
-      def test_connections_are_active_after_call
-        @management.call(@env)
-        assert ActiveRecord::Base.connection_handler.active_connections?
-      end
-
       def test_body_responds_to_each
         _, _, body = @management.call(@env)
         bits = []
@@ -74,49 +48,65 @@ module ActiveRecord
         assert !ActiveRecord::Base.connection_handler.active_connections?
       end
 
-      def test_active_connections_are_not_cleared_on_body_close_during_test
-        @env['rack.test'] = true
-        _, _, body = @management.call(@env)
-        body.close
-        assert ActiveRecord::Base.connection_handler.active_connections?
+      def test_active_connections_are_not_cleared_on_body_close_during_transaction
+        ActiveRecord::Base.transaction do
+          _, _, body = @management.call(@env)
+          body.close
+          assert ActiveRecord::Base.connection_handler.active_connections?
+        end
       end
 
       def test_connections_closed_if_exception
         app       = Class.new(App) { def call(env); raise NotImplementedError; end }.new
-        explosive = ConnectionManagement.new(app)
+        explosive = middleware(app)
         assert_raises(NotImplementedError) { explosive.call(@env) }
         assert !ActiveRecord::Base.connection_handler.active_connections?
       end
 
-      def test_connections_not_closed_if_exception_and_test
-        @env['rack.test'] = true
-        app               = Class.new(App) { def call(env); raise; end }.new
-        explosive         = ConnectionManagement.new(app)
-        assert_raises(RuntimeError) { explosive.call(@env) }
-        assert ActiveRecord::Base.connection_handler.active_connections?
-      end
-
-      def test_connections_closed_if_exception_and_explicitly_not_test
-        @env['rack.test'] = false
-        app       = Class.new(App) { def call(env); raise NotImplementedError; end }.new
-        explosive = ConnectionManagement.new(app)
-        assert_raises(NotImplementedError) { explosive.call(@env) }
-        assert !ActiveRecord::Base.connection_handler.active_connections?
+      def test_connections_not_closed_if_exception_inside_transaction
+        ActiveRecord::Base.transaction do
+          app               = Class.new(App) { def call(env); raise RuntimeError; end }.new
+          explosive         = middleware(app)
+          assert_raises(RuntimeError) { explosive.call(@env) }
+          assert ActiveRecord::Base.connection_handler.active_connections?
+        end
       end
 
       test "doesn't clear active connections when running in a test case" do
-        @env['rack.test'] = true
-        @management.call(@env)
-        assert ActiveRecord::Base.connection_handler.active_connections?
+        executor.wrap do
+          @management.call(@env)
+          assert ActiveRecord::Base.connection_handler.active_connections?
+        end
       end
 
-      test "proxy is polite to it's body and responds to it" do
+      test "proxy is polite to its body and responds to it" do
         body = Class.new(String) { def to_path; "/path"; end }.new
         app = lambda { |_| [200, {}, body] }
-        response_body = ConnectionManagement.new(app).call(@env)[2]
+        response_body = middleware(app).call(@env)[2]
         assert response_body.respond_to?(:to_path)
-        assert_equal response_body.to_path, "/path"
+        assert_equal "/path", response_body.to_path
+      end
+
+      test "doesn't mutate the original response" do
+        original_response = [200, {}, 'hi']
+        app = lambda { |_| original_response }
+        middleware(app).call(@env)[2]
+        assert_equal 'hi', original_response.last
       end
+
+      private
+        def executor
+          @executor ||= Class.new(ActiveSupport::Executor).tap do |exe|
+            ActiveRecord::QueryCache.install_executor_hooks(exe)
+          end
+        end
+
+        def middleware(app)
+          lambda do |env|
+            a, b, c = executor.wrap { app.call(env) }
+            [a, b, Rack::BodyProxy.new(c) { }]
+          end
+        end
     end
   end
 end

data/test/cases/connection_pool_test.rb

@@ -1,5 +1,5 @@
 require "cases/helper"
-require 'active_support/concurrency/latch'
+require 'concurrent/atomic/count_down_latch'
 
 module ActiveRecord
   module ConnectionAdapters
@@ -100,7 +100,7 @@ module ActiveRecord
         t = Thread.new { @pool.checkout }
 
         # make sure our thread is in the timeout section
-        Thread.pass until t.status == "sleep"
+        Thread.pass until @pool.num_waiting_in_queue == 1
 
         connection = cs.first
         connection.close
@@ -112,7 +112,7 @@ module ActiveRecord
         t = Thread.new { @pool.checkout }
 
         # make sure our thread is in the timeout section
-        Thread.pass until t.status == "sleep"
+        Thread.pass until @pool.num_waiting_in_queue == 1
 
         connection = cs.first
         @pool.remove connection
@@ -133,15 +133,15 @@ module ActiveRecord
       end
 
       def test_reap_inactive
-        ready = ActiveSupport::Concurrency::Latch.new
+        ready = Concurrent::CountDownLatch.new
         @pool.checkout
         child = Thread.new do
           @pool.checkout
           @pool.checkout
-          ready.release
+          ready.count_down
           Thread.stop
         end
-        ready.await
+        ready.wait
 
         assert_equal 3, active_connections(@pool).size
 
@@ -151,7 +151,7 @@ module ActiveRecord
 
         assert_equal 1, active_connections(@pool).size
       ensure
-        @pool.connections.each(&:close)
+        @pool.connections.each { |conn| conn.close if conn.in_use? }
       end
 
       def test_remove_connection
@@ -184,14 +184,14 @@ module ActiveRecord
 
       def test_checkout_behaviour
         pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
-        connection = pool.connection
-        assert_not_nil connection
+        main_connection = pool.connection
+        assert_not_nil main_connection
         threads = []
         4.times do |i|
           threads << Thread.new(i) do
-            connection = pool.connection
-            assert_not_nil connection
-            connection.close
+            thread_connection = pool.connection
+            assert_not_nil thread_connection
+            thread_connection.close
           end
         end
 
@@ -204,13 +204,13 @@ module ActiveRecord
       end
 
       # The connection pool is "fair" if threads waiting for
-      # connections receive them the order in which they began
+      # connections receive them in the order in which they began
       # waiting.  This ensures that we don't timeout one HTTP request
       # even while well under capacity in a multi-threaded environment
       # such as a Java servlet container.
       #
       # We don't need strict fairness: if two connections become
-      # available at the same time, it's fine of two threads that were
+      # available at the same time, it's fine if two threads that were
       # waiting acquire the connections out of order.
       #
       # Thus this test prepares waiting threads and then trickles in
@@ -234,7 +234,7 @@ module ActiveRecord
               mutex.synchronize { errors << e }
             end
           }
-          Thread.pass until t.status == "sleep"
+          Thread.pass until @pool.num_waiting_in_queue == i
           t
         end
 
@@ -271,7 +271,7 @@ module ActiveRecord
               mutex.synchronize { errors << e }
             end
           }
-          Thread.pass until t.status == "sleep"
+          Thread.pass until @pool.num_waiting_in_queue == i
           t
         end
 
@@ -335,11 +335,186 @@ module ActiveRecord
       # is called with an anonymous class
       def test_anonymous_class_exception
         anonymous = Class.new(ActiveRecord::Base)
-        handler = ActiveRecord::Base.connection_handler
 
-        assert_raises(RuntimeError) {
-          handler.establish_connection anonymous, nil
-        }
+        assert_raises(RuntimeError) do
+          anonymous.establish_connection
+        end
+      end
+
+      def test_pool_sets_connection_schema_cache
+        connection = pool.checkout
+        schema_cache = SchemaCache.new connection
+        schema_cache.add(:posts)
+        pool.schema_cache = schema_cache
+
+        pool.with_connection do |conn|
+          assert_not_same pool.schema_cache, conn.schema_cache
+          assert_equal pool.schema_cache.size, conn.schema_cache.size
+          assert_same pool.schema_cache.columns(:posts), conn.schema_cache.columns(:posts)
+        end
+
+        pool.checkin connection
+      end
+
+      def test_concurrent_connection_establishment
+        assert_operator @pool.connections.size, :<=, 1
+
+        all_threads_in_new_connection = Concurrent::CountDownLatch.new(@pool.size - @pool.connections.size)
+        all_go                        = Concurrent::CountDownLatch.new
+
+        @pool.singleton_class.class_eval do
+          define_method(:new_connection) do
+            all_threads_in_new_connection.count_down
+            all_go.wait
+            super()
+          end
+        end
+
+        connecting_threads = []
+        @pool.size.times do
+          connecting_threads << Thread.new { @pool.checkout }
+        end
+
+        begin
+          Timeout.timeout(5) do
+            # the kernel of the whole test is here, everything else is just scaffolding,
+            # this latch will not be released unless conn. pool allows for concurrent
+            # connection creation
+            all_threads_in_new_connection.wait
+          end
+        rescue Timeout::Error
+          flunk 'pool unable to establish connections concurrently or implementation has ' <<
+                'changed, this test then needs to patch a different :new_connection method'
+        ensure
+          # clean up the threads
+          all_go.count_down
+          connecting_threads.map(&:join)
+        end
+      end
+
+      def test_non_bang_disconnect_and_clear_reloadable_connections_throw_exception_if_threads_dont_return_their_conns
+        @pool.checkout_timeout = 0.001 # no need to delay test suite by waiting the whole full default timeout
+        [:disconnect, :clear_reloadable_connections].each do |group_action_method|
+          @pool.with_connection do |connection|
+            assert_raises(ExclusiveConnectionTimeoutError) do
+              Thread.new { @pool.send(group_action_method) }.join
+            end
+          end
+        end
+      end
+
+      def test_disconnect_and_clear_reloadable_connections_attempt_to_wait_for_threads_to_return_their_conns
+        [:disconnect, :disconnect!, :clear_reloadable_connections, :clear_reloadable_connections!].each do |group_action_method|
+          begin
+            thread = timed_join_result = nil
+            @pool.with_connection do |connection|
+              thread = Thread.new { @pool.send(group_action_method) }
+
+              # give the other `thread` some time to get stuck in `group_action_method`
+              timed_join_result = thread.join(0.3)
+              # thread.join # => `nil` means the other thread hasn't finished running and is still waiting for us to
+              # release our connection
+              assert_nil timed_join_result
+
+              # assert that since this is within default timeout our connection hasn't been forcefully taken away from us
+              assert @pool.active_connection?
+            end
+          ensure
+            thread.join if thread && !timed_join_result # clean up the other thread
+          end
+        end
+      end
+
+      def test_bang_versions_of_disconnect_and_clear_reloadable_connections_if_unable_to_aquire_all_connections_proceed_anyway
+        @pool.checkout_timeout = 0.001 # no need to delay test suite by waiting the whole full default timeout
+        [:disconnect!, :clear_reloadable_connections!].each do |group_action_method|
+          @pool.with_connection do |connection|
+            Thread.new { @pool.send(group_action_method) }.join
+            # assert connection has been forcefully taken away from us
+            assert_not @pool.active_connection?
+
+            # make a new connection for with_connection to clean up
+            @pool.connection
+          end
+        end
+      end
+
+      def test_disconnect_and_clear_reloadable_connections_are_able_to_preempt_other_waiting_threads
+        with_single_connection_pool do |pool|
+          [:disconnect, :disconnect!, :clear_reloadable_connections, :clear_reloadable_connections!].each do |group_action_method|
+            conn               = pool.connection # drain the only available connection
+            second_thread_done = Concurrent::CountDownLatch.new
+
+            # create a first_thread and let it get into the FIFO queue first
+            first_thread = Thread.new do
+              pool.with_connection { second_thread_done.wait }
+            end
+
+            # wait for first_thread to get in queue
+            Thread.pass until pool.num_waiting_in_queue == 1
+
+            # create a different, later thread, that will attempt to do a "group action",
+            # but because of the group action semantics it should be able to preempt the
+            # first_thread when a connection is made available
+            second_thread = Thread.new do
+              pool.send(group_action_method)
+              second_thread_done.count_down
+            end
+
+            # wait for second_thread to get in queue
+            Thread.pass until pool.num_waiting_in_queue == 2
+
+            # return the only available connection
+            pool.checkin(conn)
+
+            # if the second_thread is not able to preempt the first_thread,
+            # they will temporarily (until either of them timeouts with ConnectionTimeoutError)
+            # deadlock and a join(2) timeout will be reached
+            failed = true unless second_thread.join(2)
+
+            #--- post test clean up start
+            second_thread_done.count_down if failed
+
+            first_thread.join
+            second_thread.join
+            #--- post test clean up end
+
+            flunk "#{group_action_method} is not able to preempt other waiting threads" if failed
+          end
+        end
+      end
+
+      def test_clear_reloadable_connections_creates_new_connections_for_waiting_threads_if_necessary
+        with_single_connection_pool do |pool|
+          conn = pool.connection # drain the only available connection
+          def conn.requires_reloading? # make sure it gets removed from the pool by clear_reloadable_connections
+            true
+          end
+
+          stuck_thread = Thread.new do
+            pool.with_connection {}
+          end
+
+          # wait for stuck_thread to get in queue
+          Thread.pass until pool.num_waiting_in_queue == 1
+
+          pool.clear_reloadable_connections
+
+          unless stuck_thread.join(2)
+            flunk 'clear_reloadable_connections must not let other connection waiting threads get stuck in queue'
+          end
+
+          assert_equal 0, pool.num_waiting_in_queue
+        end
+      end
+
+      private
+      def with_single_connection_pool
+        one_conn_spec = ActiveRecord::Base.connection_pool.spec.dup
+        one_conn_spec.config[:pool] = 1 # this is safe to do, because .dupped ConnectionSpecification also auto-dups its config
+        yield(pool = ConnectionPool.new(one_conn_spec))
+      ensure
+        pool.disconnect! if pool
       end
     end
   end