data_migrate 10.0.0.rc1 → 11.0.0.rc

data/lib/data_migrate/migration_context.rb

@@ -11,7 +11,8 @@ module DataMigrate
                               migrations
                             end
 
-      DataMigrator.new(:up, selected_migrations, target_version).migrate
+      data_migrator = DataMigrate::RailsHelper.data_migrator(:up, selected_migrations, DataMigrate::RailsHelper.schema_migration, DataMigrate::RailsHelper.internal_metadata, target_version)
+      data_migrator.migrate
     end
 
     def down(target_version = nil)
@@ -22,11 +23,13 @@ module DataMigrate
           migrations
         end
 
-      DataMigrator.new(:down, selected_migrations, target_version).migrate
+      data_migrator = DataMigrate::RailsHelper.data_migrator(:down, selected_migrations, DataMigrate::RailsHelper.schema_migration, DataMigrate::RailsHelper.internal_metadata, target_version)
+      data_migrator.migrate
     end
 
     def run(direction, target_version)
-      DataMigrator.new(direction, migrations, target_version).run
+      data_migrator = DataMigrate::RailsHelper.data_migrator(direction, migrations, DataMigrate::RailsHelper.schema_migration, DataMigrate::RailsHelper.internal_metadata, target_version)
+      data_migrator.run
     end
 
     def current_version
@@ -40,12 +43,12 @@ module DataMigrate
     end
 
     def migrations_status
-      db_list = DataSchemaMigration.normalized_versions
+      db_list = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
 
       file_list = migration_files.map do |file|
         version, name, scope = parse_migration_filename(file)
         raise ActiveRecord::IllegalMigrationNameError.new(file) unless version
-        version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
+        version = DataMigrate::RailsHelper.schema_migration.normalize_migration_number(version)
         status = db_list.delete(version) ? "up" : "down"
         [status, version, (name + scope).humanize]
       end.compact
@@ -60,15 +63,15 @@ module DataMigrate
     private
 
     def get_all_versions
-      if DataMigrate::DataSchemaMigration.table_exists?
-        DataSchemaMigration.normalized_versions.map(&:to_i)
+      if DataMigrate::RailsHelper.data_schema_migration.table_exists?
+        DataMigrate::RailsHelper.data_schema_migration.normalized_versions.map(&:to_i)
       else
         []
       end
     end
 
     def move(direction, steps)
-      migrator = DataMigrator.new(direction, migrations)
+      migrator = DataMigrate::RailsHelper.data_migrator(direction, migrations)
 
       if current_version != 0 && !migrator.current_migration
         raise ActiveRecord::UnknownMigrationVersionError.new(current_version)

data/lib/data_migrate/rails_helper.rb

@@ -0,0 +1,90 @@
+module DataMigrate
+  class RailsHelper
+    class << self
+      def rails_version_equal_to_or_higher_than_7_2
+        return @equal_to_or_higher_than_7_2 if defined?(@equal_to_or_higher_than_7_2)
+
+        @equal_to_or_higher_than_7_2 = Gem::Dependency.new("railties", ">= 7.2.0.alpha").match?("railties", Gem.loaded_specs["railties"].version, true)
+      end
+      def rails_version_equal_to_or_higher_than_7_1
+        return @equal_to_or_higher_than_7_1 if defined?(@equal_to_or_higher_than_7_1)
+
+        @equal_to_or_higher_than_7_1 = Gem::Dependency.new("railties", ">= 7.1.0.alpha").match?("railties", Gem.loaded_specs["railties"].version, true)
+      end
+
+      def rails_version_equal_to_or_higher_than_7_0
+        return @rails_version_equal_to_or_higher_than_7_0 if defined?(@rails_version_equal_to_or_higher_than_7_0)
+
+        @rails_version_equal_to_or_higher_than_7_0 = Gem::Dependency.new("railties", ">= 7.0").match?("railties", Gem.loaded_specs["railties"].version, true)
+      end
+
+      def internal_metadata
+        if rails_version_equal_to_or_higher_than_7_2
+          ActiveRecord::Base.connection_pool.internal_metadata
+        elsif rails_version_equal_to_or_higher_than_7_1
+          ActiveRecord::Base.connection.internal_metadata
+        else
+          ActiveRecord::InternalMetadata
+        end
+      end
+
+      def schema_migration
+        if rails_version_equal_to_or_higher_than_7_2
+          ActiveRecord::Base.connection_pool.schema_migration
+        elsif rails_version_equal_to_or_higher_than_7_1
+          ActiveRecord::Base.connection.schema_migration
+        else
+          ActiveRecord::SchemaMigration
+        end
+      end
+
+      def schema_migration_versions
+        if rails_version_equal_to_or_higher_than_7_1
+          schema_migration.versions
+        else
+          schema_migration.all.pluck(:version)
+        end
+      end
+
+      def schema_create_version(version)
+        if rails_version_equal_to_or_higher_than_7_1
+          schema_migration.create_version(version)
+        else
+          schema_migration.create(version: version)
+        end
+      end
+
+      def data_schema_delete_version(version)
+        if rails_version_equal_to_or_higher_than_7_1
+          data_schema_migration.delete_version(version)
+        else
+          data_schema_migration.where(version: version.to_s).delete_all
+        end
+      end
+
+      def data_schema_migration
+        if rails_version_equal_to_or_higher_than_7_2
+          DataMigrate::DataSchemaMigration.new(ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool)
+        elsif rails_version_equal_to_or_higher_than_7_1
+          DataMigrate::DataSchemaMigration.new(ActiveRecord::Tasks::DatabaseTasks.migration_connection)
+        else
+          DataMigrate::DataSchemaMigration
+        end
+      end
+
+      def data_migrator(
+        direction,
+        migrations,
+        schema_migration = DataMigrate::RailsHelper.schema_migration,
+        internal_metadata = DataMigrate::RailsHelper.internal_metadata,
+        target_version = nil
+      )
+        if rails_version_equal_to_or_higher_than_7_1
+          DataMigrate::DataMigrator.new(direction, migrations, schema_migration, internal_metadata, target_version)
+        else
+          DataMigrate::DataMigrator.new(direction, migrations, schema_migration, target_version)
+        end
+      end
+    end
+  end
+end

data/lib/data_migrate/schema_dumper.rb

@@ -26,7 +26,7 @@ module DataMigrate
 
     def initialize(connection)
       @connection = connection
-      all_versions =  DataSchemaMigration.normalized_versions
+      all_versions =  DataMigrate::RailsHelper.data_schema_migration.normalized_versions
 
       @version = begin
                     all_versions.max

data/lib/data_migrate/schema_migration.rb

@@ -7,14 +7,14 @@ module DataMigrate
     def self.pending_schema_migrations
       all_migrations = DataMigrate::MigrationContext.new(migrations_paths).migrations
       sort_migrations(
-        ActiveRecord::Migrator.new(:up, all_migrations, ActiveRecord::Base.connection.schema_migration).
+        ActiveRecord::Migrator.new(:up, all_migrations, DataMigrate::RailsHelper.schema_migration, DataMigrate::RailsHelper.internal_metadata).
         pending_migrations.
         map {|m| { version: m.version, kind: :schema }}
       )
     end
 
     def self.run(direction, migration_paths, version)
-      ActiveRecord::MigrationContext.new(migration_paths, ActiveRecord::Base.connection.schema_migration).run(direction, version)
+      ActiveRecord::MigrationContext.new(migration_paths, DataMigrate::RailsHelper.schema_migration).run(direction, version)
     end
 
     def self.sort_migrations(set1, set2 = nil)
@@ -24,9 +24,10 @@ module DataMigrate
 
     def self.migrations_paths
       spec_name = DataMigrate.config.spec_name
-      if spec_name && Gem::Dependency.new("rails", "~> 7.0").match?("rails", Gem.loaded_specs["rails"].version)
+      # The positional argument true is to include pre-release versions, such as 7.1.0.alpha
+      if spec_name && Gem::Dependency.new("railties", ">= 7.0").match?("railties", Gem.loaded_specs["railties"].version, true)
         ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: spec_name).migrations_paths
-      elsif spec_name && Gem::Dependency.new("rails", "~> 6.0").match?("rails", Gem.loaded_specs["rails"].version)
+      elsif spec_name && Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
         ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: spec_name).migrations_paths
       else
         Rails.application.config.paths["db/migrate"].to_a

data/lib/data_migrate/status_service.rb

@@ -24,11 +24,11 @@ module DataMigrate
     private
 
     def table_name
-      DataMigrate::DataSchemaMigration.table_name
+      DataMigrate::RailsHelper.data_schema_migration.table_name
     end
 
     def output(stream)
-      unless DataMigrate::DataSchemaMigration.table_exists?
+      unless DataMigrate::RailsHelper.data_schema_migration.table_exists?
         stream.puts "Data migrations table does not exist yet."
         return
       end
@@ -44,9 +44,9 @@ module DataMigrate
     end
 
     def database_name
-      if Gem::Dependency.new("rails", "~> 7.0").match?("rails", Gem.loaded_specs["rails"].version)
+      if Gem::Dependency.new("railties", "~> 7.0").match?("railties", Gem.loaded_specs["railties"].version)
         ActiveRecord::Base.connection_db_config.configuration_hash[:database]
-      elsif Gem::Dependency.new("rails", "~> 6.0").match?("rails", Gem.loaded_specs["rails"].version)
+      elsif Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
         ActiveRecord::Base.connection_config[:database]
       end
     end

data/lib/data_migrate/tasks/data_migrate_tasks.rb

@@ -9,9 +9,9 @@ module DataMigrate
         @migrations_paths ||= DataMigrate.config.data_migrations_path
       end
 
-      def dump(db_config)
+      def dump
         if dump_schema_after_migration?
-          filename = DataMigrate::DatabaseTasks.dump_filename(spec_name(db_config), ActiveRecord::Base.schema_format)
+          filename = DataMigrate::DatabaseTasks.schema_file
           ActiveRecord::Base.establish_connection(DataMigrate.config.db_configuration) if DataMigrate.config.db_configuration
           File.open(filename, "w:utf-8") do |file|
             DataMigrate::SchemaDumper.dump(ActiveRecord::Base.connection, file)
@@ -22,7 +22,7 @@ module DataMigrate
       def migrate
         target_version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
 
-        DataMigrate::DataMigrator.assure_data_schema_table
+        DataMigrate::DataMigrator.create_data_schema_table
         DataMigrate::MigrationContext.new(migrations_paths).migrate(target_version)
       end
 
@@ -44,16 +44,15 @@ module DataMigrate
         end
       end
 
-      def status(db_config)
-        puts "\ndatabase: #{spec_name(db_config)}\n\n"
-        DataMigrate::StatusService.dump(ActiveRecord::Base.connection)
+      def status
+        DataMigrate::StatusService.dump
       end
 
-      def status_with_schema(db_config)
+      def status_with_schema
         db_list_data = ActiveRecord::Base.connection.select_values(
-          "SELECT version FROM #{DataMigrate::DataSchemaMigration.table_name}"
+          "SELECT version FROM #{DataMigrate::RailsHelper.data_schema_migration.table_name}"
         )
-        db_list_schema = ActiveRecord::SchemaMigration.all.pluck(:version)
+        db_list_schema = DataMigrate::RailsHelper.schema_migration_versions
         file_list = []
 
         Dir.foreach(File.join(Rails.root, migrations_paths)) do |file|
@@ -77,7 +76,7 @@ module DataMigrate
         file_list.sort!{|a,b| "#{a[1]}_#{a[3] == 'data' ? 1 : 0}" <=> "#{b[1]}_#{b[3] == 'data' ? 1 : 0}" }
 
         # output
-        puts "\ndatabase: #{spec_name(db_config)}\n\n"
+        puts "\ndatabase: #{database_name}\n\n"
         puts "#{"Status".center(8)} #{"Type".center(8)}  #{"Migration ID".ljust(14)} Migration Name"
         puts "-" * 60
         file_list.each do |file|
@@ -94,11 +93,11 @@ module DataMigrate
 
       private
 
-      def spec_name(db_config)
-        if Gem::Dependency.new("rails", "~> 7.0").match?("rails", Gem.loaded_specs["rails"].version)
-          db_config.name
-        elsif Gem::Dependency.new("rails", "~> 6.0").match?("rails", Gem.loaded_specs["rails"].version)
-          db_config.spec_name
+      def database_name
+        if Gem::Dependency.new("railties", "~> 7.0").match?("railties", Gem.loaded_specs["railties"].version)
+          ActiveRecord::Base.connection_db_config.database
+        elsif Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
+          ActiveRecord::Base.connection_config[:database]
         end
       end
     end

data/lib/data_migrate/test.rb

@@ -0,0 +1,14 @@
+module Base
+  extend self
+
+  def foo
+    puts "Base#foo called"
+  end
+end
+
+module Child
+  extend Base
+  extend self
+
+  puts "foo: #{respond_to?(:foo)}"
+end

data/lib/data_migrate/version.rb

@@ -1,3 +1,3 @@
 module DataMigrate
-  VERSION = "10.0.0.rc1".freeze
+  VERSION = "11.0.0.rc".freeze
 end

data/lib/data_migrate.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require File.join(File.dirname(__FILE__), "data_migrate", "rails_helper")
 require File.join(File.dirname(__FILE__), "data_migrate", "data_migrator")
 require File.join(File.dirname(__FILE__), "data_migrate", "data_schema_migration")
 require File.join(File.dirname(__FILE__), "data_migrate", "data_schema")
@@ -9,9 +10,9 @@ require File.join(File.dirname(__FILE__), "data_migrate", "status_service")
 require File.join(File.dirname(__FILE__), "data_migrate", "migration_context")
 require File.join(File.dirname(__FILE__), "data_migrate", "railtie")
 require File.join(File.dirname(__FILE__), "data_migrate", "tasks/data_migrate_tasks")
-require File.join(File.dirname(__FILE__), "data_migrate", "legacy_migrator")
 require File.join(File.dirname(__FILE__), "data_migrate", "config")
 require File.join(File.dirname(__FILE__), "data_migrate", "schema_migration")
+require File.join(File.dirname(__FILE__), "data_migrate", "database_configurations_wrapper")
 
 module DataMigrate
   def self.root

data/spec/data_migrate/data_migrator_spec.rb

@@ -3,7 +3,8 @@
 require "spec_helper"
 
 describe DataMigrate::DataMigrator do
-  let(:subject) { DataMigrate::DataMigrator }
+  let(:described_class) { DataMigrate::DataMigrator }
+
   let(:db_config) do
     {
       adapter: "sqlite3",
@@ -13,8 +14,8 @@ describe DataMigrate::DataMigrator do
 
   before do
     ActiveRecord::Base.establish_connection(db_config)
-    ::ActiveRecord::SchemaMigration.create_table
-    DataMigrate::DataSchemaMigration.create_table
+    DataMigrate::RailsHelper.schema_migration.create_table
+    DataMigrate::RailsHelper.data_schema_migration.create_table
   end
 
   after do
@@ -23,22 +24,24 @@ describe DataMigrate::DataMigrator do
   end
 
   describe ".load_migrated" do
+    let(:migrator) { DataMigrate::RailsHelper.data_migrator(:up, []) }
+
     it "loads migrated versions" do
-      DataMigrate::DataSchemaMigration.create(version: 20090000000000)
-      ::ActiveRecord::SchemaMigration.create(version: 20100000000000)
-      DataMigrate::DataSchemaMigration.create(version: 20110000000000)
-      ::ActiveRecord::SchemaMigration.create(version: 20120000000000)
-      migrated = subject.new(:up, []).load_migrated
+      DataMigrate::RailsHelper.data_schema_migration.create_version(20090000000000)
+      DataMigrate::RailsHelper.schema_create_version(20100000000000)
+      DataMigrate::RailsHelper.data_schema_migration.create_version(20110000000000)
+      DataMigrate::RailsHelper.schema_create_version(20120000000000)
+      migrated = migrator.load_migrated
       expect(migrated.count).to eq 2
       expect(migrated).to include 20090000000000
       expect(migrated).to include 20110000000000
     end
   end
 
-  describe :assure_data_schema_table do
+  describe :create_data_schema_table do
     it "creates the data_migrations table" do
       ActiveRecord::Migration.drop_table("data_migrations") rescue nil
-      subject.assure_data_schema_table
+      described_class.create_data_schema_table
       expect(
         ActiveRecord::Base.connection.table_exists?("data_migrations")
       ).to eq true
@@ -47,7 +50,7 @@ describe DataMigrate::DataMigrator do
 
   describe "#migrations_status" do
     it "returns all migrations statuses" do
-      status = subject.migrations_status
+      status = described_class.migrations_status
       expect(status.length).to eq 2
       expect(status.first).to eq ["down", "20091231235959", "Some name"]
       expect(status.second).to eq ["down", "20171231235959", "Super update"]
@@ -57,19 +60,19 @@ describe DataMigrate::DataMigrator do
   describe :match do
     context "when the file does not match" do
       it "returns nil" do
-        expect(subject.match("not_a_data_migration_file")).to be_nil
+        expect(described_class.match("not_a_data_migration_file")).to be_nil
       end
     end
 
     context "when the file doesn't end in .rb" do
       it "returns nil" do
-        expect(subject.match("20091231235959_some_name.rb.un~")).to be_nil
+        expect(described_class.match("20091231235959_some_name.rb.un~")).to be_nil
       end
     end
 
     context "when the file matches" do
       it "returns a valid MatchData object" do
-        match_data = subject.match("20091231235959_some_name.rb")
+        match_data = described_class.match("20091231235959_some_name.rb")
 
         expect(match_data[0]).to eq "20091231235959_some_name.rb"
         expect(match_data[1]).to eq "20091231235959"

data/spec/data_migrate/data_schema_migration_spec.rb

@@ -1,16 +1,33 @@
 require 'spec_helper'
 
 describe DataMigrate::DataSchemaMigration do
-  let(:subject) { DataMigrate::DataSchemaMigration }
-  describe :table_name do
-    it "returns correct table name" do
-      expect(subject.table_name).to eq("data_migrations")
+  if DataMigrate::RailsHelper.rails_version_equal_to_or_higher_than_7_1
+    let(:connection) { double(:connection) }
+    let(:subject) { DataMigrate::DataSchemaMigration.new(connection) }
+
+    describe :table_name do
+      it "returns correct table name" do
+        expect(subject.table_name).to eq("data_migrations")
+      end
+    end
+
+    describe :index_name do
+      it "returns correct primary key name" do
+        expect(subject.primary_key).to eq("version")
+      end
+    end
+  else
+    let(:subject) { DataMigrate::DataSchemaMigration }
+    describe :table_name do
+      it "returns correct table name" do
+        expect(subject.table_name).to eq("data_migrations")
+      end
     end
-  end
 
-  describe :index_name do
-    it "returns correct primary key name" do
-      expect(subject.primary_key).to eq("version")
+    describe :index_name do
+      it "returns correct primary key name" do
+        expect(subject.primary_key).to eq("version")
+      end
     end
   end
 end

data/spec/data_migrate/data_spec.rb

@@ -55,7 +55,7 @@ describe DataMigrate::Data do
 
         sql_select = <<-SQL
           SELECT version
-          FROM #{DataMigrate::DataSchemaMigration.table_name}
+          FROM #{DataMigrate::RailsHelper.data_schema_migration.table_name}
         SQL
 
         db_list_data = ActiveRecord::Base.connection.

data/spec/data_migrate/database_tasks_spec.rb

@@ -8,12 +8,6 @@ describe DataMigrate::DatabaseTasks do
   let(:data_migrations_path) {
     DataMigrate.config.data_migrations_path
   }
-  let(:db_config) do
-    {
-      adapter: "sqlite3",
-      database: "spec/db/test.db"
-    }
-  end
 
   before do
     # In a normal Rails installation, db_dir would defer to
@@ -27,14 +21,10 @@ describe DataMigrate::DatabaseTasks do
     allow(DataMigrate::Tasks::DataMigrateTasks).to receive(:migrations_paths) {
       data_migrations_path
     }
-    ActiveRecord::Base.establish_connection(db_config)
-    if Gem::Dependency.new("rails", ">= 6.1").match?("rails", Gem.loaded_specs["rails"].version)
-      hash_config = ActiveRecord::DatabaseConfigurations::HashConfig.new('test', 'test', db_config)
-      config_obj = ActiveRecord::DatabaseConfigurations.new([hash_config])
-      allow(ActiveRecord::Base).to receive(:configurations).and_return(config_obj)
-    else
-      ActiveRecord::Base.configurations[:test] = db_config
-    end
+    ActiveRecord::Base.establish_connection({ adapter: "sqlite3", database: "spec/db/test.db" })
+    hash_config = ActiveRecord::DatabaseConfigurations::HashConfig.new('test', 'test', { adapter: "sqlite3", database: "spec/db/test.db" })
+    config_obj = ActiveRecord::DatabaseConfigurations.new([hash_config])
+    allow(ActiveRecord::Base).to receive(:configurations).and_return(config_obj)
   end
 
   context "migrations" do
@@ -44,7 +34,7 @@ describe DataMigrate::DatabaseTasks do
     end
 
     before do
-      ActiveRecord::SchemaMigration.create_table
+      DataMigrate::RailsHelper.schema_migration.create_table
 
       allow(DataMigrate::SchemaMigration).to receive(:migrations_paths) {
         migration_path
@@ -69,22 +59,47 @@ describe DataMigrate::DatabaseTasks do
     end
 
     describe :forward do
-
       it "run forward default amount of times" do
         subject.forward
-        versions = DataMigrate::DataSchemaMigration.normalized_versions
+        versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
         expect(versions.count).to eq(1)
       end
 
       it "run forward defined number of times" do
         subject.forward(2)
-        versions = DataMigrate::DataSchemaMigration.normalized_versions
+        versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
         expect(versions.count).to eq(1)
         expect(versions.first).to eq "20091231235959"
-        versions = ActiveRecord::SchemaMigration.normalized_versions
+        versions = DataMigrate::RailsHelper.schema_migration.normalized_versions
         expect(versions.count).to eq(1)
         expect(versions.first).to eq "20131111111111"
       end
     end
+
+    if DataMigrate::RailsHelper.rails_version_equal_to_or_higher_than_7_0
+      describe :schema_dump_path do
+        before do
+          allow(ActiveRecord::Base).to receive(:configurations).and_return(ActiveRecord::DatabaseConfigurations.new([db_config]))
+        end
+
+        context "for primary database" do
+          let(:db_config) { ActiveRecord::DatabaseConfigurations::HashConfig.new("development", "primary", {} ) }
+
+          context "for :ruby db format" do
+            it 'returns the data schema path' do
+              allow(ActiveRecord).to receive(:schema_format).and_return(:ruby)
+              expect(subject.schema_dump_path(db_config)).to eq("db/data_schema.rb")
+            end
+          end
+
+          context "for :sql db format" do
+            it 'returns the data schema path' do
+              allow(ActiveRecord).to receive(:schema_format).and_return(:sql)
+              expect(subject.schema_dump_path(db_config, :sql)).to eq("db/data_schema.rb")
+            end
+          end
+        end
+      end
+    end
   end
 end

data/spec/data_migrate/migration_context_spec.rb

@@ -4,11 +4,18 @@ require "spec_helper"
 
 describe DataMigrate::DataMigrator do
   let(:context) { DataMigrate::MigrationContext.new("spec/db/data") }
-  let(:schema_context) { ActiveRecord::MigrationContext.new("spec/db/migrate", ActiveRecord::Base.connection.schema_migration) }
+  let(:schema_context) { ActiveRecord::MigrationContext.new("spec/db/migrate", ar_schema_migration) }
+  let(:db_config) do
+    {
+      adapter: "sqlite3",
+      database: "spec/db/test.db"
+    }
+  end
 
   before do
-    ActiveRecord::SchemaMigration.create_table
-    DataMigrate::DataSchemaMigration.create_table
+    ActiveRecord::Base.establish_connection(db_config)
+    DataMigrate::RailsHelper.schema_migration.create_table
+    DataMigrate::RailsHelper.data_schema_migration.create_table
   end
 
   after do
@@ -20,7 +27,7 @@ describe DataMigrate::DataMigrator do
     it "migrates existing file" do
       context.migrate(nil)
       context.migrations_status
-      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
       expect(versions.count).to eq(2)
       expect(versions).to include("20091231235959")
       expect(versions).to include("20171231235959")
@@ -29,7 +36,7 @@ describe DataMigrate::DataMigrator do
     it "undo migration" do
       context.migrate(nil)
       context.run(:down, 20171231235959)
-      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
       expect(versions.count).to eq(1)
       expect(versions).to include("20091231235959")
     end
@@ -46,7 +53,7 @@ describe DataMigrate::DataMigrator do
 
     it "runs a specific migration" do
       context.run(:up, 20171231235959)
-      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
       expect(versions.count).to eq(1)
       expect(versions).to include("20171231235959")
     end
@@ -74,7 +81,7 @@ describe DataMigrate::DataMigrator do
       expect {
         context.rollback
       }.to output(/Undoing SuperUpdate/).to_stdout
-      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
       expect(versions.count).to eq(1)
       expect(versions).to include("20091231235959")
     end
@@ -85,7 +92,7 @@ describe DataMigrate::DataMigrator do
       expect {
         context.rollback(2)
       }.to output(/Undoing SomeName/).to_stdout
-      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
       expect(versions.count).to eq(0)
     end
 
@@ -94,8 +101,17 @@ describe DataMigrate::DataMigrator do
       expect {
         context.rollback(2)
       }.to output(/Undoing SomeName/).to_stdout
-      versions = DataMigrate::DataSchemaMigration.normalized_versions
+      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
       expect(versions.count).to eq(0)
     end
   end
+
+  # schema migration changed in Rails 7.2, from the connection to the pool object.
+  def ar_schema_migration
+    if ActiveRecord::Base.connection_pool.respond_to?(:schema_migration)
+      ActiveRecord::Base.connection_pool.schema_migration
+    else
+      ActiveRecord::Base.connection.schema_migration
+    end
+  end
 end

data/spec/data_migrate/schema_dumper_spec.rb

@@ -9,9 +9,12 @@ describe DataMigrate::SchemaDumper do
   end
 
   before do
-    ActiveRecord::SchemaMigration.create_table
-    DataMigrate::DataSchemaMigration.create_table
-    DataMigrate::DataSchemaMigration.create(fixture_file_timestamps.map { |t| { version: t } })
+    DataMigrate::RailsHelper.schema_migration.create_table
+    DataMigrate::RailsHelper.data_schema_migration.create_table
+
+    fixture_file_timestamps.map do |t|
+      DataMigrate::RailsHelper.data_schema_migration.create_version(t)
+    end
   end
 
   after do