ibm_db 5.6.1-arm64-darwin-24

data/test/cases/forbidden_attributes_protection_test.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/company"
+require "models/person"
+require "models/ship"
+require "models/ship_part"
+require "models/treasure"
+require "support/stubs/strong_parameters"
+
+class ForbiddenAttributesProtectionTest < ActiveRecord::TestCase
+  def test_forbidden_attributes_cannot_be_used_for_mass_assignment
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
+    assert_raises(ActiveModel::ForbiddenAttributesError) do
+      Person.new(params)
+    end
+  end
+
+  def test_permitted_attributes_can_be_used_for_mass_assignment
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
+    params.permit!
+    person = Person.new(params)
+
+    assert_equal "Guille", person.first_name
+    assert_equal "m", person.gender
+  end
+
+  def test_forbidden_attributes_cannot_be_used_for_sti_inheritance_column
+    params = ProtectedParams.new(type: "Client")
+    assert_raises(ActiveModel::ForbiddenAttributesError) do
+      Company.new(params)
+    end
+  end
+
+  def test_permitted_attributes_can_be_used_for_sti_inheritance_column
+    params = ProtectedParams.new(type: "Client")
+    params.permit!
+    person = Company.new(params)
+    assert_equal person.class, Client
+  end
+
+  def test_regular_hash_should_still_be_used_for_mass_assignment
+    person = Person.new(first_name: "Guille", gender: "m")
+
+    assert_equal "Guille", person.first_name
+    assert_equal "m", person.gender
+  end
+
+  def test_blank_attributes_should_not_raise
+    person = Person.new
+    assert_nil person.assign_attributes(ProtectedParams.new({}))
+  end
+
+  def test_create_with_checks_permitted
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
+
+    assert_raises(ActiveModel::ForbiddenAttributesError) do
+      Person.create_with(params).create!
+    end
+  end
+
+  def test_create_with_works_with_permitted_params
+    params = ProtectedParams.new(first_name: "Guille").permit!
+
+    person = Person.create_with(params).create!
+    assert_equal "Guille", person.first_name
+  end
+
+  def test_create_with_works_with_params_values
+    params = ProtectedParams.new(first_name: "Guille")
+
+    person = Person.create_with(first_name: params[:first_name]).create!
+    assert_equal "Guille", person.first_name
+  end
+
+  def test_where_checks_permitted
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
+
+    assert_raises(ActiveModel::ForbiddenAttributesError) do
+      Person.where(params).create!
+    end
+  end
+
+  def test_where_works_with_permitted_params
+    params = ProtectedParams.new(first_name: "Guille").permit!
+
+    person = Person.where(params).create!
+    assert_equal "Guille", person.first_name
+  end
+
+  def test_where_works_with_params_values
+    params = ProtectedParams.new(first_name: "Guille")
+
+    person = Person.where(first_name: params[:first_name]).create!
+    assert_equal "Guille", person.first_name
+  end
+
+  def test_where_not_checks_permitted
+    params = ProtectedParams.new(first_name: "Guille", gender: "m")
+
+    assert_raises(ActiveModel::ForbiddenAttributesError) do
+      Person.where().not(params)
+    end
+  end
+
+  def test_where_not_works_with_permitted_params
+    params = ProtectedParams.new(first_name: "Guille").permit!
+    Person.create!(params)
+    assert_empty Person.where.not(params).select { |p| p.first_name == "Guille" }
+  end
+
+  def test_strong_params_style_objects_work_with_singular_associations
+    params = ProtectedParams.new(name: "Stern", ship_attributes: ProtectedParams.new(name: "The Black Rock").permit!).permit!
+    part = ShipPart.new(params)
+
+    assert_equal "Stern", part.name
+    assert_equal "The Black Rock", part.ship.name
+  end
+
+  def test_strong_params_style_objects_work_with_collection_associations
+    params = ProtectedParams.new(
+      trinkets_attributes: ProtectedParams.new(
+        "0" => ProtectedParams.new(name: "Necklace").permit!,
+        "1" => ProtectedParams.new(name: "Spoon").permit!)).permit!
+    part = ShipPart.new(params)
+
+    assert_equal "Necklace", part.trinkets[0].name
+    assert_equal "Spoon", part.trinkets[1].name
+  end
+end

data/test/cases/habtm_destroy_order_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/lesson"
+require "models/student"
+
+class HabtmDestroyOrderTest < ActiveRecord::TestCase
+  test "may not delete a lesson with students" do
+    sicp = Lesson.new(name: "SICP")
+    ben = Student.new(name: "Ben Bitdiddle")
+    sicp.students << ben
+    sicp.save!
+    assert_raises LessonError do
+      assert_no_difference("Lesson.count") do
+        sicp.destroy
+      end
+    end
+    assert_not_predicate sicp, :destroyed?
+  end
+
+  test "should not raise error if have foreign key in the join table" do
+    student = Student.new(name: "Ben Bitdiddle")
+    lesson = Lesson.new(name: "SICP")
+    lesson.students << student
+    lesson.save!
+    assert_nothing_raised do
+      student.destroy
+    end
+  end
+
+  test "not destroying a student with lessons leaves student<=>lesson association intact" do
+    # test a normal before_destroy doesn't destroy the habtm joins
+    sicp = Lesson.new(name: "SICP")
+    ben = Student.new(name: "Ben Bitdiddle")
+    # add a before destroy to student
+    Student.class_eval do
+      before_destroy do
+        raise ActiveRecord::Rollback unless lessons.empty?
+      end
+    end
+    ben.lessons << sicp
+    ben.save!
+    ben.destroy
+    assert_not_empty ben.reload.lessons
+  ensure
+    # get rid of it so Student is still like it was
+    Student.reset_callbacks(:destroy)
+  end
+
+  test "not destroying a lesson with students leaves student<=>lesson association intact" do
+    # test a more aggressive before_destroy  doesn't destroy the habtm joins and still throws the exception
+    sicp = Lesson.new(name: "SICP")
+    ben = Student.new(name: "Ben Bitdiddle")
+    sicp.students << ben
+    sicp.save!
+    assert_raises LessonError do
+      sicp.destroy
+    end
+    assert_not_empty sicp.reload.students
+  end
+end

data/test/cases/helper.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "config"
+
+require "stringio"
+
+require "active_record"
+require "cases/test_case"
+require "active_support/dependencies"
+require "active_support/logger"
+require "active_support/core_ext/kernel/singleton_class"
+
+require "support/config"
+require "support/connection"
+
+# TODO: Move all these random hacks into the ARTest namespace and into the support/ dir
+
+Thread.abort_on_exception = true
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+# Disable available locale checks to avoid warnings running the test suite.
+I18n.enforce_available_locales = false
+
+# Connect to the database
+ARTest.connect
+
+# Quote "type" if it's a reserved word for the current connection.
+QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name("type")
+
+def current_adapter?(*types)
+  types.any? do |type|
+    ActiveRecord::ConnectionAdapters.const_defined?(type) &&
+      ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters.const_get(type))
+  end
+end
+
+def in_memory_db?
+  current_adapter?(:SQLite3Adapter) &&
+  ActiveRecord::Base.connection_pool.db_config.database == ":memory:"
+end
+
+def mysql_enforcing_gtid_consistency?
+  current_adapter?(:Mysql2Adapter) && "ON" == ActiveRecord::Base.connection.show_variable("enforce_gtid_consistency")
+end
+
+def supports_default_expression?
+  if current_adapter?(:PostgreSQLAdapter)
+    true
+  elsif current_adapter?(:Mysql2Adapter)
+    conn = ActiveRecord::Base.connection
+    !conn.mariadb? && conn.database_version >= "8.0.13"
+  end
+end
+
+def supports_text_column_with_default?
+  if current_adapter?(:Mysql2Adapter)
+    conn = ActiveRecord::Base.connection
+    conn.mariadb? && conn.database_version >= "10.2.1"
+  else
+    true
+  end
+end
+
+%w[
+  supports_savepoints?
+  supports_partial_index?
+  supports_partitioned_indexes?
+  supports_expression_index?
+  supports_insert_returning?
+  supports_insert_on_duplicate_skip?
+  supports_insert_on_duplicate_update?
+  supports_insert_conflict_target?
+  supports_optimizer_hints?
+  supports_datetime_with_precision?
+].each do |method_name|
+  define_method method_name do
+    ActiveRecord::Base.connection.public_send(method_name)
+  end
+end
+
+def with_env_tz(new_tz = "US/Eastern")
+  old_tz, ENV["TZ"] = ENV["TZ"], new_tz
+  yield
+ensure
+  old_tz ? ENV["TZ"] = old_tz : ENV.delete("TZ")
+end
+
+def with_timezone_config(cfg)
+  verify_default_timezone_config
+
+  old_default_zone = ActiveRecord::Base.default_timezone
+  old_awareness = ActiveRecord::Base.time_zone_aware_attributes
+  old_zone = Time.zone
+
+  if cfg.has_key?(:default)
+    ActiveRecord::Base.default_timezone = cfg[:default]
+  end
+  if cfg.has_key?(:aware_attributes)
+    ActiveRecord::Base.time_zone_aware_attributes = cfg[:aware_attributes]
+  end
+  if cfg.has_key?(:zone)
+    Time.zone = cfg[:zone]
+  end
+  yield
+ensure
+  ActiveRecord::Base.default_timezone = old_default_zone
+  ActiveRecord::Base.time_zone_aware_attributes = old_awareness
+  Time.zone = old_zone
+end
+
+# This method makes sure that tests don't leak global state related to time zones.
+EXPECTED_ZONE = nil
+EXPECTED_DEFAULT_TIMEZONE = :utc
+EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES = false
+def verify_default_timezone_config
+  if Time.zone != EXPECTED_ZONE
+    $stderr.puts <<-MSG
+\n#{self}
+    Global state `Time.zone` was leaked.
+      Expected: #{EXPECTED_ZONE}
+      Got: #{Time.zone}
+    MSG
+  end
+  if ActiveRecord::Base.default_timezone != EXPECTED_DEFAULT_TIMEZONE
+    $stderr.puts <<-MSG
+\n#{self}
+    Global state `ActiveRecord::Base.default_timezone` was leaked.
+      Expected: #{EXPECTED_DEFAULT_TIMEZONE}
+      Got: #{ActiveRecord::Base.default_timezone}
+    MSG
+  end
+  if ActiveRecord::Base.time_zone_aware_attributes != EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES
+    $stderr.puts <<-MSG
+\n#{self}
+    Global state `ActiveRecord::Base.time_zone_aware_attributes` was leaked.
+      Expected: #{EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES}
+      Got: #{ActiveRecord::Base.time_zone_aware_attributes}
+    MSG
+  end
+end
+
+def enable_extension!(extension, connection)
+  return false unless connection.supports_extensions?
+  return connection.reconnect! if connection.extension_enabled?(extension)
+
+  connection.enable_extension extension
+  connection.commit_db_transaction if connection.transaction_open?
+  connection.reconnect!
+end
+
+def disable_extension!(extension, connection)
+  return false unless connection.supports_extensions?
+  return true unless connection.extension_enabled?(extension)
+
+  connection.disable_extension extension
+  connection.reconnect!
+end
+
+def clean_up_legacy_connection_handlers
+  handler = ActiveRecord::Base.default_connection_handler
+  ActiveRecord::Base.connection_handlers = {}
+
+  handler.connection_pool_names.each do |name|
+    next if ["ActiveRecord::Base", "ARUnit2Model", "Contact", "ContactSti", "FirstAbstractClass", "SecondAbstractClass"].include?(name)
+
+    handler.send(:owner_to_pool_manager).delete(name)
+  end
+end
+
+def clean_up_connection_handler
+  handler = ActiveRecord::Base.connection_handler
+  handler.instance_variable_get(:@owner_to_pool_manager).each do |owner, pool_manager|
+    pool_manager.role_names.each do |role_name|
+      next if role_name == ActiveRecord::Base.default_role
+      pool_manager.remove_role(role_name)
+    end
+  end
+end
+
+def load_schema
+  # silence verbose schema loading
+  original_stdout = $stdout
+  $stdout = StringIO.new
+
+  adapter_name = ActiveRecord::Base.connection.adapter_name.downcase
+  adapter_specific_schema_file = SCHEMA_ROOT + "/#{adapter_name}_specific_schema.rb"
+
+  load SCHEMA_ROOT + "/schema.rb"
+
+  if File.exist?(adapter_specific_schema_file)
+    load adapter_specific_schema_file
+  end
+
+  ActiveRecord::FixtureSet.reset_cache
+ensure
+  $stdout = original_stdout
+end
+
+load_schema
+
+class SQLSubscriber
+  attr_reader :logged
+  attr_reader :payloads
+
+  def initialize
+    @logged = []
+    @payloads = []
+  end
+
+  def start(name, id, payload)
+    @payloads << payload
+    @logged << [payload[:sql].squish, payload[:name], payload[:binds]]
+  end
+
+  def finish(name, id, payload); end
+end
+
+module InTimeZone
+  private
+    def in_time_zone(zone)
+      old_zone  = Time.zone
+      old_tz    = ActiveRecord::Base.time_zone_aware_attributes
+
+      Time.zone = zone ? ActiveSupport::TimeZone[zone] : nil
+      ActiveRecord::Base.time_zone_aware_attributes = !zone.nil?
+      yield
+    ensure
+      Time.zone = old_zone
+      ActiveRecord::Base.time_zone_aware_attributes = old_tz
+    end
+end

data/test/cases/hot_compatibility_test.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+class HotCompatibilityTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+  include ConnectionHelper
+
+  setup do
+    @klass = Class.new(ActiveRecord::Base) do
+      connection.create_table :hot_compatibilities, force: true do |t|
+        t.string :foo
+        t.string :bar
+      end
+
+      def self.name; "HotCompatibility"; end
+    end
+  end
+
+  teardown do
+    ActiveRecord::Base.connection.drop_table :hot_compatibilities
+  end
+
+  test "insert after remove_column" do
+    # warm cache
+    @klass.create!
+
+    # we have 3 columns
+    assert_equal 3, @klass.columns.length
+
+    # remove one of them
+    @klass.connection.remove_column :hot_compatibilities, :bar
+
+    # we still have 3 columns in the cache
+    assert_equal 3, @klass.columns.length
+
+    # but we can successfully create a record so long as we don't
+    # reference the removed column
+    record = @klass.create! foo: "foo"
+    record.reload
+    assert_equal "foo", record.foo
+  end
+
+  test "update after remove_column" do
+    record = @klass.create! foo: "foo"
+    assert_equal 3, @klass.columns.length
+    @klass.connection.remove_column :hot_compatibilities, :bar
+    assert_equal 3, @klass.columns.length
+
+    record.reload
+    assert_equal "foo", record.foo
+    record.foo = "bar"
+    record.save!
+    record.reload
+    assert_equal "bar", record.foo
+  end
+
+  if current_adapter?(:PostgreSQLAdapter) && ActiveRecord::Base.connection.prepared_statements
+    test "cleans up after prepared statement failure in a transaction" do
+      with_two_connections do |original_connection, ddl_connection|
+        record = @klass.create! bar: "bar"
+
+        # prepare the reload statement in a transaction
+        @klass.transaction do
+          record.reload
+        end
+
+        assert get_prepared_statement_cache(@klass.connection).any?,
+          "expected prepared statement cache to have something in it"
+
+        # add a new column
+        ddl_connection.add_column :hot_compatibilities, :baz, :string
+
+        assert_raise(ActiveRecord::PreparedStatementCacheExpired) do
+          @klass.transaction do
+            record.reload
+          end
+        end
+
+        assert_empty get_prepared_statement_cache(@klass.connection),
+          "expected prepared statement cache to be empty but it wasn't"
+      end
+    end
+
+    test "cleans up after prepared statement failure in nested transactions" do
+      with_two_connections do |original_connection, ddl_connection|
+        record = @klass.create! bar: "bar"
+
+        # prepare the reload statement in a transaction
+        @klass.transaction do
+          record.reload
+        end
+
+        assert get_prepared_statement_cache(@klass.connection).any?,
+          "expected prepared statement cache to have something in it"
+
+        # add a new column
+        ddl_connection.add_column :hot_compatibilities, :baz, :string
+
+        assert_raise(ActiveRecord::PreparedStatementCacheExpired) do
+          @klass.transaction do
+            @klass.transaction do
+              @klass.transaction do
+                record.reload
+              end
+            end
+          end
+        end
+
+        assert_empty get_prepared_statement_cache(@klass.connection),
+          "expected prepared statement cache to be empty but it wasn't"
+      end
+    end
+  end
+
+  private
+    def get_prepared_statement_cache(connection)
+      connection.instance_variable_get(:@statements)
+        .instance_variable_get(:@cache)[Process.pid]
+    end
+
+    # Rails will automatically clear the prepared statements on the connection
+    # that runs the migration, so we use two connections to simulate what would
+    # actually happen on a production system; we'd have one connection running the
+    # migration from the rake task ("ddl_connection" here), and we'd have another
+    # connection in a web worker.
+    def with_two_connections
+      run_without_connection do |original_connection|
+        ActiveRecord::Base.establish_connection(original_connection.merge(pool_size: 2))
+        begin
+          ddl_connection = ActiveRecord::Base.connection_pool.checkout
+          begin
+            yield original_connection, ddl_connection
+          ensure
+            ActiveRecord::Base.connection_pool.checkin ddl_connection
+          end
+        ensure
+          ActiveRecord::Base.clear_all_connections!
+        end
+      end
+    end
+end

data/test/cases/i18n_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+
+class ActiveRecordI18nTests < ActiveRecord::TestCase
+  def setup
+    I18n.backend = I18n::Backend::Simple.new
+  end
+
+  def test_translated_model_attributes
+    I18n.backend.store_translations "en", activerecord: { attributes: { topic: { title: "topic title attribute" } } }
+    assert_equal "topic title attribute", Topic.human_attribute_name("title")
+  end
+
+  def test_translated_model_attributes_with_symbols
+    I18n.backend.store_translations "en", activerecord: { attributes: { topic: { title: "topic title attribute" } } }
+    assert_equal "topic title attribute", Topic.human_attribute_name(:title)
+  end
+
+  def test_translated_model_attributes_with_sti
+    I18n.backend.store_translations "en", activerecord: { attributes: { reply: { title: "reply title attribute" } } }
+    assert_equal "reply title attribute", Reply.human_attribute_name("title")
+  end
+
+  def test_translated_model_attributes_with_sti_fallback
+    I18n.backend.store_translations "en", activerecord: { attributes: { topic: { title: "topic title attribute" } } }
+    assert_equal "topic title attribute", Reply.human_attribute_name("title")
+  end
+
+  def test_translated_model_names
+    I18n.backend.store_translations "en", activerecord: { models: { topic: "topic model" } }
+    assert_equal "topic model", Topic.model_name.human
+  end
+
+  def test_translated_model_names_with_sti
+    I18n.backend.store_translations "en", activerecord: { models: { reply: "reply model" } }
+    assert_equal "reply model", Reply.model_name.human
+  end
+
+  def test_translated_model_names_with_sti_fallback
+    I18n.backend.store_translations "en", activerecord: { models: { topic: "topic model" } }
+    assert_equal "topic model", Reply.model_name.human
+  end
+end