convergence 1.0.6 → 1.2.0

data/spec/convergence/diff_spec.rb

@@ -64,6 +64,96 @@ describe Convergence::DSL do
       end
     end
 
+    context 'when a table is renamed' do
+      let(:renamed_table) do
+        Convergence::Table.new('simple_table_renamed', renamed_from: 'simple_table').tap do |t|
+          t.int('id', primary_key: true)
+        end
+      end
+      let(:from_db) do
+        { 'simple_table' => simple_table }
+      end
+      let(:to_db) do
+        { 'simple_table_renamed' => renamed_table }
+      end
+
+      subject { Convergence::Diff.new.diff(from_db, to_db) }
+
+      it 'should detect it as a rename, not add/remove' do
+        expect(subject[:rename_table]).to eq('simple_table' => 'simple_table_renamed')
+        expect(subject[:add_table]).to be_empty
+        expect(subject[:remove_table]).to be_empty
+        expect(subject[:change_table]).to be_empty
+      end
+    end
+
+    context 'when renamed_from references a table that does not exist' do
+      let(:renamed_table) do
+        Convergence::Table.new('simple_table2', renamed_from: 'nonexistent_table').tap do |t|
+          t.int('id', primary_key: true)
+        end
+      end
+      let(:from_db) do
+        { 'simple_table' => simple_table }
+      end
+      let(:to_db) do
+        { 'simple_table' => simple_table, 'simple_table2' => renamed_table }
+      end
+
+      subject { Convergence::Diff.new.diff(from_db, to_db) }
+
+      it 'should fall back to a normal add' do
+        expect(subject[:rename_table]).to be_empty
+        expect(subject[:add_table]['simple_table2']).not_to be_nil
+      end
+    end
+
+    context 'when the renamed_from target already exists (idempotent re-apply)' do
+      let(:renamed_table) do
+        Convergence::Table.new('simple_table2', renamed_from: 'simple_table').tap do |t|
+          t.int('id', primary_key: true)
+        end
+      end
+      let(:from_db) do
+        { 'simple_table' => simple_table, 'simple_table2' => simple_table2 }
+      end
+      let(:to_db) do
+        { 'simple_table' => simple_table, 'simple_table2' => renamed_table }
+      end
+
+      subject { Convergence::Diff.new.diff(from_db, to_db) }
+
+      it 'should be a no-op for the rename' do
+        expect(subject[:rename_table]).to be_empty
+        expect(subject[:add_table]).to be_empty
+        expect(subject[:remove_table]).to be_empty
+        expect(subject[:change_table]).to be_empty
+      end
+    end
+
+    context 'when multiple tables claim the same renamed_from (ambiguous)' do
+      let(:renamed_table1) do
+        Convergence::Table.new('simple_table_a', renamed_from: 'simple_table').tap do |t|
+          t.int('id', primary_key: true)
+        end
+      end
+      let(:renamed_table2) do
+        Convergence::Table.new('simple_table_b', renamed_from: 'simple_table').tap do |t|
+          t.int('id', primary_key: true)
+        end
+      end
+      let(:from_db) do
+        { 'simple_table' => simple_table }
+      end
+      let(:to_db) do
+        { 'simple_table_a' => renamed_table1, 'simple_table_b' => renamed_table2 }
+      end
+
+      it 'should raise an ArgumentError' do
+        expect { Convergence::Diff.new.diff(from_db, to_db) }.to raise_error(ArgumentError)
+      end
+    end
+
     context 'table column are changed' do
       let(:table_from) do
         Convergence::Table.new('table1').tap do |t|
@@ -104,6 +194,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
 
@@ -131,134 +222,290 @@ describe Convergence::DSL do
           expect(included_after_option).to eq false
         end
       end
+
+      context 'all columns are renamed' do
+        let(:table_to) do
+          Convergence::Table.new('table1').tap do |t|
+            t.int('id_rename', primary_key: true, renamed_from: 'id')
+            t.varchar('name_rename', limit: 200, null: false, renamed_from: 'name')
+          end
+        end
+
+        it 'should detect it as a change_table with rename_column, not a drop+add' do
+          results = Convergence::Diff.new.diff({ 'table1' => table_from }, { 'table1' => table_to })
+          expect(results[:add_table]).to be_empty
+          expect(results[:remove_table]).to be_empty
+          expect(results[:change_table]).not_to be_empty
+          expect(results[:change_table]['table1'][:rename_column]).to eq('id' => 'id_rename', 'name' => 'name_rename')
+        end
+      end
     end
   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) { {} }
 
-        t.index('name')
-        t.foreign_key('id', reference: 'ref_tables', reference_column: 'ref_id')
+    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 } }
+
+        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
+    context 'rename column' 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('full_name', limit: 200, null: false, renamed_from: 'name')
         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'])
+      it 'should detect it as a rename, not remove+add' do
+        expect(results[:rename_column]).to eq('name' => 'full_name')
+        expect(results[:remove_column]).to be_empty
+        expect(results[:add_column]).to be_empty
       end
     end
 
-    context 'add index' do
+    context 'rename column together with an unrelated change on another column' 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('full_name', limit: 300, null: false, renamed_from: 'name')
+        end
+      end
 
-          t.index('id')
-          t.index('name')
+      it 'should detect only the rename, deferring the other change to the next apply pass' do
+        expect(results[:rename_column]).to eq('name' => 'full_name')
+        expect(results[:change_column]).to be_empty
+      end
+    end
+
+    context 'rename the only column in a table' do
+      let(:table_from) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+        end
+      end
+      let(:table_to) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('identifier', primary_key: true, renamed_from: 'id')
         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'])
+      it 'should not be misdetected as removing all columns' do
+        expect(results[:rename_column]).to eq('id' => 'identifier')
+        expect(results[:remove_column]).to be_empty
+        expect(results[:add_column]).to be_empty
       end
     end
 
-    context 'remove foreign key' do
+    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: 200, null: false)
+        end
+      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('name')
         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'])
+      it { expect(results[:add_index].values.first.index_columns).to eq(['name']) }
+    end
+
+    context 'remove 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)
+
+          t.foreign_key('id', reference: 'ref_tables', reference_column: 'ref_id')
+        end
+      end
+      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