ibm_db 5.2.0 → 5.3.1

data/test/cases/quoting_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
@@ -8,28 +10,28 @@ module ActiveRecord
       end
 
       def test_quoted_true
-        assert_equal "'t'", @quoter.quoted_true
+        assert_equal "TRUE", @quoter.quoted_true
       end
 
       def test_quoted_false
-        assert_equal "'f'", @quoter.quoted_false
+        assert_equal "FALSE", @quoter.quoted_false
       end
 
       def test_quote_column_name
-        assert_equal "foo", @quoter.quote_column_name('foo')
+        assert_equal "foo", @quoter.quote_column_name("foo")
       end
 
       def test_quote_table_name
-        assert_equal "foo", @quoter.quote_table_name('foo')
+        assert_equal "foo", @quoter.quote_table_name("foo")
       end
 
       def test_quote_table_name_calls_quote_column_name
         @quoter.extend(Module.new {
           def quote_column_name(string)
-            'lol'
+            "lol"
           end
         })
-        assert_equal 'lol', @quoter.quote_table_name('foo')
+        assert_equal "lol", @quoter.quote_table_name("foo")
       end
 
       def test_quote_string
@@ -69,8 +71,8 @@ module ActiveRecord
         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 ", "")
+          expected = t.change(year: 2000, month: 1, day: 1)
+          expected = expected.getutc.to_s(:db).slice(11..-1)
 
           assert_equal expected, @quoter.quoted_time(t)
         end
@@ -87,6 +89,32 @@ module ActiveRecord
         end
       end
 
+      def test_quoted_time_dst_utc
+        with_env_tz "America/New_York" do
+          with_timezone_config default: :utc do
+            t = Time.new(2000, 7, 1, 0, 0, 0, "+04:30")
+
+            expected = t.change(year: 2000, month: 1, day: 1)
+            expected = expected.getutc.to_s(:db).slice(11..-1)
+
+            assert_equal expected, @quoter.quoted_time(t)
+          end
+        end
+      end
+
+      def test_quoted_time_dst_local
+        with_env_tz "America/New_York" do
+          with_timezone_config default: :local do
+            t = Time.new(2000, 7, 1, 0, 0, 0, "+04:30")
+
+            expected = t.change(year: 2000, month: 1, day: 1)
+            expected = expected.getlocal.to_s(:db).slice(11..-1)
+
+            assert_equal expected, @quoter.quoted_time(t)
+          end
+        end
+      end
+
       def test_quoted_time_crazy
         with_timezone_config default: :asdfasdf do
           t = Time.now.change(usec: 0)
@@ -114,68 +142,64 @@ module ActiveRecord
         end
       end
 
-      def test_quote_with_quoted_id
-        assert_equal 1, @quoter.quote(Struct.new(:quoted_id).new(1), nil)
-      end
-
       def test_quote_nil
-        assert_equal 'NULL', @quoter.quote(nil, nil)
+        assert_equal "NULL", @quoter.quote(nil)
       end
 
       def test_quote_true
-        assert_equal @quoter.quoted_true, @quoter.quote(true, nil)
+        assert_equal @quoter.quoted_true, @quoter.quote(true)
       end
 
       def test_quote_false
-        assert_equal @quoter.quoted_false, @quoter.quote(false, nil)
+        assert_equal @quoter.quoted_false, @quoter.quote(false)
       end
 
       def test_quote_float
         float = 1.2
-        assert_equal float.to_s, @quoter.quote(float, nil)
+        assert_equal float.to_s, @quoter.quote(float)
       end
 
       def test_quote_integer
         integer = 1
-        assert_equal integer.to_s, @quoter.quote(integer, nil)
+        assert_equal integer.to_s, @quoter.quote(integer)
       end
 
       def test_quote_bignum
         bignum = 1 << 100
-        assert_equal bignum.to_s, @quoter.quote(bignum, nil)
+        assert_equal bignum.to_s, @quoter.quote(bignum)
       end
 
       def test_quote_bigdecimal
-        bigdec = BigDecimal.new((1 << 100).to_s)
-        assert_equal bigdec.to_s('F'), @quoter.quote(bigdec, nil)
+        bigdec = BigDecimal((1 << 100).to_s)
+        assert_equal bigdec.to_s("F"), @quoter.quote(bigdec)
       end
 
       def test_dates_and_times
-        @quoter.extend(Module.new { def quoted_date(value) 'lol' end })
-        assert_equal "'lol'", @quoter.quote(Date.today, nil)
-        assert_equal "'lol'", @quoter.quote(Time.now, nil)
-        assert_equal "'lol'", @quoter.quote(DateTime.now, nil)
+        @quoter.extend(Module.new { def quoted_date(value) "lol" end })
+        assert_equal "'lol'", @quoter.quote(Date.today)
+        assert_equal "'lol'", @quoter.quote(Time.now)
+        assert_equal "'lol'", @quoter.quote(DateTime.now)
+      end
+
+      def test_quoting_classes
+        assert_equal "'Object'", @quoter.quote(Object)
       end
 
       def test_crazy_object
         crazy = Object.new
         e = assert_raises(TypeError) do
-          @quoter.quote(crazy, nil)
+          @quoter.quote(crazy)
         end
         assert_equal "can't quote Object", e.message
       end
 
       def test_quote_string_no_column
-        assert_equal "'lo\\\\l'", @quoter.quote('lo\l', nil)
+        assert_equal "'lo\\\\l'", @quoter.quote('lo\l')
       end
 
       def test_quote_as_mb_chars_no_column
         string = ActiveSupport::Multibyte::Chars.new('lo\l')
-        assert_equal "'lo\\\\l'", @quoter.quote(string, nil)
-      end
-
-      def test_string_with_crazy_column
-        assert_equal "'lo\\\\l'", @quoter.quote('lo\l')
+        assert_equal "'lo\\\\l'", @quoter.quote(string)
       end
 
       def test_quote_duration
@@ -183,6 +207,50 @@ module ActiveRecord
       end
     end
 
+    class TypeCastingTest < ActiveRecord::TestCase
+      def setup
+        @conn = ActiveRecord::Base.connection
+      end
+
+      def test_type_cast_symbol
+        assert_equal "foo", @conn.type_cast(:foo)
+      end
+
+      def test_type_cast_date
+        date = Date.today
+        if current_adapter?(:Mysql2Adapter)
+          expected = date
+        else
+          expected = @conn.quoted_date(date)
+        end
+        assert_equal expected, @conn.type_cast(date)
+      end
+
+      def test_type_cast_time
+        time = Time.now
+        if current_adapter?(:Mysql2Adapter)
+          expected = time
+        else
+          expected = @conn.quoted_date(time)
+        end
+        assert_equal expected, @conn.type_cast(time)
+      end
+
+      def test_type_cast_numeric
+        assert_equal 10, @conn.type_cast(10)
+        assert_equal 2.2, @conn.type_cast(2.2)
+      end
+
+      def test_type_cast_nil
+        assert_nil @conn.type_cast(nil)
+      end
+
+      def test_type_cast_unknown_should_raise_error
+        obj = Class.new.new
+        assert_raise(TypeError) { @conn.type_cast(obj) }
+      end
+    end
+
     class QuoteBooleanTest < ActiveRecord::TestCase
       def setup
         @connection = ActiveRecord::Base.connection
@@ -198,5 +266,38 @@ module ActiveRecord
         assert_predicate @connection.type_cast(false), :frozen?
       end
     end
+
+    if supports_datetime_with_precision?
+      class QuoteARBaseTest < ActiveRecord::TestCase
+        class DatetimePrimaryKey < ActiveRecord::Base
+        end
+
+        def setup
+          @time = ::Time.utc(2017, 2, 14, 12, 34, 56, 789999)
+          @connection = ActiveRecord::Base.connection
+          @connection.create_table :datetime_primary_keys, id: :datetime, precision: 3, force: true
+        end
+
+        def teardown
+          @connection.drop_table :datetime_primary_keys, if_exists: true
+        end
+
+        def test_quote_ar_object
+          value = DatetimePrimaryKey.new(id: @time)
+          expected = "'2017-02-14 12:34:56.789000'"
+          assert_deprecated do
+            assert_equal expected, @connection.quote(value)
+          end
+        end
+
+        def test_type_cast_ar_object
+          value = DatetimePrimaryKey.new(id: @time)
+          expected = @connection.type_cast(value.id)
+          assert_deprecated do
+            assert_equal expected, @connection.type_cast(value)
+          end
+        end
+      end
+    end
   end
 end

data/test/cases/readonly_test.rb

@@ -1,28 +1,30 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/author'
-require 'models/post'
-require 'models/comment'
-require 'models/developer'
-require 'models/computer'
-require 'models/project'
-require 'models/reader'
-require 'models/person'
-require 'models/ship'
+require "models/author"
+require "models/post"
+require "models/comment"
+require "models/developer"
+require "models/computer"
+require "models/project"
+require "models/reader"
+require "models/person"
+require "models/ship"
 
 class ReadOnlyTest < ActiveRecord::TestCase
-  fixtures :authors, :posts, :comments, :developers, :projects, :developers_projects, :people, :readers
+  fixtures :authors, :author_addresses, :posts, :comments, :developers, :projects, :developers_projects, :people, :readers
 
   def test_cant_save_readonly_record
     dev = Developer.find(1)
-    assert !dev.readonly?
+    assert_not_predicate dev, :readonly?
 
     dev.readonly!
-    assert dev.readonly?
+    assert_predicate dev, :readonly?
 
     assert_nothing_raised do
-      dev.name = 'Luscious forbidden fruit.'
-      assert !dev.save
-      dev.name = 'Forbidden.'
+      dev.name = "Luscious forbidden fruit."
+      assert_not dev.save
+      dev.name = "Forbidden."
     end
 
     e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save  }
@@ -35,74 +37,73 @@ class ReadOnlyTest < ActiveRecord::TestCase
     assert_equal "Developer is marked as readonly", e.message
   end
 
-
   def test_find_with_readonly_option
-    Developer.all.each { |d| assert !d.readonly? }
-    Developer.readonly(false).each { |d| assert !d.readonly? }
+    Developer.all.each { |d| assert_not d.readonly? }
+    Developer.readonly(false).each { |d| assert_not d.readonly? }
     Developer.readonly(true).each { |d| assert d.readonly? }
     Developer.readonly.each { |d| assert d.readonly? }
   end
 
   def test_find_with_joins_option_does_not_imply_readonly
-    Developer.joins('  ').each { |d| assert_not d.readonly? }
-    Developer.joins('  ').readonly(true).each { |d| assert d.readonly? }
+    Developer.joins("  ").each { |d| assert_not d.readonly? }
+    Developer.joins("  ").readonly(true).each { |d| assert d.readonly? }
 
-    Developer.joins(', projects').each { |d| assert_not d.readonly? }
-    Developer.joins(', projects').readonly(true).each { |d| assert d.readonly? }
+    Developer.joins(", projects").each { |d| assert_not d.readonly? }
+    Developer.joins(", projects").readonly(true).each { |d| assert d.readonly? }
   end
 
   def test_has_many_find_readonly
     post = Post.find(1)
-    assert !post.comments.empty?
-    assert !post.comments.any?(&:readonly?)
-    assert !post.comments.to_a.any?(&:readonly?)
+    assert_not_empty post.comments
+    assert_not post.comments.any?(&:readonly?)
+    assert_not post.comments.to_a.any?(&:readonly?)
     assert post.comments.readonly(true).all?(&:readonly?)
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly
     assert people = Post.find(1).people
-    assert !people.any?(&:readonly?)
+    assert_not people.any?(&:readonly?)
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_by_id
-    assert !posts(:welcome).people.find(1).readonly?
+    assert_not_predicate posts(:welcome).people.find(1), :readonly?
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_first
-    assert !posts(:welcome).people.first.readonly?
+    assert_not_predicate posts(:welcome).people.first, :readonly?
   end
 
   def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_last
-    assert !posts(:welcome).people.last.readonly?
+    assert_not_predicate posts(:welcome).people.last, :readonly?
   end
 
   def test_readonly_scoping
-    Post.where('1=1').scoping do
-      assert !Post.find(1).readonly?
-      assert Post.readonly(true).find(1).readonly?
-      assert !Post.readonly(false).find(1).readonly?
+    Post.where("1=1").scoping do
+      assert_not_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly(true).find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
 
-    Post.joins('   ').scoping do
-      assert !Post.find(1).readonly?
-      assert Post.readonly.find(1).readonly?
-      assert !Post.readonly(false).find(1).readonly?
+    Post.joins("   ").scoping do
+      assert_not_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly.find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
 
     # Oracle barfs on this because the join includes unqualified and
     # conflicting column names
     unless current_adapter?(:OracleAdapter)
-      Post.joins(', developers').scoping do
-        assert_not Post.find(1).readonly?
-        assert Post.readonly.find(1).readonly?
-        assert !Post.readonly(false).find(1).readonly?
+      Post.joins(", developers").scoping do
+        assert_not_predicate Post.find(1), :readonly?
+        assert_predicate Post.readonly.find(1), :readonly?
+        assert_not_predicate Post.readonly(false).find(1), :readonly?
       end
     end
 
     Post.readonly(true).scoping do
-      assert Post.find(1).readonly?
-      assert Post.readonly.find(1).readonly?
-      assert !Post.readonly(false).find(1).readonly?
+      assert_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly.find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
   end
 
@@ -110,10 +111,10 @@ class ReadOnlyTest < ActiveRecord::TestCase
     developer = Developer.find(1)
     project   = Post.find(1)
 
-    assert !developer.projects.all_as_method.first.readonly?
-    assert !developer.projects.all_as_scope.first.readonly?
+    assert_not_predicate developer.projects.all_as_method.first, :readonly?
+    assert_not_predicate developer.projects.all_as_scope.first, :readonly?
 
-    assert !project.comments.all_as_method.first.readonly?
-    assert !project.comments.all_as_scope.first.readonly?
+    assert_not_predicate project.comments.all_as_method.first, :readonly?
+    assert_not_predicate project.comments.all_as_scope.first, :readonly?
   end
 end

data/test/cases/reaper_test.rb

@@ -1,85 +1,199 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 module ActiveRecord
   module ConnectionAdapters
     class ReaperTest < ActiveRecord::TestCase
-      attr_reader :pool
-
-      def setup
-        super
-        @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
-      end
-
-      teardown do
-        @pool.connections.each(&:close)
-      end
-
       class FakePool
         attr_reader :reaped
+        attr_reader :flushed
 
-        def initialize
+        def initialize(discarded: false)
           @reaped = false
+          @discarded = discarded
         end
 
         def reap
           @reaped = true
         end
+
+        def flush
+          @flushed = true
+        end
+
+        def discard!
+          @discarded = true
+        end
+
+        def discarded?
+          @discarded
+        end
       end
 
       # A reaper with nil time should never reap connections
       def test_nil_time
         fp = FakePool.new
-        assert !fp.reaped
+        assert_not fp.reaped
         reaper = ConnectionPool::Reaper.new(fp, nil)
         reaper.run
-        assert !fp.reaped
+        assert_not fp.reaped
+      ensure
+        fp.discard!
       end
 
       def test_some_time
         fp = FakePool.new
-        assert !fp.reaped
+        assert_not fp.reaped
 
         reaper = ConnectionPool::Reaper.new(fp, 0.0001)
         reaper.run
-        until fp.reaped
+        until fp.flushed
           Thread.pass
         end
         assert fp.reaped
+        assert fp.flushed
+      ensure
+        fp.discard!
       end
 
       def test_pool_has_reaper
+        config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        pool_config = PoolConfig.new(ActiveRecord::Base, config)
+        pool = ConnectionPool.new(pool_config)
+
         assert pool.reaper
+      ensure
+        pool.discard!
       end
 
       def test_reaping_frequency_configuration
-        spec = ActiveRecord::Base.connection_pool.spec.dup
-        spec.config[:reaping_frequency] = 100
-        pool = ConnectionPool.new spec
-        assert_equal 100, pool.reaper.frequency
+        pool_config = duplicated_pool_config(reaping_frequency: "10.01")
+        pool = ConnectionPool.new(pool_config)
+
+        assert_equal 10.01, pool.reaper.frequency
+      ensure
+        pool.discard!
       end
 
       def test_connection_pool_starts_reaper
-        spec = ActiveRecord::Base.connection_pool.spec.dup
-        spec.config[:reaping_frequency] = '0.0001'
+        pool_config = duplicated_pool_config(reaping_frequency: "0.0001")
+        pool = ConnectionPool.new(pool_config)
+
+        conn, child = new_conn_in_thread(pool)
+
+        assert_predicate conn, :in_use?
+
+        child.terminate
+
+        wait_for_conn_idle(conn)
+        assert_not_predicate conn, :in_use?
+      ensure
+        pool.discard!
+      end
+
+      def test_reaper_works_after_pool_discard
+        pool_config = duplicated_pool_config(reaping_frequency: "0.0001")
 
-        pool = ConnectionPool.new spec
+        2.times do
+          pool = ConnectionPool.new(pool_config)
 
-        conn = nil
-        child = Thread.new do
-          conn = pool.checkout
-          Thread.stop
+          conn, child = new_conn_in_thread(pool)
+
+          assert_predicate conn, :in_use?
+
+          child.terminate
+
+          wait_for_conn_idle(conn)
+          assert_not_predicate conn, :in_use?
+
+          pool.discard!
         end
-        Thread.pass while conn.nil?
+      end
 
-        assert conn.in_use?
+      # This doesn't test the reaper directly, but we want to test the action
+      # it would take on a discarded pool
+      def test_reap_flush_on_discarded_pool
+        pool_config = duplicated_pool_config
+        pool = ConnectionPool.new(pool_config)
 
-        child.terminate
+        pool.discard!
+        pool.reap
+        pool.flush
+      end
+
+      if Process.respond_to?(:fork)
+        def test_connection_pool_starts_reaper_in_fork
+          pool_config = duplicated_pool_config(reaping_frequency: "0.0001")
+          pool = ConnectionPool.new(pool_config)
+          pool.checkout
+
+          pid = fork do
+            pool = ConnectionPool.new(pool_config)
+
+            conn, child = new_conn_in_thread(pool)
+            child.terminate
+
+            wait_for_conn_idle(conn)
+            if conn.in_use?
+              exit!(1)
+            else
+              exit!(0)
+            end
+          end
+
+          Process.waitpid(pid)
+          assert $?.success?
+        ensure
+          pool.discard!
+        end
+      end
+
+      def test_reaper_does_not_reap_discarded_connection_pools
+        discarded_pool = FakePool.new(discarded: true)
+        pool = FakePool.new
+        frequency = 0.001
 
-        while conn.in_use?
+        ConnectionPool::Reaper.new(discarded_pool, frequency).run
+        ConnectionPool::Reaper.new(pool, frequency).run
+
+        until pool.flushed
           Thread.pass
         end
-        assert !conn.in_use?
+
+        assert_not discarded_pool.reaped
+        assert pool.reaped
+      ensure
+        pool.discard!
       end
+
+      private
+        def duplicated_pool_config(merge_config_options = {})
+          old_config = ActiveRecord::Base.connection_pool.db_config.configuration_hash.merge(merge_config_options)
+          db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit", "primary", old_config.dup)
+          PoolConfig.new(ActiveRecord::Base, db_config)
+        end
+
+        def new_conn_in_thread(pool)
+          event = Concurrent::Event.new
+          conn = nil
+
+          child = Thread.new do
+            conn = pool.checkout
+            event.set
+            Thread.stop
+          end
+
+          event.wait
+          [conn, child]
+        end
+
+        def wait_for_conn_idle(conn, timeout = 5)
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          while conn.in_use? && Process.clock_gettime(Process::CLOCK_MONOTONIC) - start < timeout
+            Thread.pass
+          end
+        end
     end
   end
 end