ibm_db 5.6.1 → 5.7.0

data/test/cases/fixtures_test.rb

@@ -6,6 +6,8 @@ require "models/admin"
 require "models/admin/account"
 require "models/admin/randomly_named_c1"
 require "models/admin/user"
+require "models/aircraft"
+require "models/author"
 require "models/binary"
 require "models/book"
 require "models/bulb"
@@ -16,10 +18,13 @@ require "models/company"
 require "models/computer"
 require "models/course"
 require "models/developer"
+require "models/dog_lover"
 require "models/dog"
 require "models/doubloon"
+require "models/essay"
 require "models/joke"
 require "models/matey"
+require "models/organization"
 require "models/other_dog"
 require "models/parrot"
 require "models/pirate"
@@ -30,7 +35,8 @@ require "models/task"
 require "models/topic"
 require "models/traffic_light"
 require "models/treasure"
-require "tempfile"
+require "models/tree"
+require "models/cpk"
 
 class FixturesTest < ActiveRecord::TestCase
   include ConnectionHelper
@@ -39,7 +45,7 @@ class FixturesTest < ActiveRecord::TestCase
   self.use_transactional_tests = false
 
   # other_topics fixture should not be included here
-  fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes, :binaries, :traffic_lights, :treasures
+  fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes, :binaries, :traffic_lights, :trees
 
   FIXTURES = %w( accounts binaries companies customers
                  developers developers_projects entrants
@@ -79,7 +85,7 @@ class FixturesTest < ActiveRecord::TestCase
     end
   end
 
-  if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :PostgreSQLAdapter)
     def test_bulk_insert
       subscriber = InsertQuerySubscriber.new
       subscription = ActiveSupport::Notifications.subscribe("sql.active_record", subscriber)
@@ -93,12 +99,12 @@ class FixturesTest < ActiveRecord::TestCase
       subscriber = InsertQuerySubscriber.new
       subscription = ActiveSupport::Notifications.subscribe("sql.active_record", subscriber)
 
-      create_fixtures("bulbs", "authors", "computers")
+      create_fixtures("bulbs", "movies", "computers")
 
       expected_sql = <<~EOS.chop
-        INSERT INTO #{ActiveRecord::Base.connection.quote_table_name("bulbs")} .*
-        INSERT INTO #{ActiveRecord::Base.connection.quote_table_name("authors")} .*
-        INSERT INTO #{ActiveRecord::Base.connection.quote_table_name("computers")} .*
+        INSERT INTO #{quote_table_name("bulbs")} .*
+        INSERT INTO #{quote_table_name("movies")} .*
+        INSERT INTO #{quote_table_name("computers")} .*
       EOS
       assert_equal 1, subscriber.events.size
       assert_match(/#{expected_sql}/, subscriber.events.first)
@@ -107,8 +113,6 @@ class FixturesTest < ActiveRecord::TestCase
     end
 
     def test_bulk_insert_with_a_multi_statement_query_raises_an_exception_when_any_insert_fails
-      require "models/aircraft"
-
       assert_equal false, Aircraft.columns_hash["wheels_count"].null
       fixtures = {
         "aircraft" => [
@@ -119,7 +123,7 @@ class FixturesTest < ActiveRecord::TestCase
 
       assert_no_difference "Aircraft.count" do
         assert_raises(ActiveRecord::NotNullViolation) do
-          ActiveRecord::Base.connection.insert_fixtures_set(fixtures)
+          ActiveRecord::Base.lease_connection.insert_fixtures_set(fixtures)
         end
       end
     end
@@ -133,7 +137,7 @@ class FixturesTest < ActiveRecord::TestCase
 
       assert_difference "TrafficLight.count" do
         ActiveRecord::Base.transaction do
-          conn = ActiveRecord::Base.connection
+          conn = ActiveRecord::Base.lease_connection
           assert_equal 1, conn.open_transactions
           conn.insert_fixtures_set(fixtures)
           assert_equal 1, conn.open_transactions
@@ -142,12 +146,20 @@ class FixturesTest < ActiveRecord::TestCase
     end
   end
 
-  if current_adapter?(:Mysql2Adapter)
+  if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
     def test_bulk_insert_with_multi_statements_enabled
+      adapter_name = ActiveRecord::Base.lease_connection.adapter_name
       run_without_connection do |orig_connection|
-        ActiveRecord::Base.establish_connection(
-          orig_connection.merge(flags: %w[MULTI_STATEMENTS])
-        )
+        case adapter_name
+        when "Trilogy"
+          ActiveRecord::Base.establish_connection(
+            orig_connection.merge(multi_statement: true)
+          )
+        else
+          ActiveRecord::Base.establish_connection(
+            orig_connection.merge(flags: %w[MULTI_STATEMENTS])
+          )
+        end
 
         fixtures = {
           "traffic_lights" => [
@@ -156,14 +168,19 @@ class FixturesTest < ActiveRecord::TestCase
         }
 
         assert_nothing_raised do
-          conn = ActiveRecord::Base.connection
+          conn = ActiveRecord::Base.lease_connection
           conn.execute("SELECT 1; SELECT 2;")
-          conn.raw_connection.abandon_results!
+          case adapter_name
+          when "Trilogy"
+            conn.raw_connection.next_result while conn.raw_connection.more_results_exist?
+          else
+            conn.raw_connection.abandon_results!
+          end
         end
 
         assert_difference "TrafficLight.count" do
           ActiveRecord::Base.transaction do
-            conn = ActiveRecord::Base.connection
+            conn = ActiveRecord::Base.lease_connection
             assert_equal 1, conn.open_transactions
             conn.insert_fixtures_set(fixtures)
             assert_equal 1, conn.open_transactions
@@ -171,18 +188,31 @@ class FixturesTest < ActiveRecord::TestCase
         end
 
         assert_nothing_raised do
-          conn = ActiveRecord::Base.connection
+          conn = ActiveRecord::Base.lease_connection
           conn.execute("SELECT 1; SELECT 2;")
-          conn.raw_connection.abandon_results!
+          case adapter_name
+          when "Trilogy"
+            conn.raw_connection.next_result while conn.raw_connection.more_results_exist?
+          else
+            conn.raw_connection.abandon_results!
+          end
         end
       end
     end
 
     def test_bulk_insert_with_multi_statements_disabled
+      adapter_name = ActiveRecord::Base.lease_connection.adapter_name
       run_without_connection do |orig_connection|
-        ActiveRecord::Base.establish_connection(
-          orig_connection.merge(flags: [])
-        )
+        case adapter_name
+        when "Trilogy"
+          ActiveRecord::Base.establish_connection(
+            orig_connection.merge(multi_statement: false)
+          )
+        else
+          ActiveRecord::Base.establish_connection(
+            orig_connection.merge(flags: [])
+          )
+        end
 
         fixtures = {
           "traffic_lights" => [
@@ -191,26 +221,36 @@ class FixturesTest < ActiveRecord::TestCase
         }
 
         assert_raises(ActiveRecord::StatementInvalid) do
-          conn = ActiveRecord::Base.connection
+          conn = ActiveRecord::Base.lease_connection
           conn.execute("SELECT 1; SELECT 2;")
-          conn.raw_connection.abandon_results!
+          case adapter_name
+          when "Trilogy"
+            conn.raw_connection.next_result while conn.raw_connection.more_results_exist?
+          else
+            conn.raw_connection.abandon_results!
+          end
         end
 
         assert_difference "TrafficLight.count" do
-          conn = ActiveRecord::Base.connection
+          conn = ActiveRecord::Base.lease_connection
           conn.insert_fixtures_set(fixtures)
         end
 
         assert_raises(ActiveRecord::StatementInvalid) do
-          conn = ActiveRecord::Base.connection
+          conn = ActiveRecord::Base.lease_connection
           conn.execute("SELECT 1; SELECT 2;")
-          conn.raw_connection.abandon_results!
+          case adapter_name
+          when "Trilogy"
+            conn.raw_connection.next_result while conn.raw_connection.more_results_exist?
+          else
+            conn.raw_connection.abandon_results!
+          end
         end
       end
     end
 
     def test_insert_fixtures_set_raises_an_error_when_max_allowed_packet_is_smaller_than_fixtures_set_size
-      conn = ActiveRecord::Base.connection
+      conn = ActiveRecord::Base.lease_connection
       mysql_margin = 2
       packet_size = 1024
       bytes_needed_to_have_a_1024_bytes_fixture = 906
@@ -227,7 +267,7 @@ class FixturesTest < ActiveRecord::TestCase
     end
 
     def test_insert_fixture_set_when_max_allowed_packet_is_bigger_than_fixtures_set_size
-      conn = ActiveRecord::Base.connection
+      conn = ActiveRecord::Base.lease_connection
       packet_size = 1024
       fixtures = {
         "traffic_lights" => [
@@ -245,7 +285,7 @@ class FixturesTest < ActiveRecord::TestCase
     def test_insert_fixtures_set_split_the_total_sql_into_two_chunks_smaller_than_max_allowed_packet
       subscriber = InsertQuerySubscriber.new
       subscription = ActiveSupport::Notifications.subscribe("sql.active_record", subscriber)
-      conn = ActiveRecord::Base.connection
+      conn = ActiveRecord::Base.lease_connection
       packet_size = 1024
       fixtures = {
         "traffic_lights" => [
@@ -270,7 +310,7 @@ class FixturesTest < ActiveRecord::TestCase
     def test_insert_fixtures_set_concat_total_sql_into_a_single_packet_smaller_than_max_allowed_packet
       subscriber = InsertQuerySubscriber.new
       subscription = ActiveSupport::Notifications.subscribe("sql.active_record", subscriber)
-      conn = ActiveRecord::Base.connection
+      conn = ActiveRecord::Base.lease_connection
       packet_size = 1024
       fixtures = {
         "traffic_lights" => [
@@ -297,7 +337,7 @@ class FixturesTest < ActiveRecord::TestCase
       { "name" => "first", "wheels_count" => 2 },
       { "name" => "second", "wheels_count" => 3 }
     ]
-    conn = ActiveRecord::Base.connection
+    conn = ActiveRecord::Base.lease_connection
     assert_nothing_raised do
       conn.insert_fixtures_set({ "aircraft" => fixtures }, ["aircraft"])
     end
@@ -321,9 +361,9 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_create_fixtures
-    fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, "parrots")
-    assert Parrot.find_by_name("Curious George"), "George is not in the database"
-    assert fixtures.detect { |f| f.name == "parrots" }, "no fixtures named 'parrots' in #{fixtures.map(&:name).inspect}"
+    fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, "organizations")
+    assert Organization.find_by_name("No Such Agency"), "'No Such Agency' is not in the database"
+    assert fixtures.detect { |f| f.name == "organizations" }, "no fixtures named 'organizations' in #{fixtures.map(&:name).inspect}"
   end
 
   def test_multiple_clean_fixtures
@@ -334,7 +374,7 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_create_symbol_fixtures
-    fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, :collections, collections: Course) { Course.connection }
+    fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, :collections, collections: Course)
 
     assert Course.find_by_name("Collection"), "course is not in the database"
     assert fixtures.detect { |f| f.name == "collections" }, "no fixtures named 'collections' in #{fixtures.map(&:name).inspect}"
@@ -366,10 +406,10 @@ class FixturesTest < ActiveRecord::TestCase
 
   def test_inserts
     create_fixtures("topics")
-    first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'David'")
+    first_row = ActiveRecord::Base.lease_connection.select_one("SELECT * FROM topics WHERE author_name = 'David'")
     assert_equal("The First Topic", first_row["title"])
 
-    second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'Mary'")
+    second_row = ActiveRecord::Base.lease_connection.select_one("SELECT * FROM topics WHERE author_name = 'Mary'")
     assert_nil(second_row["author_email_address"])
   end
 
@@ -377,7 +417,7 @@ class FixturesTest < ActiveRecord::TestCase
     # Reset cache to make finds on the new table work
     ActiveRecord::FixtureSet.reset_cache
 
-    ActiveRecord::Base.connection.create_table :prefix_other_topics_suffix do |t|
+    ActiveRecord::Base.lease_connection.create_table :prefix_other_topics_suffix do |t|
       t.column :title, :string
       t.column :author_name, :string
       t.column :author_email_address, :string
@@ -411,11 +451,11 @@ class FixturesTest < ActiveRecord::TestCase
     # class-level configuration helper.
     assert_not_nil topics, "Fixture data inserted, but fixture objects not returned from create"
 
-    first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_other_topics_suffix WHERE author_name = 'David'")
+    first_row = ActiveRecord::Base.lease_connection.select_one("SELECT * FROM prefix_other_topics_suffix WHERE author_name = 'David'")
     assert_not_nil first_row, "The prefix_other_topics_suffix table appears to be empty despite create_fixtures: the row with author_name = 'David' was not found"
     assert_equal("The First Topic", first_row["title"])
 
-    second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_other_topics_suffix WHERE author_name = 'Mary'")
+    second_row = ActiveRecord::Base.lease_connection.select_one("SELECT * FROM prefix_other_topics_suffix WHERE author_name = 'Mary'")
     assert_nil(second_row["author_email_address"])
 
     assert_equal :prefix_other_topics_suffix, topics.table_name.to_sym
@@ -428,7 +468,7 @@ class FixturesTest < ActiveRecord::TestCase
     ActiveRecord::Base.table_name_prefix = old_prefix
     ActiveRecord::Base.table_name_suffix = old_suffix
 
-    ActiveRecord::Base.connection.drop_table :prefix_other_topics_suffix rescue nil
+    ActiveRecord::Base.lease_connection.drop_table :prefix_other_topics_suffix rescue nil
   end
 
   def test_insert_with_datetime
@@ -437,10 +477,44 @@ class FixturesTest < ActiveRecord::TestCase
     assert first
   end
 
+  def test_insert_with_default_function
+    create_fixtures("aircrafts")
+
+    aircraft = Aircraft.find_by(name: "boeing-with-no-manufactured-at")
+    if current_adapter?(:IBM_DBAdapter)
+      # DB2 CURRENT TIMESTAMP returns the server's local wall-clock time, but the
+      # IBM_DB driver parses it as UTC, producing an epoch 4h off on a UTC-4 host.
+      # Reinterpret the stored components as local time so the epoch is correct.
+      stored_local = Time.local(
+        aircraft.manufactured_at.year,
+        aircraft.manufactured_at.month,
+        aircraft.manufactured_at.day,
+        aircraft.manufactured_at.hour,
+        aircraft.manufactured_at.min,
+        aircraft.manufactured_at.sec
+      )
+      assert_in_delta Time.now.to_i, stored_local.to_i, 2
+    else
+      assert_in_delta Time.now.utc, aircraft.manufactured_at.utc, 1.1
+    end
+  end
+
+  def test_insert_with_default_value
+    create_fixtures("aircrafts")
+
+    aircraft = Aircraft.find_by(name: "boeing-with-no-wheels")
+    assert_equal 0, aircraft.wheels_count
+  end
+
   def test_logger_level_invariant
+    previous_logger = ActiveRecord::Base.logger
+    ActiveRecord::Base.logger = ActiveSupport::Logger.new(nil)
+
     level = ActiveRecord::Base.logger.level
     create_fixtures("topics")
     assert_equal level, ActiveRecord::Base.logger.level
+  ensure
+    ActiveRecord::Base.logger = previous_logger
   end
 
   def test_instantiation
@@ -471,10 +545,10 @@ class FixturesTest < ActiveRecord::TestCase
   def test_nonexistent_fixture_file
     nonexistent_fixture_path = FIXTURES_ROOT + "/imnothere"
 
-    # sanity check to make sure that this file never exists
+    # Ensure that this file never exists
     assert_empty Dir[nonexistent_fixture_path + "*"]
 
-    assert_raise(Errno::ENOENT) do
+    assert_raise(ArgumentError) do
       ActiveRecord::FixtureSet.new(nil, "companies", Company, nonexistent_fixture_path)
     end
   end
@@ -505,6 +579,8 @@ class FixturesTest < ActiveRecord::TestCase
 
   def test_yaml_file_with_symbol_columns
     ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/naked/yml", "trees")
+    root = Tree.find(1)
+    assert root
   end
 
   def test_omap_fixtures
@@ -519,12 +595,12 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_yml_file_in_subdirectory
-    assert_equal(categories(:sub_special_1).name, "A special category in a subdir file")
+    assert_equal("A special category in a subdir file", categories(:sub_special_1).name)
     assert_equal(categories(:sub_special_1).class, SpecialCategory)
   end
 
   def test_subsubdir_file_with_arbitrary_name
-    assert_equal(categories(:sub_special_3).name, "A special category in an arbitrarily named subsubdir file")
+    assert_equal("A special category in an arbitrarily named subsubdir file", categories(:sub_special_3).name)
     assert_equal(categories(:sub_special_3).class, SpecialCategory)
   end
 
@@ -554,11 +630,36 @@ class FixturesTest < ActiveRecord::TestCase
 
       result = test_case.new(:test_fixtures).run
 
-      assert result.passed?, "Expected #{result.name} to pass:\n#{result}"
+      assert_predicate result, :passed?, "Expected #{result.name} to pass:\n#{result}"
     end
   ensure
     ENV["DATABASE_URL"] = db_url_tmp
   end
+
+  def test_fixture_method_and_private_alias
+    assert_equal "The First Topic", topics(:first).title
+    assert_equal "The First Topic", fixture(:topics, :first).title
+    assert_equal "The First Topic", active_record_fixture(:topics, :first).title
+  end
+
+  def test_fixture_method_does_not_clash_with_a_test_case_method
+    test_case = Class.new(ActiveRecord::TestCase) do
+      fixtures :accounts
+
+      def test_fixtures
+        assert accounts(:signals37)
+      end
+
+      private
+        def fixture
+          Account.new
+        end
+    end
+
+    result = test_case.new(:test_fixtures).run
+
+    assert_predicate result, :passed?, "Expected #{result.name} to pass:\n#{result}"
+  end
 end
 
 class HasManyThroughFixture < ActiveRecord::TestCase
@@ -566,7 +667,7 @@ class HasManyThroughFixture < ActiveRecord::TestCase
     Class.new(ActiveRecord::Base) { define_singleton_method(:name) { name } }
   end
 
-  def test_has_many_through_with_default_table_name
+  def test_has_many_through_with_join_table_name_changed_to_match_habtm_table_name
     pt = make_model "ParrotTreasure"
     parrot = make_model "Parrot"
     treasure = make_model "Treasure"
@@ -585,7 +686,7 @@ class HasManyThroughFixture < ActiveRecord::TestCase
     assert_equal load_has_and_belongs_to_many["parrots_treasures"], rows["parrots_treasures"]
   end
 
-  def test_has_many_through_with_renamed_table
+  def test_has_many_through_with_default_table_name_on_join_table
     pt = make_model "ParrotTreasure"
     parrot = make_model "Parrot"
     treasure = make_model "Treasure"
@@ -618,7 +719,7 @@ class HasManyThroughFixture < ActiveRecord::TestCase
   end
 end
 
-if Account.connection.respond_to?(:reset_pk_sequence!)
+if Account.lease_connection.respond_to?(:reset_pk_sequence!)
   class FixturesResetPkSequenceTest < ActiveRecord::TestCase
     fixtures :accounts
     fixtures :companies
@@ -633,7 +734,7 @@ if Account.connection.respond_to?(:reset_pk_sequence!)
       @instances.each do |instance|
         model = instance.class
         model.delete_all
-        model.connection.reset_pk_sequence!(model.table_name, model.primary_key, model.sequence_name)
+        model.lease_connection.reset_pk_sequence!(model.table_name, model.primary_key, model.sequence_name)
 
         instance.save!
         assert_equal 1, instance.id, "Sequence reset for #{model.table_name} failed."
@@ -644,7 +745,7 @@ if Account.connection.respond_to?(:reset_pk_sequence!)
       @instances.each do |instance|
         model = instance.class
         model.delete_all
-        model.connection.reset_pk_sequence!(model.table_name)
+        model.lease_connection.reset_pk_sequence!(model.table_name)
 
         instance.save!
         assert_equal 1, instance.id, "Sequence reset for #{model.table_name} failed."
@@ -738,7 +839,7 @@ class MultipleFixturesTest < ActiveRecord::TestCase
   fixtures :developers, :accounts
 
   def test_fixture_table_names
-    assert_equal %w(topics developers accounts), fixture_table_names
+    assert_equal %w(accounts developers topics), fixture_table_names
   end
 end
 
@@ -750,6 +851,7 @@ class SetupTest < ActiveRecord::TestCase
   end
 
   def test_nothing
+    pass
   end
 end
 
@@ -770,7 +872,7 @@ class OverlappingFixturesTest < ActiveRecord::TestCase
   fixtures :developers, :accounts
 
   def test_fixture_table_names
-    assert_equal %w(topics developers accounts), fixture_table_names
+    assert_equal %w(accounts developers topics), fixture_table_names
   end
 end
 
@@ -790,6 +892,80 @@ class ForeignKeyFixturesTest < ActiveRecord::TestCase
   end
 end
 
+class FkObjectToPointTo < ActiveRecord::Base
+  has_many :fk_pointing_to_non_existent_objects
+end
+class FkPointingToNonExistentObject < ActiveRecord::Base
+  belongs_to :fk_object_to_point_to
+end
+
+class FixturesWithForeignKeyViolationsTest < ActiveRecord::TestCase
+  fixtures :fk_object_to_point_to
+
+  def setup
+    # other tests in this file load the parrots fixture but not the treasure one (see `test_create_fixtures`).
+    # this creates FK violations since Parrot and ParrotTreasure records are created.
+    # those violations can cause false positives in these tests. since they aren't related to these tests we
+    # delete the irrelevant records here (this test is transactional so it's fine).
+    Parrot.all.each(&:destroy)
+
+    @path = "/fk_pointing_to_non_existent_object.yml"
+  end
+
+  def test_raises_fk_violations
+    fk_pointing_to_non_existent_object = <<~FIXTURE
+    first:
+      fk_object_to_point_to: one
+    FIXTURE
+    File.write(FIXTURES_ROOT + @path, fk_pointing_to_non_existent_object)
+
+    with_verify_foreign_keys_for_fixtures do
+      if current_adapter?(:SQLite3Adapter, :PostgreSQLAdapter)
+        error = assert_raise RuntimeError do
+          ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, ["fk_pointing_to_non_existent_object"])
+        end
+        assert_includes error.message, "Foreign key violations found in your fixture data. Ensure you aren't referring to labels that don't exist on associations."
+        assert_includes error.message, "fk_pointing_to_non_existent_objects"
+      else
+        assert_nothing_raised do
+          ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, ["fk_pointing_to_non_existent_object"])
+        end
+      end
+    end
+
+  ensure
+    File.delete(FIXTURES_ROOT + @path)
+    ActiveRecord::FixtureSet.reset_cache
+  end
+
+  def test_does_not_raise_if_no_fk_violations
+    fk_pointing_to_valid_object = <<~FIXTURE
+    first:
+      fk_object_to_point_to_id: 1
+    FIXTURE
+    File.write(FIXTURES_ROOT + @path, fk_pointing_to_valid_object)
+
+    with_verify_foreign_keys_for_fixtures do
+      assert_nothing_raised do
+        ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, ["fk_pointing_to_non_existent_object"])
+      end
+    end
+
+  ensure
+    File.delete(FIXTURES_ROOT + @path)
+    ActiveRecord::FixtureSet.reset_cache
+  end
+
+  private
+    def with_verify_foreign_keys_for_fixtures
+      setting_was = ActiveRecord.verify_foreign_keys_for_fixtures
+      ActiveRecord.verify_foreign_keys_for_fixtures = true
+      yield
+    ensure
+      ActiveRecord.verify_foreign_keys_for_fixtures = setting_was
+    end
+end
+
 class OverRideFixtureMethodTest < ActiveRecord::TestCase
   fixtures :topics
 
@@ -837,6 +1013,16 @@ class SetFixtureClassPrevailsTest < ActiveRecord::TestCase
   end
 end
 
+class FixtureWithSetModelClassPrevailsOverNamingConventionTest < ActiveRecord::TestCase
+  def test_model_class_in_fixture_file_is_respected
+    Object.const_set(:OtherPost, Class.new(ActiveRecord::Base))
+    other_posts = create_fixtures("other_posts").first
+    assert_kind_of Post, other_posts["second_welcome"].find
+  ensure
+    Object.send(:remove_const, :OtherPost)
+  end
+end
+
 class CheckSetTableNameFixturesTest < ActiveRecord::TestCase
   set_fixture_class funny_jokes: Joke
   fixtures :funny_jokes
@@ -918,14 +1104,19 @@ class TransactionalFixturesOnConnectionNotification < ActiveRecord::TestCase
       def transaction_open?; end
       def begin_transaction(*args); end
       def rollback_transaction(*args); end
+      def connect!; end
     end.new
 
-    connection.pool = Class.new do
-      def lock_thread=(lock_thread); end
-    end.new
+    pool = connection.pool = Class.new do
+      def initialize(connection); @connection = connection; end
+      def lease_connection; @connection; end
+      def release_connection; end
+      def pin_connection!(_); end
+      def unpin_connection!; @connection.rollback_transaction; true; end
+    end.new(connection)
 
-    assert_called_with(connection, :begin_transaction, [joinable: false, _lazy: false]) do
-      fire_connection_notification(connection)
+    assert_called_with(pool, :pin_connection!, [true]) do
+      fire_connection_notification(connection.pool)
     end
   end
 
@@ -939,13 +1130,19 @@ class TransactionalFixturesOnConnectionNotification < ActiveRecord::TestCase
       def rollback_transaction(*args)
         @rollback_transaction_called = true
       end
-    end.new
-
-    connection.pool = Class.new do
       def lock_thread=(lock_thread); end
+      def connect!; end
     end.new
 
-    fire_connection_notification(connection)
+    connection.pool = Class.new do
+      def initialize(connection); @connection = connection; end
+      def lease_connection; @connection; end
+      def release_connection; end
+      def pin_connection!(_); end
+      def unpin_connection!; @connection.rollback_transaction; true; end
+    end.new(connection)
+
+    fire_connection_notification(connection.pool)
     teardown_fixtures
 
     assert(connection.rollback_transaction_called, "Expected <mock connection>#rollback_transaction to be called but was not")
@@ -958,25 +1155,30 @@ class TransactionalFixturesOnConnectionNotification < ActiveRecord::TestCase
       def transaction_open?; end
       def begin_transaction(*args); end
       def rollback_transaction(*args); end
+      def connect!; end
     end.new
 
     connection.pool = Class.new do
-      def lock_thread=(lock_thread); end
-    end.new
-
-    assert_called_with(connection, :begin_transaction, [joinable: false, _lazy: false]) do
-      fire_connection_notification(connection, shard: :shard_two)
+      def initialize(connection); @connection = connection; end
+      def lease_connection; @connection; end
+      def release_connection; end
+      def pin_connection!(_); end
+      def unpin_connection!; @connection.rollback_transaction; true; end
+    end.new(connection)
+
+    assert_called_with(connection.pool, :pin_connection!, [true]) do
+      fire_connection_notification(connection.pool, shard: :shard_two)
     end
   end
 
   private
-    def fire_connection_notification(connection, shard: ActiveRecord::Base.default_shard)
-      assert_called_with(ActiveRecord::Base.connection_handler, :retrieve_connection, ["book", { shard: shard }], returns: connection) do
+    def fire_connection_notification(pool, shard: ActiveRecord::Base.default_shard)
+      assert_called_with(ActiveRecord::Base.connection_handler, :retrieve_connection_pool, ["book"], returns: pool, shard: shard) do
         message_bus = ActiveSupport::Notifications.instrumenter
         payload = {
-          spec_name: "book",
+          connection_name: "book",
           shard: shard,
-          config: nil,
+          config: nil
         }
 
         message_bus.instrument("!connection.active_record", payload) { }
@@ -1020,7 +1222,7 @@ end
 
 class FixturesBrokenRollbackTest < ActiveRecord::TestCase
   def blank_setup
-    @fixture_connections = [ActiveRecord::Base.connection]
+    @fixture_connection_pools = [ActiveRecord::Base.connection_pool]
   end
   alias_method :ar_setup_fixtures, :setup_fixtures
   alias_method :setup_fixtures, :blank_setup
@@ -1031,12 +1233,14 @@ class FixturesBrokenRollbackTest < ActiveRecord::TestCase
   alias_method :teardown_fixtures, :blank_teardown
   alias_method :teardown, :blank_teardown
 
+  fixtures rand.to_s # bypass fixtures cache
+
   def test_no_rollback_in_teardown_unless_transaction_active
-    assert_equal 0, ActiveRecord::Base.connection.open_transactions
+    assert_equal 0, ActiveRecord::Base.lease_connection.open_transactions
     assert_raise(RuntimeError) { ar_setup_fixtures }
-    assert_equal 0, ActiveRecord::Base.connection.open_transactions
+    assert_equal 0, ActiveRecord::Base.lease_connection.open_transactions
     assert_nothing_raised { ar_teardown_fixtures }
-    assert_equal 0, ActiveRecord::Base.connection.open_transactions
+    assert_equal 0, ActiveRecord::Base.lease_connection.open_transactions
   end
 
   private
@@ -1047,7 +1251,7 @@ end
 
 class LoadAllFixturesTest < ActiveRecord::TestCase
   def test_all_there
-    self.class.fixture_path = FIXTURES_ROOT + "/all"
+    self.class.fixture_paths = [FIXTURES_ROOT + "/all"]
     self.class.fixtures :all
 
     if File.symlink? FIXTURES_ROOT + "/all/admin"
@@ -1058,9 +1262,22 @@ class LoadAllFixturesTest < ActiveRecord::TestCase
   end
 end
 
+class LoadAllFixturesWithArrayTest < ActiveRecord::TestCase
+  def test_all_there
+    self.class.fixture_paths = [FIXTURES_ROOT + "/all", FIXTURES_ROOT + "/categories"]
+    self.class.fixtures :all
+
+    if File.symlink? FIXTURES_ROOT + "/all/admin"
+      assert_equal %w(admin/accounts admin/users developers namespaced/accounts people special_categories subsubdir/arbitrary_filename tasks), fixture_table_names.sort
+    end
+  ensure
+    ActiveRecord::FixtureSet.reset_cache
+  end
+end
+
 class LoadAllFixturesWithPathnameTest < ActiveRecord::TestCase
   def test_all_there
-    self.class.fixture_path = Pathname.new(FIXTURES_ROOT).join("all")
+    self.class.fixture_paths = [Pathname.new(FIXTURES_ROOT).join("all")]
     self.class.fixtures :all
 
     if File.symlink? FIXTURES_ROOT + "/all/admin"
@@ -1082,8 +1299,8 @@ class FasterFixturesTest < ActiveRecord::TestCase
   end
 
   def test_cache
-    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, "categories")
-    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, "authors")
+    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection_pool, "categories")
+    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection_pool, "authors")
 
     assert_no_queries do
       create_fixtures("categories")
@@ -1091,7 +1308,7 @@ class FasterFixturesTest < ActiveRecord::TestCase
     end
 
     load_extra_fixture("posts")
-    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection, "posts")
+    assert ActiveRecord::FixtureSet.fixture_is_cached?(ActiveRecord::Base.connection_pool, "posts")
     self.class.setup_fixture_accessors :posts
     assert_equal "Welcome to the weblog", posts(:welcome).title
   end
@@ -1103,7 +1320,7 @@ class FoxyFixturesTest < ActiveRecord::TestCase
   fixtures :parrots, :parrots_pirates, :pirates, :treasures, :mateys, :ships, :computers,
            :developers, :"admin/accounts", :"admin/users", :live_parrots, :dead_parrots, :books
 
-  if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+  if current_adapter?(:PostgreSQLAdapter)
     require "models/uuid_parent"
     require "models/uuid_child"
     fixtures :uuid_parents, :uuid_children
@@ -1189,6 +1406,18 @@ class FoxyFixturesTest < ActiveRecord::TestCase
     assert(parrots(:george).pirates.include?(pirates(:blackbeard)))
   end
 
+  def test_supports_timestamps_in_join_tables
+    assert_not_nil developers(:david).created_at
+    assert_not_nil computers(:laptop).created_at
+
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "computers_developers"
+    end
+
+    computers_developers = klass.find_by(developer_id: developers(:david), computer_id: computers(:laptop))
+    assert_not_nil computers_developers.created_at
+  end
+
   def test_supports_inline_habtm
     assert(parrots(:george).treasures.include?(treasures(:diamond)))
     assert(parrots(:george).treasures.include?(treasures(:sapphire)))
@@ -1231,9 +1460,11 @@ class FoxyFixturesTest < ActiveRecord::TestCase
   end
 
   def test_only_generates_a_pk_if_necessary
-    m = Matey.first
-    m.pirate = pirates(:blackbeard)
-    m.target = pirates(:redbeard)
+    assert_nothing_raised do
+      m = Matey.first
+      m.pirate = pirates(:blackbeard)
+      m.target = pirates(:redbeard)
+    end
   end
 
   def test_supports_sti
@@ -1247,6 +1478,12 @@ class FoxyFixturesTest < ActiveRecord::TestCase
     assert_equal pirates(:blackbeard), dead_parrots(:deadbird).killer
   end
 
+  def test_resolves_enums_in_sti_subclasses
+    assert_predicate parrots(:george), :australian?
+    assert_predicate parrots(:louis), :african?
+    assert_predicate parrots(:frederick), :african?
+  end
+
   def test_namespaced_models
     assert_includes admin_accounts(:signals37).users, admin_users(:david)
     assert_equal 2, admin_accounts(:signals37).users.size
@@ -1261,12 +1498,12 @@ class FoxyFixturesTest < ActiveRecord::TestCase
 end
 
 class ActiveSupportSubclassWithFixturesTest < ActiveRecord::TestCase
-  fixtures :parrots, :pirates, :parrots_pirates, :treasures
+  fixtures :organizations
 
   # This seemingly useless assertion catches a bug that caused the fixtures
   # setup code call nil[]
   def test_foo
-    assert_equal parrots(:louis), Parrot.find_by_name("King Louis")
+    assert_equal organizations(:nsa), Organization.find_by_name("No Such Agency")
   end
 end
 
@@ -1302,12 +1539,21 @@ class CustomNameForFixtureOrModelTest < ActiveRecord::TestCase
 end
 
 class IgnoreFixturesTest < ActiveRecord::TestCase
-  fixtures :other_books, :parrots
+  fixtures :other_books, :parrots, :parrots_pirates, :pirates, :treasures
 
   # Set to false to blow away fixtures cache and ensure our fixtures are loaded
   # without interfering with other tests that use the same `model_class`.
   self.use_transactional_tests = false
 
+  def before_setup
+    if ActiveRecord::Base.lease_connection.is_a?(ActiveRecord::ConnectionAdapters::IBM_DBAdapter) &&
+        name.end_with?("ignores_books_fixtures", "ignores_parrots_fixtures")
+      skip
+    end
+
+    super
+  end
+
   test "ignores books fixtures" do
     assert_raise(StandardError) { other_books(:published) }
     assert_raise(StandardError) { other_books(:published_paperback) }
@@ -1386,13 +1632,13 @@ class NilFixturePathTest < ActiveRecord::TestCase
     error = assert_raises(StandardError) do
       TestCase = Class.new(ActiveRecord::TestCase)
       TestCase.class_eval do
-        self.fixture_path = nil
+        self.fixture_paths = nil
         fixtures :all
       end
     end
     assert_equal <<~MSG.squish, error.message
       No fixture path found.
-      Please set `NilFixturePathTest::TestCase.fixture_path`.
+      Please set `NilFixturePathTest::TestCase.fixture_paths`.
     MSG
   end
 end
@@ -1403,15 +1649,25 @@ class FileFixtureConflictTest < ActiveRecord::TestCase
   end
 
   test "ignores file fixtures" do
-    self.class.fixture_path = FIXTURES_ROOT + "/all"
+    self.class.fixture_paths = [FIXTURES_ROOT + "/all"]
     self.class.fixtures :all
 
     assert_equal %w(developers namespaced/accounts people tasks), fixture_table_names.sort
   end
 end
 
-if current_adapter?(:SQLite3Adapter) && !in_memory_db?
-  class MultipleFixtureConnectionsTest < ActiveRecord::TestCase
+class PrimaryKeyErrorTest < ActiveRecord::TestCase
+  test "generates the correct value" do
+    e = assert_raise(ActiveRecord::FixtureSet::TableRow::PrimaryKeyError) do
+      ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/primary_key_error", "primary_key_error")
+    end
+
+    assert_includes e.message, "Unable to set"
+  end
+end
+
+class MultipleFixtureConnectionsTest < ActiveRecord::TestCase
+  if current_adapter?(:SQLite3Adapter) && !in_memory_db?
     include ActiveRecord::TestFixtures
 
     fixtures :dogs
@@ -1450,15 +1706,15 @@ if current_adapter?(:SQLite3Adapter) && !in_memory_db?
 
     def test_writing_and_reading_connections_are_the_same
       handler = ActiveRecord::Base.connection_handler
-      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing).connection
-      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading).connection
+      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing).lease_connection
+      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading).lease_connection
 
       assert_equal rw_conn, ro_conn
 
       teardown_shared_connection_pool
 
-      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing).connection
-      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading).connection
+      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing).lease_connection
+      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading).lease_connection
 
       assert_not_equal rw_conn, ro_conn
     end
@@ -1470,15 +1726,15 @@ if current_adapter?(:SQLite3Adapter) && !in_memory_db?
       }
 
       handler = ActiveRecord::Base.connection_handler
-      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing, shard: :two).connection
-      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading, shard: :two).connection
+      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing, shard: :two).lease_connection
+      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading, shard: :two).lease_connection
 
       assert_equal rw_conn, ro_conn
 
       teardown_shared_connection_pool
 
-      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing, shard: :two).connection
-      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading, shard: :two).connection
+      rw_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :writing, shard: :two).lease_connection
+      ro_conn = handler.retrieve_connection_pool("ActiveRecord::Base", role: :reading, shard: :two).lease_connection
 
       assert_not_equal rw_conn, ro_conn
     end
@@ -1491,7 +1747,7 @@ if current_adapter?(:SQLite3Adapter) && !in_memory_db?
 
       setup_shared_connection_pool
 
-      assert_raises(ActiveRecord::ConnectionNotEstablished) do
+      assert_raises(ActiveRecord::ConnectionNotDefined) do
         ActiveRecord::Base.connected_to(role: :reading, shard: :two) do
           ActiveRecord::Base.retrieve_connection
         end
@@ -1502,7 +1758,7 @@ if current_adapter?(:SQLite3Adapter) && !in_memory_db?
       clean_up_connection_handler
       teardown_shared_connection_pool
 
-      assert_raises(ActiveRecord::ConnectionNotEstablished) do
+      assert_raises(ActiveRecord::ConnectionNotDefined) do
         ActiveRecord::Base.connected_to(role: :reading) do
           ActiveRecord::Base.retrieve_connection
         end
@@ -1523,123 +1779,103 @@ if current_adapter?(:SQLite3Adapter) && !in_memory_db?
       end
   end
 
-  class MultipleFixtureLegacyConnectionsTest < ActiveRecord::TestCase
-    include ActiveRecord::TestFixtures
-
-    fixtures :dogs
-
-    def setup
-      @old_value = ActiveRecord::Base.legacy_connection_handling
-      ActiveRecord::Base.legacy_connection_handling = true
-
-      @old_handler = ActiveRecord::Base.connection_handler
-      @prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
-      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(ENV["RAILS_ENV"], "readonly", readonly_config)
+  class CompositePkFixturesTest < ActiveRecord::TestCase
+    fixtures :cpk_orders, :cpk_books, :cpk_posts, :cpk_tags, :cpk_authors, :cpk_reviews, :cpk_order_agreements
 
-      teardown_shared_connection_pool
+    def test_supports_inline_habtm
+      skip if current_adapter?(:IBM_DBAdapter)
 
-      handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
-      ActiveRecord::Base.connection_handler = handler
-      handler.establish_connection(db_config)
-      ActiveRecord::Base.connection_handlers = {}
-      ActiveRecord::Base.connects_to(database: { writing: :default, reading: :readonly })
+      assert_includes cpk_posts(:welcome).tags, cpk_tags(:cpk_tag_ruby_on_rails)
+      assert_includes cpk_posts(:welcome).tags, cpk_tags(:cpk_tag_digital_product)
+      assert_not_includes cpk_posts(:welcome).tags, cpk_tags(:cpk_tag_loyal_customer)
 
-      setup_shared_connection_pool
+      assert_equal [cpk_tags(:cpk_tag_digital_product)], cpk_posts(:thinking).tags
     end
 
-    def teardown
-      ActiveRecord::Base.configurations = @prev_configs
-      ActiveRecord::Base.connection_handler = @old_handler
-      clean_up_legacy_connection_handlers
-      ActiveRecord::Base.legacy_connection_handling = false
+    def test_generates_composite_primary_key_for_partially_filled_fixtures
+      alice = cpk_authors(:cpk_great_author)
+      alice_cpk_book = cpk_books(:cpk_great_author_first_book)
+
+      assert_not_empty(alice_cpk_book.id.compact)
+      assert_equal alice_cpk_book.id.first, alice.id
+      assert_not_nil alice_cpk_book.id.last
     end
 
-    def test_uses_writing_connection_for_fixtures
-      ActiveRecord::Base.connected_to(role: :reading) do
-        Dog.first
+    def test_generates_composite_primary_key_ids
+      assert_not_empty(cpk_orders(:cpk_groceries_order_1).id.compact)
 
-        assert_nothing_raised do
-          ActiveRecord::Base.connected_to(role: :writing) { Dog.create! alias: "Doggo" }
-        end
+      cpk_books(:cpk_great_author_first_book).id.each do |id_column|
+        assert_not_nil(id_column)
       end
     end
 
-    def test_writing_and_reading_connections_are_the_same_with_legacy_handling
-      writing = ActiveRecord::Base.connection_handlers[:writing]
-      reading = ActiveRecord::Base.connection_handlers[:reading]
-
-      rw_conn = writing.retrieve_connection_pool("ActiveRecord::Base").connection
-      ro_conn = reading.retrieve_connection_pool("ActiveRecord::Base").connection
+    def test_generates_composite_primary_key_with_unique_components
+      assert_equal 2, cpk_orders(:cpk_groceries_order_1).id.uniq.size
+    end
 
-      assert_equal rw_conn, ro_conn
+    def test_resolves_associations_using_composite_primary_keys
+      review = cpk_reviews(:first_book_review)
+      generated_book = cpk_books(:cpk_book_with_generated_pk)
 
-      teardown_shared_connection_pool
+      assert_equal generated_book.id, [review.author_id, review.number]
+      assert_equal generated_book, review.book
+    end
 
-      rw_conn = writing.retrieve_connection_pool("ActiveRecord::Base").connection
-      ro_conn = reading.retrieve_connection_pool("ActiveRecord::Base").connection
+    def test_resolves_associations_using_composite_primary_keys_with_partially_filled_values
+      review = cpk_reviews(:second_book_review_for_book_with_partial_pk_defined)
+      book_with_partially_filled_cpk = cpk_books(:cpk_great_author_first_book)
 
-      assert_not_equal rw_conn, ro_conn
+      assert_equal book_with_partially_filled_cpk.id, [review.author_id, review.number]
+      assert_equal book_with_partially_filled_cpk, review.book
     end
 
-    def test_writing_and_reading_connections_are_the_same_for_non_default_shards_with_legacy_handling
-      ActiveRecord::Base.connects_to shards: {
-        default: { writing: :default, reading: :readonly },
-        two: { writing: :default, reading: :readonly }
-      }
+    def test_association_with_custom_primary_key
+      order = cpk_orders(:cpk_groceries_order_2)
+      order_agreement = cpk_order_agreements(:order_agreement_three)
 
-      writing = ActiveRecord::Base.connection_handlers[:writing]
-      reading = ActiveRecord::Base.connection_handlers[:reading]
+      _, order_id = order.id
 
-      rw_conn = writing.retrieve_connection_pool("ActiveRecord::Base", shard: :two).connection
-      ro_conn = reading.retrieve_connection_pool("ActiveRecord::Base", shard: :two).connection
+      assert_equal order_id, order_agreement.order_id
+      assert_equal order, order_agreement.order
+    end
 
-      assert_equal rw_conn, ro_conn
+    def test_composite_identify_resolves_to_same_values
+      identify_one = ActiveRecord::FixtureSet.composite_identify("label", [:a, :b, :c])
+      identify_two = ActiveRecord::FixtureSet.composite_identify("label", [:a, :b, :c])
 
-      teardown_shared_connection_pool
+      assert_equal identify_one, identify_two
+    end
 
-      rw_conn = writing.retrieve_connection_pool("ActiveRecord::Base", shard: :two).connection
-      ro_conn = reading.retrieve_connection_pool("ActiveRecord::Base", shard: :two).connection
+    def test_composite_identify_returns_hash_with_key_names
+      id = ActiveRecord::FixtureSet.composite_identify("order", Cpk::Order.primary_key)
 
-      assert_not_equal rw_conn, ro_conn
+      assert_equal ["shop_id", "id"], id.keys
     end
 
-    def test_only_existing_connections_are_replaced
-      ActiveRecord::Base.connects_to shards: {
-        default: { writing: :default, reading: :readonly },
-        two: { writing: :default }
-      }
-
-      setup_shared_connection_pool
+    def test_composite_identify_uses_same_hashing_algorithm_as_identify_for_first_attribute
+      id_hash = ActiveRecord::FixtureSet.composite_identify("order", [:first_attribute, :second_attribute])
+      id = ActiveRecord::FixtureSet.identify("order")
 
-      assert_raises(ActiveRecord::ConnectionNotEstablished) do
-        ActiveRecord::Base.connected_to(role: :reading, shard: :two) do
-          ActiveRecord::Base.retrieve_connection
-        end
-      end
+      assert_equal id, id_hash[:first_attribute]
+      assert_not_equal id, id_hash[:second_attribute]
     end
 
-    def test_only_existing_connections_are_restored
-      clean_up_legacy_connection_handlers
-      teardown_shared_connection_pool
+    def test_composite_identify_hashes_one_label_to_same_values_irrespective_of_column_names
+      id_hash_one = ActiveRecord::FixtureSet.composite_identify("order", [:first_attribute, :second_attribute])
+      id_hash_two = ActiveRecord::FixtureSet.composite_identify("order", [:shop_id, :id])
 
-      assert_raises(ActiveRecord::ConnectionNotEstablished) do
-        ActiveRecord::Base.connected_to(role: :reading) do
-          ActiveRecord::Base.retrieve_connection
-        end
-      end
+      assert_equal id_hash_one.values, id_hash_two.values
+      assert_not_equal id_hash_one.keys, id_hash_two.keys
     end
 
-    private
-      def config
-        { "default" => default_config, "readonly" => readonly_config }
-      end
-
-      def default_config
-        { "adapter" => "sqlite3", "database" => "test/fixtures/fixture_database.sqlite3" }
-      end
+    def test_composite_identify_hashes_to_same_values_based_on_position_in_key
+      id = ActiveRecord::FixtureSet.identify("order")
+      id_hash_two = ActiveRecord::FixtureSet.composite_identify("order", [:one, :two])
+      id_hash_three = ActiveRecord::FixtureSet.composite_identify("order", [:one, :two, :three])
 
-      def readonly_config
-        default_config.merge("replica" => true)
-      end
+      assert_equal id, id_hash_two.values.first
+      assert_equal id, id_hash_three.values.first
+      assert_equal id_hash_two.values, id_hash_three.values.slice(0, 2)
+    end
   end
 end