flydata 0.6.3 → 0.6.4

data/lib/flydata/table_ddl.rb

@@ -0,0 +1,18 @@
+module Flydata
+
+class TableDdl
+  VERSION0 = 0 # the version where no .generated_ddl file was generated.
+               # Therefore, this version never shows up in anywhere.
+  VERSION1 = 1 # the version which doesn't handle server side encoding support.
+  VERSION2 = 2 # the version with server side encoding support, migrated from
+               # the previous versions.  Format/functionality-wise, it's the
+               # same as Version 3.
+  VERSION3 = 3 # the version with server side encoding support, generated by
+               # sync:generated_table_ddl command.
+  VERSION4 = 4 # the version with server side encoding support, generated by
+               # the auto-generated CREATE TABLE event.
+
+  VERSION = VERSION3
+end
+
+end

data/spec/flydata/cli_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'flydata/cli'
+require 'flydata/command/base'
 
 module Flydata
   describe Cli do

data/spec/flydata/command/exclusive_runnable_spec.rb

@@ -23,12 +23,23 @@ describe Exclusiverunnabletest do
   let(:subject_object) { described_class.new }
 
   let(:file_path) { "/tmp" }
-  let(:lock_file) { File.join(file_path, 'exclusive_run.info') }
-  let(:lock_file_content) { { command: 'exclusiverunnabletest:long_running_command', pid: 234 } }
+  let(:info_file) { File.join(file_path, 'exclusive_run.info') }
+  let(:info_command) { 'exclusiverunnabletest:long_running_command' }
+  let(:dummy_pid) { 11234 }
+  let(:info_file_content) { { command: info_command, pid: dummy_pid } }
+  let(:opts) { double('opts') }
+  let(:force_run) { false }
 
+  before do
+    File.unlink info_file if File.exists? info_file
+  end
   before do
     described_class.exclusive_run_home = file_path
   end
+  before do
+    allow(subject_object).to receive(:opts).and_return opts
+    allow(opts).to receive(:force_run?).and_return force_run
+  end
 
   describe '#normal_method_call' do
     subject { subject_object.normal_method_call }
@@ -38,17 +49,17 @@ describe Exclusiverunnabletest do
 
     context "when a lock file already exists" do
       before do
-        File.open(lock_file, "w") {|f| f.write(lock_file_content)}
+        File.open(info_file, "w") {|f| f.write(info_file_content)}
       end
 
       it "does not delete the lock file" do
         expect{ subject }.to raise_error
 
-        expect(File.exists?(lock_file)).to eq true
+        expect(File.exists?(info_file)).to eq true
       end
 
       after do
-        File.delete(lock_file) if File.exists?(lock_file)
+        File.delete(info_file) if File.exists?(info_file)
       end
     end
   end
@@ -62,7 +73,7 @@ describe Exclusiverunnabletest do
 
           sleep 0.1
 
-          expect(File.exists?(lock_file)).to eq true
+          expect(File.exists?(info_file)).to eq true
 
           th.join
         end
@@ -73,7 +84,7 @@ describe Exclusiverunnabletest do
 
           th.join
 
-          expect(File.exists?(lock_file)).to eq false
+          expect(File.exists?(info_file)).to eq false
         end
       end
     end
@@ -83,7 +94,7 @@ describe Exclusiverunnabletest do
         th = Thread.new{ subject }
         sleep 0.1
         expect{ subject_object.normal_method_call }.to raise_exception(
-         /`exclusiverunnabletest:long_running_command` is already running\..*\(pid: *[0-9]+\)/)
+         /`#{info_command}` is already running or terminated abnormally. \(pid:[0-9]+\)/)
 
         th.join
       end

data/spec/flydata/command/sender_spec.rb

@@ -23,7 +23,7 @@ module Flydata
           allow(data_port).to receive(:get).and_return("Wibble")
 
           allow_any_instance_of(Flydata::AgentCompatibilityCheck).to receive(:check).and_return(true)
-          Flydata::Command::Sync.any_instance.should_receive(:try_mysql_sync).and_return("Wobble")
+          Flydata::Command::Sync.any_instance.should_receive(:try_initial_sync).and_return("Wobble")
         end
 
         context "as daemon" do

data/spec/flydata/command/setup_spec.rb

@@ -19,21 +19,21 @@ module Flydata
       before do
         allow(subject).to receive(:retrieve_data_entries).and_return(data_entries)
         allow(subject).to receive(:flydata).and_return(flydata)
-        expect(flydata).to receive(:data_port).and_return(data_port)
+        allow(flydata).to receive(:data_port).and_return(data_port)
         allow(flydata).to receive(:flydata_api_host).and_return('localhost')
         expect(flydata).to receive(:credentials).and_return(credentials)
         expect(credentials).to receive(:authenticated?).and_return(false)
-        expect(data_port).to receive(:get).and_return(dp)
+        allow(data_port).to receive(:get).and_return(dp)
         expect(sender).to receive(:process_exist?).and_return(true)
         expect(sender).to receive(:stop)
-        expect(sync_fm).to receive(:binlog_path).and_return('/tmp')
+        allow(sync_fm).to receive(:source_pos_path).and_return('/tmp')
         expect(conf).to receive(:copy_templates)
         expect(login).to receive(:run)
         expect(sender).to receive(:restart)
+        allow(Flydata::SyncFileManager).to receive(:new).with(de).and_return(sync_fm)
       end
       it do
         expect(Flydata::Command::Conf).to receive(:new).and_return(conf)
-        expect(Flydata::SyncFileManager).to receive(:new).with(de).and_return(sync_fm)
         expect(Flydata::Command::Login).to receive(:new).and_return(login)
         expect(Flydata::Command::Sender).to receive(:new).and_return(sender).twice
 

data/spec/flydata/command/sync_spec.rb

@@ -5,10 +5,10 @@ require 'flydata/command/sync'
 module Flydata
   module Command
     describe Sync do
-      let(:subject_object){ described_class.new }
       subject { subject_object }
+      let(:subject_object){ described_class.new }
 
-      let(:default_mysqldump_dir) do
+      let(:default_dump_dir) do
         File.join('/tmp', "sync_dump_#{Time.now.to_i}")
       end
       let(:default_data_entry) do
@@ -36,7 +36,7 @@ module Flydata
             "password"=>"welcome", "database"=>"sync_test", "tables"=>["table1", "table2", "table4"],
             "invalid_tables"=>["table3"],
             "new_tables"=>["table4"],
-            "mysqldump_dir"=>default_mysqldump_dir, "forwarder" => "tcpforwarder",
+            "dump_dir"=>default_dump_dir, "forwarder" => "tcpforwarder",
             "data_servers"=>"localhost:9905" }
          }
       end
@@ -46,16 +46,12 @@ module Flydata
       let(:mysql_table_columns) {
         {"id"=>{:column_name=>"id", :format_type_str=>"int(11)", :format_type=>"int", :format_size=>11}, "name"=>{:column_name=>"name", :format_type_str=>"varchar(40)", :format_type=>"varchar", :format_size=>40, :default=>nil}, "created_at"=>{:column_name=>"created_at", :format_type_str=>"timestamp", :format_type=>"timestamp", :default=>"CURRENT_TIMESTAMP"}, "bin"=>{:column_name=>"bin", :format_type_str=>col4_type_str, :format_type=>col4_type, :format_size=>col4_width, :default=>nil}, "bin2"=>{:column_name=>"bin2", :format_type_str=>"blob", :format_type=>"blob"}, "varbin"=>{:column_name=>"varbin", :format_type_str=>"varchar(34)", :format_type=>"varchar", :format_size=>34, :default=>nil}}
       }
-      let(:mysql_table) do
-        Flydata::Parser::Mysql::MysqlTable.new("test_table", mysql_table_columns, ['id'])
-      end
-
       after :each do
-        if Dir.exists?(default_mysqldump_dir)
-          Dir.delete(default_mysqldump_dir) rescue nil
+        if Dir.exists?(default_dump_dir)
+          Dir.delete(default_dump_dir) rescue nil
         end
-        if File.exists?(default_mysqldump_dir)
-          File.delete(default_mysqldump_dir) rescue nil
+        if File.exists?(default_dump_dir)
+          File.delete(default_dump_dir) rescue nil
         end
       end
 
@@ -78,7 +74,7 @@ module Flydata
           end
         end
       end
-      describe '#generate_mysqldump' do
+      describe '#generate_source_dump' do
         let (:flydata) { double('flydata') }
         let (:dp) { double('dp') }
         let (:default_data_port) { double('default_data_port') }
@@ -92,10 +88,15 @@ module Flydata
         let (:target_tables) { ["test_table_1"] }
         let (:db_byte) { 1 }
         let (:disk_byte) { 100 }
+        before do
+          require 'flydata/source_mysql/generate_source_dump'
+          allow_any_instance_of(Flydata::SourceMysql::GenerateSourceDump).to receive(:dump_size).and_return(db_byte)
+          allow_any_instance_of(Flydata::SourceMysql::GenerateSourceDump).to receive(:run_compatibility_check)
+        end
         before do
           expect(subject).to receive(:flydata).and_return(flydata).at_least(:once)
+          allow(subject).to receive(:data_entry).and_return(default_data_entry)
           expect(flydata).to receive(:data_port).and_return(dp)
-          allow(flydata).to receive(:data_entry).and_return(default_data_entry)
           expect(dp).to receive(:get).and_return(default_data_port)
           allow(File).to receive(:exists?).and_return(false)
           expect(default_sync_fm).to receive(:load_dump_pos).and_return(default_dump_pos)
@@ -106,8 +107,6 @@ module Flydata
           expect(subject).to receive(:log_info)
           expect(subject).to receive(:log_info_stdout).at_least(:once)
           expect(subject).to receive(:ask_yes_no).and_return(true).at_least(:once)
-          Flydata::Parser::Mysql::DatabaseSizeCheck.any_instance.should_receive(:get_db_bytesize).and_return(db_byte)
-          Flydata::MysqlCompatibilityCheck.any_instance.should_receive(:check)
           expect_any_instance_of(FlydataCore::Event::ApiEventSender).to receive(:send_event).once
         end
         context 'with no stream option' do
@@ -118,145 +117,43 @@ module Flydata
           end
           it 'will export to dump file' do
             expect(subject).to receive(:call_block_or_return_io)
-            Flydata::Parser::Mysql::MysqlDumpGeneratorNoMasterData.any_instance.should_receive(:dump).with(default_fp)
+            expect_any_instance_of(Flydata::SourceMysql::GenerateSourceDump).
+              to receive(:dump).with(target_tables, default_fp)
 
-            subject.send(:generate_mysqldump, default_data_entry, default_sync_fm)
+            subject.send(:generate_source_dump, default_data_entry, default_sync_fm)
           end
           it 'will remove dump file on interrupt' do
             expect(default_sync_fm).to receive(:delete_dump_file)
+            expect_any_instance_of(Flydata::SourceMysql::Parser::MysqlDumpGeneratorNoMasterData).to receive(:dump).and_raise(Interrupt)
 
             expect {
-              Flydata::Parser::Mysql::MysqlDumpGeneratorNoMasterData.any_instance.should_receive(:dump).and_raise(Interrupt)
-              subject.send(:generate_mysqldump, default_data_entry, default_sync_fm)
+              subject.send(:generate_source_dump, default_data_entry, default_sync_fm)
             }.to raise_error
           end
         end
         context 'with stream option' do
           it 'will export to io' do
             expect(default_sync_fm).to receive(:save_sync_info).once
-            Flydata::Parser::Mysql::MysqlDumpGeneratorNoMasterData.any_instance.should_receive(:dump)
+            expect_any_instance_of(Flydata::SourceMysql::Parser::MysqlDumpGeneratorNoMasterData).to receive(:dump)
 
-            subject.send(:generate_mysqldump, default_data_entry, default_sync_fm, false)
-          end
-        end
-      end
-      describe '#do_generate_table_ddl' do
-        before do
-          allow(subject).to receive(:data_entry).and_return(default_data_entry)
-          allow_any_instance_of(Flydata::Api::DataEntry).to receive(:update_table_validity).and_return(true)
-          subject.send(:set_current_tables, nil, include_all_tables: true)
-        end
-        shared_examples 'throws an error' do
-          it "throws an error" do
-            expect {
-              subject.send(:do_generate_table_ddl, default_data_entry)
-            }.to raise_error
-          end
-        end
-        context 'with full options' do
-          it 'issues mysqldump command with expected parameters' do
-            expect(Open3).to receive(:popen3).with(
-             'mysqldump -h localhost -P 3306 -umasashi -pwelcome --default-character-set=utf8 --protocol=tcp -d sync_test table1 table2 table4 table3')
-            subject.send(:do_generate_table_ddl, default_data_entry)
-          end
-        end
-        context 'without_host' do
-          before do
-            default_data_entry['mysql_data_entry_preference'].delete('host')
-          end
-          include_examples 'throws an error'
-        end
-        context 'with empty host' do
-          before do
-            default_data_entry['mysql_data_entry_preference']['host'] = ""
-          end
-          include_examples 'throws an error'
-        end
-        context 'without_port' do
-          before do
-            default_data_entry['mysql_data_entry_preference'].delete('port')
-          end
-          it "uses the default port" do
-            expect(Open3).to receive(:popen3).with(
-             'mysqldump -h localhost -umasashi -pwelcome --default-character-set=utf8 --protocol=tcp -d sync_test table1 table2 table4 table3')
-            subject.send(:do_generate_table_ddl, default_data_entry)
-          end
-        end
-        context 'with_port_override' do
-          before do
-            default_data_entry['mysql_data_entry_preference']['port'] = 1234
-          end
-          it "uses the specified port" do
-            expect(Open3).to receive(:popen3).with(
-             'mysqldump -h localhost -P 1234 -umasashi -pwelcome --default-character-set=utf8 --protocol=tcp -d sync_test table1 table2 table4 table3')
-            subject.send(:do_generate_table_ddl, default_data_entry)
-          end
-        end
-        context 'without_username' do
-          before do
-            default_data_entry['mysql_data_entry_preference'].delete('username')
-          end
-          include_examples 'throws an error'
-        end
-        context 'with empty username' do
-          before do
-            default_data_entry['mysql_data_entry_preference']['username'] = ""
-          end
-          include_examples 'throws an error'
-        end
-        context 'without_password' do
-          before do
-            default_data_entry['mysql_data_entry_preference'].delete('password')
-          end
-          it "call mysqldump without MYSQL_PW set" do
-            expect(Open3).to receive(:popen3).with(
-             'mysqldump -h localhost -P 3306 -umasashi --default-character-set=utf8 --protocol=tcp -d sync_test table1 table2 table4 table3')
-            subject.send(:do_generate_table_ddl, default_data_entry)
-          end
-        end
-        context 'with password containing symbols' do
-          before do
-            default_data_entry['mysql_data_entry_preference'].delete('password')
-            default_data_entry['mysql_data_entry_preference']['password']="welcome&!@^@#^"
-          end
-          it "call mysqldump with MYSQL_PW set with correct symbols" do
-            expect(Open3).to receive(:popen3).with(
-             'mysqldump -h localhost -P 3306 -umasashi -pwelcome\\&\\!@\\^@\\#\\^ --default-character-set=utf8 --protocol=tcp -d sync_test table1 table2 table4 table3')
-            subject.send(:do_generate_table_ddl, default_data_entry)
-          end
-        end
-        context 'without_database' do
-          before do
-            default_data_entry['mysql_data_entry_preference'].delete('database')
-          end
-          include_examples 'throws an error'
-        end
-        context 'with empty database' do
-          before do
-            default_data_entry['mysql_data_entry_preference']['database'] = ""
-          end
-          include_examples 'throws an error'
-        end
-        context 'with empty tables' do
-          let(:sync_cmd) { described_class.new }
-          before do
-            default_data_entry['mysql_data_entry_preference']['tables'] = []
-            default_data_entry['mysql_data_entry_preference']['invalid_tables'] = []
-            default_data_entry['mysql_data_entry_preference']['new_tables'] = []
-            allow(sync_cmd).to receive(:data_entry).and_return(default_data_entry)
-            sync_cmd.send(:set_current_tables, nil, include_all_tables: true)
-          end
-          it 'should raise error' do
-            expect{sync_cmd.send(:do_generate_table_ddl, default_data_entry)}.to raise_error
+            subject.send(:generate_source_dump, default_data_entry, default_sync_fm, false)
           end
         end
       end
       describe '#convert_to_flydata_values' do
-        subject { subject_object.send(:convert_to_flydata_values, mysql_table, values) }
+        subject { subject_object.send(:convert_to_flydata_values, source_table, values) }
         let(:values) { [4, 'John', nil, col4_value, nil, nil] }
 
+        let(:source_table) do
+          Flydata::Parser::SourceTable.new("test_table", mysql_table_columns, ['id'])
+        end
+
         before do
-          mysql_table.set_value_converters(FlydataCore::TableDef::MysqlTableDef::VALUE_CONVERTERS)
+          require 'flydata/parser/source_table'
+        end
+
+        before do
+          source_table.set_value_converters(FlydataCore::TableDef::MysqlTableDef::VALUE_CONVERTERS)
         end
 
         context 'with binary column' do
@@ -273,6 +170,72 @@ module Flydata
           end
         end
       end
+
+      describe '#data_entry' do
+        subject { subject_object.send(:data_entry) }
+
+        let(:de) { { 'mysql_data_entry_preference' => mp } }
+        let(:mp) { { 'tables' => 'Users,Addresses' } }
+
+        let(:sfm) { double('sfm') }
+        let(:ssl_ca_content) { double('ssl_ca_content') }
+        let(:ssl_ca_path) { double('ssl_ca_path') }
+
+        before do
+          allow(subject_object).to receive(:retrieve_data_entries).
+            and_return([de])
+        end
+
+        context 'type RedshiftMysqlDataEntry' do
+          before { de['type'] = 'RedshiftMysqlDataEntry' }
+          context 'called once' do
+            before do
+              expect(subject_object).to receive(:retrieve_data_entries).
+                and_return([de])
+            end
+            context 'without tables_append_only' do
+              it "expands a table list string to an array of tables" do
+                subject
+                expect(mp['tables']).to eq %w(Users Addresses)
+              end
+            end
+            context 'with tables_append_only' do
+              before { mp['tables_append_only'] = 'Invoices,Sessions,Addresses' }
+              it "creates an array of tables from 'tables' and 'tables_append_only' combined" do
+                subject
+                expect(mp['tables']).to eq %w(Users Addresses Invoices Sessions)
+              end
+            end
+            context 'with ssl_ca_content' do
+              before { mp["ssl_ca_content"] = ssl_ca_content }
+              it "saves the content to a local file via SyncFileManager" do
+                expect(SyncFileManager).to receive(:new).with(de).
+                  and_return(sfm)
+                expect(sfm).to receive(:save_ssl_ca).with(ssl_ca_content)
+                expect(sfm).to receive(:ssl_ca_path).and_return(ssl_ca_path)
+
+                subject
+                expect(mp['ssl_ca']).to eq ssl_ca_path
+                expect(mp['sslca']).to eq ssl_ca_path
+              end
+            end
+          end
+          context 'called twice' do
+            before { subject }
+            it "repurposes the saved de" do
+              expect(subject_object).to receive(:retrieve_data_entries).never
+              subject
+              expect(mp['tables']).to eq %w(Users Addresses)
+            end
+          end
+        end
+        context 'type RedshiftFileDataEntry' do
+          before { de['type'] = 'RedshiftFileDataEntry' }
+          it "raises an error about unsupported data entry" do
+            expect { subject }.to raise_error /(supported data entry|data entry.*support)/
+          end
+        end
+      end
     end
   end
 end

data/spec/flydata/compatibility_check_spec.rb

@@ -3,309 +3,36 @@ require 'flydata/compatibility_check'
 
 module Flydata
   describe AgentCompatibilityCheck do
+    let(:subject_object) { AgentCompatibilityCheck.new("servers" => ['localhost']) }
     let(:default_data_port) do
       {
         "servers"=>["sample-test-site.com"]
       }
-     end
-
-    describe "#check" do
-      subject { AgentCompatibilityCheck.new("servers" => ['localhost']) }
-      context "runs all check methods" do
-        context "when all ports are accessible" do
-          let(:sock) { double('sock') }
-          before do
-            allow(TCPSocket).to receive(:new).and_return(sock)
-            allow(sock).to receive(:close)
-          end
-          it "does nothing" do
-            subject.check
-          end
-        end
-        context "when a port access fails" do
-          before do
-            allow(TCPSocket).to receive(:new).and_raise(Errno::ETIMEDOUT)
-          end
-          it do
-            expect{subject.check_outgoing_ports}.to raise_error(FlydataCore::AgentCompatibilityError, /ports/)
-          end
-        end
-      end
     end
-  end
-
-  describe MysqlCompatibilityCheck do
-    let(:default_data_port) do
-      {
-        "servers"=>["sample-test-site.com"]
-      }
-     end
-
-    let(:default_mysql_cred) do
-      {
-        "host" => "test",
-        "port" => 1234,
-        "username" => "test",
-        "password" => "password",
-        "database" => "test_db"
-      }
+    let(:sock) { double('sock') }
+    before do
+      allow(sock).to receive(:close)
     end
 
-    describe "#check_mysql_user_compat" do
-      let(:client) { double('client') }
-      subject { MysqlCompatibilityCheck.new(default_data_port, default_mysql_cred) }
-      before do
-        allow(Mysql2::Client).to receive(:new).and_return(client)
-        allow(client).to receive(:close)
-      end
-
-      context "with all privileges in all databases" do
-        before do
-          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT ALL PRIVILEGES ON *.* TO 'test'@'host"}])
-        end
-        it do
-          expect{subject.check_mysql_user_compat}.to_not raise_error
-        end
-      end
-      context "with missing privileges in one database" do
-        before do
-          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT ALL PRIVILEGES ON 'mysql'.* TO 'test'@'host"},
-                                                       {"Grants for test"=>"GRANT SELECT, RELOAD, REPLICATION CLIENT ON `test_db`.* TO 'test'@'host"}])
-        end
-        it do
-          expect{subject.check_mysql_user_compat}.to raise_error(FlydataCore::MysqlCompatibilityError, /test_db': LOCK TABLES, REPLICATION SLAVE/)
-        end
-      end
-      context "with all required privileges in between all and specific databases" do
-        before do
-          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT RELOAD, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'test'@'host"},
-                                                       {"Grants for test"=>"GRANT SELECT, LOCK TABLES ON `test_db`.* TO 'test'@'host"},
-                                                       {"Grants for test"=>"GRANT SELECT, LOCK TABLES ON `mysql`.* TO 'test'@'host"}])
-        end
-        it do
-          expect{subject.check_mysql_user_compat}.to_not raise_error
-        end
-      end
-      context "with missing privileges in each database" do
-        before do
-          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'test'@'host"},
-                                                       {"Grants for test"=>"GRANT SELECT, LOCK TABLES ON `test_db`.* TO 'test'@'host"},
-                                                       {"Grants for test"=>"GRANT SELECT, LOCK TABLES ON `mysql`.* TO 'test'@'host"}])
-        end
-        it do
-          expect{subject.check_mysql_user_compat}.to raise_error(FlydataCore::MysqlCompatibilityError, /mysql': RELOAD\n.*test_db': RELOAD/)
-        end
-      end
-      context "with all required privileges in all databases" do
-        before do
-          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT SELECT, LOCK TABLES, RELOAD, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'test'@'host"}])
-        end
-        it do
-          expect{subject.check_mysql_user_compat}.to_not raise_error
-        end
-      end
-      context "with missing privileges in all databases" do
-        before do
-          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT RELOAD, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'test'@'host"}])
-        end
-        it do
-          expect{subject.check_mysql_user_compat}.to raise_error(FlydataCore::MysqlCompatibilityError, /mysql': SELECT, LOCK TABLES\n.*test_db': SELECT, LOCK TABLES/)
-        end
-      end
-      context "with privileges for other databases only" do
+    describe "#check" do
+      subject { subject_object.check }
+      context "when all ports are accessible" do
         before do
-          allow(client).to receive(:query).and_return([{"Grants for test"=>"GRANT REPLICATION CLIENT ON `test_db_01`.* TO 'test'@'host"},
-                                                       {"Grants for test"=>"GRANT LOCK TABLES ON `test_db_02`.* TO 'test'@'host"},
-                                                       {"Grants for test"=>"GRANT SELECT ON `text_db_03`.* TO 'test'@'host"}])
-        end
-        it do
-          expect{subject.check_mysql_user_compat}.to raise_error(FlydataCore::MysqlCompatibilityError, /mysql': SELECT, RELOAD, LOCK TABLES, REPLICATION SLAVE, REPLICATION CLIENT\n.*test_db': SELECT, RELOAD, LOCK TABLES, REPLICATION SLAVE, REPLICATION CLIENT/)
-        end
-      end
-
-    end
-
-    describe "#check_mysql_binlog_retention" do
-      context "on on-premise mysql server" do
-        subject { MysqlCompatibilityCheck.new(default_data_port, default_mysql_cred) }
-        context "where retention is below limit" do
-          let(:client) { double('client') }
-          before do
-            allow(Mysql2::Client).to receive(:new).and_return(client)
-            allow(client).to receive(:query).and_return([{"Variable_name" => "expire_logs_days", "Value" => 1}])
-            allow(client).to receive(:close)
-            allow(subject).to receive(:is_rds?).and_return(false)
-          end
-          it do
-            expect{subject.check_mysql_binlog_retention}.to raise_error(FlydataCore::MysqlCompatibilityError, /expire_logs_days/)
-          end
-        end
-        context "where retention is 0" do
-          let(:client) { double('client') }
-          before do
-            allow(Mysql2::Client).to receive(:new).and_return(client)
-            allow(client).to receive(:query).and_return([{"Variable_name" => "expire_logs_days", "Value" => 0}])
-            allow(client).to receive(:close)
-            allow(subject).to receive(:is_rds?).and_return(false)
-          end
-          it do
-            expect{subject.check_mysql_binlog_retention}.to_not raise_error
-          end
-        end
-        context "where retention is above limit" do
-          let(:client) { double('client') }
-          before do
-            allow(Mysql2::Client).to receive(:new).and_return(client)
-            allow(client).to receive(:query).and_return([{"expire_logs_days"=>11}])
-            allow(client).to receive(:query).and_return([{"Variable_name" => "expire_logs_days", "Value" => 11}])
-            allow(client).to receive(:close)
-            allow(subject).to receive(:is_rds?).and_return(false)
-          end
-          it do
-            expect{subject.check_mysql_binlog_retention}.to_not raise_error
-          end
-        end
-      end
-      context "on RDS" do
-        subject { MysqlCompatibilityCheck.new(default_data_port, default_mysql_cred) }
-        context "where retention period is nil" do
-          let(:client) { double('client') }
-          before do
-            allow(Mysql2::Client).to receive(:new).and_return(client)
-            allow(client).to receive(:query).with("SELECT @@expire_logs_days").and_return([{"@@expire_logs_days"=>0}])
-            allow(client).to receive(:query).with("call mysql.rds_show_configuration;").and_return([{"name"=>"binlog retention hours", "value"=>nil}])
-            allow(client).to receive(:close)
-            allow(subject).to receive(:is_rds?).and_return(true)
-          end
-          it do
-            expect{subject.check_mysql_binlog_retention}.to raise_error(FlydataCore::MysqlCompatibilityError, /rds_set_config/)
-          end
+          allow(TCPSocket).to receive(:new).and_return(sock)
         end
-        context "where retention period is too low" do
-           let(:client) { double('client') }
-          before do
-            allow(Mysql2::Client).to receive(:new).and_return(client)
-            allow(client).to receive(:query).with("SELECT @@expire_logs_days").and_return([{"@@expire_logs_days"=>0}])
-            allow(client).to receive(:query).with("call mysql.rds_show_configuration;").and_return([{"name"=>"binlog retention hours", "value"=>4}])
-            allow(client).to receive(:close)
-            allow(subject).to receive(:is_rds?).and_return(true)
-          end
-          it do
-            expect{subject.check_mysql_binlog_retention}.to raise_error(FlydataCore::MysqlCompatibilityError, /rds_set_config/)
-          end
-        end
-        context "where retention period is over recommended limit" do
-         let(:client) { double('client') }
-          before do
-            allow(Mysql2::Client).to receive(:new).and_return(client)
-            allow(client).to receive(:query).with("SELECT @@expire_logs_days").and_return([{"@@expire_logs_days"=>0}])
-            allow(client).to receive(:query).with("call mysql.rds_show_configuration;").and_return([{"name"=>"binlog retention hours", "value"=>120}])
-            allow(client).to receive(:close)
-            allow(subject).to receive(:is_rds?).and_return(true)
-          end
-          it do
-            expect{subject.check_mysql_binlog_retention}.to_not raise_error
-          end
-        end
-        context "where user has no access to rds configuration" do
-          let(:client) { double('client') }
-          before do
-            allow(Mysql2::Client).to receive(:new).and_return(client)
-            allow(client).to receive(:query).with("SELECT @@expire_logs_days").and_return([{"@@expire_logs_days"=>0}])
-            allow(client).to receive(:query).with("call mysql.rds_show_configuration;").and_raise(Mysql2::Error, "execute command denied to user")
-            allow(client).to receive(:close)
-            allow(subject).to receive(:is_rds?).and_return(true)
-          end
-          it do
-            expect{subject.check_mysql_binlog_retention}.to_not raise_error
-          end
+        it "does nothing" do
+          subject
         end
       end
     end
-
-    describe "#check_mysql_table_types" do
-      let(:test_data_entry) do
-        { "host" => "test",
-          "port" => 1234,
-          "username" => "test",
-          "password" => "password",
-          "database" => "test_db",
-          "tables"=>["normal_table", "engine_table", "view_table"] }
-      end
-      let(:normal_table) { {"table_name"=>"normal_table", "table_type"=>"BASE TABLE", "engine"=>"InnoDB"} }
-      let(:engine_table) { {"table_name"=>"engine_table", "table_type"=>"BASE TABLE", "engine"=>"MEMORY"} }
-      let(:blackhole_table) { {"table_name"=>"blackhole_table", "table_type"=>"BASE TABLE", "engine"=>"BLACKHOLE"} }
-      let(:view) { {"table_name"=>"view_table", "table_type"=>"VIEW", "engine"=>nil} }
-      let(:client) { double('client') }
-      let(:subject_object) { MysqlCompatibilityCheck.new(default_data_port,test_data_entry, {}) }
-      let(:error) { FlydataCore::MysqlCompatibilityError }
-      let(:base_error_msg) { "FlyData does not support VIEW and MEMORY,BLACKHOLE STORAGE ENGINE table. Remove following tables from data entry: %s" }
-      subject { subject_object.check_mysql_table_types }
-      before do
-        allow(Mysql2::Client).to receive(:new).and_return(client)
-        allow(client).to receive(:query).and_return(table_list)
-        allow(client).to receive(:escape).and_return("aaa")
-        allow(client).to receive(:close)
-      end
-      context "where data entry has VIEW and MEMORY engine table" do
-        let(:error_msg) { base_error_msg %  engine_table['table_name'] + ', ' + view['table_name'] }
-        let(:table_list) { [ engine_table, view ] }
-        it { expect{subject}.to raise_error(error, /#{error_msg}/) }
-      end
-      context "where data entry has MEMORY engine table" do
-        let(:error_msg) { base_error_msg %  engine_table['table_name'] } 
-        let(:table_list) { [ engine_table ] }
-        it { expect{subject}.to raise_error(error, /#{error_msg}/) }
-      end
-      context "where data entry has BLACKHOLE engine table" do
-        let(:error_msg) { base_error_msg %  blackhole_table['table_name'] }
-        let(:table_list) { [ blackhole_table ] }
-        it { expect{subject}.to raise_error(error, /#{error_msg}/) }
-      end
-      context "where data entry has the VIEW" do
-        let(:error_msg) { base_error_msg % view['table_name'] }
-        let(:table_list) { [ view ] }
-        it { expect{subject}.to raise_error(error, /#{error_msg}/) }
-      end
-      context "where data entry does not have either VIEW and ENGINE table" do
-        let(:table_list) { [ normal_table ] }
-        it { expect{subject}.to_not raise_error }
-      end
-    end
-
-    describe "#check_rds_master_status" do
-      let(:client) { double('client') }
-      let(:subject_object) { MysqlCompatibilityCheck.new(default_data_port, default_mysql_cred) }
-      subject { subject_object.check_rds_master_status }
-      let(:master_status) { [] }
-
-      before do
-        allow(Mysql2::Client).to receive(:new).and_return(client)
-        allow(client).to receive(:query).and_return(master_status)
-        allow(client).to receive(:close)
-      end
-
-      context 'when host is rds' do
+    describe '#check_outgoing_ports' do
+      subject { subject_object.check_outgoing_ports }
+      context "when a port access fails" do
         before do
-          default_mysql_cred['host'] = 'rdrss.xxyyzz.rds.amazonaws.com'
+          allow(TCPSocket).to receive(:new).and_raise(Errno::ETIMEDOUT)
         end
-
-        context "where backup retention period is not set" do
-          let(:master_status) { [] }
-          it { expect{subject}.to raise_error(FlydataCore::MysqlCompatibilityError, /Backup Retention Period/) }
-        end
-
-        context "where backup retention period is set" do
-          let(:master_status) do
-            [{
-              'File' => 'mysql-bin-changelog.026292',
-              'Position' => '31300',
-              'Binlog_Do_DB' => '',
-              'Binlog_Ignore_DB' => '',
-              'Executed_Gtid_Set' => '',
-            }]
-          end
-          it { expect{subject}.not_to raise_error }
+        it do
+          expect{subject}.to raise_error(FlydataCore::AgentCompatibilityError, /ports/)
         end
       end
     end