data_migrate 8.5.0 → 9.2.0

data/spec/data_migrate/data_migrator_spec.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe DataMigrate::DataMigrator do
-  let(:subject) { DataMigrate::DataMigrator }
+  let(:described_class) { DataMigrate::DataMigrator }
+
   let(:db_config) do
     {
       adapter: "sqlite3",
@@ -10,49 +13,35 @@ describe DataMigrate::DataMigrator do
   end
 
   before do
-    allow(DataMigrate::DataMigrator).to receive(:db_config) { db_config }
     ActiveRecord::Base.establish_connection(db_config)
+    DataMigrate::RailsHelper.schema_migration.create_table
+    DataMigrate::RailsHelper.data_schema_migration.create_table
   end
 
-  describe :load_migrated do
-    before do
-      allow(subject).to receive(:db_config) { db_config }.at_least(:once)
-      ActiveRecord::Base.establish_connection(db_config)
-      ::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
 
-    after do
-      ActiveRecord::Migration.drop_table("data_migrations")
-      ActiveRecord::Migration.drop_table("schema_migrations")
-    end
+  describe ".load_migrated" do
+    let(:migrator) { DataMigrate::RailsHelper.data_migrator(:up, []) }
 
-    it do
-      subject.assure_data_schema_table
-      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
+    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
       expect(migrated.count).to eq 2
       expect(migrated).to include 20090000000000
       expect(migrated).to include 20110000000000
     end
   end
 
-  describe :assure_data_schema_table do
-    before do
-      allow(subject).to receive(:db_config) { db_config }.at_least(:once)
-      ActiveRecord::Base.establish_connection(db_config)
-    end
-
-    after do
-      ActiveRecord::Migration.drop_table("data_migrations")
-    end
-
-    it 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
@@ -60,15 +49,8 @@ describe DataMigrate::DataMigrator do
   end
 
   describe "#migrations_status" do
-    before do
-      allow(subject).to receive(:db_config) { db_config }.at_least(:once)
-      ActiveRecord::Base.establish_connection(db_config)
-      ::ActiveRecord::SchemaMigration.create_table
-      DataMigrate::DataSchemaMigration.create_table
-    end
-
     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"]
@@ -78,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

@@ -4,12 +4,6 @@ require "spec_helper"
 
 describe DataMigrate::Data do
   let(:subject) { DataMigrate::Data }
-  let(:db_config) do
-    {
-      adapter: "sqlite3",
-      database: "spec/db/test.db"
-    }
-  end
   let(:fixture_file_timestamps) do
     %w[20091231235959 20101231235959 20111231235959]
   end
@@ -28,11 +22,6 @@ describe DataMigrate::Data do
   end
 
   describe :define do
-    before do
-      allow(DataMigrate::DataMigrator).
-        to receive(:db_config) { db_config }
-    end
-
     after do
       ActiveRecord::Migration.drop_table("data_migrations")
     end
@@ -66,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

@@ -4,22 +4,10 @@ require "spec_helper"
 
 describe DataMigrate::DatabaseTasks do
   let(:subject) { DataMigrate::DatabaseTasks }
-  let(:migration_path) {
-    if Rails::VERSION::MAJOR == 5
-      "spec/db/migrate/5.2"
-    else
-      "spec/db/migrate/6.0"
-    end
-  }
+  let(:migration_path) { "spec/db/migrate" }
   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
@@ -33,34 +21,20 @@ describe DataMigrate::DatabaseTasks do
     allow(DataMigrate::Tasks::DataMigrateTasks).to receive(:migrations_paths) {
       data_migrations_path
     }
-    allow(DataMigrate::DataMigrator).to receive(:db_config) { db_config }
-    ActiveRecord::Base.establish_connection(db_config)
-    if Rails.version >= '6.1'
-      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
-
-  describe :schema_file do
-    it "returns the correct data schema file path" do
-      expect(subject.schema_file(nil)).to eq "db/data_schema.rb"
-    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
     after do
-      begin
-        ActiveRecord::Migration.drop_table("data_migrations")
-      rescue ActiveRecord::StatementInvalid
-      end
-      ActiveRecord::Migration.drop_table("schema_migrations")
+      ActiveRecord::Migration.drop_table("data_migrations") rescue nil
+      ActiveRecord::Migration.drop_table("schema_migrations") rescue nil
     end
 
     before do
-      ActiveRecord::SchemaMigration.create_table
+      DataMigrate::RailsHelper.schema_migration.create_table
 
       allow(DataMigrate::SchemaMigration).to receive(:migrations_paths) {
         migration_path
@@ -68,71 +42,64 @@ describe DataMigrate::DatabaseTasks do
       allow(DataMigrate::DatabaseTasks).to receive(:data_migrations_path) {
         data_migrations_path
       }.at_least(:once)
-      allow(DataMigrate::DatabaseTasks).to receive(:schema_migrations_path) {
-        migration_path
-      }.at_least(:once)
     end
 
     describe :past_migrations do
-      it do
+      it "returns past migration records" do
         subject.forward
-        m = subject.past_migrations
-        expect(m.count).to eq 1
-        expect(m.first[:version]).to eq 20091231235959
+        migrations = subject.past_migrations
+        expect(migrations.count).to eq 1
+        expect(migrations.first[:version]).to eq 20091231235959
       end
 
       it "shows nothing without any migrations" do
-        m = subject.past_migrations
-        expect(m.count).to eq 0
-      end
-    end
-
-    describe :load_schema_current do
-      before do
-        allow(DataMigrate::DataMigrator).to receive(:full_migrations_path).and_return(migration_path)
-      end
-
-      it "loads the current schema file" do
-        if Rails::VERSION::MAJOR < 6
-          skip("Not implemented for Rails lower than 6")
-        end
-        allow(subject).to receive(:schema_location).and_return("spec/db/data/schema/")
-
-        subject.load_schema_current
-        versions = DataMigrate::DataSchemaMigration.normalized_versions
-        expect(versions.count).to eq(2)
-      end
-
-      it "loads schema file that has not been update with latest data migrations" do
-        if Rails::VERSION::MAJOR < 6
-          skip("Not implemented for Rails lower than 6")
-        end
-
-        allow(subject).to receive(:schema_location).and_return("spec/db/data/partial_schema/")
-
-        subject.load_schema_current
-        versions = DataMigrate::DataSchemaMigration.normalized_versions
-        expect(versions.count).to eq(1)
+        migrations = subject.past_migrations
+        expect(migrations.count).to eq 0
       end
     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.rb

@@ -1,19 +1,17 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-if Rails::VERSION::MAJOR >= 5
-  subject = DataMigrate::MigrationFive
-else
-  subject = DataMigrate::Migration
-end
+require 'spec_helper'
 
-describe subject do
-  it "uses correct table name" do
-    expect(subject.table_name).to eq("data_migrations")
+describe DataMigrate::Migration do
+  describe ".table_name" do
+    it "returns correct table name" do
+      expect(subject.table_name).to eq("data_migrations")
+    end
   end
 
-  it "uses correct index name" do
-    expect(subject).to receive(:table_name_prefix) { "" }
-    expect(subject).to receive(:table_name_suffix) { "" }
-    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

data/spec/data_migrate/migration_context_spec.rb

@@ -1,30 +1,10 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe DataMigrate::DataMigrator do
-  let(:context) {
-    if (Rails::VERSION::MAJOR == 5)
-      DataMigrate::MigrationContext.new("spec/db/data")
-    else
-      DataMigrate::MigrationContext.new("spec/db/data-6.0")
-    end
-  }
-  let(:schema_context) {
-    if (Rails::VERSION::MAJOR == 5)
-      ActiveRecord::MigrationContext.new("spec/db/migrate/5.2")
-    else
-      ActiveRecord::MigrationContext.new("spec/db/migrate/6.0", ActiveRecord::Base.connection.schema_migration)
-    end
-  }
-
-  after do
-    begin
-      ActiveRecord::Migration.drop_table("data_migrations")
-      ActiveRecord::Migration.drop_table("schema_migrations")
-    rescue StandardError
-      nil
-    end
-  end
-
+  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",
@@ -32,21 +12,22 @@ describe DataMigrate::DataMigrator do
     }
   end
 
-  describe :migrate do
-    before do
-      ActiveRecord::Base.establish_connection(db_config)
-      ActiveRecord::SchemaMigration.create_table
-    end
+  before do
+    ActiveRecord::Base.establish_connection(db_config)
+    DataMigrate::RailsHelper.schema_migration.create_table
+    DataMigrate::RailsHelper.data_schema_migration.create_table
+  end
 
-    after do
-      ActiveRecord::Migration.drop_table("data_migrations")
-      ActiveRecord::Migration.drop_table("schema_migrations")
-    end
+  after do
+    ActiveRecord::Migration.drop_table("data_migrations") rescue nil
+    ActiveRecord::Migration.drop_table("schema_migrations") rescue nil
+  end
 
+  describe "migrate" 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")
@@ -55,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
@@ -72,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
@@ -100,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
@@ -111,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
 
@@ -120,7 +101,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
   end

data/spec/data_migrate/schema_dumper_spec.rb

@@ -4,35 +4,25 @@ require "spec_helper"
 
 describe DataMigrate::SchemaDumper do
   let(:subject) { DataMigrate::SchemaDumper }
-  let(:db_config) do
-    {
-      adapter: "sqlite3",
-      database: "spec/db/test.db"
-    }
-  end
   let(:fixture_file_timestamps) do
     %w[20091231235959 20101231235959 20111231235959]
   end
 
-  describe :dump do
-    before do
-      allow(DataMigrate::DataMigrator).
-        to receive(:db_config) { db_config }.at_least(:once)
-      ActiveRecord::Base.establish_connection(db_config)
-
-      ActiveRecord::SchemaMigration.create_table
-      DataMigrate::DataMigrator.assure_data_schema_table
+  before do
+    DataMigrate::RailsHelper.schema_migration.create_table
+    DataMigrate::RailsHelper.data_schema_migration.create_table
 
-      ActiveRecord::Base.connection.execute <<-SQL
-        INSERT INTO #{DataMigrate::DataSchemaMigration.table_name}
-        VALUES #{fixture_file_timestamps.map { |t| "(#{t})" }.join(', ')}
-      SQL
+    fixture_file_timestamps.map do |t|
+      DataMigrate::RailsHelper.data_schema_migration.create_version(t)
     end
+  end
 
-    after do
-      ActiveRecord::Migration.drop_table("data_migrations")
-    end
+  after do
+    ActiveRecord::Migration.drop_table("data_migrations") rescue nil
+    ActiveRecord::Migration.drop_table("schema_migrations") rescue nil
+  end
 
+  describe ".dump" do
     it "writes the define method with the version key to the stream" do
       stream = StringIO.new
       DataMigrate::SchemaDumper.dump(ActiveRecord::Base.connection, stream)