data_migrate 11.1.0 → 11.2.0

data/spec/data_migrate/data_schema_migration_spec.rb

@@ -1,33 +0,0 @@
-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
-    end
-
-    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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe DataMigrate::Data do
-  let(:subject) { DataMigrate::Data }
-  let(:fixture_file_timestamps) do
-    %w[20091231235959 20101231235959 20111231235959]
-  end
-
-  around do |example|
-    Dir.mktmpdir do |temp_dir|
-      @temp_dir = temp_dir
-
-      # create the fake data migration files
-      fixture_file_timestamps.each do |timestamp|
-        FileUtils.touch File.join(temp_dir, "#{timestamp}_data_migration.rb")
-      end
-
-      example.run
-    end
-  end
-
-  describe :define do
-    after do
-      ActiveRecord::Migration.drop_table("data_migrations")
-    end
-
-    context "when no version is supplied" do
-      it "returns nil" do
-        expect(subject.define(version: nil)).to be_nil
-      end
-    end
-
-    context "when a version is supplied" do
-      before do
-        allow(DataMigrate::DataMigrator).
-          to receive(:full_migrations_path).and_return(@temp_dir)
-      end
-
-      it "sets the current version to the supplied version" do
-        version = fixture_file_timestamps[1]
-
-        expect(DataMigrate::DataMigrator.current_version).not_to eq version.to_i
-        subject.define(version: version)
-        expect(DataMigrate::DataMigrator.current_version).to eq version.to_i
-      end
-
-      it "creates entries for migration versions that come " \
-         "before the supplied version" do
-
-        version = fixture_file_timestamps[1]
-
-        subject.define(version: version)
-
-        sql_select = <<-SQL
-          SELECT version
-          FROM #{DataMigrate::RailsHelper.data_schema_migration.table_name}
-        SQL
-
-        db_list_data = ActiveRecord::Base.connection.
-          select_values(sql_select).map(&:to_i)
-        expect(db_list_data).to match_array(
-          [fixture_file_timestamps[0], fixture_file_timestamps[1]].map(&:to_i)
-        )
-
-        # The last remaining migration (fixture_file_timestamps[2]) was
-        # not included as part of the supplied version and so should not
-        # appear in the data_migrations table.
-        expect(db_list_data).not_to include(fixture_file_timestamps[2])
-      end
-    end
-  end
-end

data/spec/data_migrate/database_tasks_spec.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe DataMigrate::DatabaseTasks do
-  let(:subject) { DataMigrate::DatabaseTasks }
-  let(:migration_path) { "spec/db/migrate" }
-  let(:data_migrations_path) { DataMigrate.config.data_migrations_path }
-
-  before do
-    # In a normal Rails installation, db_dir would defer to
-    # Rails.application.config.paths["db"].first
-    # @see https://github.com/rails/rails/blob/a7d49ef78c36df2d1ca876451f30915ada1079a5/activerecord/lib/active_record/tasks/database_tasks.rb#L54
-    allow(subject).to receive(:db_dir).and_return("db")
-    allow(ActiveRecord::Tasks::DatabaseTasks).to receive(:db_dir).and_return("db")
-  end
-
-  before do
-    allow(DataMigrate::Tasks::DataMigrateTasks).to receive(:migrations_paths) do
-      data_migrations_path
-    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
-      ActiveRecord::Migration.drop_table("data_migrations") rescue nil
-      ActiveRecord::Migration.drop_table("schema_migrations") rescue nil
-    end
-
-    before do
-      DataMigrate::RailsHelper.schema_migration.create_table
-
-      allow(DataMigrate::SchemaMigration).to receive(:migrations_paths) { migration_path }
-      allow(DataMigrate::DatabaseTasks).to receive(:data_migrations_path) do
-        data_migrations_path
-      end.at_least(:once)
-    end
-
-    describe :past_migrations do
-      it "returns past migration records" do
-        subject.forward
-        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
-        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::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::RailsHelper.data_schema_migration.normalized_versions
-        expect(versions.count).to eq(1)
-        expect(versions.first).to eq "20091231235959"
-        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) do
-            ActiveRecord::DatabaseConfigurations::HashConfig.new("development", "primary", {})
-          end
-
-          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
-
-    describe :prepare_all_with_data do
-      let(:db_config) do
-        ActiveRecord::DatabaseConfigurations::HashConfig.new(
-          'test',
-          'primary',
-          adapter: "sqlite3",
-          database: "spec/db/test.db"
-        )
-      end
-
-      let(:pool) { double("ConnectionPool") }
-      let(:connection) { double("Connection") }
-
-      before do
-        allow(subject).to receive(:each_current_configuration).and_yield(db_config)
-        allow(subject).to receive(:with_temporary_pool).with(db_config).and_yield(pool)
-        allow(pool).to receive(:connection).and_return(connection)
-        allow(subject).to receive(:schema_dump_path).and_return("db/data_schema.rb")
-        allow(File).to receive(:exist?).and_return(true)
-        allow(subject).to receive(:load_schema)
-        allow(subject).to receive(:load_schema_current)
-        allow(subject).to receive(:migrate_with_data)
-        allow(subject).to receive(:dump_schema)
-        allow(DataMigrate::Tasks::DataMigrateTasks).to receive(:dump)
-        allow(subject).to receive(:load_seed)
-
-        configurations = ActiveRecord::DatabaseConfigurations.new([db_config])
-        allow(ActiveRecord::Base).to receive(:configurations).and_return(configurations)
-      end
-
-      context "when the database does not exist" do
-        before do
-          allow(subject).to receive(:database_exists?).with(connection).and_return(false)
-          allow_any_instance_of(ActiveRecord::Tasks::DatabaseTasks).to receive(:create)
-            .and_return(true)
-        end
-
-        it "creates the database" do
-          expect_any_instance_of(ActiveRecord::Tasks::DatabaseTasks).to receive(:create)
-            .with(db_config)
-          subject.prepare_all_with_data
-        end
-
-        it "loads the schema" do
-          expect(subject).to receive(:load_schema).with(
-            db_config,
-            subject.send(:schema_format),
-            nil
-          )
-          subject.prepare_all_with_data
-        end
-
-        it "loads the current data schema" do
-          expect(subject).to receive(:load_schema_current).with(:ruby, ENV["DATA_SCHEMA"])
-          subject.prepare_all_with_data
-        end
-
-        it "runs migrations with data" do
-          expect(subject).to receive(:migrate_with_data)
-          subject.prepare_all_with_data
-        end
-
-        it "dumps the schema after migration" do
-          expect(subject).to receive(:dump_schema).with(db_config)
-          expect(DataMigrate::Tasks::DataMigrateTasks).to receive(:dump)
-          subject.prepare_all_with_data
-        end
-
-        it "loads seed data" do
-          expect(subject).to receive(:load_seed)
-          subject.prepare_all_with_data
-        end
-      end
-
-      context "when the database exists" do
-        before do
-          allow(subject).to receive(:database_exists?).with(connection).and_return(true)
-        end
-
-        it "does not create the database" do
-          expect(ActiveRecord::Tasks::DatabaseTasks).not_to receive(:create)
-          subject.prepare_all_with_data
-        end
-
-        it "does not load the schema" do
-          expect(subject).not_to receive(:load_schema)
-          expect(subject).not_to receive(:load_schema_current)
-          subject.prepare_all_with_data
-        end
-
-        it "runs migrations with data" do
-          expect(subject).to receive(:migrate_with_data)
-          subject.prepare_all_with_data
-        end
-
-        it "dumps the schema after migration" do
-          expect(subject).to receive(:dump_schema).with(db_config)
-          expect(DataMigrate::Tasks::DataMigrateTasks).to receive(:dump)
-          subject.prepare_all_with_data
-        end
-
-        it "does not load seed data" do
-          expect(subject).not_to receive(:load_seed)
-          subject.prepare_all_with_data
-        end
-      end
-    end
-  end
-end

data/spec/data_migrate/migration.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe DataMigrate::Migration do
-  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
-end

data/spec/data_migrate/migration_context_spec.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe DataMigrate::DataMigrator do
-  let(:context) { DataMigrate::MigrationContext.new("spec/db/data") }
-  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::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") 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::RailsHelper.data_schema_migration.normalized_versions
-      expect(versions.count).to eq(2)
-      expect(versions).to include("20091231235959")
-      expect(versions).to include("20171231235959")
-    end
-
-    it "undo migration" do
-      context.migrate(nil)
-      context.run(:down, 20171231235959)
-      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
-      expect(versions.count).to eq(1)
-      expect(versions).to include("20091231235959")
-    end
-
-    it "does not do anything if migration is undone twice" do
-      context.migrate(nil)
-      expect {
-        context.run(:down, 20171231235959)
-      }.to output(/Undoing SuperUpdate/).to_stdout
-      expect {
-        context.run(:down, 20171231235959)
-      }.not_to output(/Undoing SuperUpdate/).to_stdout
-    end
-
-    it "runs a specific migration" do
-      context.run(:up, 20171231235959)
-      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
-      expect(versions.count).to eq(1)
-      expect(versions).to include("20171231235959")
-    end
-
-    it "does not do anything if migration is ran twice" do
-      expect {
-        context.run(:up, 20171231235959)
-      }.to output(/Doing SuperUpdate/).to_stdout
-      expect {
-        context.run(:down, 20171231235959)
-      }.not_to output(/Doing SuperUpdate/).to_stdout
-    end
-
-    it "alerts for an invalid specific migration" do
-      expect {
-        context.run(:up, 201712312)
-      }.to raise_error(
-        ActiveRecord::UnknownMigrationVersionError,
-        /No migration with version number 201712312/
-      )
-    end
-
-    it "rolls back latest migration" do
-      context.migrate(nil)
-      expect {
-        context.rollback
-      }.to output(/Undoing SuperUpdate/).to_stdout
-      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
-      expect(versions.count).to eq(1)
-      expect(versions).to include("20091231235959")
-    end
-
-    it "rolls back 2 migrations" do
-      context.migrate(nil)
-      schema_context.migrate(nil)
-      expect {
-        context.rollback(2)
-      }.to output(/Undoing SomeName/).to_stdout
-      versions = DataMigrate::RailsHelper.data_schema_migration.normalized_versions
-      expect(versions.count).to eq(0)
-    end
-
-    it "rolls back 2 migrations" do
-      context.migrate(nil)
-      expect {
-        context.rollback(2)
-      }.to output(/Undoing SomeName/).to_stdout
-      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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe DataMigrate::SchemaDumper do
-  let(:subject) { DataMigrate::SchemaDumper }
-  let(:fixture_file_timestamps) do
-    %w[20091231235959 20101231235959 20111231235959]
-  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
-  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)
-      stream.rewind
-
-      last_version = fixture_file_timestamps.last
-      expected = "DataMigrate::Data.define(version: #{last_version})"
-      expect(stream.read).to include expected
-    end
-  end
-end

data/spec/data_migrate/schema_migration_spec.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe DataMigrate::SchemaMigration do
-  let(:subject) { DataMigrate::SchemaMigration }
-  let(:migration_path) { "spec/db/migrate" }
-  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
-  end
-
-  after do
-    ActiveRecord::Migration.drop_table("data_migrations") rescue nil
-    ActiveRecord::Migration.drop_table("schema_migrations") rescue nil
-  end
-
-  describe :pending_schema_migrations do
-    it "list sorted schema migrations" do
-      expect(subject).to receive(:migrations_paths) {
-        migration_path
-      }
-
-      migrations = subject.pending_schema_migrations
-
-      expect(migrations.count).to eq 2
-      expect(migrations[0][:version]).to eq(20131111111111)
-      expect(migrations[1][:version]).to eq(20202020202011)
-    end
-  end
-
-  describe :run do
-    it "can run up task" do
-      expect {
-        subject.run(:up, migration_path, 20202020202011)
-      }.to output(/20202020202011 DbMigration: migrating/).to_stdout
-      versions = DataMigrate::RailsHelper.schema_migration.normalized_versions
-      expect(versions.first).to eq("20202020202011")
-    end
-
-    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 = DataMigrate::RailsHelper.schema_migration.normalized_versions
-
-      expect(versions.count).to eq(0)
-    end
-  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("railties", "~> 6.1").match?("railties", Gem.loaded_specs["railties"].version)
-          { env_name: Rails.env, spec_name: specification_name }
-        else
-          { env_name: Rails.env, name: specification_name }
-        end
-      end
-
-      before do
-        @original_config_spec_name = DataMigrate.config.spec_name
-
-        DataMigrate.configure do |config|
-          config.spec_name = specification_name
-        end
-
-        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,76 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe DataMigrate::StatusService do
-  let(:subject) { DataMigrate::StatusService }
-  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)
-      ActiveRecord::Base.connection_db_config
-    else
-      ActiveRecord::Base.configurations.configs_for.first
-    end
-  end
-
-  context "table does not exists" do
-    before do
-      allow_any_instance_of(subject).to receive(:table_name) { "bogus"}
-
-      subject.dump(connection_db_config, stream)
-      stream.rewind
-    end
-
-    it "show error message" do
-      expect(stream_data).to include("Data migrations table does not exist")
-    end
-  end
-
-  context "table exists" do
-    let(:fixture_file_timestamps) do
-      %w[20091231235959 20101231235959 20111231235959]
-    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
-
-      subject.dump(connection_db_config, stream)
-      stream.rewind
-    end
-
-    after do
-      ActiveRecord::Migration.drop_table("data_migrations") rescue nil
-      ActiveRecord::Migration.drop_table("schema_migrations") rescue nil
-    end
-
-    it "shows successfully executed migration" do
-      expected = "   up     20091231235959  Some name"
-      expect(stream_data).to include expected
-    end
-
-    it "excludes files without .rb extension" do
-      expected = "20181128000207  Excluded file"
-      expect(stream_data).to_not include expected
-    end
-
-    it "shows missing file migration" do
-      expected = "   up     20101231235959  ********** NO FILE **********"
-      expect(stream_data).to include expected
-    end
-
-    it "shows migration that has not run yet" do
-      expected = "  down    20171231235959  Super update"
-      expect(stream_data).to include expected
-    end
-
-    it "outputs migrations in chronological order" do
-      expect(stream_data.index("20091231235959")).to be < stream_data.index("20111231235959")
-    end
-  end
-end