ibm_db 5.6.1 → 5.7.0

data/test/cases/tasks/database_tasks_test.rb

@@ -2,7 +2,8 @@
 
 require "cases/helper"
 require "active_record/tasks/database_tasks"
-require "models/author"
+require "models/course"
+require "models/college"
 
 module ActiveRecord
   module DatabaseTasksSetupper
@@ -30,146 +31,207 @@ module ActiveRecord
       $stdout, $stderr = @original_stdout, @original_stderr
     end
 
-    def with_stubbed_new
+    def with_stubbed_new(&block)
       ActiveRecord::Tasks::MySQLDatabaseTasks.stub(:new, @mysql_tasks) do
         ActiveRecord::Tasks::PostgreSQLDatabaseTasks.stub(:new, @postgresql_tasks) do
-          ActiveRecord::Tasks::SQLiteDatabaseTasks.stub(:new, @sqlite_tasks) do
-            yield
-          end
+          ActiveRecord::Tasks::SQLiteDatabaseTasks.stub(:new, @sqlite_tasks, &block)
         end
       end
     end
   end
 
+  module DatabaseTasksHelper
+    def assert_called_for_configs(method_name, configs, &block)
+      mock = Minitest::Mock.new
+      configs.each { |config| mock.expect(:call, nil, config) }
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(method_name, mock, &block)
+      assert_mock(mock)
+    end
+  end
+
   ADAPTERS_TASKS = {
     mysql2:     :mysql_tasks,
+    trilogy:    :mysql_tasks,
     postgresql: :postgresql_tasks,
     sqlite3:    :sqlite_tasks
   }
 
-  class DatabaseTasksUtilsTask < ActiveRecord::TestCase
-    def test_raises_an_error_when_called_with_protected_environment
-      protected_environments = ActiveRecord::Base.protected_environments
-      current_env            = ActiveRecord::Base.connection.migration_context.current_environment
-
-      InternalMetadata[:environment] = current_env
-
-      assert_called_on_instance_of(
-        ActiveRecord::MigrationContext,
-        :current_version,
-        times: 6,
-        returns: 1
-      ) do
-        assert_not_includes protected_environments, current_env
-        # Assert no error
-        ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+  class DatabaseTasksCheckProtectedEnvironmentsTest < ActiveRecord::TestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      self.use_transactional_tests = false
 
-        ActiveRecord::Base.protected_environments = [current_env]
+      def setup
+        recreate_metadata_tables
+      end
 
-        assert_raise(ActiveRecord::ProtectedEnvironmentError) do
-          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
-        end
+      def teardown
+        recreate_metadata_tables
       end
-    ensure
-      ActiveRecord::Base.protected_environments = protected_environments
-    end
 
-    def test_raises_an_error_when_called_with_protected_environment_which_name_is_a_symbol
-      protected_environments = ActiveRecord::Base.protected_environments
-      current_env            = ActiveRecord::Base.connection.migration_context.current_environment
+      def test_raises_an_error_when_called_with_protected_environment
+        protected_environments = ActiveRecord::Base.protected_environments
+        current_env            = ActiveRecord::Base.connection_pool.migration_context.current_environment
 
-      InternalMetadata[:environment] = current_env
+        ActiveRecord::Base.connection_pool.internal_metadata[:environment] = current_env
 
-      assert_called_on_instance_of(
-        ActiveRecord::MigrationContext,
-        :current_version,
-        times: 6,
-        returns: 1
-      ) do
-        assert_not_includes protected_environments, current_env
-        # Assert no error
-        ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+        assert_called_on_instance_of(
+          ActiveRecord::MigrationContext,
+          :current_version,
+          times: 6,
+          returns: 1
+        ) do
+          assert_not_includes protected_environments, current_env
+          # Assert no error
+          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!("arunit")
 
-        ActiveRecord::Base.protected_environments = [current_env.to_sym]
-        assert_raise(ActiveRecord::ProtectedEnvironmentError) do
-          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+          ActiveRecord::Base.protected_environments = [current_env]
+
+          assert_raise(ActiveRecord::ProtectedEnvironmentError) do
+            ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!("arunit")
+          end
         end
+      ensure
+        ActiveRecord::Base.protected_environments = protected_environments
       end
-    ensure
-      ActiveRecord::Base.protected_environments = protected_environments
-    end
 
-    def test_raises_an_error_if_no_migrations_have_been_made
-      ActiveRecord::InternalMetadata.stub(:table_exists?, false) do
+      def test_raises_an_error_when_called_with_protected_environment_which_name_is_a_symbol
+        protected_environments = ActiveRecord::Base.protected_environments
+        current_env            = ActiveRecord::Base.connection_pool.migration_context.current_environment
+
+        ActiveRecord::Base.connection_pool.internal_metadata[:environment] = current_env
+
         assert_called_on_instance_of(
           ActiveRecord::MigrationContext,
           :current_version,
+          times: 6,
           returns: 1
         ) do
-          assert_raise(ActiveRecord::NoEnvironmentInSchemaError) do
-            ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+          assert_not_includes protected_environments, current_env
+          # Assert no error
+          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!("arunit")
+
+          ActiveRecord::Base.protected_environments = [current_env.to_sym]
+          assert_raise(ActiveRecord::ProtectedEnvironmentError) do
+            ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!("arunit")
           end
         end
+      ensure
+        ActiveRecord::Base.protected_environments = protected_environments
       end
-    end
-  end
 
-  class DatabaseTasksCurrentConfigTask < ActiveRecord::TestCase
-    def test_current_config_set
-      hash = {}
+      def test_raises_an_error_if_no_migrations_have_been_made
+        pool = ActiveRecord::Base.connection_pool
+        internal_metadata = pool.internal_metadata
+        schema_migration = pool.schema_migration
+        schema_migration.create_table
+        schema_migration.create_version("1")
 
-      with_stubbed_configurations do
-        ActiveRecord::Tasks::DatabaseTasks.current_config(config: hash, env: "production")
+        assert_predicate internal_metadata, :table_exists?
+        internal_metadata.drop_table
+        assert_not_predicate internal_metadata, :table_exists?
 
-        assert_equal hash, ActiveRecord::Tasks::DatabaseTasks.current_config(env: "production")
+        assert_raises(ActiveRecord::NoEnvironmentInSchemaError) do
+          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!("arunit")
+        end
+      ensure
+        pool.automatic_reconnect = true
+        schema_migration.delete_version("1")
+        internal_metadata.create_table
       end
-    end
 
-    def test_current_config_read_none_found
-      with_stubbed_configurations do
-        config = ActiveRecord::Tasks::DatabaseTasks.current_config(env: "production", spec: "empty")
+      private
+      def recreate_metadata_tables
+        schema_migration = ActiveRecord::Base.connection_pool.schema_migration
+        schema_migration.drop_table
+        schema_migration.create_table
 
-        assert_nil config
+        internal_metadata = ActiveRecord::Base.connection_pool.internal_metadata
+        internal_metadata.drop_table
+        internal_metadata.create_table
       end
     end
+  end
 
-    def test_current_config_read_found
-      with_stubbed_configurations do
-        config = ActiveRecord::Tasks::DatabaseTasks.current_config(env: "production", spec: "exists")
+  class DatabaseTasksCheckProtectedEnvironmentsMultiDatabaseTest < ActiveRecord::TestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      self.use_transactional_tests = false
 
-        assert_equal({ database: "my-db" }, config)
-      end
-    end
+      def test_with_multiple_databases
+        env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
 
-    def test_current_config_read_after_set
-      hash = {}
+        with_multi_db_configurations(env) do
+          protected_environments = ActiveRecord::Base.protected_environments
+          current_env = ActiveRecord::Base.connection_pool.migration_context.current_environment
+          assert_equal current_env, env
 
-      with_stubbed_configurations do
-        ActiveRecord::Tasks::DatabaseTasks.current_config(config: hash, env: "production")
+          ActiveRecord::Base.establish_connection(:primary)
+          ActiveRecord::Base.connection_pool.internal_metadata.create_table_and_set_flags(current_env)
 
-        config = ActiveRecord::Tasks::DatabaseTasks.current_config(env: "production", spec: "exists")
+          ActiveRecord::Base.establish_connection(:secondary)
+          ActiveRecord::Base.connection_pool.internal_metadata.create_table_and_set_flags(current_env)
 
-        assert_equal hash, config
-      end
-    end
+          assert_not_includes protected_environments, current_env
+          # Assert not raises
+          ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!(env)
 
-    private
-      def with_stubbed_configurations
-        old_configurations = ActiveRecord::Base.configurations
-        ActiveRecord::Base.configurations = { "production" => { "exists" => { "database" => "my-db" } } }
+          ActiveRecord::Base.establish_connection(:secondary)
+          pool = ActiveRecord::Base.connection_pool
+          schema_migration = pool.schema_migration
+          schema_migration.create_table
+          schema_migration.create_version("1")
 
-        assert_deprecated do
-          yield
-        end
-      ensure
-        ActiveRecord::Base.configurations = old_configurations
-        assert_deprecated do
-          ActiveRecord::Tasks::DatabaseTasks.current_config = nil
+          ActiveRecord::Base.protected_environments = [current_env.to_sym]
+
+          assert_raise(ActiveRecord::ProtectedEnvironmentError) do
+            ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!(env)
+          end
+        ensure
+          ActiveRecord::Base.protected_environments = protected_environments
         end
       end
+
+      private
+        def with_multi_db_configurations(env)
+          old_configurations = ActiveRecord::Base.configurations
+          ActiveRecord::Base.configurations = {
+            env => {
+              primary: {
+                adapter: "sqlite3",
+                database: "test/fixtures/fixture_database.sqlite3",
+              },
+              secondary: {
+                adapter: "sqlite3",
+                database: "test/fixtures/fixture_database_2.sqlite3",
+              }
+            }
+          }
+
+          ActiveRecord::Base.establish_connection(:primary)
+          yield
+        ensure
+          [:primary, :secondary].each do |db|
+            ActiveRecord::Base.establish_connection(db)
+            ActiveRecord::Base.connection_pool.schema_migration.delete_all_versions
+            ActiveRecord::Base.connection_pool.internal_metadata.delete_all_entries
+          end
+          ActiveRecord::Base.configurations = old_configurations
+          ActiveRecord::Base.establish_connection(:arunit)
+        end
+    end
   end
 
   class DatabaseTasksRegisterTask < ActiveRecord::TestCase
+    setup do
+      @tasks_was = ActiveRecord::Tasks::DatabaseTasks.instance_variable_get(:@tasks).dup
+      @adapters_was = ActiveRecord::ConnectionAdapters.instance_variable_get(:@adapters).dup
+    end
+
+    teardown do
+      ActiveRecord::Tasks::DatabaseTasks.instance_variable_set(:@tasks, @tasks_was)
+      ActiveRecord::ConnectionAdapters.instance_variable_set(:@adapters, @adapters_was)
+    end
+
     def test_register_task
       klazz = Class.new do
         def initialize(*arguments); end
@@ -179,15 +241,31 @@ module ActiveRecord
 
       klazz.stub(:new, instance) do
         assert_called_with(instance, :structure_dump, ["awesome-file.sql", nil]) do
-          ActiveRecord::Tasks::DatabaseTasks.register_task(/foo/, klazz)
-          ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :foo }, "awesome-file.sql")
+          ActiveRecord::Tasks::DatabaseTasks.register_task(/abstract/, klazz)
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => "abstract" }, "awesome-file.sql")
+        end
+      end
+    end
+
+    def test_register_task_precedence
+      klazz = Class.new do
+        def initialize(*arguments); end
+        def structure_dump(filename); end
+      end
+      instance = klazz.new
+
+      klazz.stub(:new, instance) do
+        assert_called_with(instance, :structure_dump, ["awesome-file.sql", nil]) do
+          ActiveRecord::ConnectionAdapters.register("custom_mysql", "ActiveRecord::ConnectionAdapters::Mysql2Adapter", "active_record/connection_adapters/mysql2_adapter")
+          ActiveRecord::Tasks::DatabaseTasks.register_task(/custom_mysql/, klazz)
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :custom_mysql }, "awesome-file.sql")
         end
       end
     end
 
     def test_unregistered_task
       assert_raise(ActiveRecord::Tasks::DatabaseNotSupported) do
-        ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :bar }, "awesome-file.sql")
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => "abstract" }, "awesome-file.sql")
       end
     end
   end
@@ -212,7 +290,7 @@ module ActiveRecord
         ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, dir) do
           path = File.join(dir, "schema_cache.yml")
           assert_not File.file?(path)
-          ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.connection, path)
+          ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.lease_connection, path)
           assert File.file?(path)
         end
       end
@@ -235,51 +313,49 @@ module ActiveRecord
     end
 
     def test_cache_dump_default_filename
-      old_path = ENV["SCHEMA_CACHE"]
-      ENV.delete("SCHEMA_CACHE")
+      config = DatabaseConfigurations::HashConfig.new("development", "primary", {})
 
       ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "db") do
-        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename("primary")
+        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(config)
         assert_equal "db/schema_cache.yml", path
       end
-    ensure
-      ENV["SCHEMA_CACHE"] = old_path
+    end
+
+    def test_cache_dump_default_filename_with_custom_db_dir
+      config = DatabaseConfigurations::HashConfig.new("development", "primary", {})
+
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "my_db") do
+        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(config)
+        assert_equal "my_db/schema_cache.yml", path
+      end
     end
 
     def test_cache_dump_alternate_filename
-      old_path = ENV["SCHEMA_CACHE"]
-      ENV.delete("SCHEMA_CACHE")
+      config = DatabaseConfigurations::HashConfig.new("development", "alternate", {})
 
       ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "db") do
-        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename("alternate")
+        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(config)
         assert_equal "db/alternate_schema_cache.yml", path
       end
-    ensure
-      ENV["SCHEMA_CACHE"] = old_path
     end
 
-    def test_cache_dump_filename_with_env_override
-      old_path = ENV["SCHEMA_CACHE"]
-      ENV["SCHEMA_CACHE"] = "tmp/something.yml"
+    def test_cache_dump_filename_with_path_from_db_config
+      config = DatabaseConfigurations::HashConfig.new("development", "primary", { schema_cache_path:  "tmp/something.yml" })
 
       ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "db") do
-        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename("primary")
+        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(config)
         assert_equal "tmp/something.yml", path
       end
-    ensure
-      ENV["SCHEMA_CACHE"] = old_path
     end
 
-    def test_cache_dump_filename_with_path_from_db_config
-      old_path = ENV["SCHEMA_CACHE"]
-      ENV.delete("SCHEMA_CACHE")
+
+    def test_cache_dump_filename_with_path_from_the_argument_has_precedence
+      config = DatabaseConfigurations::HashConfig.new("development", "primary", { schema_cache_path:  "tmp/something.yml" })
 
       ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "db") do
-        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename("primary", schema_cache_path: "tmp/something.yml")
-        assert_equal "tmp/something.yml", path
+        path = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(config, schema_cache_path: "tmp/another.yml")
+        assert_equal "tmp/another.yml", path
       end
-    ensure
-      ENV["SCHEMA_CACHE"] = old_path
     end
   end
 
@@ -287,7 +363,27 @@ module ActiveRecord
     def test_ensure_db_dir
       Dir.mktmpdir do |dir|
         ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, dir) do
-          db_config = OpenStruct.new(name: "fake_db_config")
+          updated_hash = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash.merge(schema_dump: "fake_db_config_schema.rb")
+          db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit", "primary", updated_hash)
+          path = "#{dir}/fake_db_config_schema.rb"
+
+          FileUtils.rm_rf(dir)
+          assert_not File.file?(path)
+
+          ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config)
+
+          assert File.file?(path)
+        end
+      end
+    ensure
+      ActiveRecord::Base.clear_cache!
+    end
+
+    def test_db_dir_ignored_if_included_in_schema_dump
+      Dir.mktmpdir do |dir|
+        ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, dir) do
+          updated_hash = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash.merge(schema_dump: "#{dir}/fake_db_config_schema.rb")
+          db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit", "primary", updated_hash)
           path = "#{dir}/fake_db_config_schema.rb"
 
           FileUtils.rm_rf(dir)
@@ -305,7 +401,7 @@ module ActiveRecord
 
   class DatabaseTasksCreateAllTest < ActiveRecord::TestCase
     def setup
-      @configurations = { "development" => { "database" => "my-db" } }
+      @configurations = { "development" => { "adapter" => "abstract", "database" => "my-db" } }
 
       $stdout, @original_stdout = StringIO.new, $stdout
       $stderr, @original_stderr = StringIO.new, $stderr
@@ -377,25 +473,25 @@ module ActiveRecord
     end
 
     private
-      def with_stubbed_configurations_establish_connection
+      def with_stubbed_configurations_establish_connection(&block)
         old_configurations = ActiveRecord::Base.configurations
         ActiveRecord::Base.configurations = @configurations
 
         # To refrain from connecting to a newly created empty DB in
         # sqlite3_mem tests
-        ActiveRecord::Base.connection_handler.stub(:establish_connection, nil) do
-          yield
-        end
+        ActiveRecord::Base.connection_handler.stub(:establish_connection, nil, &block)
       ensure
         ActiveRecord::Base.configurations = old_configurations
       end
   end
 
   class DatabaseTasksCreateCurrentTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
     def setup
       @configurations = {
-        "development" => { "database" => "dev-db" },
-        "test"        => { "database" => "test-db" },
+        "development" => { "adapter" => "abstract", "database" => "dev-db" },
+        "test"        => { "adapter" => "abstract", "database" => "test-db" },
         "production"  => { "url" => "abstract://prod-db-host/prod-db" }
       }
     end
@@ -430,8 +526,7 @@ module ActiveRecord
 
     def test_creates_test_and_development_databases_when_env_was_not_specified
       with_stubbed_configurations_establish_connection do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :create,
           [
             [config_for("development", "primary")],
@@ -450,8 +545,7 @@ module ActiveRecord
       ENV["RAILS_ENV"] = "development"
 
       with_stubbed_configurations_establish_connection do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :create,
           [
             [config_for("development", "primary")],
@@ -473,8 +567,7 @@ module ActiveRecord
       ENV["SKIP_TEST_DATABASE"] = "true"
 
       with_stubbed_configurations_establish_connection do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :create,
           [
             [config_for("development", "primary")]
@@ -505,31 +598,38 @@ module ActiveRecord
         ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: name)
       end
 
-      def with_stubbed_configurations_establish_connection
+      def with_stubbed_configurations_establish_connection(&block)
         old_configurations = ActiveRecord::Base.configurations
         ActiveRecord::Base.configurations = @configurations
 
-        ActiveRecord::Base.connection_handler.stub(:establish_connection, nil) do
-          yield
-        end
+        ActiveRecord::Base.connection_handler.stub(:establish_connection, nil, &block)
       ensure
         ActiveRecord::Base.configurations = old_configurations
       end
   end
 
   class DatabaseTasksCreateCurrentThreeTierTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
     def setup
       @configurations = {
-        "development" => { "primary" => { "database" => "dev-db" }, "secondary" => { "database" => "secondary-dev-db" } },
-        "test" => { "primary" => { "database" => "test-db" }, "secondary" => { "database" => "secondary-test-db" } },
-        "production" => { "primary" => { "url" => "abstract://prod-db-host/prod-db" }, "secondary" => { "url" => "abstract://secondary-prod-db-host/secondary-prod-db" } }
+        "development" => {
+          "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+        },
+        "test" => {
+          "primary" => { "adapter" => "abstract", "database" => "test-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-test-db" },
+        },
+        "production" => {
+          "primary" => { "url" => "abstract://prod-db-host/prod-db" },
+          "secondary" => { "url" => "abstract://secondary-prod-db-host/secondary-prod-db" } }
       }
     end
 
     def test_creates_current_environment_database
       with_stubbed_configurations_establish_connection do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :create,
           [
             [config_for("test", "primary")],
@@ -545,8 +645,7 @@ module ActiveRecord
 
     def test_creates_current_environment_database_with_url
       with_stubbed_configurations_establish_connection do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :create,
           [
             [config_for("production", "primary")],
@@ -562,8 +661,7 @@ module ActiveRecord
 
     def test_creates_test_and_development_databases_when_env_was_not_specified
       with_stubbed_configurations_establish_connection do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :create,
           [
             [config_for("development", "primary")],
@@ -584,8 +682,7 @@ module ActiveRecord
       ENV["RAILS_ENV"] = "development"
 
       with_stubbed_configurations_establish_connection do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :create,
           [
             [config_for("development", "primary")],
@@ -622,13 +719,11 @@ module ActiveRecord
         ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: name)
       end
 
-      def with_stubbed_configurations_establish_connection
+      def with_stubbed_configurations_establish_connection(&block)
         old_configurations = ActiveRecord::Base.configurations
         ActiveRecord::Base.configurations = @configurations
 
-        ActiveRecord::Base.connection_handler.stub(:establish_connection, nil) do
-          yield
-        end
+        ActiveRecord::Base.connection_handler.stub(:establish_connection, nil, &block)
       ensure
         ActiveRecord::Base.configurations = old_configurations
       end
@@ -650,7 +745,7 @@ module ActiveRecord
 
   class DatabaseTasksDropAllTest < ActiveRecord::TestCase
     def setup
-      @configurations = { development: { "database" => "my-db" } }
+      @configurations = { development: { "adapter" => "abstract", "database" => "my-db" } }
 
       $stdout, @original_stdout = StringIO.new, $stdout
       $stderr, @original_stderr = StringIO.new, $stderr
@@ -733,10 +828,12 @@ module ActiveRecord
   end
 
   class DatabaseTasksDropCurrentTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
     def setup
       @configurations = {
-        "development" => { "database" => "dev-db" },
-        "test"        => { "database" => "test-db" },
+        "development" => { "adapter" => "abstract", "database" => "dev-db" },
+        "test"        => { "adapter" => "abstract", "database" => "test-db" },
         "production"  => { "url" => "abstract://prod-db-host/prod-db" }
       }
     end
@@ -771,8 +868,7 @@ module ActiveRecord
 
     def test_drops_test_and_development_databases_when_env_was_not_specified
       with_stubbed_configurations do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :drop,
           [
             [config_for("development", "primary")],
@@ -791,8 +887,7 @@ module ActiveRecord
       ENV["RAILS_ENV"] = "development"
 
       with_stubbed_configurations do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :drop,
           [
             [config_for("development", "primary")],
@@ -824,18 +919,28 @@ module ActiveRecord
   end
 
   class DatabaseTasksDropCurrentThreeTierTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
     def setup
       @configurations = {
-        "development" => { "primary" => { "database" => "dev-db" }, "secondary" => { "database" => "secondary-dev-db" } },
-        "test" => { "primary" => { "database" => "test-db" }, "secondary" => { "database" => "secondary-test-db" } },
-        "production" => { "primary" => { "url" => "abstract://prod-db-host/prod-db" }, "secondary" => { "url" => "abstract://secondary-prod-db-host/secondary-prod-db" } }
+        "development" => {
+          "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+        },
+        "test" => {
+          "primary" => { "adapter" => "abstract", "database" => "test-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-test-db" },
+        },
+        "production" => {
+          "primary" => { "url" => "abstract://prod-db-host/prod-db" },
+          "secondary" => { "url" => "abstract://secondary-prod-db-host/secondary-prod-db" },
+        },
       }
     end
 
     def test_drops_current_environment_database
       with_stubbed_configurations do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :drop,
           [
             [config_for("test", "primary")],
@@ -851,8 +956,7 @@ module ActiveRecord
 
     def test_drops_current_environment_database_with_url
       with_stubbed_configurations do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :drop,
           [
             [config_for("production", "primary")],
@@ -868,8 +972,7 @@ module ActiveRecord
 
     def test_drops_test_and_development_databases_when_env_was_not_specified
       with_stubbed_configurations do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :drop,
           [
             [config_for("development", "primary")],
@@ -890,8 +993,7 @@ module ActiveRecord
       ENV["RAILS_ENV"] = "development"
 
       with_stubbed_configurations do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :drop,
           [
             [config_for("development", "primary")],
@@ -924,18 +1026,19 @@ module ActiveRecord
       end
   end
 
-  if current_adapter?(:SQLite3Adapter) && !in_memory_db?
-    class DatabaseTasksMigrationTestCase < ActiveRecord::TestCase
+  class DatabaseTasksMigrationTestCase < ActiveRecord::TestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
       self.use_transactional_tests = false
+      class_attribute :folder_name, default: "valid"
 
       # Use a memory db here to avoid having to rollback at the end
       setup do
-        migrations_path = MIGRATIONS_ROOT + "/valid"
-        file = ActiveRecord::Base.connection.raw_connection.filename
+        migrations_path = [MIGRATIONS_ROOT, folder_name].join("/")
+        file = ActiveRecord::Base.lease_connection.raw_connection.filename
         @conn = ActiveRecord::Base.establish_connection adapter: "sqlite3",
           database: ":memory:", migrations_paths: migrations_path
         source_db = SQLite3::Database.new file
-        dest_db = ActiveRecord::Base.connection.raw_connection
+        dest_db = ActiveRecord::Base.lease_connection.raw_connection
         backup = SQLite3::Backup.new(dest_db, "main", source_db, "main")
         backup.step(-1)
         backup.finish
@@ -945,9 +1048,18 @@ module ActiveRecord
         @conn.release_connection if @conn
         ActiveRecord::Base.establish_connection :arunit
       end
+
+      private
+        def capture_migration_output
+          capture(:stdout) do
+            ActiveRecord::Tasks::DatabaseTasks.migrate
+          end
+        end
     end
+  end
 
-    class DatabaseTasksMigrateTest < DatabaseTasksMigrationTestCase
+  class DatabaseTasksMigrateTest < DatabaseTasksMigrationTestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
       def test_migrate_set_and_unset_empty_values_for_verbose_and_version_env_vars
         verbose, version = ENV["VERBOSE"], ENV["VERSION"]
 
@@ -983,24 +1095,85 @@ module ActiveRecord
       ensure
         ENV["VERBOSE"], ENV["VERSION"] = verbose, version
       end
+    end
+  end
 
-      private
-        def capture_migration_output
-          capture(:stdout) do
-            ActiveRecord::Tasks::DatabaseTasks.migrate
-          end
-        end
+  class DatabaseTasksMigrateScopeTest < DatabaseTasksMigrationTestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      self.folder_name = "scope"
+
+      def test_migrate_using_scope_and_verbose_mode
+        verbose, version, scope = ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"]
+
+        # run up migration
+        ENV["VERSION"] = "2"
+        ENV["VERBOSE"] = "true"
+        ENV["SCOPE"] = "mysql"
+
+        output = capture_migration_output
+        assert_includes output, "migrating"
+        assert_not_includes output, "No migrations ran. (using mysql scope)"
+
+        # run no migration because 2 was already run
+        output = capture_migration_output
+        assert_includes output, "No migrations ran. (using mysql scope)"
+        assert_not_includes output, "migrating"
+      ensure
+        ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"] = verbose, version, scope
+      end
+
+      def test_migrate_using_scope_and_non_verbose_mode
+        verbose, version, scope = ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"]
+
+        # run up migration
+        ENV["VERSION"] = "2"
+        ENV["VERBOSE"] = "false"
+        ENV["SCOPE"] = "mysql"
+
+        assert_empty capture_migration_output
+
+        # run no migration because 2 was already run
+        assert_empty capture_migration_output
+      ensure
+        ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"] = verbose, version, scope
+      end
+
+      def test_migrate_using_empty_scope_and_verbose_mode
+        verbose, version, scope = ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"]
+
+        # run up migration
+        ENV["VERSION"] = "2"
+        ENV["VERBOSE"] = "true"
+        ENV["SCOPE"] = ""
+
+        output = capture_migration_output
+        assert_includes output, "migrating"
+        assert_not_includes output, "No migrations ran. (using mysql scope)"
+
+        # run no migration because 1 already ran and 2 is mysql scoped
+        output = capture_migration_output
+        assert_empty output
+        assert_not_includes output, "No migrations ran. (using mysql scope)"
+      ensure
+        ENV["VERBOSE"], ENV["VERSION"], ENV["SCOPE"] = verbose, version, scope
+      end
     end
+  end
+
+  class DatabaseTasksMigrateStatusTest < DatabaseTasksMigrationTestCase
+    if current_adapter?(:SQLite3Adapter) && !in_memory_db?
+      def setup
+        @schema_migration = ActiveRecord::Base.connection_pool.schema_migration
+      end
 
-    class DatabaseTasksMigrateStatusTest < DatabaseTasksMigrationTestCase
       def test_migrate_status_table
-        ActiveRecord::SchemaMigration.create_table
+        @schema_migration.create_table
         output = capture_migration_status
         assert_match(/database: :memory:/, output)
         assert_match(/down    001             Valid people have last names/, output)
         assert_match(/down    002             We need reminders/, output)
         assert_match(/down    003             Innocent jointable/, output)
-        ActiveRecord::SchemaMigration.drop_table
+        @schema_migration.delete_all_versions
       end
 
       private
@@ -1042,6 +1215,10 @@ module ActiveRecord
       e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
       assert_match(/Invalid format of target version/, e.message)
 
+      ENV["VERSION"] = "1__1"
+      e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
+      assert_match(/Invalid format of target version/, e.message)
+
       ENV["VERSION"] = "1_name"
       e = assert_raise(RuntimeError) { ActiveRecord::Tasks::DatabaseTasks.migrate }
       assert_match(/Invalid format of target version/, e.message)
@@ -1057,7 +1234,7 @@ module ActiveRecord
     end
 
     def test_migrate_clears_schema_cache_afterward
-      assert_called(ActiveRecord::Base, :clear_cache!) do
+      assert_called(ActiveRecord::Base.schema_cache, :clear!) do
         ActiveRecord::Tasks::DatabaseTasks.migrate
       end
     end
@@ -1081,9 +1258,9 @@ module ActiveRecord
     def test_purges_current_environment_database
       old_configurations = ActiveRecord::Base.configurations
       configurations = {
-        "development" => { "database" => "dev-db" },
-        "test"        => { "database" => "test-db" },
-        "production"  => { "database" => "prod-db" }
+        "development" => { "adapter" => "abstract", "database" => "dev-db" },
+        "test"        => { "adapter" => "abstract", "database" => "test-db" },
+        "production"  => { "adapter" => "abstract", "database" => "prod-db" },
       }
 
       ActiveRecord::Base.configurations = configurations
@@ -1105,7 +1282,7 @@ module ActiveRecord
   class DatabaseTasksPurgeAllTest < ActiveRecord::TestCase
     def test_purge_all_local_configurations
       old_configurations = ActiveRecord::Base.configurations
-      configurations = { development: { "database" => "my-db" } }
+      configurations = { development: { "adapter" => "abstract", "database" => "my-db" } }
       ActiveRecord::Base.configurations = configurations
 
       assert_called_with(
@@ -1120,33 +1297,39 @@ module ActiveRecord
     end
   end
 
-  unless in_memory_db?
-    class DatabaseTasksTruncateAllTest < ActiveRecord::TestCase
+  class DatabaseTasksTruncateAllTest < ActiveRecord::TestCase
+    unless in_memory_db?
       self.use_transactional_tests = false
 
-      fixtures :authors, :author_addresses
+      fixtures :courses, :colleges
 
       def setup
-        SchemaMigration.create_table
-        SchemaMigration.create!(version: SchemaMigration.table_name)
-        InternalMetadata.create_table
-        InternalMetadata.create!(key: InternalMetadata.table_name)
+        pool = ARUnit2Model.connection_pool
+        @schema_migration = pool.schema_migration
+        @schema_migration.create_table
+        @schema_migration.create_version(@schema_migration.table_name)
+
+        @internal_metadata = pool.internal_metadata
+        @internal_metadata.create_table
+        @internal_metadata[@internal_metadata.table_name] = nil
+
+        @old_configurations = ActiveRecord::Base.configurations
       end
 
       def teardown
-        SchemaMigration.delete_all
-        InternalMetadata.delete_all
+        @schema_migration.delete_all_versions
+        @internal_metadata.delete_all_entries
         clean_up_connection_handler
+        ActiveRecord::Base.configurations = @old_configurations
       end
 
       def test_truncate_tables
-        assert_operator SchemaMigration.count, :>, 0
-        assert_operator InternalMetadata.count, :>, 0
-        assert_operator Author.count, :>, 0
-        assert_operator AuthorAddress.count, :>, 0
+        assert_operator @schema_migration.count, :>, 0
+        assert_operator @internal_metadata.count, :>, 0
+        assert_operator Course.count, :>, 0
+        assert_operator College.count, :>, 0
 
-        old_configurations = ActiveRecord::Base.configurations
-        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit2", name: "primary")
         configurations = { development: db_config.configuration_hash }
         ActiveRecord::Base.configurations = configurations
 
@@ -1156,61 +1339,57 @@ module ActiveRecord
           )
         end
 
-        assert_operator SchemaMigration.count, :>, 0
-        assert_operator InternalMetadata.count, :>, 0
-        assert_equal 0, Author.count
-        assert_equal 0, AuthorAddress.count
-      ensure
-        ActiveRecord::Base.configurations = old_configurations
+        assert_operator @schema_migration.count, :>, 0
+        assert_operator @internal_metadata.count, :>, 0
+        assert_equal 0, Course.count
+        assert_equal 0, College.count
       end
     end
 
     class DatabaseTasksTruncateAllWithPrefixTest < DatabaseTasksTruncateAllTest
       setup do
         ActiveRecord::Base.table_name_prefix = "p_"
-
-        SchemaMigration.reset_table_name
-        InternalMetadata.reset_table_name
       end
 
       teardown do
         ActiveRecord::Base.table_name_prefix = nil
-
-        SchemaMigration.reset_table_name
-        InternalMetadata.reset_table_name
       end
     end
 
     class DatabaseTasksTruncateAllWithSuffixTest < DatabaseTasksTruncateAllTest
       setup do
         ActiveRecord::Base.table_name_suffix = "_s"
-
-        SchemaMigration.reset_table_name
-        InternalMetadata.reset_table_name
       end
 
       teardown do
         ActiveRecord::Base.table_name_suffix = nil
-
-        SchemaMigration.reset_table_name
-        InternalMetadata.reset_table_name
       end
     end
   end
 
   class DatabaseTasksTruncateAllWithMultipleDatabasesTest < ActiveRecord::TestCase
+    include DatabaseTasksHelper
+
     def setup
       @configurations = {
-        "development" => { "primary" => { "database" => "dev-db" }, "secondary" => { "database" => "secondary-dev-db" } },
-        "test" => { "primary" => { "database" => "test-db" }, "secondary" => { "database" => "secondary-test-db" } },
-        "production" => { "primary" => { "url" => "abstract://prod-db-host/prod-db" }, "secondary" => { "url" => "abstract://secondary-prod-db-host/secondary-prod-db" } }
+        "development" => {
+          "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+        },
+        "test" => {
+          "primary" => { "adapter" => "abstract", "database" => "test-db" },
+          "secondary" => { "adapter" => "abstract", "database" => "secondary-test-db" },
+        },
+        "production" => {
+          "primary" => { "url" => "abstract://prod-db-host/prod-db" },
+          "secondary" => { "url" => "abstract://secondary-prod-db-host/secondary-prod-db" },
+         }
       }
     end
 
     def test_truncate_all_databases_for_environment
       with_stubbed_configurations do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :truncate_tables,
           [
             [config_for("test", "primary")],
@@ -1226,8 +1405,7 @@ module ActiveRecord
 
     def test_truncate_all_databases_with_url_for_environment
       with_stubbed_configurations do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :truncate_tables,
           [
             [config_for("production", "primary")],
@@ -1243,8 +1421,7 @@ module ActiveRecord
 
     def test_truncate_all_development_databases_when_env_is_not_specified
       with_stubbed_configurations do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :truncate_tables,
           [
             [config_for("development", "primary")],
@@ -1263,8 +1440,7 @@ module ActiveRecord
       ENV["RAILS_ENV"] = "development"
 
       with_stubbed_configurations do
-        assert_called_with(
-          ActiveRecord::Tasks::DatabaseTasks,
+        assert_called_for_configs(
           :truncate_tables,
           [
             [config_for("development", "primary")],
@@ -1311,7 +1487,7 @@ module ActiveRecord
     def test_charset_current
       old_configurations = ActiveRecord::Base.configurations
       configurations = {
-        "production" => { "database" => "prod-db" }
+        "production" => { "adapter" => "abstract", "database" => "prod-db" }
       }
 
       ActiveRecord::Base.configurations = configurations
@@ -1344,7 +1520,7 @@ module ActiveRecord
     def test_collation_current
       old_configurations = ActiveRecord::Base.configurations
       configurations = {
-        "production" => { "database" => "prod-db" }
+        "production" => { "adapter" => "abstract", "database" => "prod-db" }
       }
 
       ActiveRecord::Base.configurations = configurations
@@ -1382,13 +1558,16 @@ module ActiveRecord
       version = ENV["VERSION"]
 
       ENV["VERSION"] = "0"
-      assert_equal ENV["VERSION"].to_i, ActiveRecord::Tasks::DatabaseTasks.target_version
+      assert_equal 0, ActiveRecord::Tasks::DatabaseTasks.target_version
 
       ENV["VERSION"] = "42"
-      assert_equal ENV["VERSION"].to_i, ActiveRecord::Tasks::DatabaseTasks.target_version
+      assert_equal 42, ActiveRecord::Tasks::DatabaseTasks.target_version
 
       ENV["VERSION"] = "042"
-      assert_equal ENV["VERSION"].to_i, ActiveRecord::Tasks::DatabaseTasks.target_version
+      assert_equal 42, ActiveRecord::Tasks::DatabaseTasks.target_version
+
+      ENV["VERSION"] = "2000_01_01_000042"
+      assert_equal 20000101000042, ActiveRecord::Tasks::DatabaseTasks.target_version
     ensure
       ENV["VERSION"] = version
     end
@@ -1403,7 +1582,7 @@ module ActiveRecord
       ENV["VERSION"] = version
     end
 
-    def test_check_target_version_does_not_raise_error_if_version_is_not_setted
+    def test_check_target_version_does_not_raise_error_if_version_is_not_set
       version = ENV.delete("VERSION")
       assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
     ensure
@@ -1456,6 +1635,9 @@ module ActiveRecord
       ENV["VERSION"] = "001"
       assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
 
+      ENV["VERSION"] = "1_001"
+      assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
+
       ENV["VERSION"] = "001_name.rb"
       assert_nothing_raised { ActiveRecord::Tasks::DatabaseTasks.check_target_version }
     ensure
@@ -1506,21 +1688,112 @@ module ActiveRecord
     end
   end
 
-  class DatabaseTasksCheckSchemaFileDefaultsTest < ActiveRecord::TestCase
-    def test_check_schema_file_defaults
+  class DatabaseTasksCheckSchemaFileMethods < ActiveRecord::TestCase
+    setup do
+      @configurations = { "development" => { "adapter" => "abstract", "database" => "my-db" } }
+    end
+
+    def test_check_dump_filename_defaults
       ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
-        assert_equal "/tmp/schema.rb", ActiveRecord::Tasks::DatabaseTasks.schema_file
+        with_stubbed_configurations do
+          assert_equal "/tmp/schema.rb", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "primary"))
+        end
       end
     end
-  end
 
-  class DatabaseTasksCheckSchemaFileSpecifiedFormatsTest < ActiveRecord::TestCase
+    def test_check_dump_filename_with_schema_env
+      schema = ENV["SCHEMA"]
+      ENV["SCHEMA"] = "schema_path"
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+        with_stubbed_configurations do
+          assert_equal "schema_path", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "primary"))
+        end
+      end
+    ensure
+      ENV["SCHEMA"] = schema
+    end
+
+    { ruby: "schema.rb", sql: "structure.sql" }.each_pair do |fmt, filename|
+      define_method("test_check_dump_filename_for_#{fmt}_format") do
+        ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+          with_stubbed_configurations do
+            assert_equal "/tmp/#{filename}", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "primary"), fmt)
+          end
+        end
+      end
+    end
+
+    def test_check_dump_filename_defaults_for_non_primary_databases
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+        configurations = {
+          "development" => {
+            "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+            "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+          },
+        }
+        with_stubbed_configurations(configurations) do
+          assert_equal "/tmp/secondary_schema.rb", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "secondary"))
+        end
+      end
+    end
+
+    def test_setting_schema_dump_to_nil
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+        configurations = {
+          "development" => { "primary" => { "adapter" => "abstract", "database" => "dev-db", "schema_dump" => false } },
+        }
+        with_stubbed_configurations(configurations) do
+          assert_nil ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "primary"))
+        end
+      end
+    end
+
+    def test_check_dump_filename_with_schema_env_with_non_primary_databases
+      schema = ENV["SCHEMA"]
+      ENV["SCHEMA"] = "schema_path"
+      ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
+        configurations = {
+          "development" => {
+            "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+            "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+          },
+        }
+        with_stubbed_configurations(configurations) do
+          assert_equal "schema_path", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "secondary"))
+        end
+      end
+    ensure
+      ENV["SCHEMA"] = schema
+    end
+
     { ruby: "schema.rb", sql: "structure.sql" }.each_pair do |fmt, filename|
-      define_method("test_check_schema_file_for_#{fmt}_format") do
+      define_method("test_check_dump_filename_for_#{fmt}_format_with_non_primary_databases") do
         ActiveRecord::Tasks::DatabaseTasks.stub(:db_dir, "/tmp") do
-          assert_equal "/tmp/#{filename}", ActiveRecord::Tasks::DatabaseTasks.schema_file(fmt)
+          configurations = {
+            "development" => {
+              "primary" => { "adapter" => "abstract", "database" => "dev-db" },
+              "secondary" => { "adapter" => "abstract", "database" => "secondary-dev-db" },
+            },
+          }
+          with_stubbed_configurations(configurations) do
+            assert_equal "/tmp/secondary_#{filename}", ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(config_for("development", "secondary"), fmt)
+          end
         end
       end
     end
+
+    private
+      def config_for(env_name, name)
+        ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: name)
+      end
+
+      def with_stubbed_configurations(configurations = @configurations)
+        old_configurations = ActiveRecord::Base.configurations
+        ActiveRecord::Base.configurations = configurations
+
+        yield
+      ensure
+        ActiveRecord::Base.configurations = old_configurations
+      end
   end
 end