data_migrate 9.0.0 → 10.0.0.rc1

data/spec/data_migrate/database_tasks_spec.rb

@@ -4,13 +4,7 @@ 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
   }
@@ -33,9 +27,8 @@ 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'
+    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)
@@ -44,19 +37,10 @@ describe DataMigrate::DatabaseTasks do
     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
-  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
@@ -68,51 +52,19 @@ 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
 

data/spec/data_migrate/legacy_migrator_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe DataMigrate::LegacyMigrator do
@@ -5,30 +7,17 @@ describe DataMigrate::LegacyMigrator do
     DataMigrate::MigrationContext.new("spec/db/data")
   }
 
-  after do
-    begin
-      ActiveRecord::Migration.drop_table("data_migrations")
-      ActiveRecord::Migration.drop_table("schema_migrations")
-    rescue StandardError
-      nil
-    end
-  end
-
   before do
-    ActiveRecord::Base.establish_connection(db_config)
     ActiveRecord::SchemaMigration.create_table
     DataMigrate::DataSchemaMigration.create_table
   end
 
-  let(:db_config) do
-    {
-      adapter: "sqlite3",
-      database: "spec/db/test.db"
-    }
+  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
-    DataMigrate::DataSchemaMigration.create_table
     # simulate creation of legacy data migration when
     # it was recorded in schema table
     ActiveRecord::SchemaMigration.create(version: "20091231235959")
@@ -36,7 +25,7 @@ describe DataMigrate::LegacyMigrator do
     # create one migration in correct place
     DataMigrate::DataSchemaMigration.create(version: "20171231235959")
 
-    migrated = DataMigrate::DataMigrator .new(:up, []).load_migrated
+    migrated = DataMigrate::DataMigrator.new(:up, []).load_migrated
     expect(migrated.count).to eq 1
 
     DataMigrate::LegacyMigrator.new("spec/db/data").migrate
@@ -46,5 +35,4 @@ describe DataMigrate::LegacyMigrator do
     migrated = DataMigrate::DataMigrator .new(:up, []).load_migrated
     expect(migrated.count).to eq 2
   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,48 +1,22 @@
+# 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
-  }
+  let(:context) { DataMigrate::MigrationContext.new("spec/db/data") }
+  let(:schema_context) { ActiveRecord::MigrationContext.new("spec/db/migrate", ActiveRecord::Base.connection.schema_migration) }
 
-  after do
-    begin
-      ActiveRecord::Migration.drop_table("data_migrations")
-      ActiveRecord::Migration.drop_table("schema_migrations")
-    rescue StandardError
-      nil
-    end
+  before do
+    ActiveRecord::SchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create_table
   end
 
-  let(:db_config) do
-    {
-      adapter: "sqlite3",
-      database: "spec/db/test.db"
-    }
+  after do
+    ActiveRecord::Migration.drop_table("data_migrations") rescue nil
+    ActiveRecord::Migration.drop_table("schema_migrations") rescue nil
   end
 
-  describe :migrate do
-    before do
-      ActiveRecord::Base.establish_connection(db_config)
-      ActiveRecord::SchemaMigration.create_table
-    end
-
-    after do
-      ActiveRecord::Migration.drop_table("data_migrations")
-      ActiveRecord::Migration.drop_table("schema_migrations")
-    end
-
+  describe "migrate" do
     it "migrates existing file" do
       context.migrate(nil)
       context.migrations_status

data/spec/data_migrate/schema_dumper_spec.rb

@@ -4,35 +4,22 @@ 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
-
-      ActiveRecord::Base.connection.execute <<-SQL
-        INSERT INTO #{DataMigrate::DataSchemaMigration.table_name}
-        VALUES #{fixture_file_timestamps.map { |t| "(#{t})" }.join(', ')}
-      SQL
-    end
+  before do
+    ActiveRecord::SchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create(fixture_file_timestamps.map { |t| { version: t } })
+  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)

data/spec/data_migrate/schema_migration_spec.rb

@@ -3,32 +3,20 @@
 require "spec_helper"
 
 describe DataMigrate::SchemaMigration do
-  let(:migration_path) {
-    if Rails::VERSION::MAJOR == 5
-      "spec/db/migrate/5.2"
-    else
-      "spec/db/migrate/6.0"
-    end
-  }
-
   let(:subject) { DataMigrate::SchemaMigration }
-  let(:db_config) do
-    {
-      adapter: "sqlite3",
-      database: "spec/db/test.db"
-    }
-  end
+  let(:migration_path) { "spec/db/migrate" }
   let(:fixture_file_timestamps) do
     %w[20091231235959 20101231235959 20111231235959]
   end
 
   before do
-    ActiveRecord::Base.establish_connection(db_config)
     ActiveRecord::SchemaMigration.create_table
+    DataMigrate::DataSchemaMigration.create_table
   end
 
   after do
-    ActiveRecord::Migration.drop_table("schema_migrations")
+    ActiveRecord::Migration.drop_table("data_migrations") rescue nil
+    ActiveRecord::Migration.drop_table("schema_migrations") rescue nil
   end
 
   describe :pending_schema_migrations do
@@ -36,6 +24,7 @@ describe DataMigrate::SchemaMigration do
       expect(subject).to receive(:migrations_paths) {
         migration_path
       }
+
       migrations = subject.pending_schema_migrations
 
       expect(migrations.count).to eq 2
@@ -45,7 +34,7 @@ describe DataMigrate::SchemaMigration do
   end
 
   describe :run do
-    it do
+    it "can run up task" do
       expect {
         subject.run(:up, migration_path, 20202020202011)
       }.to output(/20202020202011 DbMigration: migrating/).to_stdout
@@ -53,47 +42,56 @@ describe DataMigrate::SchemaMigration do
       expect(versions.first).to eq("20202020202011")
     end
 
-    it "undo migration" do
+    it "can run down task" do
       subject.run(:up, migration_path, 20202020202011)
+
       expect {
         subject.run(:down, migration_path, 20202020202011)
       }.to output(/Undoing DbMigration/).to_stdout
+
       versions = ActiveRecord::SchemaMigration.normalized_versions
+
       expect(versions.count).to eq(0)
     end
   end
 
-  if Rails.version > '6'
-    describe :migrations_paths do
-      context 'when a db_name is configured' do
-        let(:config) { double(:config) }
-        let(:paths) { ['spec/db/migrate/6.0', 'spec/db/components/migrate/6.0'] }
-        let(:config_options) do
-          if Rails.version > '6.1'
-            { env_name: 'test', name: 'primary' }
-          else
-            { env_name: 'test', spec_name: 'primary' }
-          end
+  describe :migrations_paths do
+    context 'when a db_name is configured' do
+      let(:config) { double(:config) }
+      let(:paths) { ['spec/db/migrate', 'spec/db/migrate/other'] }
+      let(:specification_name) { "primary" }
+      let(:config_options) do
+        if Gem::Dependency.new("rails", "~> 6.0").match?("rails", Gem.loaded_specs["rails"].version)
+          { env_name: Rails.env, spec_name: specification_name }
+        elsif Gem::Dependency.new("rails", "~> 7.0").match?("rails", Gem.loaded_specs["rails"].version)
+          { env_name: Rails.env, name: specification_name }
         end
+      end
 
-        before do
-          DataMigrate.configure do |config|
-            config.spec_name = 'primary'
-          end
-
-          allow(ActiveRecord::Base.configurations)
-            .to receive(:configs_for)
-            .with(config_options)
-            .and_return(config)
+      before do
+        @original_config_spec_name = DataMigrate.config.spec_name
 
-          allow(config).to receive(:migrations_paths).and_return(paths)
+        DataMigrate.configure do |config|
+          config.spec_name = specification_name
         end
 
-        it 'lists schema migration paths' do
-          expect(subject.migrations_paths.size).to eq(2)
-          expect(subject.migrations_paths).to eq(paths)
+        allow(ActiveRecord::Base.configurations)
+          .to receive(:configs_for)
+          .with(config_options)
+          .and_return(config)
+        allow(config).to receive(:migrations_paths).and_return(paths)
+      end
+
+      after do
+        DataMigrate.configure do |config|
+          config.spec_name = @original_config_spec_name
         end
       end
+
+      it 'lists schema migration paths' do
+        expect(subject.migrations_paths.size).to eq(paths.count)
+        expect(subject.migrations_paths).to eq(paths)
+      end
     end
   end
 end

data/spec/data_migrate/status_service_spec.rb

@@ -1,30 +1,29 @@
 # frozen_string_literal: true
+
 require "spec_helper"
 
 describe DataMigrate::StatusService do
-  let(:subject) { DataMigrate::SchemaDumper }
-  let(:db_config) do
-    {
-      adapter: "sqlite3",
-      database: "spec/db/test.db"
-    }
+  let(:subject) { DataMigrate::StatusService }
+  let(:stream) { StringIO.new }
+  let(:stream_data) { stream.read }
+  let(:connection_db_config) do
+    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
+    end
   end
-  let(:service) { DataMigrate::StatusService }
 
   context "table does not exists" do
     before do
-      ActiveRecord::Base.establish_connection(db_config)
+      allow_any_instance_of(subject).to receive(:table_name) { "bogus"}
+
+      subject.dump(connection_db_config, stream)
+      stream.rewind
     end
 
     it "show error message" do
-      allow_any_instance_of(service).to receive(:table_name) { "bogus"}
-      stream = StringIO.new
-
-      service.dump(ActiveRecord::Base.connection, stream)
-
-      stream.rewind
-      expected = "Data migrations table does not exist"
-      expect(stream.read).to include expected
+      expect(stream_data).to include("Data migrations table does not exist")
     end
   end
 
@@ -34,69 +33,41 @@ describe DataMigrate::StatusService do
     end
 
     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
+      DataMigrate::DataSchemaMigration.create_table
+      DataMigrate::DataSchemaMigration.create(fixture_file_timestamps.map { |t| { version: t } })
 
-      ActiveRecord::Base.connection.execute <<-SQL
-        INSERT INTO #{DataMigrate::DataSchemaMigration.table_name}
-        VALUES #{fixture_file_timestamps.map { |t| "(#{t})" }.join(', ')}
-      SQL
-
-      allow_any_instance_of(service).to receive(:root_folder) { "./" }
+      subject.dump(connection_db_config, stream)
+      stream.rewind
     end
 
     after do
-      ActiveRecord::Migration.drop_table("data_migrations")
+      ActiveRecord::Migration.drop_table("data_migrations") rescue nil
+      ActiveRecord::Migration.drop_table("schema_migrations") rescue nil
     end
 
     it "shows successfully executed migration" do
-      stream = StringIO.new
-      service.dump(ActiveRecord::Base.connection, stream)
-      stream.rewind
-
       expected = "   up     20091231235959  Some name"
-      expect(stream.read).to include expected
+      expect(stream_data).to include expected
     end
 
     it "excludes files without .rb extension" do
-      stream = StringIO.new
-      service.dump(ActiveRecord::Base.connection, stream)
-      stream.rewind
-
       expected = "20181128000207  Excluded file"
-      expect(stream.read).to_not include expected
+      expect(stream_data).to_not include expected
     end
 
     it "shows missing file migration" do
-      stream = StringIO.new
-      service.dump(ActiveRecord::Base.connection, stream)
-      stream.rewind
-
       expected = "   up     20101231235959  ********** NO FILE **********"
-      s = stream.read
-      expect(s).to include expected
+      expect(stream_data).to include expected
     end
 
     it "shows migration that has not run yet" do
-      stream = StringIO.new
-      service.dump(ActiveRecord::Base.connection, stream)
-      stream.rewind
-
       expected = "  down    20171231235959  Super update"
-      s = stream.read
-      expect(s).to include expected
+      expect(stream_data).to include expected
     end
 
     it "outputs migrations in chronological order" do
-      stream = StringIO.new
-      service.dump(ActiveRecord::Base.connection, stream)
-      stream.rewind
-      s = stream.read
-      expect(s.index("20091231235959")).to be < s.index("20111231235959")
+      expect(stream_data.index("20091231235959")).to be < stream_data.index("20111231235959")
     end
   end
 end