flydata 0.2.8 → 0.2.9

data/spec/flydata/output/forwarder_spec.rb

@@ -0,0 +1,105 @@
+# coding: utf-8
+require 'spec_helper'
+
+module Flydata
+  module Output
+    describe ForwarderFactory do
+      let(:forwarder) do
+        ForwarderFactory.create('tcpforwarder', 'test_tag', ['localhost:3456', 'localhost:4567'])
+      end
+      before :each do
+        conn = double(TCPSocket)
+        allow(conn).to receive(:setsockopt)
+        allow(conn).to receive(:write)
+        allow(conn).to receive(:close)
+        allow(TCPSocket).to receive(:new).and_return(conn)
+        allow(StringIO).to receive(:open)
+      end
+
+      describe '.create' do
+        context 'with nil forwarder_key' do
+          it 'should return TcpForwarder object' do
+            forwarder = ForwarderFactory.create(nil, 'test_tag', ['localhost:3456', 'localhost:4567'])
+            expect(forwarder.kind_of?(TcpForwarder)).to be_truthy
+          end
+        end
+
+        context 'with tcpforwarder forwarder_key' do
+          it 'should return TcpForwarder object' do
+            forwarder = ForwarderFactory.create('tcpforwarder', 'test_tag', ['localhost:3456', 'localhost:4567'])
+            expect(forwarder.kind_of?(TcpForwarder)).to be_truthy
+          end
+        end
+
+        context 'with sslforwarder forwarder_key' do
+          it 'should return SslForwarder object' do
+            forwarder = ForwarderFactory.create('sslforwarder', 'test_tag', ['localhost:3456', 'localhost:4567'])
+            expect(forwarder.kind_of?(SslForwarder)).to be_truthy
+          end
+        end
+      end
+
+      describe '#initialize' do
+        context 'servers is empty' do
+          it do
+            expect{ForwarderFactory.create('tcpforwarder', 'test_tag', [])}.to raise_error
+          end
+        end
+        context 'servers is nil' do
+          it do
+            expect{ForwarderFactory.create('tcpforwarder', 'test_tag', nil)}.to raise_error
+          end
+        end
+      end
+
+      describe '#emit' do
+        let(:record) { {table_name: 'test_table_name', log: '{"key":"value"}'} }
+        before :each do
+          forwarder.set_options({buffer_size_limit: ([Time.now.to_i,record].to_msgpack.bytesize * 2.5)})
+        end
+        context 'when the buffer size is less than threthold' do
+          it do
+            expect(forwarder.emit(record)).to be(false)
+            expect(forwarder.buffer_record_count).to be(1)
+          end
+        end
+        context 'when the buffer size exceeds threthold' do
+          it do
+            expect(forwarder.emit(record)).to be(false)
+            expect(forwarder.emit(record)).to be(false)
+            expect(forwarder.buffer_record_count).to be(2)
+            expect(forwarder.emit(record)).to be(true)
+            expect(forwarder.buffer_record_count).to be(0)
+          end
+        end
+      end
+
+      describe '#pickup_server' do
+        context 'with only one server' do
+          let(:servers) { ['localhost:1111'] }
+          let(:forwarder) {
+            ForwarderFactory.create('tcpforwarder', 'test_tag', servers)
+          }
+          it 'expect to return same server' do
+            expect(forwarder.pickup_server).to eq('localhost:1111')
+            expect(forwarder.pickup_server).to eq('localhost:1111')
+            expect(forwarder.pickup_server).to eq('localhost:1111')
+          end
+        end
+        context 'with servers' do
+          let(:servers) { ['localhost:1111', 'localhost:2222', 'localhost:3333'] }
+          let(:forwarder) {
+            ForwarderFactory.create('tcpforwarder', 'test_tag', servers)
+          }
+          it 'expect to return same server' do
+            expect(forwarder.pickup_server).to eq('localhost:1111')
+            expect(forwarder.pickup_server).to eq('localhost:2222')
+            expect(forwarder.pickup_server).to eq('localhost:3333')
+            expect(forwarder.pickup_server).to eq('localhost:1111')
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/flydata/parser/mysql/alter_table_parser_spec.rb

@@ -556,6 +556,11 @@ describe 'MysqlAlterTableParser' do
         })
       end
     end
+    shared_examples "a parser raising an error" do
+      it do
+        expect { subject }.to raise_error
+      end
+    end
     shared_examples "a parser parsing a nonbreaking query" do
       let(:action_hash) {
           {
@@ -710,23 +715,36 @@ describe 'MysqlAlterTableParser' do
         end
       end
     end
-    shared_examples "test field identifier" do |*examples|
-      context "without ." do
-        it_behaves_like "test identifier", *examples do
-          let(:field_ident) { " #{ident}" }
-        end
+    shared_examples "test identifier combination without ." do |*examples|
+      it_behaves_like "test identifier", *examples do
+        let(:identifier) { " #{ident}" }
       end
-      context "with single ." do
-        it_behaves_like "test identifier", *examples do
-          let(:field_ident) { " #{ident}.#{ident}"}
-        end
+    end
+    shared_examples "test identifier combination with single ." do |*examples|
+      it_behaves_like "test identifier", *examples do
+        let(:identifier) { " #{ident}.#{ident}" }
       end
-      context "with two ." do
-        it_behaves_like "test identifier", *examples do
-          let(:field_ident) { " #{ident}.#{ident}.#{ident}" }
-        end
+    end
+    shared_examples "test identifier combination with single . starting with ." do |*examples|
+      it_behaves_like "test identifier", *examples do
+        let(:identifier) { " .#{ident}" }
+      end
+    end
+    shared_examples "test identifier combination with two ." do |*examples|
+      it_behaves_like "test identifier", *examples do
+        let(:identifier) { " #{ident}.#{ident}.#{ident}" }
+      end
+    end
+    shared_examples "test identifier combination with two . starting with ." do |*examples|
+      it_behaves_like "test identifier", *examples do
+        let(:identifier) { " .#{ident}.#{ident}" }
       end
     end
+    shared_examples "test field identifier" do |*examples|
+      it_behaves_like "test identifier combination without .", *examples
+      it_behaves_like "test identifier combination with single .", *examples
+      it_behaves_like "test identifier combination with two .", *examples
+    end
     shared_examples "test identifier" do |*examples|
       context "unquoted identifier" do
         it_behaves_like *examples do
@@ -739,7 +757,109 @@ describe 'MysqlAlterTableParser' do
         end
       end
     end
-
+    shared_examples "test optional to" do |*examples|
+      context "with to" do
+        it_behaves_like *examples do
+          let(:opt_to) {" TO "}
+        end
+      end
+      context "with =" do
+        it_behaves_like *examples do
+          let(:opt_to) {" = "}
+        end
+      end
+      context "with = without spaces" do
+        it_behaves_like *examples do
+          let(:opt_to) {"="}
+        end
+      end
+      context "with AS" do
+        it_behaves_like *examples do
+          let(:opt_to) {" as "}
+        end
+      end
+      context "with none" do
+        it_behaves_like *examples do
+          let(:opt_to) { "" }
+        end
+      end
+    end
+    shared_examples "test table identifier" do |*examples|
+      it_behaves_like "test identifier combination without .", *examples
+      it_behaves_like "test identifier combination with single .", *examples
+      it_behaves_like "test identifier combination with single . starting with .", *examples
+    end
+    shared_examples "test simple identifier" do |*examples|
+      it_behaves_like "test identifier combination without .", *examples
+      it_behaves_like "test identifier combination with single .", *examples
+      it_behaves_like "test identifier combination with two .", *examples
+      it_behaves_like "test identifier combination with two . starting with .", *examples
+    end
+    shared_examples "test order" do |*examples|
+      context "ascending" do
+        it_behaves_like *examples do
+          let(:order){" ASC"}
+        end
+      end
+      context "descending" do
+        it_behaves_like *examples do
+          let(:order){" desc"}
+        end
+      end
+      context "no order" do
+        it_behaves_like *examples do
+          let(:order){""}
+        end
+      end
+    end
+    shared_examples "test charset" do |*examples|
+      ["CHARACTER SET", "charset"].each do |charset|
+        context "charset is #{charset}" do
+          it_behaves_like *examples do
+            let(:charset){"#{charset}"}
+          end
+        end
+      end
+    end
+    shared_examples "test charsetname" do |*examples|
+      ["default","binary","utf8","latin1"].each do |charsetname|
+        context "charsetname is #{charsetname}" do
+          it_behaves_like *examples do
+            let(:charsetname){"#{charsetname}"}
+          end
+        end
+      end
+    end
+    shared_examples "test collate" do |*examples|
+      ["collate default", "collate utf8_general_ci", "collate latin1_bin"].each do |collate|
+        context "collate is #{collate}" do
+          it_behaves_like *examples do
+            let(:collate){"#{collate}"}
+          end
+        end
+      end
+    end
+    shared_examples "test collate with equals" do |*examples|
+      ["collate=default", "collate = utf8_general_ci"].each do |collate|
+        context "collate is #{collate}" do
+          it_behaves_like *examples do
+            let(:collate){"#{collate}"}
+          end
+        end
+      end
+    end
+    shared_examples "test optional default" do |*examples|
+      context "with default" do
+        it_behaves_like *examples do
+          let(:default){"default "}
+        end
+      end
+      context "without default" do
+        it_behaves_like *examples do
+          let(:default){""}
+        end
+      end
+    end
     context 'add index' do
       let(:action) { :add_index }
       context "with a simple add index" do
@@ -911,13 +1031,12 @@ describe 'MysqlAlterTableParser' do
     context "enable keys" do
       let(:alter_table_action) { "ENABLE KEYS" }
       let(:action) { :enable_keys }
-      let(:action_hash) {
-        {
-          action: action,
-          support_level: :nonbreaking,
-          query: alter_table_action,
-        }
-      }
+      it_behaves_like "a parser parsing a nonbreaking query"
+    end
+    context "disable keys" do
+      let(:alter_table_action) { "DISABLE KEYS" }
+      let(:action) { :disable_keys }
+      it_behaves_like "a parser parsing a nonbreaking query"
     end
     context "drop primary key" do
       let(:alter_table_action) { "DROP PRIMARY KEY" }
@@ -926,16 +1045,98 @@ describe 'MysqlAlterTableParser' do
       it_behaves_like "a parser parsing a breaking query"
     end
     context "drop foreign key" do
-      let(:alter_table_action) { "DROP FOREIGN KEY#{field_ident}" }
+      let(:alter_table_action) { "DROP FOREIGN KEY#{identifier}" }
       let(:action) { :drop_foreign_key }
 
       it_behaves_like "test field identifier", "a parser parsing a nonbreaking query"
     end
     context "drop key or index" do
-      let(:alter_table_action) { "DROP#{key_or_index}#{field_ident}" }
+      let(:alter_table_action) { "DROP#{key_or_index}#{identifier}" }
       let(:action) { "drop_#{key_or_index.strip.downcase}".to_sym }
 
       it_behaves_like "test key or index", "test field identifier", "a parser parsing a nonbreaking query"
     end
+    context "rename table" do
+      let(:alter_table_action) { "rename#{opt_to}#{identifier}" }
+      let(:action) { :rename_table }
+
+      it_behaves_like "test optional to", "test table identifier", "a parser parsing a breaking query"
+      context "exception cases" do
+        context "with as followed by quoted identifier and no space in between" do
+          let(:alter_table_action) { "rename as`test_ident1`" } #strange, but valid
+          it_behaves_like "a parser parsing a breaking query"
+        end
+        context "with to followed by quoted identifier and no space in between" do
+          let(:alter_table_action) { "rename to`test_ident1`" }
+          it_behaves_like "a parser parsing a breaking query"
+        end
+        context "no space between rename and to" do
+          let(:alter_table_action) { "renameto `test_ident1`" }
+          it_behaves_like "a parser raising an error"
+        end
+        context "no space between to and table name" do
+          let(:alter_table_action) { "rename totest_ident1" }
+          describe "'totest_ident1' is treated as a table name" do
+            it_behaves_like "a parser parsing a breaking query"
+          end
+        end
+      end
+    end
+    context "order by" do
+      let(:action) { :order_table }
+      context "with single column" do
+        let(:alter_table_action) { "order by#{identifier}#{order}" }
+        it_behaves_like "test simple identifier", "test order", "a parser parsing a breaking query"
+      end
+      context "with multiple columns" do
+        let(:alter_table_action) { "order by#{identifier}#{order},#{identifier}#{order},#{identifier}#{order}" }
+        it_behaves_like "test simple identifier", "test order", "a parser parsing a breaking query"
+      end
+    end
+    context "convert to charset" do
+      let(:action) { :convert_charset }
+      context "test with collate" do
+        let(:alter_table_action) { "convert to #{charset} #{charsetname} #{collate}" }
+        it_behaves_like "test charset", "test charsetname", "test collate", "a parser parsing a breaking query"
+      end
+      context "test without collate" do
+        let(:alter_table_action) { "convert to #{charset} #{charsetname}" }
+        it_behaves_like "test charset", "test charsetname", "a parser parsing a breaking query"
+      end
+    end
+    context "default charset" do
+      let(:action) { :default_charset }
+      context "with collate" do
+        let(:alter_table_action) { "#{default}#{charset}=#{charsetname} #{collate}" }
+        it_behaves_like "test optional default", "test charset",  "test charsetname", "test collate", "a parser parsing a breaking query"
+        it_behaves_like "test optional default",  "test charset", "test charsetname", "test collate with equals", "a parser parsing a breaking query"
+      end
+      context "without collate" do
+        let(:alter_table_action) { "#{default}#{charset} #{charsetname}" }
+        it_behaves_like "test optional default", "test charset",  "test charsetname", "a parser parsing a breaking query"
+      end
+      context "without charset" do
+      #The doc at http://dev.mysql.com/doc/refman/5.6/en/alter-table.html does not indicate that
+      #charset is optional. But this works (tested on mysql 5.5.38)
+        let(:alter_table_action) { "#{default}#{collate}" }
+        it_behaves_like  "test optional default","test collate", "a parser parsing a breaking query"
+        it_behaves_like  "test optional default","test collate with equals", "a parser parsing a breaking query"
+      end
+    end
+    context "force" do
+      let(:alter_table_action) { "force" }
+      let(:action) { :force }
+      it_behaves_like "a parser parsing a nonbreaking query"
+    end
+    context "discard tablespace" do
+      let(:alter_table_action) { "discard tablespace" }
+      let(:action) { :discard_tablespace }
+      it_behaves_like "a parser parsing a breaking query"
+    end
+    context "import tablespace" do
+      let(:alter_table_action) { "import tablespace" }
+      let(:action) { :import_tablespace }
+      it_behaves_like "a parser parsing a breaking query"
+    end
   end
 end

data/spec/flydata/parser/mysql/dump_parser_spec.rb

@@ -0,0 +1,900 @@
+# coding: utf-8
+require 'spec_helper'
+
+module Flydata
+  module Parser
+    module Mysql
+      describe MysqlDumpGeneratorMasterData do
+        let(:stdout) { double(:stdout) }
+        let(:stderr) { double(:stderr) }
+        let(:status) { double(:status) }
+        let(:file_path) { File.join('/tmp', "flydata_sync_spec_mysqldump_#{Time.now.to_i}") }
+        let(:dump_io) { File.open(file_path, 'r', encoding: "utf-8") }
+        let(:default_conf) { {
+          'host' => 'localhost', 'port' => 3306, 'username' => 'admin',
+          'password' => 'pass', 'database' => 'dev', 'tables' => 'users,groups',
+        } }
+        let(:default_dump_generator) { MysqlDumpGeneratorMasterData.new(default_conf) }
+
+        describe '#initialize' do
+          context 'with password' do
+            subject { default_dump_generator.instance_variable_get(:@dump_cmd) }
+            it { is_expected.to eq('mysqldump --protocol=tcp -h localhost -P 3306 -uadmin -ppass --skip-lock-tables ' +
+                                   '--single-transaction --hex-blob --flush-logs --master-data=2 dev users groups') }
+          end
+          context 'without password' do
+            let (:dump_generator) do
+              MysqlDumpGeneratorMasterData.new(default_conf.merge({'password' => ''}))
+            end
+            subject { dump_generator.instance_variable_get(:@dump_cmd) }
+            it { is_expected.to eq('mysqldump --protocol=tcp -h localhost -P 3306 -uadmin  --skip-lock-tables ' +
+                                   '--single-transaction --hex-blob --flush-logs --master-data=2 dev users groups') }
+          end
+        end
+
+        describe '#dump' do
+          context 'when exit status is not 0' do
+            before do
+              `touch #{file_path}`
+              expect(status).to receive(:exitstatus).and_return 1
+              expect(Open3).to receive(:capture3).and_return(
+                ['(dummy std out)', '(dummy std err)', status]
+              )
+            end
+            it do
+              expect{ default_dump_generator.dump(file_path) }.to raise_error
+              expect(File.exists?(file_path)).to be_falsey
+            end
+          end
+          context 'when exit status is 0 but no file' do
+            before do
+              expect(status).to receive(:exitstatus).and_return 0
+              expect(Open3).to receive(:capture3).and_return(
+                ['(dummy std out)', '(dummy std err)', status]
+              )
+            end
+            it do
+              expect{ default_dump_generator.dump(file_path) }.to raise_error
+              expect(File.exists?(file_path)).to be_falsey
+            end
+          end
+          context 'when exit status is 0 but file size is 0' do
+            before do
+              `touch #{file_path}`
+              expect(status).to receive(:exitstatus).and_return 0
+              expect(Open3).to receive(:capture3).and_return(
+                ['(dummy std out)', '(dummy std err)', status]
+              )
+            end
+            it do
+              expect{ default_dump_generator.dump(file_path) }.to raise_error
+              expect(File.exists?(file_path)).to be_truthy
+            end
+          end
+          context 'when exit status is 0' do
+            before do
+              `echo "something..." > #{file_path}`
+              expect(status).to receive(:exitstatus).and_return 0
+              expect(Open3).to receive(:capture3).and_return(
+                ['(dummy std out)', '(dummy std err)', status]
+              )
+            end
+            it do
+              expect(default_dump_generator.dump(file_path)).to be_truthy
+              expect(File.exists?(file_path)).to be_truthy
+            end
+          end
+          after :each do
+            File.delete(file_path) if File.exists?(file_path)
+          end
+        end
+      end
+
+      describe MysqlDumpParser do
+        let(:file_path) { File.join('/tmp', "flydata_sync_spec_mysqldump_parse_#{Time.now.to_i}") }
+        let(:dump_io) { File.open(file_path, 'r', encoding: "utf-8") }
+        let(:default_parser) { MysqlDumpParser.new }
+
+        def generate_dump_file(content)
+          File.open(file_path, 'w') {|f| f.write(content)}
+        end
+
+        after do
+          File.delete(file_path) if File.exists?(file_path)
+        end
+
+        describe '#parse' do
+          DUMP_HEADER = <<EOT
+-- MySQL dump 10.13  Distrib 5.6.13, for osx10.9 (x86_64)
+--
+-- Host: localhost    Database: sync_test
+-- ------------------------------------------------------
+-- Server version>--5.6.13-log
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+/*!40101 SET NAMES utf8 */;
+/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
+/*!40103 SET TIME_ZONE='+00:00' */;
+/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
+/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
+/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
+/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
+
+--
+-- Position to start replication or point-in-time recovery from
+--
+
+-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000267', MASTER_LOG_POS=120;
+EOT
+
+          def index_after(content, string)
+            content.index(string) + string.bytesize + 1
+          end
+
+          let(:default_parser) { MysqlDumpParser.new }
+          let(:default_binlog_pos) { {binfile: 'mysql-bin.000267', pos: 120 } }
+          let(:dump_pos_after_binlog_pos) { index_after(DUMP_HEADER, 'MASTER_LOG_POS=120;') }
+
+          let(:create_table_block) { double('create_table_block') }
+          let(:insert_record_block) { double('insert_record_block') }
+          let(:check_point_block) { double('check_point_block') }
+
+          before do
+            generate_dump_file('')
+          end
+
+          context 'when dump does not contain binlog pos' do
+            before { generate_dump_file('dummy content') }
+            it do
+              expect(create_table_block).to receive(:call).never
+              expect(insert_record_block).to receive(:call).never
+              expect(check_point_block).to receive(:call).never
+              binlog_pos = default_parser.parse(
+                dump_io, create_table_block, insert_record_block, check_point_block
+              )
+              expect(binlog_pos).to be_nil
+            end
+          end
+
+          context 'when dump contains only binlog pos' do
+            before { generate_dump_file(<<EOT
+#{DUMP_HEADER}
+EOT
+                                       ) }
+            it do
+              expect(create_table_block).to receive(:call).never
+              expect(insert_record_block).to receive(:call).never
+              expect(check_point_block).to receive(:call).once
+              binlog_pos = default_parser.parse(
+                dump_io, create_table_block, insert_record_block, check_point_block
+              )
+              expect(binlog_pos).to eq(default_binlog_pos)
+            end
+          end
+
+          context 'when dump contains create table without records' do
+            let(:dump_content) { <<EOT
+#{DUMP_HEADER}
+
+DROP TABLE IF EXISTS `users_login`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `users_login` (
+  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
+  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
+  `create_time` datetime NOT NULL COMMENT 'create time',
+  `update_time` datetime NOT NULL COMMENT 'update time',
+  PRIMARY KEY (`user_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='';
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `users_login`
+--
+
+LOCK TABLES `users_login` WRITE;
+/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
+/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
+UNLOCK TABLES;
+
+EOT
+            }
+            before { generate_dump_file(dump_content) }
+            it do
+              expect(create_table_block).to receive(:call) { |mysql_table|
+                expect(mysql_table.table_name).to eq('users_login')
+              }.once
+              expect(insert_record_block).to receive(:call).never
+              expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                expect(mysql_table).to be_nil
+                expect(last_pos).to eq(dump_pos_after_binlog_pos)
+                expect(binlog_pos).to eq(default_binlog_pos)
+                expect(state).to eq(MysqlDumpParser::State::CREATE_TABLE)
+                expect(substate).to be_nil
+              }
+              expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                expect(mysql_table.table_name).to eq('users_login')
+                expect(mysql_table.columns.keys).to eq(['user_id', 'login_count', 'create_time', 'update_time'])
+                expect(last_pos).to eq(index_after(dump_content, 'ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT=\'\';'))
+                expect(binlog_pos).to eq(default_binlog_pos)
+                expect(state).to eq(MysqlDumpParser::State::INSERT_RECORD)
+                expect(substate).to be_nil
+              }
+              expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                expect(mysql_table.table_name).to eq('users_login')
+                expect(last_pos).to eq(index_after(dump_content, 'UNLOCK TABLES;'))
+                expect(binlog_pos).to eq(default_binlog_pos)
+                expect(state).to eq(MysqlDumpParser::State::CREATE_TABLE)
+                expect(substate).to be_nil
+              }
+              expect(check_point_block).to receive(:call).never
+
+              binlog_pos = default_parser.parse(
+                dump_io, create_table_block, insert_record_block, check_point_block
+              )
+              expect(binlog_pos).to eq(default_binlog_pos)
+            end
+          end
+
+          context 'when dump contains create table with multi inserts' do
+            let(:dump_content) { <<EOT
+#{DUMP_HEADER}
+
+DROP TABLE IF EXISTS `users_login`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `users_login` (
+  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
+  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
+  `comment` varchar(255) DEFAULT NULL COMMENT 'comment',
+  `create_time` datetime NOT NULL COMMENT 'create time',
+  `update_time` datetime NOT NULL COMMENT 'update time',
+  PRIMARY KEY (`user_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `users_login`
+--
+
+LOCK TABLES `users_login` WRITE;
+/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
+INSERT INTO `users_login` VALUES (15,46,'moodier','2001-10-02 08:18:08','1986-06-11 22:50:10'),(35,6,'missあいうえおteer','1991-10-15 19:38:07','1970-10-01 22:03:10'),(52,33,'sub\\\\field','1972-08-23 20:16:08','1974-10-10 23:28:11');
+INSERT INTO `users_login` VALUES (373,31,'out\\'swearing','1979-10-07 08:10:08','2006-02-22 16:26:04'),(493,8,'schizophrenic','1979-07-06 07:34:07','1970-08-09 01:21:01');
+/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
+UNLOCK TABLES;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+
+EOT
+            }
+            before { generate_dump_file(dump_content) }
+            it do
+              # create_table_block
+              expect(create_table_block).to receive(:call) { |mysql_table|
+                expect(mysql_table.table_name).to eq('users_login')
+                expect(mysql_table.columns.keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
+              }.once
+              expect(create_table_block).to receive(:call).never
+
+              # insert_record_block
+              [
+                [ %w(15 46 moodier 2001-10-02\ 08:18:08 1986-06-11\ 22:50:10),
+                  %w(35 6 missあいうえおteer  1991-10-15\ 19:38:07 1970-10-01\ 22:03:10),
+                  %w(52 33 sub\\field 1972-08-23\ 20:16:08 1974-10-10\ 23:28:11),],
+                [ %w(373 31 out'swearing 1979-10-07\ 08:10:08 2006-02-22\ 16:26:04),
+                  %w(493 8 schizophrenic 1979-07-06\ 07:34:07 1970-08-09\ 01:21:01),]
+              ].each do |expected_values|
+                expect(insert_record_block).to receive(:call) { |mysql_table, values_set|
+                  expect(mysql_table.table_name).to eq('users_login')
+                  expect(values_set).to eq(expected_values)
+                  nil
+                }.once
+              end
+              expect(insert_record_block).to receive(:call).never
+
+              # insert_record_block
+              [
+                {state: MysqlDumpParser::State::CREATE_TABLE},
+                {state: MysqlDumpParser::State::INSERT_RECORD},
+                {state: MysqlDumpParser::State::CREATE_TABLE,
+                 last_pos: index_after(dump_content, 'UNLOCK TABLES;') + 10}
+              ].each do |expected_params|
+                expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                  expect(mysql_table.table_name).to eq('users_login') if mysql_table
+                  expect(state).to eq(expected_params[:state])
+                  if expected_params[:last_pos]
+                    expect(last_pos).to eq(expected_params[:last_pos])
+                  end
+                  expect(binlog_pos).to eq(default_binlog_pos)
+                  expect(substate).to eq(expected_params[:substate])
+                  expected_params[:result]
+                }.once
+              end
+              expect(check_point_block).to receive(:call).never
+
+              binlog_pos = default_parser.parse(
+                dump_io, create_table_block, insert_record_block, check_point_block
+              )
+              expect(binlog_pos).to eq(default_binlog_pos)
+            end
+          end
+
+          context 'when dump contains create table with records' do
+            let(:dump_content) { <<EOT
+#{DUMP_HEADER}
+
+DROP TABLE IF EXISTS `users_login`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `users_login` (
+  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
+  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
+  `comment` varchar(255) DEFAULT NULL COMMENT 'comment',
+  `create_time` datetime NOT NULL COMMENT 'create time',
+  `update_time` datetime NOT NULL COMMENT 'update time',
+  PRIMARY KEY (`user_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `users_login`
+--
+
+LOCK TABLES `users_login` WRITE;
+/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
+INSERT INTO `users_login` VALUES (15,46,'moodier','2001-10-02 08:18:08','1986-06-11 22:50:10'),(35,6,NULL,'1991-10-15 19:38:07','1970-10-01 22:03:10'),(52,33,'subfield','1972-08-23 20:16:08','1974-10-10 23:28:11');
+/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
+UNLOCK TABLES;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+
+EOT
+            }
+            before { generate_dump_file(dump_content) }
+            it do
+              # create_table_block
+              expect(create_table_block).to receive(:call) { |mysql_table|
+                expect(mysql_table.table_name).to eq('users_login')
+                expect(mysql_table.columns.keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
+              }.once
+              expect(create_table_block).to receive(:call).never
+
+              # insert_record_block
+              [
+                [ %w(15 46 moodier 2001-10-02\ 08:18:08 1986-06-11\ 22:50:10),
+                  ['35', '6', nil, '1991-10-15 19:38:07', '1970-10-01 22:03:10'],
+                  %w(52 33 subfield 1972-08-23\ 20:16:08 1974-10-10\ 23:28:11),],
+              ].each do |expected_values|
+                expect(insert_record_block).to receive(:call) { |mysql_table, values_set|
+                  expect(mysql_table.table_name).to eq('users_login')
+                  expect(values_set).to eq(expected_values)
+                  nil
+                }.once
+              end
+              expect(insert_record_block).to receive(:call).never
+
+              # insert_record_block
+              [
+                {state: MysqlDumpParser::State::CREATE_TABLE},
+                {state: MysqlDumpParser::State::INSERT_RECORD},
+                {state: MysqlDumpParser::State::CREATE_TABLE,
+                 last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
+              ].each do |expected_params|
+                expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                  expect(mysql_table.table_name).to eq('users_login') if mysql_table
+                  expect(state).to eq(expected_params[:state])
+                  if expected_params[:last_pos]
+                    expect(last_pos).to eq(expected_params[:last_pos])
+                  end
+                  expect(binlog_pos).to eq(default_binlog_pos)
+                  expect(substate).to eq(expected_params[:substate])
+                  expected_params[:result]
+                }.once
+              end
+              expect(check_point_block).to receive(:call).never
+
+              binlog_pos = default_parser.parse(
+                dump_io, create_table_block, insert_record_block, check_point_block
+              )
+              expect(binlog_pos).to eq(default_binlog_pos)
+            end
+          end
+
+          context 'with resume after creating table' do
+            let(:dump_content_head) { <<EOT
+#{DUMP_HEADER}
+
+DROP TABLE IF EXISTS `users_login`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `users_login` (
+  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
+  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
+  `comment` varchar(255) DEFAULT NULL COMMENT 'comment',
+  `create_time` datetime NOT NULL COMMENT 'create time',
+  `update_time` datetime NOT NULL COMMENT 'update time',
+  PRIMARY KEY (`user_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+EOT
+            }
+            let(:dump_content_all) { <<EOT
+                                     #{dump_content_head}
+--
+-- Dumping data for table `users_login`
+--
+
+LOCK TABLES `users_login` WRITE;
+/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
+INSERT INTO `users_login` VALUES (15,46,'moodier','2001-10-02 08:18:08','1986-06-11 22:50:10'),(35,6,'missteer','1991-10-15 19:38:07','1970-10-01 22:03:10'),(52,33,'subfield','1972-08-23 20:16:08','1974-10-10 23:28:11');
+/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
+UNLOCK TABLES;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+EOT
+            }
+            before do
+              generate_dump_file(dump_content_head)
+              default_parser.parse(
+                dump_io,
+                Proc.new{},
+                Proc.new{
+                  raise "Should not be called"
+                },
+                Proc.new{ |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                  if mysql_table
+                    @mysql_table = mysql_table
+                    @option = { status: Flydata::Command::Sync::STATUS_PARSING,
+                                table_name: mysql_table.table_name,
+                                last_pos: last_pos,
+                                binlog_pos: binlog_pos,
+                                state: state,
+                                substate: substate,
+                                mysql_table: mysql_table }
+                  end
+                }
+              )
+              expect(@option).to eq({
+                status: Flydata::Command::Sync::STATUS_PARSING,
+                table_name: 'users_login',
+                last_pos: index_after(dump_content_head, 'ENGINE=InnoDB DEFAULT CHARSET=utf8;'),
+                binlog_pos: default_binlog_pos,
+                state: MysqlDumpParser::State::INSERT_RECORD,
+                substate: nil,
+                mysql_table: @mysql_table
+              })
+            end
+            it do
+              generate_dump_file(dump_content_all)
+              parser_for_resume = MysqlDumpParser.new(@option)
+
+              # create_table_block
+              expect(create_table_block).to receive(:call).never
+
+              # insert_record_block
+              [
+                [ %w(15 46 moodier 2001-10-02\ 08:18:08 1986-06-11\ 22:50:10),
+                  %w(35 6 missteer  1991-10-15\ 19:38:07 1970-10-01\ 22:03:10),
+                  %w(52 33 subfield 1972-08-23\ 20:16:08 1974-10-10\ 23:28:11),],
+              ].each do |expected_values|
+                expect(insert_record_block).to receive(:call) { |mysql_table, values|
+                  expect(mysql_table.table_name).to eq('users_login')
+                  expect(values).to eq(expected_values)
+                  nil
+                }.once
+              end
+              expect(insert_record_block).to receive(:call).never
+
+              # check_point_block
+              [
+                {state: MysqlDumpParser::State::CREATE_TABLE,
+                 last_pos: index_after(dump_content_all, 'UNLOCK TABLES;')}
+              ].each do |expected_params|
+                expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                  expect(mysql_table.table_name).to eq('users_login') if mysql_table
+                  expect(state).to eq(expected_params[:state])
+                  if expected_params[:last_pos]
+                    expect(last_pos).to eq(expected_params[:last_pos])
+                  end
+                  expect(binlog_pos).to eq(default_binlog_pos)
+                  expect(substate).to eq(expected_params[:substate])
+                  expected_params[:result]
+                }.once
+              end
+              expect(check_point_block).to receive(:call).never
+
+              binlog_pos = parser_for_resume.parse(
+                dump_io, create_table_block, insert_record_block, check_point_block
+              )
+              expect(binlog_pos).to eq(default_binlog_pos)
+            end
+          end
+
+          context 'with resume during insert records' do
+            let(:dump_content) { <<EOT
+#{DUMP_HEADER}
+
+DROP TABLE IF EXISTS `users_login`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `users_login` (
+  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
+  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
+  `comment` varchar(255) DEFAULT NULL COMMENT 'comment',
+  `create_time` datetime NOT NULL COMMENT 'create time',
+  `update_time` datetime NOT NULL COMMENT 'update time',
+  PRIMARY KEY (`user_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `users_login`
+--
+
+LOCK TABLES `users_login` WRITE;
+/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
+INSERT INTO `users_login` VALUES (15,46,'moodier','2001-10-02 08:18:08','1986-06-11 22:50:10'),(35,6,'missteer','1991-10-15 19:38:07','1970-10-01 22:03:10'),(52,33,'subfield','1972-08-23 20:16:08','1974-10-10 23:28:11');
+INSERT INTO `users_login` VALUES (194,11,'pandemonium','2008-01-22 22:15:10','1991-04-04 17:30:05'),(230,7,'cloudburst','2010-12-28 11:46:11','1971-06-22 13:08:01');
+/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
+UNLOCK TABLES;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+EOT
+            }
+            before do
+              generate_dump_file(dump_content)
+
+              insert_record_block_for_resume = double('insert_record_block_for_resume')
+              expect(insert_record_block_for_resume).to receive(:call) { true }.once
+              expect(insert_record_block_for_resume).to receive(:call) { false }.once
+
+              default_parser.parse(
+                dump_io,
+                Proc.new{},
+                insert_record_block_for_resume,
+                Proc.new{ |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                  if last_pos == index_after(dump_content, "'1972-08-23 20:16:08','1974-10-10 23:28:11');")
+                    @mysql_table = mysql_table
+                    @option = { status: Flydata::Command::Sync::STATUS_PARSING,
+                                table_name: mysql_table.table_name,
+                                last_pos: last_pos,
+                                binlog_pos: binlog_pos,
+                                state: state,
+                                substate: substate,
+                                mysql_table: mysql_table }
+                  end
+                }
+              )
+              expect(@option).to eq({
+                status: Flydata::Command::Sync::STATUS_PARSING,
+                table_name: 'users_login',
+                last_pos: index_after(dump_content, "'1972-08-23 20:16:08','1974-10-10 23:28:11');"),
+                binlog_pos: default_binlog_pos,
+                state: MysqlDumpParser::State::INSERT_RECORD,
+                substate: nil,
+                mysql_table: @mysql_table
+              })
+            end
+            it do
+              generate_dump_file(dump_content)
+              parser_for_resume = MysqlDumpParser.new(@option)
+
+              # create_table_block
+              expect(create_table_block).to receive(:call).never
+
+              # insert_record_block
+              [
+                [ %w(194 11 pandemonium 2008-01-22\ 22:15:10 1991-04-04\ 17:30:05),
+                  %w(230 7 cloudburst 2010-12-28\ 11:46:11 1971-06-22\ 13:08:01),],
+              ].each do |expected_values|
+                expect(insert_record_block).to receive(:call) { |mysql_table, values_set|
+                  expect(mysql_table.table_name).to eq('users_login')
+                  expect(values_set).to eq(expected_values)
+                  nil
+                }.once
+              end
+              expect(insert_record_block).to receive(:call).never
+
+              # check_point_block
+              [
+                {state: MysqlDumpParser::State::CREATE_TABLE,
+                 last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
+              ].each do |expected_params|
+                expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                  expect(mysql_table.table_name).to eq('users_login') if mysql_table
+                  expect(state).to eq(expected_params[:state])
+                  if expected_params[:last_pos]
+                    expect(last_pos).to eq(expected_params[:last_pos])
+                  end
+                  expect(binlog_pos).to eq(default_binlog_pos)
+                  expect(substate).to eq(expected_params[:substate])
+                  expected_params[:result]
+                }.once
+              end
+              expect(check_point_block).to receive(:call).never
+
+              binlog_pos = parser_for_resume.parse(
+                dump_io, create_table_block, insert_record_block, check_point_block
+              )
+              expect(binlog_pos).to eq(default_binlog_pos)
+            end
+          end
+
+          context 'when dump contains contain escape characters' do
+            let(:dump_content) { <<EOT
+#{DUMP_HEADER}
+
+DROP TABLE IF EXISTS `users_login`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `users_login` (
+  `user_id` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'users id',
+  `login_count` int(10) unsigned DEFAULT '0' COMMENT 'login count',
+  `comment` varchar(255) DEFAULT NULL COMMENT 'comment',
+  `create_time` datetime NOT NULL COMMENT 'create time',
+  `update_time` datetime NOT NULL COMMENT 'update time',
+  PRIMARY KEY (`user_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `users_login`
+--
+
+LOCK TABLES `users_login` WRITE;
+/*!40000 ALTER TABLE `users_login` DISABLE KEYS */;
+INSERT INTO `users_login` VALUES (15,46,'moodier)','2001-10-02 08:18:08','1986-06-11 22:50:10'),(35,6,'miss,teer','1991-10-15 19:38:07','1970-10-01 22:03:10'),(52,33,'subfield\\'','1972-08-23 20:16:08','1974-10-10 23:28:11');
+INSERT INTO `users_login` VALUES (373,31,'outs\\nwearing','1979-10-07 08:10:08','2006-02-22 16:26:04'),(493,8,'schiz\tophrenic','1979-07-06 07:34:07\\'),','1970-08-09,01:21:01,\\')');
+/*!40000 ALTER TABLE `users_login` ENABLE KEYS */;
+UNLOCK TABLES;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+
+EOT
+            }
+            before { generate_dump_file(dump_content) }
+            it do
+              # create_table_block
+              expect(create_table_block).to receive(:call) { |mysql_table|
+                expect(mysql_table.table_name).to eq('users_login')
+                expect(mysql_table.columns.keys).to eq(['user_id', 'login_count', 'comment', 'create_time', 'update_time'])
+              }.once
+              expect(create_table_block).to receive(:call).never
+
+              # insert_record_block
+              [
+                [ %w(15 46 moodier\) 2001-10-02\ 08:18:08 1986-06-11\ 22:50:10),
+                  %w(35 6 miss,teer  1991-10-15\ 19:38:07 1970-10-01\ 22:03:10),
+                  %w(52 33 subfield' 1972-08-23\ 20:16:08 1974-10-10\ 23:28:11),],
+                [ ['373','31',"outs\nwearing",'1979-10-07 08:10:08','2006-02-22 16:26:04'],
+                  ['493','8',"schiz\tophrenic",'1979-07-06 07:34:07\'),','1970-08-09,01:21:01,\')'] ]
+              ].each do |expected_values|
+                expect(insert_record_block).to receive(:call) { |mysql_table, values_set|
+                  expect(mysql_table.table_name).to eq('users_login')
+                  expect(values_set).to eq(expected_values)
+                  nil
+                }.once
+              end
+              expect(insert_record_block).to receive(:call).never
+
+              # insert_record_block
+              [
+                {state: MysqlDumpParser::State::CREATE_TABLE},
+                {state: MysqlDumpParser::State::INSERT_RECORD},
+                {state: MysqlDumpParser::State::CREATE_TABLE,
+                 last_pos: index_after(dump_content, 'UNLOCK TABLES;')}
+              ].each do |expected_params|
+                expect(check_point_block).to receive(:call) { |mysql_table, last_pos, bytesize, binlog_pos, state, substate|
+                  expect(mysql_table.table_name).to eq('users_login') if mysql_table
+                  expect(state).to eq(expected_params[:state])
+                  if expected_params[:last_pos]
+                    expect(last_pos).to eq(expected_params[:last_pos])
+                  end
+                  expect(binlog_pos).to eq(default_binlog_pos)
+                  expect(substate).to eq(expected_params[:substate])
+                  expected_params[:result]
+                }.once
+              end
+              expect(check_point_block).to receive(:call).never
+
+              binlog_pos = default_parser.parse(
+                dump_io, create_table_block, insert_record_block, check_point_block
+              )
+              expect(binlog_pos).to eq(default_binlog_pos)
+            end
+          end
+        end
+      end
+      describe MysqlDumpParser::InsertParser do
+        describe '#parse' do
+          let(:target_line) { '' }
+          let(:parser) { MysqlDumpParser::InsertParser.new }
+          subject { parser.parse(target_line) }
+
+          context 'when single record' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'hogehoge','2014-04-15 13:49:14');" }
+            it 'should return one element array' do
+              expect(subject).to eq([['1','hogehoge','2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when 2 records' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'foo','2014-04-15 13:49:14'),(2,'var','2014-04-15 14:21:05');" }
+            it 'should return two element array' do
+              expect(subject).to eq([['1','foo','2014-04-15 13:49:14'],['2','var','2014-04-15 14:21:05']])
+            end
+          end
+
+          context 'when data includes carriage return' do
+            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'abcd\refgh','2014-04-15 13:49:14');| }
+            it 'should escape return carriage' do
+              expect(subject).to eq([['1',"abcd\refgh",'2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when data includes new line' do
+            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'abcd\nefgh','2014-04-15 13:49:14');| }
+            it 'should escape new line' do
+              expect(subject).to eq([['1',"abcd\nefgh",'2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when data includes escaped single quotation' do
+            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'abcd\',\'efgh','2014-04-15 13:49:14');| }
+            it 'should escape single quotation' do
+              expect(subject).to eq([['1',"abcd','efgh",'2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when data includes back slash' do
+            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'abcd\\efgh','2014-04-15 13:49:14');| }
+            it 'should escape back slash' do
+              expect(subject).to eq([['1',"abcd\\efgh",'2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when data includes back slash with double quote' do
+            # \"\'\' value on insert query shoulde be "''
+            let(:target_line) { %q|INSERT INTO `tast_table` VALUES (1,'\"\'\'','2014-04-15 13:49:14');| }
+            it 'should escape back slash' do
+              expect(subject).to eq([['1',%q|"''| ,'2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when data includes back slash with double quote another case' do
+            # \"\"\"\"\"''\"'' value on insert query shoulde be """""''"''
+            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'\"\"\"\"\"\'\'\"\'\'','2014-04-15 13:49:14');| }
+            it 'should escape back slash' do
+              expect(subject).to eq([['1',%q|"""""''"''|,'2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when data includes mixed escaped characters' do
+            let(:target_line) { %q|INSERT INTO `test_table` VALUES (1,'ab\rcd\\e\nf\',\'gh','2014-04-15 13:49:14');| }
+            it 'should escape all' do
+              expect(subject).to eq([['1',"ab\rcd\\e\nf','gh",'2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when data includes mixed escaped characters in a row' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'ab\\\\ncd\\\\\\nefgh','2014-04-15 13:49:14');" }
+            it 'should escape all' do
+              expect(subject).to eq([['1',"ab\\ncd\\\nefgh",'2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when data end with back slash' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'D:\\\\download\\\\','2014-04-15 13:49:14');" }
+            it 'should escape back slash' do
+              expect(subject).to eq([['1',"D:\\download\\",'2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when comma is the first character of a string' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,',9','2014-04-15 13:49:14');" }
+            it 'should parse the string correctly' do
+              expect(subject).to eq([['1',',9','2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when comma is the last character of a string' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'9,','2014-04-15 13:49:14');" }
+            it 'should parse the string correctly' do
+              expect(subject).to eq([['1','9,','2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when a string consists of a comma' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,',','2014-04-15 13:49:14');" }
+            it 'should parse the string correctly' do
+              expect(subject).to eq([['1',',','2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when two commas are given as a string' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,',,','2014-04-15 13:49:14');" }
+            it 'should parse the string correctly' do
+              expect(subject).to eq([['1',',,','2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when an empty string value is given' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'','2014-04-15 13:49:14');" }
+            it 'should parse the string correctly' do
+              expect(subject).to eq([['1','','2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when a value consists of a comma followed by closing bracket' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'),ksd','2014-04-15 13:49:14');" }
+            it 'should parse the string correctly' do
+              expect(subject).to eq([['1','),ksd','2014-04-15 13:49:14']])
+            end
+          end
+
+          context 'when there is a white space before the closing bracket' do
+            let(:target_line) { "INSERT INTO `test_table` VALUES (1,'aa','2014-04-15 13:49:14' );" }
+            it 'should fail to parse.  This is intentional for performance reason' do
+              expect{subject}.to raise_error
+            end
+          end
+
+          context 'when an integer that has leading zeros is given' do
+            let(:target_line) {"INSERT INTO `test_table` VALUES (1,00013);"}
+            it 'should remove the leading zeros' do
+              expect(subject).to eq([['1', '13']])
+            end
+          end
+
+          context 'when a decimal that has leading zeros is given' do
+            let(:target_line) {"INSERT INTO `test_table` VALUES (1,00013.40);"}
+            it 'should remove the leading zeros' do
+              expect(subject).to eq([['1', '13.40']])
+            end
+          end
+
+          context 'when a timestamp that has leading zeros is given' do
+            let(:target_line) {"INSERT INTO `test_table` VALUES (1,'0004-04-15 13:49:14');"}
+            it 'should not remove the leading zeros' do
+              expect(subject).to eq([['1', '0004-04-15 13:49:14']])
+            end
+          end
+
+          context 'when a string that has leading zeros is given' do
+            let(:target_line) {"INSERT INTO `test_table` VALUES (1,'00000aa');"}
+            it 'should not remove the leading zeros' do
+              expect(subject).to eq([['1', '00000aa']])
+            end
+          end
+
+          context 'when a string that has leading zeros, numbers and a comma in between is given' do
+            let(:target_line) {"INSERT INTO `test_table` VALUES (1,'0003,00033');"}
+            it 'should not remove the leading zeros' do
+              expect(subject).to eq([['1', '0003,00033']])
+            end
+          end
+
+          context 'when a string that has leading zeros, has only numbers is given' do
+            let(:target_line) {"INSERT INTO `test_table` VALUES (1,'00033');"}
+            it 'should not remove the leading zeros' do
+              expect(subject).to eq([['1', '00033']])
+            end
+          end
+
+          context 'when 0 is given' do
+            let(:target_line) {"INSERT INTO `test_table` VALUES (1,0);"}
+            it 'should not remove the leading zeros' do
+              expect(subject).to eq([['1', '0']])
+            end
+          end
+
+          context 'when 0.00 is given' do
+            let(:target_line) {"INSERT INTO `test_table` VALUES (1,0.00);"}
+            it 'should not remove the leading zeros' do
+              expect(subject).to eq([['1', '0.00']])
+            end
+          end
+        end
+      end
+    end
+  end
+end