convergence 1.0.5 → 1.1.0

data/spec/convergence/diff_spec.rb

@@ -104,6 +104,7 @@ describe Convergence::DSL do
         let(:table_to) do
           Convergence::Table.new('table1').tap do |t|
             t.int('id')
+            t.varchar('name', limit: 200, null: false)
           end
         end
 
@@ -135,130 +136,209 @@ describe Convergence::DSL do
   end
 
   describe '#diff_table' do
-    let(:table_from) do
-      Convergence::Table.new('table1').tap do |t|
-        t.int('id', primary_key: true)
-        t.varchar('name', limit: 200, null: false)
+    subject(:results) { Convergence::Diff.new(**diff_options).diff_table(table_from, table_to) }
+    let(:diff_options) { {} }
+
+    context 'change auto_increment table option' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.table_options = { auto_increment: 1 }
+        end
+      end
+      let(:table_to) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.table_options = { auto_increment: 5000 }
+        end
+      end
+
+      it 'detects the auto_increment change by default' do
+        expect(results[:change_table_option][:auto_increment]).to eq(5000)
+      end
+
+      context 'when ignore_auto_increment is enabled' do
+        let(:diff_options) { { ignore_auto_increment: true } }
 
-        t.index('name')
-        t.foreign_key('id', reference: 'ref_tables', reference_column: 'ref_id')
+        it 'ignores the auto_increment change' do
+          expect(results[:change_table_option]).not_to have_key(:auto_increment)
+        end
       end
     end
 
     context 'change column options' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+          t.datetime('created_at', default: -> { "CURRENT_TIMESTAMP" })
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1').tap do |t|
           t.int('id', primary_key: true)
-          t.varchar('name', limit: 300, null: true, unsigned: true)
-
-          t.index('name')
+          t.varchar('name', limit: 300, null: true, unsigned: true)     # option changed
+          t.datetime('created_at', default: -> { "CURRENT_TIMESTAMP" }) # option[:default] not changed
         end
       end
 
       it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
         expect(results[:change_column]['name']).not_to be_nil
         expect(results[:change_column]['name'][:limit]).to eq('300')
         expect(results[:change_column]['name'][:null]).to eq('true')
         expect(results[:change_column]['name'][:unsigned]).to eq('true')
+        expect(results[:change_column]['created_at']).to be_nil
+      end
+    end
+
+    context 'change enum/set column values' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.enum('status', values: %w(Active Inactive))
+        end
+      end
+
+      context 'when values are identical' do
+        let(:table_to) do
+          Convergence::Table.new('table1').tap do |t|
+            t.int('id', primary_key: true)
+            t.enum('status', values: %w(Active Inactive))
+          end
+        end
+
+        it 'does not detect a change' do
+          expect(results[:change_column]['status']).to be_nil
+        end
+      end
+
+      context 'when only the letter case differs' do
+        let(:table_to) do
+          Convergence::Table.new('table1').tap do |t|
+            t.int('id', primary_key: true)
+            t.enum('status', values: %w(active inactive))
+          end
+        end
+
+        it 'detects the change since values are case-sensitive' do
+          expect(results[:change_column]['status']).not_to be_nil
+          expect(results[:change_column]['status'][:values]).to eq('["active", "inactive"]')
+        end
       end
     end
 
     context 'change column order' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1').tap do |t|
-          t.varchar('name', limit: 300, null: true)
+          t.varchar('name', limit: 200, null: false)
           t.int('id', primary_key: true)
-
-          t.index('name')
         end
       end
 
       it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:change_column]['name']).not_to be_nil
+        expect(results[:change_column]['name']).to be_nil
         expect(results[:change_column]['id']).not_to be_nil
         expect(results[:change_column]['id'][:after]).to eq('name')
       end
     end
 
     context 'remove index' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+
+          t.index('name')
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1').tap do |t|
           t.int('id', primary_key: true)
-          t.varchar('name', limit: 300, null: true)
+          t.varchar('name', limit: 200, null: false)
         end
       end
 
-      it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:remove_index].values.first.index_columns).to eq(['name'])
-      end
+      it { expect(results[:remove_index].values.first.index_columns).to eq(['name']) }
     end
 
     context 'add index' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1').tap do |t|
           t.int('id', primary_key: true)
-          t.varchar('name', limit: 300, null: true)
+          t.varchar('name', limit: 200, null: false)
 
-          t.index('id')
           t.index('name')
         end
       end
 
-      it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:add_index].values.first.index_columns).to eq(['id'])
-      end
+      it { expect(results[:add_index].values.first.index_columns).to eq(['name']) }
     end
 
     context 'remove foreign key' do
-      let(:table_to) do
+      let(:table_from) do
         Convergence::Table.new('table1').tap do |t|
           t.int('id', primary_key: true)
-          t.varchar('name', limit: 300, null: true)
+          t.varchar('name', limit: 200, null: false)
 
-          t.index('name')
+          t.foreign_key('id', reference: 'ref_tables', reference_column: 'ref_id')
         end
       end
-
-      it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:remove_foreign_key].values.first.from_columns).to eq(['id'])
+      let(:table_to) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+        end
       end
+
+      it { expect(results[:remove_foreign_key].values.first.from_columns).to eq(['id']) }
     end
 
     context 'add foreign key' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1').tap do |t|
           t.int('id', primary_key: true)
-          t.varchar('name', limit: 300, null: true)
+          t.varchar('name', limit: 200, null: false)
 
-          t.index('name')
           t.foreign_key('id', reference: 'ref_tables', reference_column: 'ref_id')
-          t.foreign_key('id2', reference: 'ref_tables2', reference_column: 'ref_id2')
         end
       end
 
-      it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:add_foreign_key].values.first.from_columns).to eq(['id2'])
-      end
+      it { expect(results[:add_foreign_key].values.first.from_columns).to eq(['id']) }
     end
 
     context 'change table options' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
+        end
+      end
       let(:table_to) do
         Convergence::Table.new('table1', engine: 'MyISAM').tap do |t|
-          t.varchar('name', limit: 300, null: true)
           t.int('id', primary_key: true)
+          t.varchar('name', limit: 200, null: false)
         end
       end
 
-      it do
-        results = Convergence::Diff.new.diff_table(table_from, table_to)
-        expect(results[:change_table_option][:engine]).to eq('MyISAM')
-      end
+      it { expect(results[:change_table_option][:engine]).to eq('MyISAM') }
     end
   end
 end

data/spec/convergence/dsl_spec.rb

@@ -89,4 +89,30 @@ describe Convergence::DSL do
       end
     end
   end
+
+  describe '#parse_dsl' do
+    let(:dsl_with_execute) do
+      <<-DSL
+      create_table "users" do |t|
+        t.int "id", primary_key: true, extra: "auto_increment"
+      end
+
+      execute "CREATE OR REPLACE VIEW active_users AS SELECT * FROM users"
+      execute "GRANT SELECT ON users TO readonly"
+      DSL
+    end
+
+    subject { Convergence::DSL.parse_dsl(dsl_with_execute, '') }
+
+    it 'should be able to parse tables' do
+      expect(subject.tables['users']).not_to be_nil
+    end
+
+    it 'should be able to collect raw sql statements in order' do
+      expect(subject.raw_sqls).to eq([
+        'CREATE OR REPLACE VIEW active_users AS SELECT * FROM users',
+        'GRANT SELECT ON users TO readonly'
+      ])
+    end
+  end
 end

data/spec/convergence/dumper/mysql_schema_dumper_spec.rb

@@ -37,14 +37,17 @@ describe Convergence::Dumper::MysqlSchemaDumper do
         expect(papers.columns['title1']).not_to be_nil
         expect(papers.columns['title2']).not_to be_nil
         expect(papers.columns['description']).not_to be_nil
+        expect(papers.columns['edition_number']).not_to be_nil
+        expect(papers.columns['published_at']).not_to be_nil
       end
 
       it 'should be dump columns in the correct order' do
         papers = subject['papers']
-        expect(papers.columns.keys).to eq(%w(id slug title1 title2 description))
+        expect(papers.columns.keys)
+          .to eq(%w(id slug title1 title2 description edition_number published_at))
       end
 
-      describe 'table options' do
+      describe 'table column options' do
         it 'should be dump primary key' do
           expect(subject['papers'].columns['id'].options[:primary_key]).to be_truthy
         end
@@ -69,6 +72,13 @@ describe Convergence::Dumper::MysqlSchemaDumper do
         it 'should be dump unsigned definition' do
           expect(subject['authors'].columns['age'].options[:unsigned]).to be_truthy
         end
+
+        it 'should be dump default' do
+          expect(subject['papers'].columns['edition_number'].options[:default]).to eq "0"
+          expect(subject['papers'].columns['published_at'].options[:default])
+            .to be_a(Proc)
+            .and have_attributes(call: "CURRENT_TIMESTAMP")
+        end
       end
     end
 
@@ -96,6 +106,19 @@ describe Convergence::Dumper::MysqlSchemaDumper do
       end
     end
 
+    describe 'enum/set columns' do
+      it 'should be dump enum values' do
+        expect(subject['enum_set_samples'].columns['status'].options[:values])
+          .to eq(%w(active inactive pending))
+        expect(subject['enum_set_samples'].columns['status'].options[:default]).to eq('active')
+      end
+
+      it 'should be dump set values, including values containing quotes' do
+        expect(subject['enum_set_samples'].columns['flags'].options[:values])
+          .to eq(['a', 'b', "it's tricky"])
+      end
+    end
+
     describe 'foreign keys' do
       it do
         foreign_key = subject['paper_authors'].foreign_keys['paper_authors_author_id_fk']

data/spec/convergence/dumper/postgres_schema_dumper_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'convergence/dumper/postgres_schema_dumper'
+require 'convergence/database_connector'
+
+describe Convergence::Dumper::PostgresSchemaDumper do
+  let(:connector) do
+    Convergence::DatabaseConnector.new(postgres_settings)
+  end
+  let(:dumper) do
+    Convergence::Dumper::PostgresSchemaDumper.new(connector)
+  end
+
+  describe '#dump' do
+    subject { dumper.dump }
+
+    it 'should be dump tables' do
+      expect(subject['papers']).not_to be_nil
+      expect(subject['authors']).not_to be_nil
+      expect(subject['paper_authors']).not_to be_nil
+    end
+
+    describe 'table options' do
+      it 'should be dump comment' do
+        expect(subject['papers'].table_options[:comment]).to eq('Paper')
+      end
+    end
+
+    describe 'table columns' do
+      it 'should be dump table columns' do
+        papers = subject['papers']
+        expect(papers.columns['id']).not_to be_nil
+        expect(papers.columns['slug']).not_to be_nil
+        expect(papers.columns['title1']).not_to be_nil
+        expect(papers.columns['title2']).not_to be_nil
+        expect(papers.columns['description']).not_to be_nil
+        expect(papers.columns['edition_number']).not_to be_nil
+        expect(papers.columns['published_at']).not_to be_nil
+      end
+
+      it 'should be dump columns in the correct order' do
+        papers = subject['papers']
+        expect(papers.columns.keys)
+          .to eq(%w(id slug title1 title2 description edition_number published_at))
+      end
+
+      describe 'table column options' do
+        it 'should be dump primary key' do
+          expect(subject['papers'].columns['id'].options[:primary_key]).to be_truthy
+        end
+
+        it 'should be dump extra (identity columns as auto_increment)' do
+          expect(subject['papers'].columns['id'].options[:extra]).to eq('auto_increment')
+        end
+
+        it 'should be dump comment' do
+          expect(subject['papers'].columns['title1'].options[:comment]).to eq('Title 1')
+        end
+
+        it 'should be dump limit' do
+          expect(subject['papers'].columns['title1'].options[:limit]).to eq('300')
+        end
+
+        it 'should be dump not null definition' do
+          expect(subject['papers'].columns['title1'].options[:null]).to be_falsy
+          expect(subject['authors'].columns['created_at'].options[:null]).to be_truthy
+        end
+
+        it 'should be dump default' do
+          expect(subject['papers'].columns['edition_number'].options[:default]).to eq('0')
+          expect(subject['papers'].columns['published_at'].options[:default])
+            .to be_a(Proc)
+            .and have_attributes(call: 'CURRENT_TIMESTAMP')
+        end
+      end
+    end
+
+    describe 'indexes' do
+      it 'should be dump index of authors' do
+        index = subject['authors'].indexes['index_authors_on_created_at']
+        expect(index).not_to be_nil
+        expect(index.index_columns).to eq(['created_at'])
+        expect(index.options[:unique]).to eq(false)
+      end
+
+      it 'should be dump unique index of papers' do
+        index = subject['papers'].indexes['index_papers_on_slug']
+        expect(index).not_to be_nil
+        expect(index.index_columns).to eq(['slug'])
+        expect(index.options[:unique]).to eq(true)
+      end
+    end
+
+    describe 'foreign keys' do
+      it do
+        foreign_key = subject['paper_authors'].foreign_keys['paper_authors_author_id_fk']
+        expect(foreign_key).not_to be_nil
+        expect(foreign_key.from_columns).to eq(['author_id'])
+        expect(foreign_key.to_table).to eq('authors')
+        expect(foreign_key.to_columns).to eq(['id'])
+      end
+    end
+  end
+end

data/spec/convergence/dumper/sqlite_schema_dumper_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'convergence/dumper/sqlite_schema_dumper'
+require 'convergence/database_connector'
+
+describe Convergence::Dumper::SqliteSchemaDumper do
+  let(:connector) do
+    Convergence::DatabaseConnector.new(sqlite_settings)
+  end
+  let(:dumper) do
+    Convergence::Dumper::SqliteSchemaDumper.new(connector)
+  end
+
+  describe '#dump' do
+    subject { dumper.dump }
+
+    it 'should be dump tables' do
+      expect(subject['papers']).not_to be_nil
+      expect(subject['authors']).not_to be_nil
+      expect(subject['paper_authors']).not_to be_nil
+    end
+
+    describe 'table columns' do
+      it 'should be dump table columns' do
+        papers = subject['papers']
+        expect(papers.columns['id']).not_to be_nil
+        expect(papers.columns['slug']).not_to be_nil
+        expect(papers.columns['title1']).not_to be_nil
+        expect(papers.columns['title2']).not_to be_nil
+        expect(papers.columns['description']).not_to be_nil
+        expect(papers.columns['edition_number']).not_to be_nil
+        expect(papers.columns['published_at']).not_to be_nil
+      end
+
+      describe 'table column options' do
+        it 'should be dump primary key as auto_increment' do
+          expect(subject['papers'].columns['id'].options[:primary_key]).to be_truthy
+          expect(subject['papers'].columns['id'].options[:extra]).to eq('auto_increment')
+          expect(subject['papers'].columns['id'].options[:null]).to be_falsy
+        end
+
+        it 'should be dump limit' do
+          expect(subject['papers'].columns['title1'].options[:limit]).to eq('300')
+        end
+
+        it 'should be dump not null definition' do
+          expect(subject['papers'].columns['title1'].options[:null]).to be_falsy
+          expect(subject['authors'].columns['created_at'].options[:null]).to be_truthy
+        end
+
+        it 'should be dump default' do
+          expect(subject['papers'].columns['edition_number'].options[:default]).to eq('0')
+          expect(subject['papers'].columns['published_at'].options[:default])
+            .to be_a(Proc)
+            .and have_attributes(call: 'CURRENT_TIMESTAMP')
+        end
+      end
+    end
+
+    describe 'indexes' do
+      it 'should be dump index of authors' do
+        index = subject['authors'].indexes['index_authors_on_created_at']
+        expect(index).not_to be_nil
+        expect(index.index_columns).to eq(['created_at'])
+        expect(index.options[:unique]).to eq(false)
+      end
+
+      it 'should be dump unique index of papers' do
+        index = subject['papers'].indexes['index_papers_on_slug']
+        expect(index).not_to be_nil
+        expect(index.index_columns).to eq(['slug'])
+        expect(index.options[:unique]).to eq(true)
+      end
+    end
+
+    describe 'foreign keys' do
+      it 'should be dump the foreign key with its original constraint name' do
+        foreign_key = subject['paper_authors'].foreign_keys['paper_authors_author_id_fk']
+        expect(foreign_key).not_to be_nil
+        expect(foreign_key.from_columns).to eq(['author_id'])
+        expect(foreign_key.to_table).to eq('authors')
+        expect(foreign_key.to_columns).to eq(['id'])
+      end
+    end
+  end
+end

data/spec/convergence/dumper_spec.rb

@@ -13,15 +13,15 @@ describe Convergence::Dumper do
     end
   end
   let(:table1_dsl) do
-    dsl = <<-DSL
-create_table :dummy_table, engine: "MyISAM" do |t|
-  t.int :id, limit: 11
-  t.varchar :name, limit: 100, null: true, comment: "name"
+    dsl = <<~DSL
+      create_table :dummy_table, engine: "MyISAM" do |t|
+        t.int :id, limit: 11
+        t.varchar :name, limit: 100, null: true, comment: "name"
 
-  t.index :name, name: "idx_name"
-  t.foreign_key :id, reference: :dummy_ref, reference_column: :id, name: "dummy_table_id_fk"
-end
-  DSL
+        t.index :name, name: "idx_name"
+        t.foreign_key :id, reference: :dummy_ref, reference_column: :id, name: "dummy_table_id_fk"
+      end
+    DSL
     dsl.strip
   end
 
@@ -51,15 +51,15 @@ end
       end
 
       let(:table1_dsl) do
-        dsl = <<-DSL
-create_table :"dummy-table", engine: "MyISAM" do |t|
-  t.int :id, limit: 11
-  t.varchar :"column-1", limit: 100, null: true, comment: "column 1"
+        dsl = <<~DSL
+          create_table :"dummy-table", engine: "MyISAM" do |t|
+            t.int :id, limit: 11
+            t.varchar :"column-1", limit: 100, null: true, comment: "column 1"
 
-  t.index :"column-1", name: "idx_column-1"
-  t.foreign_key :"column-1", reference: :"dummy-ref", reference_column: :"dummy-column", name: "dummy-table_column-1_fk"
-end
-      DSL
+            t.index :"column-1", name: "idx_column-1"
+            t.foreign_key :"column-1", reference: :"dummy-ref", reference_column: :"dummy-column", name: "dummy-table_column-1_fk"
+          end
+        DSL
         dsl.strip
       end
 
@@ -68,5 +68,99 @@ end
         expect(dsl).to eq(table1_dsl)
       end
     end
+
+    context "when the table column has default option with proc" do
+      let(:table1) do
+        Convergence::Table.new('dummy_table').tap do |t|
+          t.int :edition_number, default: 0
+          t.datetime :created_at, default: -> { "CURRENT_TIMESTAMP" }
+        end
+      end
+
+      let(:table1_dsl) do
+        dsl = <<~DSL
+          create_table :dummy_table do |t|
+            t.int :edition_number, default: 0
+            t.datetime :created_at, default: -> { "CURRENT_TIMESTAMP" }
+          end
+        DSL
+        dsl.strip
+      end
+
+      it 'should be able to dump dsl' do
+        dsl = Convergence::Dumper.new.dump_table_dsl(table1)
+        expect(dsl).to eq(table1_dsl)
+      end
+    end
+  end
+
+  describe '#dump_rails_migration' do
+    let(:table1) do
+      Convergence::Table.new('dummy_table', engine: 'MyISAM').tap do |t|
+        t.int :id, primary_key: true, extra: 'auto_increment'
+        t.varchar :name, limit: 100, null: true, comment: 'name'
+        t.datetime :created_at, null: false
+        t.datetime :updated_at, null: false
+
+        t.index :name, name: 'idx_name'
+        t.foreign_key :id, reference: 'dummy_ref', reference_column: :id
+      end
+    end
+
+    let(:migration_dsl) do
+      dsl = <<~DSL
+        class DummyMigration < ActiveRecord::Migration[7.0]
+          def change
+            create_table :dummy_table do |t|
+              t.string :name, limit: 100, null: true, comment: "name"
+              t.timestamps null: false
+              t.index :name, name: "idx_name"
+              t.foreign_key :dummy_ref, column: :id, name: "dummy_table_id_fk"
+            end
+          end
+        end
+      DSL
+      dsl.strip
+    end
+
+    it 'omits the implicit auto-increment id column' do
+      migration = Convergence::Dumper.new.dump_rails_migration({ 'dummy_table' => table1 }, 'DummyMigration')
+      expect(migration).to eq(migration_dsl)
+    end
+
+    it 'collapses created_at/updated_at into t.timestamps' do
+      migration = Convergence::Dumper.new.dump_rails_migration({ 'dummy_table' => table1 }, 'DummyMigration')
+      expect(migration).to be_include('t.timestamps null: false')
+      expect(migration).not_to be_include('t.datetime :created_at')
+    end
+
+    context 'when the column is a MySQL tinyint(1) boolean' do
+      let(:table1) do
+        Convergence::Table.new('dummy_table').tap do |t|
+          t.boolean :active, default: true
+        end
+      end
+
+      it 'maps it to a native boolean column' do
+        migration = Convergence::Dumper.new.dump_rails_migration({ 'dummy_table' => table1 }, 'DummyMigration')
+        expect(migration).to be_include('t.boolean :active, default: true')
+      end
+    end
+
+    context 'when created_at/updated_at have mismatched null options' do
+      let(:table1) do
+        Convergence::Table.new('dummy_table').tap do |t|
+          t.datetime :created_at, null: false
+          t.datetime :updated_at, null: true
+        end
+      end
+
+      it 'keeps them as separate columns instead of collapsing into t.timestamps' do
+        migration = Convergence::Dumper.new.dump_rails_migration({ 'dummy_table' => table1 }, 'DummyMigration')
+        expect(migration).not_to be_include('t.timestamps')
+        expect(migration).to be_include('t.datetime :created_at, null: false')
+        expect(migration).to be_include('t.datetime :updated_at, null: true')
+      end
+    end
   end
 end