data_migrate 9.4.0 → 10.0.0.rc1

data/lib/data_migrate/migration_context.rb

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

data/lib/data_migrate/schema_dumper.rb

@@ -26,7 +26,7 @@ module DataMigrate
 
     def initialize(connection)
       @connection = connection
-      all_versions =  DataMigrate::RailsHelper.data_schema_migration.normalized_versions
+      all_versions =  DataSchemaMigration.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, DataMigrate::RailsHelper.schema_migration, DataMigrate::RailsHelper.internal_metadata).
+        ActiveRecord::Migrator.new(:up, all_migrations, ActiveRecord::Base.connection.schema_migration).
         pending_migrations.
         map {|m| { version: m.version, kind: :schema }}
       )
     end
 
     def self.run(direction, migration_paths, version)
-      ActiveRecord::MigrationContext.new(migration_paths, DataMigrate::RailsHelper.schema_migration).run(direction, version)
+      ActiveRecord::MigrationContext.new(migration_paths, ActiveRecord::Base.connection.schema_migration).run(direction, version)
     end
 
     def self.sort_migrations(set1, set2 = nil)
@@ -24,10 +24,9 @@ module DataMigrate
 
     def self.migrations_paths
       spec_name = DataMigrate.config.spec_name
-      # 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)
+      if spec_name && Gem::Dependency.new("rails", "~> 7.0").match?("rails", Gem.loaded_specs["rails"].version)
         ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: spec_name).migrations_paths
-      elsif spec_name && Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
+      elsif spec_name && Gem::Dependency.new("rails", "~> 6.0").match?("rails", Gem.loaded_specs["rails"].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::RailsHelper.data_schema_migration.table_name
+      DataMigrate::DataSchemaMigration.table_name
     end
 
     def output(stream)
-      unless DataMigrate::RailsHelper.data_schema_migration.table_exists?
+      unless DataMigrate::DataSchemaMigration.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("railties", "~> 7.0").match?("railties", Gem.loaded_specs["railties"].version)
+      if Gem::Dependency.new("rails", "~> 7.0").match?("rails", Gem.loaded_specs["rails"].version)
         ActiveRecord::Base.connection_db_config.configuration_hash[:database]
-      elsif Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
+      elsif Gem::Dependency.new("rails", "~> 6.0").match?("rails", Gem.loaded_specs["rails"].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
+      def dump(db_config)
         if dump_schema_after_migration?
-          filename = DataMigrate::DatabaseTasks.schema_file
+          filename = DataMigrate::DatabaseTasks.dump_filename(spec_name(db_config), ActiveRecord::Base.schema_format)
           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.create_data_schema_table
+        DataMigrate::DataMigrator.assure_data_schema_table
         DataMigrate::MigrationContext.new(migrations_paths).migrate(target_version)
       end
 
@@ -44,15 +44,16 @@ module DataMigrate
         end
       end
 
-      def status
-        DataMigrate::StatusService.dump
+      def status(db_config)
+        puts "\ndatabase: #{spec_name(db_config)}\n\n"
+        DataMigrate::StatusService.dump(ActiveRecord::Base.connection)
       end
 
-      def status_with_schema
+      def status_with_schema(db_config)
         db_list_data = ActiveRecord::Base.connection.select_values(
-          "SELECT version FROM #{DataMigrate::RailsHelper.data_schema_migration.table_name}"
+          "SELECT version FROM #{DataMigrate::DataSchemaMigration.table_name}"
         )
-        db_list_schema = DataMigrate::RailsHelper.schema_migration_versions
+        db_list_schema = ActiveRecord::SchemaMigration.all.pluck(:version)
         file_list = []
 
         Dir.foreach(File.join(Rails.root, migrations_paths)) do |file|
@@ -76,7 +77,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: #{database_name}\n\n"
+        puts "\ndatabase: #{spec_name(db_config)}\n\n"
         puts "#{"Status".center(8)} #{"Type".center(8)}  #{"Migration ID".ljust(14)} Migration Name"
         puts "-" * 60
         file_list.each do |file|
@@ -93,11 +94,11 @@ module DataMigrate
 
       private
 
-      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]
+      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
         end
       end
     end

data/lib/data_migrate/version.rb

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

data/lib/data_migrate.rb

@@ -1,6 +1,5 @@
 # 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")
@@ -10,9 +9,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,8 +3,7 @@
 require "spec_helper"
 
 describe DataMigrate::DataMigrator do
-  let(:described_class) { DataMigrate::DataMigrator }
-
+  let(:subject) { DataMigrate::DataMigrator }
   let(:db_config) do
     {
       adapter: "sqlite3",
@@ -14,8 +13,8 @@ describe DataMigrate::DataMigrator do
 
   before do
     ActiveRecord::Base.establish_connection(db_config)
-    DataMigrate::RailsHelper.schema_migration.create_table
-    DataMigrate::RailsHelper.data_schema_migration.create_table
+    ::ActiveRecord::SchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create_table
   end
 
   after do
@@ -24,24 +23,22 @@ describe DataMigrate::DataMigrator do
   end
 
   describe ".load_migrated" do
-    let(:migrator) { DataMigrate::RailsHelper.data_migrator(:up, []) }
-
     it "loads migrated versions" do
-      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
+      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
       expect(migrated.count).to eq 2
       expect(migrated).to include 20090000000000
       expect(migrated).to include 20110000000000
     end
   end
 
-  describe :create_data_schema_table do
+  describe :assure_data_schema_table do
     it "creates the data_migrations table" do
       ActiveRecord::Migration.drop_table("data_migrations") rescue nil
-      described_class.create_data_schema_table
+      subject.assure_data_schema_table
       expect(
         ActiveRecord::Base.connection.table_exists?("data_migrations")
       ).to eq true
@@ -50,7 +47,7 @@ describe DataMigrate::DataMigrator do
 
   describe "#migrations_status" do
     it "returns all migrations statuses" do
-      status = described_class.migrations_status
+      status = subject.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"]
@@ -60,19 +57,19 @@ describe DataMigrate::DataMigrator do
   describe :match do
     context "when the file does not match" do
       it "returns nil" do
-        expect(described_class.match("not_a_data_migration_file")).to be_nil
+        expect(subject.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(described_class.match("20091231235959_some_name.rb.un~")).to be_nil
+        expect(subject.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 = described_class.match("20091231235959_some_name.rb")
+        match_data = subject.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,33 +1,16 @@
 require 'spec_helper'
 
 describe DataMigrate::DataSchemaMigration do
-  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
+  let(:subject) { DataMigrate::DataSchemaMigration }
+  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
+  describe :index_name do
+    it "returns correct primary key name" do
+      expect(subject.primary_key).to eq("version")
     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::RailsHelper.data_schema_migration.table_name}
+          FROM #{DataMigrate::DataSchemaMigration.table_name}
         SQL
 
         db_list_data = ActiveRecord::Base.connection.

data/spec/data_migrate/database_tasks_spec.rb

@@ -8,6 +8,12 @@ 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
@@ -21,10 +27,14 @@ describe DataMigrate::DatabaseTasks do
     allow(DataMigrate::Tasks::DataMigrateTasks).to receive(:migrations_paths) {
       data_migrations_path
     }
-    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)
+    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
   end
 
   context "migrations" do
@@ -34,7 +44,7 @@ describe DataMigrate::DatabaseTasks do
     end
 
     before do
-      DataMigrate::RailsHelper.schema_migration.create_table
+      ActiveRecord::SchemaMigration.create_table
 
       allow(DataMigrate::SchemaMigration).to receive(:migrations_paths) {
         migration_path
@@ -59,47 +69,22 @@ describe DataMigrate::DatabaseTasks do
     end
 
     describe :forward do
+
       it "run forward default amount of times" do
         subject.forward
-        versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
+        versions = DataMigrate::DataSchemaMigration.normalized_versions
         expect(versions.count).to eq(1)
       end
 
       it "run forward defined number of times" do
         subject.forward(2)
-        versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
+        versions = DataMigrate::DataSchemaMigration.normalized_versions
         expect(versions.count).to eq(1)
         expect(versions.first).to eq "20091231235959"
-        versions = DataMigrate::RailsHelper.schema_migration.normalized_versions
+        versions = ActiveRecord::SchemaMigration.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/legacy_migrator_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe DataMigrate::LegacyMigrator do
+  let(:context) {
+    DataMigrate::MigrationContext.new("spec/db/data")
+  }
+
+  before do
+    ActiveRecord::SchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create_table
+  end
+
+  after do
+    ActiveRecord::Migration.drop_table("data_migrations") rescue nil
+    ActiveRecord::Migration.drop_table("schema_migrations") rescue nil
+  end
+
+  it "migrate legacy migrations to be in correct table" do
+    # simulate creation of legacy data migration when
+    # it was recorded in schema table
+    ActiveRecord::SchemaMigration.create(version: "20091231235959")
+
+    # create one migration in correct place
+    DataMigrate::DataSchemaMigration.create(version: "20171231235959")
+
+    migrated = DataMigrate::DataMigrator.new(:up, []).load_migrated
+    expect(migrated.count).to eq 1
+
+    DataMigrate::LegacyMigrator.new("spec/db/data").migrate
+
+    # after migacy migrator has been run, we should have records
+    # of both migrations
+    migrated = DataMigrate::DataMigrator .new(:up, []).load_migrated
+    expect(migrated.count).to eq 2
+  end
+end

data/spec/data_migrate/migration_context_spec.rb

@@ -5,17 +5,10 @@ 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(:db_config) do
-    {
-      adapter: "sqlite3",
-      database: "spec/db/test.db"
-    }
-  end
 
   before do
-    ActiveRecord::Base.establish_connection(db_config)
-    DataMigrate::RailsHelper.schema_migration.create_table
-    DataMigrate::RailsHelper.data_schema_migration.create_table
+    ActiveRecord::SchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create_table
   end
 
   after do
@@ -27,7 +20,7 @@ describe DataMigrate::DataMigrator do
     it "migrates existing file" do
       context.migrate(nil)
       context.migrations_status
-      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
       expect(versions.count).to eq(2)
       expect(versions).to include("20091231235959")
       expect(versions).to include("20171231235959")
@@ -36,7 +29,7 @@ describe DataMigrate::DataMigrator do
     it "undo migration" do
       context.migrate(nil)
       context.run(:down, 20171231235959)
-      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
       expect(versions.count).to eq(1)
       expect(versions).to include("20091231235959")
     end
@@ -53,7 +46,7 @@ describe DataMigrate::DataMigrator do
 
     it "runs a specific migration" do
       context.run(:up, 20171231235959)
-      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
       expect(versions.count).to eq(1)
       expect(versions).to include("20171231235959")
     end
@@ -81,7 +74,7 @@ describe DataMigrate::DataMigrator do
       expect {
         context.rollback
       }.to output(/Undoing SuperUpdate/).to_stdout
-      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
       expect(versions.count).to eq(1)
       expect(versions).to include("20091231235959")
     end
@@ -92,7 +85,7 @@ describe DataMigrate::DataMigrator do
       expect {
         context.rollback(2)
       }.to output(/Undoing SomeName/).to_stdout
-      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
       expect(versions.count).to eq(0)
     end
 
@@ -101,7 +94,7 @@ describe DataMigrate::DataMigrator do
       expect {
         context.rollback(2)
       }.to output(/Undoing SomeName/).to_stdout
-      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
+      versions = DataMigrate::DataSchemaMigration.normalized_versions
       expect(versions.count).to eq(0)
     end
   end

data/spec/data_migrate/schema_dumper_spec.rb

@@ -9,12 +9,9 @@ describe DataMigrate::SchemaDumper do
   end
 
   before do
-    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
+    ActiveRecord::SchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create(fixture_file_timestamps.map { |t| { version: t } })
   end
 
   after do

data/spec/data_migrate/schema_migration_spec.rb

@@ -8,17 +8,10 @@ describe DataMigrate::SchemaMigration do
   let(:fixture_file_timestamps) do
     %w[20091231235959 20101231235959 20111231235959]
   end
-  let(:db_config) do
-    {
-      adapter: "sqlite3",
-      database: "spec/db/test.db"
-    }
-  end
 
   before do
-    ActiveRecord::Base.establish_connection(db_config)
-    DataMigrate::RailsHelper.schema_migration.create_table
-    DataMigrate::RailsHelper.data_schema_migration.create_table
+    ActiveRecord::SchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create_table
   end
 
   after do
@@ -45,7 +38,7 @@ describe DataMigrate::SchemaMigration do
       expect {
         subject.run(:up, migration_path, 20202020202011)
       }.to output(/20202020202011 DbMigration: migrating/).to_stdout
-      versions = DataMigrate::RailsHelper.schema_migration.normalized_versions
+      versions = ActiveRecord::SchemaMigration.normalized_versions
       expect(versions.first).to eq("20202020202011")
     end
 
@@ -56,7 +49,7 @@ describe DataMigrate::SchemaMigration do
         subject.run(:down, migration_path, 20202020202011)
       }.to output(/Undoing DbMigration/).to_stdout
 
-      versions = DataMigrate::RailsHelper.schema_migration.normalized_versions
+      versions = ActiveRecord::SchemaMigration.normalized_versions
 
       expect(versions.count).to eq(0)
     end
@@ -68,9 +61,9 @@ describe DataMigrate::SchemaMigration do
       let(:paths) { ['spec/db/migrate', 'spec/db/migrate/other'] }
       let(:specification_name) { "primary" }
       let(:config_options) do
-        if Gem::Dependency.new("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
+        if Gem::Dependency.new("rails", "~> 6.0").match?("rails", Gem.loaded_specs["rails"].version)
           { env_name: Rails.env, spec_name: specification_name }
-        else
+        elsif Gem::Dependency.new("rails", "~> 7.0").match?("rails", Gem.loaded_specs["rails"].version)
           { env_name: Rails.env, name: specification_name }
         end
       end

data/spec/data_migrate/status_service_spec.rb

@@ -7,7 +7,7 @@ describe DataMigrate::StatusService do
   let(:stream) { StringIO.new }
   let(:stream_data) { stream.read }
   let(:connection_db_config) do
-    if Gem::Dependency.new("railties", ">= 6.1").match?("railties", Gem.loaded_specs["railties"].version)
+    if Gem::Dependency.new("rails", ">= 6.1").match?("rails", Gem.loaded_specs["rails"].version)
       ActiveRecord::Base.connection_db_config
     else
       ActiveRecord::Base.configurations.configs_for.first
@@ -33,12 +33,9 @@ describe DataMigrate::StatusService do
     end
 
     before do
-      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
+      ActiveRecord::SchemaMigration.create_table
+      DataMigrate::DataSchemaMigration.create_table
+      DataMigrate::DataSchemaMigration.create(fixture_file_timestamps.map { |t| { version: t } })
 
       subject.dump(connection_db_config, stream)
       stream.rewind