ibm_db 5.6.1 → 5.7.0

data/test/cases/helper.rb

@@ -8,226 +8,100 @@ require "active_record"
 require "cases/test_case"
 require "active_support/dependencies"
 require "active_support/logger"
+require "active_support/core_ext/kernel/reporting"
 require "active_support/core_ext/kernel/singleton_class"
 
-require "support/config"
-require "support/connection"
+if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+end
 
 # 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
+ActiveRecord.deprecator.debug = true
 
-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
+# ActiveRecord::Base.connection is only soft deprecated but we ban it from the test suite
+# to ensure it's not used internally.
+ActiveRecord.permanent_connection_checkout = :disallowed
 
-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
+ActiveRecord::Delegation::DelegateCache.delegate_base_methods = false
 
-%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
+# Ensure this alias isn't being used by Active Record itself.
+ActiveRecord::Relation.remove_method(:klass)
 
-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
+# Disable available locale checks to avoid warnings running the test suite.
+I18n.enforce_available_locales = false
 
-# 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
+# Quote "type" if it's a reserved word for the current connection.
+QUOTED_TYPE = ActiveRecord::Base.lease_connection.quote_column_name("type")
 
-def enable_extension!(extension, connection)
-  return false unless connection.supports_extensions?
-  return connection.reconnect! if connection.extension_enabled?(extension)
+ActiveRecord::Base.automatically_invert_plural_associations = true
 
-  connection.enable_extension extension
-  connection.commit_db_transaction if connection.transaction_open?
-  connection.reconnect!
-end
+ActiveRecord.raise_on_assign_to_attr_readonly = true
+ActiveRecord.belongs_to_required_validates_foreign_key = false
 
-def disable_extension!(extension, connection)
-  return false unless connection.supports_extensions?
-  return true unless connection.extension_enabled?(extension)
+ActiveRecord::ConnectionAdapters.register("abstract", "ActiveRecord::ConnectionAdapters::AbstractAdapter", "active_record/connection_adapters/abstract_adapter")
+ActiveRecord::ConnectionAdapters.register("fake", "FakeActiveRecordAdapter", File.expand_path("../support/fake_adapter.rb", __dir__))
 
-  connection.disable_extension extension
-  connection.reconnect!
-end
+class ActiveRecord::TestCase
+  class SQLSubscriber
+    attr_reader :logged
+    attr_reader :payloads
 
-def clean_up_legacy_connection_handlers
-  handler = ActiveRecord::Base.default_connection_handler
-  ActiveRecord::Base.connection_handlers = {}
+    def initialize
+      @logged = []
+      @payloads = []
+    end
 
-  handler.connection_pool_names.each do |name|
-    next if ["ActiveRecord::Base", "ARUnit2Model", "Contact", "ContactSti", "FirstAbstractClass", "SecondAbstractClass"].include?(name)
+    def start(name, id, payload)
+      @payloads << payload
+      @logged << [payload[:sql].squish, payload[:name], payload[:binds]]
+    end
 
-    handler.send(:owner_to_pool_manager).delete(name)
+    def finish(name, id, payload); end
   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
+  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
-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"
+  module WaitForAsyncTestHelper
+    private
+      def wait_for_async_query(connection = ActiveRecord::Base.lease_connection, timeout: 5)
+        return unless connection.async_enabled?
 
-  load SCHEMA_ROOT + "/schema.rb"
+        executor = connection.pool.async_executor
+        (timeout * 100).times do
+          return unless executor.scheduled_task_count > executor.completed_task_count
+          sleep 0.01
+        end
 
-  if File.exist?(adapter_specific_schema_file)
-    load adapter_specific_schema_file
+        raise Timeout::Error, "The async executor wasn't drained after #{timeout} seconds"
+      end
   end
-
-  ActiveRecord::FixtureSet.reset_cache
-ensure
-  $stdout = original_stdout
 end
 
-load_schema
-
-class SQLSubscriber
-  attr_reader :logged
-  attr_reader :payloads
+# Encryption
 
-  def initialize
-    @logged = []
-    @payloads = []
-  end
+ActiveRecord::Encryption.configure \
+  primary_key: "test master key",
+  deterministic_key: "test deterministic key",
+  key_derivation_salt: "testing key derivation salt"
 
-  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
+# Simulate https://github.com/rails/rails/blob/735cba5bed7a54c7397dfeec1bed16033ae286f8/activerecord/lib/active_record/railtie.rb#L392
+ActiveRecord::Encryption.config.extend_queries = true
+ActiveRecord::Encryption::ExtendedDeterministicQueries.install_support
+ActiveRecord::Encryption::ExtendedDeterministicUniquenessValidator.install_support

data/test/cases/hot_compatibility_test.rb

@@ -9,7 +9,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
 
   setup do
     @klass = Class.new(ActiveRecord::Base) do
-      connection.create_table :hot_compatibilities, force: true do |t|
+      lease_connection.create_table :hot_compatibilities, force: true do |t|
         t.string :foo
         t.string :bar
       end
@@ -19,7 +19,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
   end
 
   teardown do
-    ActiveRecord::Base.connection.drop_table :hot_compatibilities
+    ActiveRecord::Base.lease_connection.drop_table :hot_compatibilities
   end
 
   test "insert after remove_column" do
@@ -30,7 +30,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
     assert_equal 3, @klass.columns.length
 
     # remove one of them
-    @klass.connection.remove_column :hot_compatibilities, :bar
+    @klass.lease_connection.remove_column :hot_compatibilities, :bar
 
     # we still have 3 columns in the cache
     assert_equal 3, @klass.columns.length
@@ -45,7 +45,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
   test "update after remove_column" do
     record = @klass.create! foo: "foo"
     assert_equal 3, @klass.columns.length
-    @klass.connection.remove_column :hot_compatibilities, :bar
+    @klass.lease_connection.remove_column :hot_compatibilities, :bar
     assert_equal 3, @klass.columns.length
 
     record.reload
@@ -56,7 +56,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
     assert_equal "bar", record.foo
   end
 
-  if current_adapter?(:PostgreSQLAdapter) && ActiveRecord::Base.connection.prepared_statements
+  if current_adapter?(:PostgreSQLAdapter) && ActiveRecord::Base.lease_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"
@@ -66,7 +66,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
           record.reload
         end
 
-        assert get_prepared_statement_cache(@klass.connection).any?,
+        assert_predicate get_prepared_statement_cache(@klass.lease_connection), :any?,
           "expected prepared statement cache to have something in it"
 
         # add a new column
@@ -78,7 +78,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
           end
         end
 
-        assert_empty get_prepared_statement_cache(@klass.connection),
+        assert_empty get_prepared_statement_cache(@klass.lease_connection),
           "expected prepared statement cache to be empty but it wasn't"
       end
     end
@@ -92,7 +92,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
           record.reload
         end
 
-        assert get_prepared_statement_cache(@klass.connection).any?,
+        assert_predicate get_prepared_statement_cache(@klass.lease_connection), :any?,
           "expected prepared statement cache to have something in it"
 
         # add a new column
@@ -108,7 +108,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
           end
         end
 
-        assert_empty get_prepared_statement_cache(@klass.connection),
+        assert_empty get_prepared_statement_cache(@klass.lease_connection),
           "expected prepared statement cache to be empty but it wasn't"
       end
     end
@@ -136,7 +136,7 @@ class HotCompatibilityTest < ActiveRecord::TestCase
             ActiveRecord::Base.connection_pool.checkin ddl_connection
           end
         ensure
-          ActiveRecord::Base.clear_all_connections!
+          ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
         end
       end
     end

data/test/cases/inheritance_test.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/inflector"
+require "zeitwerk"
 require "cases/helper"
 require "models/author"
 require "models/company"
@@ -11,6 +13,7 @@ require "models/subscriber"
 require "models/vegetables"
 require "models/shop"
 require "models/sponsor"
+require "models/club"
 
 module InheritanceTestHelper
   def with_store_full_sti_class(&block)
@@ -43,14 +46,8 @@ class InheritanceTest < ActiveRecord::TestCase
   def test_class_with_blank_sti_name
     company = Company.first
     company = company.dup
-    company.extend(Module.new {
-      def _read_attribute(name)
-        return "  " if name == "type"
-        super
-      end
-    })
-    company.save!
-    company = Company.all.to_a.find { |x| x.id == company.id }
+    company.update!(type: "  ")
+    company = Company.find(company.id)
     assert_equal "  ", company.type
   end
 
@@ -73,37 +70,33 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_compute_type_no_method_error
-    ActiveSupport::Dependencies.stub(:safe_constantize, proc { raise NoMethodError }) do
-      assert_raises NoMethodError do
-        Company.send :compute_type, "InvalidModel"
-      end
-    end
+    # Done via autoload because you need the exception to happen when the file
+    # is required.
+    model = "RaisesNoMethodError"
+    Object.autoload(model, "#{MODELS_ROOT}/#{model.underscore}")
+    assert_raises(NoMethodError) { Company.send(:compute_type, model) }
+  ensure
+    Object.send(:remove_const, model)
   end
 
   def test_compute_type_on_undefined_method
-    error = nil
-    begin
-      Class.new(Author) do
-        alias_method :foo, :bar
-      end
-    rescue => e
-      error = e
-    end
-
-    ActiveSupport::Dependencies.stub(:safe_constantize, proc { raise e }) do
-      exception = assert_raises NameError do
-        Company.send :compute_type, "InvalidModel"
-      end
-      assert_equal error.message, exception.message
-    end
+    # Done via autoload because you need the exception to happen when the file
+    # is required.
+    model = "InvokesAnUndefinedMethod"
+    Object.autoload(model, "#{MODELS_ROOT}/#{model.underscore}")
+    assert_raises(NameError) { Company.send(:compute_type, model) }
+  ensure
+    Object.send(:remove_const, model)
   end
 
   def test_compute_type_argument_error
-    ActiveSupport::Dependencies.stub(:safe_constantize, proc { raise ArgumentError }) do
-      assert_raises ArgumentError do
-        Company.send :compute_type, "InvalidModel"
-      end
-    end
+    # Done via autoload because you need the exception to happen when the file
+    # is required.
+    model = "RaisesArgumentError"
+    Object.autoload(model, "#{MODELS_ROOT}/#{model.underscore}")
+    assert_raises(ArgumentError) { Company.send(:compute_type, model) }
+  ensure
+    Object.send(:remove_const, model)
   end
 
   def test_should_store_demodulized_class_name_with_store_full_sti_class_option_disabled
@@ -160,8 +153,8 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_company_descends_from_active_record
     assert_not_predicate ActiveRecord::Base, :descends_from_active_record?
-    assert AbstractCompany.descends_from_active_record?, "AbstractCompany should descend from ActiveRecord::Base"
-    assert Company.descends_from_active_record?, "Company should descend from ActiveRecord::Base"
+    assert_predicate AbstractCompany, :descends_from_active_record?, "AbstractCompany should descend from ActiveRecord::Base"
+    assert_predicate Company, :descends_from_active_record?, "Company should descend from ActiveRecord::Base"
     assert_not Class.new(Company).descends_from_active_record?, "Company subclass should not descend from ActiveRecord::Base"
   end
 
@@ -196,12 +189,13 @@ class InheritanceTest < ActiveRecord::TestCase
   end
 
   def test_base_class_activerecord_error
-    klass = Class.new { include ActiveRecord::Inheritance }
-    assert_raise(ActiveRecord::ActiveRecordError) { klass.base_class }
+    assert_raise(ActiveRecord::ActiveRecordError) do
+      Class.new { include ActiveRecord::Inheritance }
+    end
   end
 
   def test_a_bad_type_column
-    Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
+    Company.lease_connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
 
     assert_raise(ActiveRecord::SubclassNotFound) { Company.find(100) }
   end
@@ -382,13 +376,15 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_new_with_autoload_paths
     path = File.expand_path("../models/autoloadable", __dir__)
-    ActiveSupport::Dependencies.autoload_paths << path
-
-    firm = Company.new(type: "ExtraFirm")
-    assert_equal ExtraFirm, firm.class
-  ensure
-    ActiveSupport::Dependencies.autoload_paths.reject! { |p| p == path }
-    ActiveSupport::Dependencies.clear
+    Zeitwerk.with_loader do |loader|
+      loader.push_dir(path)
+      loader.setup
+
+      firm = Company.new(type: "ExtraFirm")
+      assert_equal ExtraFirm, firm.class
+    ensure
+      loader.unload
+    end
   end
 
   def test_inheritance_condition
@@ -472,18 +468,17 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_eager_load_belongs_to_something_inherited
     account = Account.all.merge!(includes: :firm).find(1)
-    assert account.association(:firm).loaded?, "association was not eager loaded"
+    assert_predicate account.association(:firm), :loaded?, "association was not eager loaded"
   end
 
   def test_alt_eager_loading
     cabbage = RedCabbage.all.merge!(includes: :seller).find(4)
-    assert cabbage.association(:seller).loaded?, "association was not eager loaded"
+    assert_predicate cabbage.association(:seller), :loaded?, "association was not eager loaded"
   end
 
   def test_eager_load_belongs_to_primary_key_quoting
-    c = Account.connection
     bind_param = Arel::Nodes::BindParam.new(nil)
-    assert_sql(/#{Regexp.escape(c.quote_table_name("companies.id"))} = (?:#{Regexp.escape(bind_param.to_sql)}|1)/i) do
+    assert_queries_match(/#{Regexp.escape(quote_table_name("companies.id"))} = (?:#{Regexp.escape(bind_param.to_sql)}|1)/i) do
       Account.all.merge!(includes: :firm).find(1)
     end
   end
@@ -548,7 +543,7 @@ class InheritanceComputeTypeTest < ActiveRecord::TestCase
 
   def test_inheritance_new_with_subclass_as_default
     original_type = Company.columns_hash["type"].default
-    ActiveRecord::Base.connection.change_column_default :companies, :type, "Firm"
+    ActiveRecord::Base.lease_connection.change_column_default :companies, :type, "Firm"
     Company.reset_column_information
 
     firm = Company.new # without arguments
@@ -567,7 +562,7 @@ class InheritanceComputeTypeTest < ActiveRecord::TestCase
     assert_equal "Client", firm.type
     assert_instance_of Client, firm
   ensure
-    ActiveRecord::Base.connection.change_column_default :companies, :type, original_type
+    ActiveRecord::Base.lease_connection.change_column_default :companies, :type, original_type
     Company.reset_column_information
   end
 end
@@ -597,17 +592,10 @@ end
 
 class InheritanceAttributeMappingTest < ActiveRecord::TestCase
   setup do
-    @old_registry = ActiveRecord::Type.registry
-    ActiveRecord::Type.registry = ActiveRecord::Type.registry.dup
-    ActiveRecord::Type.register :omg_sti, InheritanceAttributeMappingTest::OmgStiType
     Company.delete_all
     Sponsor.delete_all
   end
 
-  teardown do
-    ActiveRecord::Type.registry = @old_registry
-  end
-
   class OmgStiType < ActiveRecord::Type::String
     def cast_value(value)
       if value =~ /\Aomg_(.+)\z/
@@ -624,6 +612,8 @@ class InheritanceAttributeMappingTest < ActiveRecord::TestCase
     end
   end
 
+  ActiveRecord::Type.register :omg_sti, OmgStiType
+
   class Company < ActiveRecord::Base
     self.table_name = "companies"
     attribute :type, :omg_sti
@@ -644,7 +634,7 @@ class InheritanceAttributeMappingTest < ActiveRecord::TestCase
     Empire.create! name: "an Empire"
 
     assert_equal [["a Startup", "omg_inheritance_attribute_mapping_test/startup"],
-                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.connection.select_rows("SELECT name, type FROM companies").sort
+                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.lease_connection.select_rows("SELECT name, type FROM companies").sort
     assert_equal [["a Startup", "InheritanceAttributeMappingTest::Startup"],
                   ["an Empire", "InheritanceAttributeMappingTest::Empire"]], Company.all.map { |a| [a.name, a.type] }.sort
 
@@ -653,7 +643,7 @@ class InheritanceAttributeMappingTest < ActiveRecord::TestCase
     startup.save!
 
     assert_equal [["a Startup", "omg_inheritance_attribute_mapping_test/empire"],
-                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.connection.select_rows("SELECT name, type FROM companies").sort
+                  ["an Empire", "omg_inheritance_attribute_mapping_test/empire"]], ActiveRecord::Base.lease_connection.select_rows("SELECT name, type FROM companies").sort
 
     assert_equal [["a Startup", "InheritanceAttributeMappingTest::Empire"],
                   ["an Empire", "InheritanceAttributeMappingTest::Empire"]], Company.all.map { |a| [a.name, a.type] }.sort
@@ -663,7 +653,7 @@ class InheritanceAttributeMappingTest < ActiveRecord::TestCase
     startup = Startup.create! name: "a Startup"
     sponsor = Sponsor.create! sponsorable: startup
 
-    assert_equal ["omg_inheritance_attribute_mapping_test/company"], ActiveRecord::Base.connection.select_values("SELECT sponsorable_type FROM sponsors")
+    assert_equal ["omg_inheritance_attribute_mapping_test/company"], ActiveRecord::Base.lease_connection.select_values("SELECT sponsorable_type FROM sponsors")
 
     sponsor = Sponsor.find(sponsor.id)
     assert_equal startup, sponsor.sponsorable

data/test/cases/inherited_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module Inherited
+  # When running the test with `RAILS_STRICT_WARNINGS` enabled, the `belongs_to`
+  # call should not emit a warning that the constant `GeneratedAssociationMethods`
+  # is already defined.
+  class Person < ActiveRecord::Base; end
+
+  class Device < ActiveRecord::Base
+    def self.inherited(subclass)
+      subclass.belongs_to :person, inverse_of: subclass.name.demodulize.tableize.to_sym
+      subclass.filter_attributes = [:secret_attribute, :"#{subclass.name.demodulize.downcase}_key"]
+      super
+    end
+  end
+
+  class Computer < Device; end
+
+  class Vehicle < ActiveRecord::Base
+    def self.inherited(subclass)
+      super
+      subclass.belongs_to :person, inverse_of: subclass.name.demodulize.tableize.to_sym
+      subclass.filter_attributes = [:secret_attribute, :"#{subclass.name.demodulize.downcase}_key"]
+    end
+  end
+
+  class Car < Vehicle; end
+end
+
+class InheritedTest < ActiveRecord::TestCase
+  def test_super_before_filter_attributes
+    assert_equal %i[secret_attribute car_key], Inherited::Car.filter_attributes
+  end
+
+  def test_super_after_filter_attributes
+    assert_equal %i[secret_attribute computer_key], Inherited::Computer.filter_attributes
+  end
+end