ibm_db 5.6.1-arm64-darwin-24

data/test/cases/quoting_test.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class QuotingTest < ActiveRecord::TestCase
+      def setup
+        @quoter = Class.new { include Quoting }.new
+      end
+
+      def test_quoted_true
+        assert_equal "TRUE", @quoter.quoted_true
+      end
+
+      def test_quoted_false
+        assert_equal "FALSE", @quoter.quoted_false
+      end
+
+      def test_quote_column_name
+        assert_equal "foo", @quoter.quote_column_name("foo")
+      end
+
+      def test_quote_table_name
+        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"
+          end
+        })
+        assert_equal "lol", @quoter.quote_table_name("foo")
+      end
+
+      def test_quote_string
+        assert_equal "''", @quoter.quote_string("'")
+        assert_equal "\\\\", @quoter.quote_string("\\")
+        assert_equal "hi''i", @quoter.quote_string("hi'i")
+        assert_equal "hi\\\\i", @quoter.quote_string("hi\\i")
+      end
+
+      def test_quoted_date
+        t = Date.today
+        assert_equal t.to_s(:db), @quoter.quoted_date(t)
+      end
+
+      def test_quoted_timestamp_utc
+        with_timezone_config default: :utc do
+          t = Time.now.change(usec: 0)
+          assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
+        end
+      end
+
+      def test_quoted_timestamp_local
+        with_timezone_config default: :local do
+          t = Time.now.change(usec: 0)
+          assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
+        end
+      end
+
+      def test_quoted_timestamp_crazy
+        with_timezone_config default: :asdfasdf do
+          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.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
+
+      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_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)
+
+          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 = Time.now.change(usec: 0).to_datetime
+          assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
+        end
+      end
+
+      ###
+      # DateTime doesn't define getlocal, so make sure it does nothing
+      def test_quoted_datetime_local
+        with_timezone_config default: :local do
+          t = Time.now.change(usec: 0).to_datetime
+          assert_equal t.to_s(:db), @quoter.quoted_date(t)
+        end
+      end
+
+      def test_quote_nil
+        assert_equal "NULL", @quoter.quote(nil)
+      end
+
+      def test_quote_true
+        assert_equal @quoter.quoted_true, @quoter.quote(true)
+      end
+
+      def test_quote_false
+        assert_equal @quoter.quoted_false, @quoter.quote(false)
+      end
+
+      def test_quote_float
+        float = 1.2
+        assert_equal float.to_s, @quoter.quote(float)
+      end
+
+      def test_quote_integer
+        integer = 1
+        assert_equal integer.to_s, @quoter.quote(integer)
+      end
+
+      def test_quote_bignum
+        bignum = 1 << 100
+        assert_equal bignum.to_s, @quoter.quote(bignum)
+      end
+
+      def test_quote_bigdecimal
+        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)
+        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)
+        end
+        assert_equal "can't quote Object", e.message
+      end
+
+      def test_quote_string_no_column
+        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)
+      end
+
+      def test_quote_duration
+        assert_equal "1800", @quoter.quote(30.minutes)
+      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
+      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
+
+    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

@@ -0,0 +1,120 @@
+# 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"
+
+class ReadOnlyTest < ActiveRecord::TestCase
+  fixtures :authors, :author_addresses, :posts, :comments, :developers, :projects, :developers_projects, :people, :readers
+
+  def test_cant_save_readonly_record
+    dev = Developer.find(1)
+    assert_not_predicate dev, :readonly?
+
+    dev.readonly!
+    assert_predicate dev, :readonly?
+
+    assert_nothing_raised do
+      dev.name = "Luscious forbidden fruit."
+      assert_not dev.save
+      dev.name = "Forbidden."
+    end
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save  }
+    assert_equal "Developer is marked as readonly", e.message
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save! }
+    assert_equal "Developer is marked as readonly", e.message
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.destroy }
+    assert_equal "Developer is marked as readonly", e.message
+  end
+
+  def test_find_with_readonly_option
+    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(", 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_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_not people.any?(&:readonly?)
+  end
+
+  def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_by_id
+    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_not_predicate posts(:welcome).people.first, :readonly?
+  end
+
+  def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_last
+    assert_not_predicate posts(:welcome).people.last, :readonly?
+  end
+
+  def test_readonly_scoping
+    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_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_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_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly.find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
+    end
+  end
+
+  def test_association_collection_method_missing_scoping_not_readonly
+    developer = Developer.find(1)
+    project   = Post.find(1)
+
+    assert_not_predicate developer.projects.all_as_method.first, :readonly?
+    assert_not_predicate developer.projects.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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ReaperTest < ActiveRecord::TestCase
+      class FakePool
+        attr_reader :reaped
+        attr_reader :flushed
+
+        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_not fp.reaped
+        reaper = ConnectionPool::Reaper.new(fp, nil)
+        reaper.run
+        assert_not fp.reaped
+      ensure
+        fp.discard!
+      end
+
+      def test_some_time
+        fp = FakePool.new
+        assert_not fp.reaped
+
+        reaper = ConnectionPool::Reaper.new(fp, 0.0001)
+        reaper.run
+        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
+        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
+        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")
+
+        2.times do
+          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?
+
+          pool.discard!
+        end
+      end
+
+      # 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)
+
+        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
+
+        ConnectionPool::Reaper.new(discarded_pool, frequency).run
+        ConnectionPool::Reaper.new(pool, frequency).run
+
+        until pool.flushed
+          Thread.pass
+        end
+
+        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