ibm_db 5.6.1-arm64-darwin-24

data/test/cases/adapters/sqlite3/transaction_test.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class SQLite3TransactionTest < ActiveRecord::SQLite3TestCase
+  test "shared_cached? is true when cache-mode is enabled" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      assert_predicate(conn, :shared_cache?)
+    end
+  end
+
+  test "shared_cached? is false when cache-mode is disabled" do
+    flags = ::SQLite3::Constants::Open::READWRITE | SQLite3::Constants::Open::CREATE
+
+    with_connection(flags: flags) do |conn|
+      assert_not_predicate(conn, :shared_cache?)
+    end
+  end
+
+  test "raises when trying to open a transaction in a isolation level other than `read_uncommitted`" do
+    with_connection do |conn|
+      assert_raises(ActiveRecord::TransactionIsolationError) do
+        conn.transaction(requires_new: true, isolation: :something) do
+          conn.transaction_manager.materialize_transactions
+        end
+      end
+    end
+  end
+
+  test "raises when trying to open a read_uncommitted transaction but shared-cache mode is turned off" do
+    with_connection do |conn|
+      error = assert_raises(StandardError) do
+        conn.transaction(requires_new: true, isolation: :read_uncommitted) do
+          conn.transaction_manager.materialize_transactions
+        end
+      end
+
+      assert_match("You need to enable the shared-cache mode", error.message)
+    end
+  end
+
+  test "opens a `read_uncommitted` transaction" do
+    with_connection(flags: shared_cache_flags) do |conn1|
+      conn1.create_table(:zines) { |t| t.column(:title, :string) } if in_memory_db?
+      conn1.transaction do
+        conn1.transaction_manager.materialize_transactions
+        conn1.execute("INSERT INTO zines (title) VALUES ('foo')")
+
+        with_connection(flags: shared_cache_flags) do |conn2|
+          conn2.transaction(joinable: false, isolation: :read_uncommitted) do
+            assert_not_empty(conn2.execute("SELECT * FROM zines WHERE title = 'foo'"))
+          end
+        end
+
+        raise ActiveRecord::Rollback
+      end
+    end
+  end
+
+  test "reset the read_uncommitted PRAGMA when a transaction is rolled back" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      conn.transaction(joinable: false, isolation: :read_uncommitted) do
+        assert_not(read_uncommitted?(conn))
+        conn.transaction_manager.materialize_transactions
+        assert(read_uncommitted?(conn))
+
+        raise ActiveRecord::Rollback
+      end
+
+      assert_not(read_uncommitted?(conn))
+    end
+  end
+
+  test "reset the read_uncommitted PRAGMA when a transaction is committed" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      conn.transaction(joinable: false, isolation: :read_uncommitted) do
+        assert_not(read_uncommitted?(conn))
+        conn.transaction_manager.materialize_transactions
+        assert(read_uncommitted?(conn))
+      end
+
+      assert_not(read_uncommitted?(conn))
+    end
+  end
+
+  test "set the read_uncommitted PRAGMA to its previous value" do
+    with_connection(flags: shared_cache_flags) do |conn|
+      conn.transaction(joinable: false, isolation: :read_uncommitted) do
+        conn.instance_variable_get(:@connection).read_uncommitted = true
+        assert(read_uncommitted?(conn))
+        conn.transaction_manager.materialize_transactions
+        assert(read_uncommitted?(conn))
+      end
+
+      assert(read_uncommitted?(conn))
+    end
+  end
+
+  private
+    def read_uncommitted?(conn)
+      conn.instance_variable_get(:@connection).get_first_value("PRAGMA read_uncommitted") != 0
+    end
+
+    def shared_cache_flags
+      ::SQLite3::Constants::Open::READWRITE | SQLite3::Constants::Open::CREATE | ::SQLite3::Constants::Open::SHAREDCACHE
+    end
+
+    def with_connection(options = {})
+      options = options.dup
+      if in_memory_db?
+        options[:database] ||= "file::memory:"
+        options[:flags] = options[:flags].to_i | ::SQLite3::Constants::Open::URI | ::SQLite3::Constants::Open::READWRITE
+      else
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        options[:database] ||= db_config.database
+      end
+      conn = ActiveRecord::Base.sqlite3_connection(options)
+
+      yield(conn)
+    ensure
+      conn.disconnect! if conn
+    end
+end

data/test/cases/aggregations_test.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/customer"
+
+class AggregationsTest < ActiveRecord::TestCase
+  fixtures :customers
+
+  def test_find_single_value_object
+    assert_equal 50, customers(:david).balance.amount
+    assert_kind_of Money, customers(:david).balance
+    assert_equal 300, customers(:david).balance.exchange_to("DKK").amount
+  end
+
+  def test_find_multiple_value_object
+    assert_equal customers(:david).address_street, customers(:david).address.street
+    assert(
+      customers(:david).address.close_to?(Address.new("Different Street", customers(:david).address_city, customers(:david).address_country))
+    )
+  end
+
+  def test_change_single_value_object
+    customers(:david).balance = Money.new(100)
+    customers(:david).save
+    assert_equal 100, customers(:david).reload.balance.amount
+  end
+
+  def test_immutable_value_objects
+    customers(:david).balance = Money.new(100)
+    assert_raise(FrozenError) { customers(:david).balance.instance_eval { @amount = 20 } }
+  end
+
+  def test_inferred_mapping
+    assert_equal "35.544623640962634", customers(:david).gps_location.latitude
+    assert_equal "-105.9309951055148", customers(:david).gps_location.longitude
+
+    customers(:david).gps_location = GpsLocation.new("39x-110")
+
+    assert_equal "39", customers(:david).gps_location.latitude
+    assert_equal "-110", customers(:david).gps_location.longitude
+
+    customers(:david).save
+
+    customers(:david).reload
+
+    assert_equal "39", customers(:david).gps_location.latitude
+    assert_equal "-110", customers(:david).gps_location.longitude
+  end
+
+  def test_reloaded_instance_refreshes_aggregations
+    assert_equal "35.544623640962634", customers(:david).gps_location.latitude
+    assert_equal "-105.9309951055148", customers(:david).gps_location.longitude
+
+    Customer.update_all("gps_location = '24x113'")
+    customers(:david).reload
+    assert_equal "24x113", customers(:david)["gps_location"]
+
+    assert_equal GpsLocation.new("24x113"), customers(:david).gps_location
+  end
+
+  def test_gps_equality
+    assert_equal GpsLocation.new("39x110"), GpsLocation.new("39x110")
+  end
+
+  def test_gps_inequality
+    assert_not_equal GpsLocation.new("39x110"), GpsLocation.new("39x111")
+  end
+
+  def test_allow_nil_gps_is_nil
+    assert_nil customers(:zaphod).gps_location
+  end
+
+  def test_allow_nil_gps_set_to_nil
+    customers(:david).gps_location = nil
+    customers(:david).save
+    customers(:david).reload
+    assert_nil customers(:david).gps_location
+  end
+
+  def test_allow_nil_set_address_attributes_to_nil
+    customers(:zaphod).address = nil
+    assert_nil customers(:zaphod).attributes[:address_street]
+    assert_nil customers(:zaphod).attributes[:address_city]
+    assert_nil customers(:zaphod).attributes[:address_country]
+  end
+
+  def test_allow_nil_address_set_to_nil
+    customers(:zaphod).address = nil
+    customers(:zaphod).save
+    customers(:zaphod).reload
+    assert_nil customers(:zaphod).address
+  end
+
+  def test_nil_raises_error_when_allow_nil_is_false
+    assert_raise(NoMethodError) { customers(:david).balance = nil }
+  end
+
+  def test_allow_nil_address_loaded_when_only_some_attributes_are_nil
+    customers(:zaphod).address_street = nil
+    customers(:zaphod).save
+    customers(:zaphod).reload
+    assert_kind_of Address, customers(:zaphod).address
+    assert_nil customers(:zaphod).address.street
+  end
+
+  def test_nil_assignment_results_in_nil
+    customers(:david).gps_location = GpsLocation.new("39x111")
+    assert_not_nil customers(:david).gps_location
+    customers(:david).gps_location = nil
+    assert_nil customers(:david).gps_location
+  end
+
+  def test_nil_return_from_converter_is_respected_when_allow_nil_is_true
+    customers(:david).non_blank_gps_location = ""
+    customers(:david).save
+    customers(:david).reload
+    assert_nil customers(:david).non_blank_gps_location
+  ensure
+    Customer.gps_conversion_was_run = nil
+  end
+
+  def test_nil_return_from_converter_results_in_failure_when_allow_nil_is_false
+    assert_raises(NoMethodError) do
+      customers(:barney).gps_location = ""
+    end
+  end
+
+  def test_do_not_run_the_converter_when_nil_was_set
+    customers(:david).non_blank_gps_location = nil
+    assert_nil Customer.gps_conversion_was_run
+  end
+
+  def test_custom_constructor
+    assert_equal "Barney GUMBLE", customers(:barney).fullname.to_s
+    assert_kind_of Fullname, customers(:barney).fullname
+  end
+
+  def test_custom_converter
+    customers(:barney).fullname = "Barnoit Gumbleau"
+    assert_equal "Barnoit GUMBLEAU", customers(:barney).fullname.to_s
+    assert_kind_of Fullname, customers(:barney).fullname
+  end
+
+  def test_assigning_hash_to_custom_converter
+    customers(:barney).fullname = { first: "Barney", last: "Stinson" }
+    assert_equal "Barney STINSON", customers(:barney).name
+  end
+
+  def test_assigning_hash_without_custom_converter
+    customers(:barney).fullname_no_converter = { first: "Barney", last: "Stinson" }
+    assert_equal({ first: "Barney", last: "Stinson" }.to_s, customers(:barney).name)
+  end
+end
+
+class OverridingAggregationsTest < ActiveRecord::TestCase
+  class DifferentName; end
+
+  class Person < ActiveRecord::Base
+    composed_of :composed_of, mapping: %w(person_first_name first_name)
+  end
+
+  class DifferentPerson < Person
+    composed_of :composed_of, class_name: "DifferentName", mapping: %w(different_person_first_name first_name)
+  end
+
+  def test_composed_of_aggregation_redefinition_reflections_should_differ_and_not_inherited
+    assert_not_equal Person.reflect_on_aggregation(:composed_of),
+                     DifferentPerson.reflect_on_aggregation(:composed_of)
+  end
+end

data/test/cases/annotate_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+class AnnotateTest < ActiveRecord::TestCase
+  fixtures :posts
+
+  def test_annotate_wraps_content_in_an_inline_comment
+    quoted_posts_id, quoted_posts = regexp_escape_table_name("posts.id"), regexp_escape_table_name("posts")
+
+    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
+      posts = Post.select(:id).annotate("foo")
+      assert posts.first
+    end
+  end
+
+  def test_annotate_is_sanitized
+    quoted_posts_id, quoted_posts = regexp_escape_table_name("posts.id"), regexp_escape_table_name("posts")
+
+    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
+      posts = Post.select(:id).annotate("*/foo/*")
+      assert posts.first
+    end
+
+    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
+      posts = Post.select(:id).annotate("**//foo//**")
+      assert posts.first
+    end
+
+    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/ /\* bar \*/}i) do
+      posts = Post.select(:id).annotate("*/foo/*").annotate("*/bar")
+      assert posts.first
+    end
+
+    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \+ MAX_EXECUTION_TIME\(1\) \*/}i) do
+      posts = Post.select(:id).annotate("+ MAX_EXECUTION_TIME(1)")
+      assert posts.first
+    end
+  end
+
+  private
+    def regexp_escape_table_name(name)
+      Regexp.escape(Post.connection.quote_table_name(name))
+    end
+end

data/test/cases/ar_schema_test.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class ActiveRecordSchemaTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  setup do
+    @original_verbose = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+    @connection = ActiveRecord::Base.connection
+    @schema_migration = @connection.schema_migration
+    @schema_migration.drop_table
+  end
+
+  teardown do
+    @connection.drop_table :fruits rescue nil
+    @connection.drop_table :nep_fruits rescue nil
+    @connection.drop_table :nep_schema_migrations rescue nil
+    @connection.drop_table :has_timestamps rescue nil
+    @connection.drop_table :multiple_indexes rescue nil
+    @schema_migration.delete_all rescue nil
+    ActiveRecord::Migration.verbose = @original_verbose
+  end
+
+  def test_has_primary_key
+    old_primary_key_prefix_type = ActiveRecord::Base.primary_key_prefix_type
+    ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
+    assert_equal "version", @schema_migration.primary_key
+
+    @schema_migration.create_table
+    assert_difference "@schema_migration.count", 1 do
+      @schema_migration.create version: 12
+    end
+  ensure
+    @schema_migration.drop_table
+    ActiveRecord::Base.primary_key_prefix_type = old_primary_key_prefix_type
+  end
+
+  def test_schema_define
+    ActiveRecord::Schema.define(version: 7) do
+      create_table :fruits do |t|
+        t.column :color, :string
+        t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
+        t.column :texture, :string
+        t.column :flavor, :string
+      end
+    end
+
+    assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
+    assert_nothing_raised { @connection.select_all "SELECT * FROM schema_migrations" }
+    assert_equal 7, @connection.migration_context.current_version
+  end
+
+  def test_schema_define_with_table_name_prefix
+    old_table_name_prefix = ActiveRecord::Base.table_name_prefix
+    ActiveRecord::Base.table_name_prefix = "nep_"
+    @schema_migration.reset_table_name
+    ActiveRecord::InternalMetadata.reset_table_name
+    ActiveRecord::Schema.define(version: 7) do
+      create_table :fruits do |t|
+        t.column :color, :string
+        t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
+        t.column :texture, :string
+        t.column :flavor, :string
+      end
+    end
+    assert_equal 7, @connection.migration_context.current_version
+  ensure
+    ActiveRecord::Base.table_name_prefix = old_table_name_prefix
+    @schema_migration.reset_table_name
+    ActiveRecord::InternalMetadata.reset_table_name
+  end
+
+  def test_schema_raises_an_error_for_invalid_column_type
+    assert_raise NoMethodError do
+      ActiveRecord::Schema.define(version: 8) do
+        create_table :vegetables do |t|
+          t.unknown :color
+        end
+      end
+    end
+  end
+
+  def test_schema_subclass
+    Class.new(ActiveRecord::Schema).define(version: 9) do
+      create_table :fruits
+    end
+    assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
+  end
+
+  def test_normalize_version
+    assert_equal "118", @schema_migration.normalize_migration_number("0000118")
+    assert_equal "002", @schema_migration.normalize_migration_number("2")
+    assert_equal "017", @schema_migration.normalize_migration_number("0017")
+    assert_equal "20131219224947", @schema_migration.normalize_migration_number("20131219224947")
+  end
+
+  def test_schema_load_with_multiple_indexes_for_column_of_different_names
+    ActiveRecord::Schema.define do
+      create_table :multiple_indexes do |t|
+        t.string "foo"
+        t.index ["foo"], name: "multiple_indexes_foo_1"
+        t.index ["foo"], name: "multiple_indexes_foo_2"
+      end
+    end
+
+    indexes = @connection.indexes("multiple_indexes")
+
+    assert_equal 2, indexes.length
+    assert_equal ["multiple_indexes_foo_1", "multiple_indexes_foo_2"], indexes.collect(&:name).sort
+  end
+
+  def test_timestamps_without_null_set_null_to_false_on_create_table
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps do |t|
+        t.timestamps
+      end
+    end
+
+    assert @connection.column_exists?(:has_timestamps, :created_at, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, null: false)
+  end
+
+  def test_timestamps_without_null_set_null_to_false_on_change_table
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps
+
+      change_table :has_timestamps do |t|
+        t.timestamps default: Time.now
+      end
+    end
+
+    assert @connection.column_exists?(:has_timestamps, :created_at, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, null: false)
+  end
+
+  if ActiveRecord::Base.connection.supports_bulk_alter?
+    def test_timestamps_without_null_set_null_to_false_on_change_table_with_bulk
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps
+
+        change_table :has_timestamps, bulk: true do |t|
+          t.timestamps default: Time.now
+        end
+      end
+
+      assert @connection.column_exists?(:has_timestamps, :created_at, null: false)
+      assert @connection.column_exists?(:has_timestamps, :updated_at, null: false)
+    end
+  end
+
+  def test_timestamps_without_null_set_null_to_false_on_add_timestamps
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps
+      add_timestamps :has_timestamps, default: Time.now
+    end
+
+    assert @connection.column_exists?(:has_timestamps, :created_at, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, null: false)
+  end
+
+  if supports_datetime_with_precision?
+    def test_timestamps_sets_precision_on_create_table
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps do |t|
+          t.timestamps
+        end
+      end
+
+      assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+      assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+    end
+
+    def test_timestamps_sets_precision_on_change_table
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps
+
+        change_table :has_timestamps do |t|
+          t.timestamps default: Time.now
+        end
+      end
+
+      assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+      assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+    end
+
+    if ActiveRecord::Base.connection.supports_bulk_alter?
+      def test_timestamps_sets_precision_on_change_table_with_bulk
+        ActiveRecord::Schema.define do
+          create_table :has_timestamps
+
+          change_table :has_timestamps, bulk: true do |t|
+            t.timestamps default: Time.now
+          end
+        end
+
+        assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+        assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+      end
+    end
+
+    def test_timestamps_sets_precision_on_add_timestamps
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps
+        add_timestamps :has_timestamps, default: Time.now
+      end
+
+      assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+      assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+    end
+  end
+end