convergence 0.0.1

data/lib/convergence/table.rb

@@ -0,0 +1,37 @@
+class Convergence::Table
+  attr_accessor :table_name, :table_options, :columns, :indexes, :foreign_keys
+
+  Convergence::Column::COLUMN_TYPE.each do |column_type|
+    define_method "#{column_type}" do |column_name, options = {}|
+      @columns[column_name.to_s] = Convergence::Column.new(column_type, column_name.to_s, options)
+    end
+  end
+
+  def index(index_columns, options = {})
+    index_name = options[:name]
+    index_name = "index_#{table_name}_on_#{[index_columns].flatten.join('_')}" if index_name.nil?
+    @indexes[index_name] = Convergence::Index.new(index_name, index_columns, options)
+  end
+
+  def foreign_key(key_columns, options = {})
+    if options[:reference].nil? || options[:reference_column].nil?
+      fail ArgumentError.new("#{@table_name} - #{key_columns}: require reference/reference_column parameters")
+    end
+    key_name = options[:name]
+    key_name = "#{table_name}_#{[key_columns].flatten.join('_')}_fk" if key_name.nil?
+    @foreign_keys[key_name] = Convergence::ForeignKey.new(
+      key_name,
+      key_columns,
+      options[:reference],
+      [options[:reference_column]].flatten,
+      options.reject { |k, _v| k == :reference || k == :reference_column })
+  end
+
+  def initialize(table_name, options = {})
+    @table_name = table_name
+    @table_options = options
+    @columns = {}
+    @indexes = {}
+    @foreign_keys = {}
+  end
+end

data/lib/convergence/version.rb

@@ -0,0 +1,3 @@
+module Convergence
+  VERSION = '0.0.1'
+end

data/spec/config/spec_database.yml

@@ -0,0 +1,6 @@
+mysql:
+  adapter: mysql
+  database: convergence_test_db
+  host: localhost
+  port: 3389
+  username: root

data/spec/convergence/diff_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+
+describe Convergence::DSL do
+  describe '#diff' do
+    let(:simple_table) do
+      Convergence::Table.new('simple_table').tap do |t|
+        t.int('id', primary_key: true)
+      end
+    end
+    let(:simple_table2) do
+      Convergence::Table.new('simple_table2').tap do |t|
+        t.int('id', primary_key: true)
+      end
+    end
+
+    context 'when from database and to database are same' do
+      let(:from_db) do
+        { 'simple_table' => simple_table }
+      end
+      let(:to_db) do
+        from_db
+      end
+
+      subject { Convergence::Diff.new.diff(from_db, to_db) }
+
+      it 'should return empty' do
+        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 new tables are added' do
+      let(:from_db) do
+        { 'simple_table' => simple_table }
+      end
+      let(:to_db) do
+        { 'simple_table' => simple_table, 'simple_table2' => simple_table2 }
+      end
+
+      subject { Convergence::Diff.new.diff(from_db, to_db) }
+
+      it 'should be able to detect add table' do
+        expect(subject[:add_table]).not_to be_empty
+        expect(subject[:add_table]['simple_table2']).not_to be_nil
+      end
+    end
+
+    context 'when tables are removed' do
+      let(:from_db) do
+        { 'simple_table' => simple_table, 'simple_table2' => simple_table2 }
+      end
+      let(:to_db) do
+        { 'simple_table' => simple_table }
+      end
+
+      subject { Convergence::Diff.new.diff(from_db, to_db) }
+
+      it 'should be able to detect remove table' do
+        expect(subject[:remove_table]).not_to be_empty
+        expect(subject[:remove_table]['simple_table2']).not_to be_nil
+      end
+    end
+
+    context 'table column are changed' 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
+
+      context 'new column are added' do
+        let(:table_to) do
+          Convergence::Table.new('table1').tap do |t|
+            t.int('id', primary_key: true)
+            t.varchar('name', limit: 200, null: false)
+            t.varchar('data', limit: 300, null: false)
+          end
+        end
+
+        it do
+          results = Convergence::Diff.new.diff({ 'table1' => table_from }, { 'table1' => table_to })
+          expect(results[:change_table]).not_to be_empty
+        end
+      end
+
+      context 'column are deleted' do
+        let(:table_to) do
+          Convergence::Table.new('table1').tap do |t|
+            t.int('id', primary_key: true)
+          end
+        end
+
+        it do
+          results = Convergence::Diff.new.diff({ 'table1' => table_from }, { 'table1' => table_to })
+          expect(results[:change_table]).not_to be_empty
+        end
+      end
+
+      context 'column definition are changed' do
+        let(:table_to) do
+          Convergence::Table.new('table1').tap do |t|
+            t.int('id')
+          end
+        end
+
+        it do
+          results = Convergence::Diff.new.diff({ 'table1' => table_from }, { 'table1' => table_to })
+          expect(results[:change_table]).not_to be_empty
+        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)
+
+        t.index('name')
+        t.foreign_key('id', reference: 'ref_tables', reference_column: 'ref_id')
+      end
+    end
+
+    context 'change column options' do
+      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.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'][:limit]).to eq('300')
+        expect(results[:change_column]['name'][:null]).to eq('true')
+      end
+    end
+
+    context 'change column order' do
+      let(:table_to) do
+        Convergence::Table.new('table1').tap do |t|
+          t.varchar('name', limit: 300, null: true)
+          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]['id']).not_to be_nil
+        expect(results[:change_column]['id'][:after]).to eq('name')
+      end
+    end
+
+    context 'remove index' do
+      let(:table_to) do
+        Convergence::Table.new('table1').tap do |t|
+          t.int('id', primary_key: true)
+          t.varchar('name', limit: 300, null: true)
+        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
+    end
+
+    context 'add index' do
+      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.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
+    end
+
+    context 'remove foreign key' do
+      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.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'])
+      end
+    end
+
+    context 'add foreign key' do
+      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.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
+    end
+
+    context 'change table options' do
+      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)
+        end
+      end
+
+      it do
+        results = Convergence::Diff.new.diff_table(table_from, table_to)
+        expect(results[:change_table_option][:engine]).to eq('MyISAM')
+      end
+    end
+  end
+end

data/spec/convergence/dsl_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Convergence::DSL do
+  let(:dsl_single_table) do
+    <<-DSL
+    create_table "users", comment: 'Users' do |t|
+      t.int "id", primary_key: true, null: false, limit: 11, extra: "auto_increment"
+      t.datetime "created_at", null: true
+
+      t.index 'created_at'
+      t.foreign_key "user_id", reference: "users", reference_column: "id"
+    end
+    DSL
+  end
+
+  let(:dsl_multi_table) do
+    <<-DSL
+    create_table "users", comment: 'Users' do |t|
+      t.int "id", primary_key: true, extra: "auto_increment"
+      t.varchar "name", limit: 100
+      t.datetime "created_at", null: true
+    end
+
+    create_table "posts", comment: "Posts" do |t|
+      t.int "id", primary_key: true, extra: "auto_increment"
+      t.int "user_id"
+      t.datetime "created_at", null: true
+
+      t.foreign_key "user_id", reference: "users", reference_column: "id"
+    end
+    DSL
+  end
+
+  describe '#parse' do
+    context 'when exist only one table' do
+      subject { Convergence::DSL.parse(dsl_single_table) }
+
+      it 'should be able to parse tables' do
+        expect(subject['users']).not_to be_nil
+      end
+
+      it 'should be able to parse table options' do
+        expect(subject['users'].table_options[:comment]).to eq('Users')
+      end
+
+      it 'should be able to parse table columns' do
+        columns = subject['users'].columns
+        expect(columns['id']).not_to be_nil
+        expect(columns['created_at']).not_to be_nil
+      end
+
+      it 'should be able to parse table column options' do
+        columns = subject['users'].columns
+        expect(columns['id'].options[:primary_key]).to be_truthy
+        expect(columns['id'].options[:null]).to be_falsy
+        expect(columns['id'].options[:limit]).to eq(11)
+        expect(columns['id'].options[:extra]).to eq('auto_increment')
+      end
+
+      it 'should be able to parse indexes' do
+        expect(subject['users'].indexes).not_to be_nil
+      end
+
+      it 'should be able to parse foreign keys' do
+        expect(subject['users'].foreign_keys).not_to be_nil
+      end
+    end
+
+    context 'when multiple tables exists' do
+      subject { Convergence::DSL.parse(dsl_multi_table) }
+
+      it 'should be able to parse tables' do
+        expect(subject['users']).not_to be_nil
+        expect(subject['posts']).not_to be_nil
+      end
+    end
+  end
+end

data/spec/convergence/dumper/mysql_schema_dumper_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Convergence::Dumper::MysqlSchemaDumper do
+  before do
+    # load fixtures
+  end
+  let(:connector) do
+    Convergence::DatabaseConnector.new(mysql_settings)
+  end
+  let(:dumper) do
+    Convergence::Dumper::MysqlSchemaDumper.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 'shoulb be dump options' do
+        papers = subject['papers']
+        expect(papers.table_options[:engine]).to eq('InnoDB')
+        expect(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['title1']).not_to be_nil
+        expect(papers.columns['title2']).not_to be_nil
+        expect(papers.columns['description']).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 title1 title2 description))
+      end
+
+      describe 'table 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' 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
+      end
+    end
+
+    describe 'indexes' do
+      it do
+        index = subject['authors'].indexes['index_authors_on_created_at']
+        expect(index).not_to be_nil
+        expect(index.index_columns).to eq(['created_at'])
+      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