flydata 0.6.14 → 0.7.0

data/spec/flydata/query_based_sync/response_handler_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'flydata/query_based_sync/query_based_sync_context'
+
+
+module Flydata
+module QueryBasedSync
+
+describe ResponseHandler do
+  include_context 'query based sync context'
+
+  let(:subject_object) { described_class.new(context) }
+
+
+  describe '#handle' do
+    subject { subject_object.handle(response) }
+
+    let(:records_for_emitting) {[
+      {row: {'1'=>1, '2'=>'a'}},
+      {row: {'1'=>2, '2'=>'b'}},
+      {row: {'1'=>3, '2'=>'c'}},
+    ]}
+
+    it do
+      expect(subject_object).to receive(:emit_sync_records).with(records_for_emitting,
+                                type: :update,
+                                src_pos: response.new_source_pos.to_s,
+                                table: 'table_1')
+      expect(table_1_src_pos_file).to receive(:save).with(response.new_source_pos)
+      subject
+    end
+  end
+
+end
+
+end
+end

data/spec/flydata/query_based_sync/response_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'flydata/query_based_sync/query_based_sync_context'
+
+
+module Flydata
+module QueryBasedSync
+
+describe Response do
+  include_context 'query based sync context'
+
+  let(:subject_object) { DummyResponse.new(context, 'table_1', records, query_cond) }
+
+  describe '#initialize' do
+    before do
+      subject_object
+    end
+
+    it { expect(subject_object.instance_variable_get(:@table_meta)).to eq(table_meta_1) }
+  end
+
+  describe '#set_new_source_pos' do
+    subject { subject_object.set_new_source_pos(required_pk_values) }
+
+    context 'when require_pk_values is false' do
+      let(:required_pk_values) { false }
+
+      it 'sets current snapshot to the new source pos' do
+        expect(context.source_pos_class).to receive(:new).with(current_snapshot)
+        subject
+      end
+    end
+
+    context 'when require_pk_values is true' do
+      let(:required_pk_values) { true }
+
+      it 'sets old snapshot and current snapshot with primary key values' do
+        expect(context.source_pos_class).to receive(:new).
+          with(previous_snapshot, current_snapshot, [{'id'=>3}])
+        subject
+      end
+    end
+  end
+
+  describe '#record_count' do
+    subject { subject_object.record_count }
+
+    context 'when records is nil' do
+      before do
+        subject_object.instance_variable_set(:@records, nil)
+      end
+      it { is_expected.to eq(0) }
+    end
+
+    context 'when records is not nil' do
+      it { is_expected.to eq(3) }
+    end
+  end
+
+  describe '#empty?' do
+    subject { subject_object.empty? }
+
+    context 'when records is nil' do
+      before do
+        subject_object.instance_variable_set(:@records, nil)
+      end
+      it { is_expected.to be(true) }
+    end
+
+    context 'when records is not nil but empty array' do
+      before do
+        subject_object.instance_variable_set(:@records, [])
+      end
+      it { is_expected.to be(true) }
+    end
+
+    context 'when records is not nil and not empty' do
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe '.create_responses' do
+    let(:raw_result) {[
+      {'id'=>1, 'value'=>'a'},
+      {'id'=>2, 'value'=>'b'},
+      {'id'=>3, 'value'=>'c'},
+    ]}
+    subject { DummyResponse.create_responses(context, 'table_1', raw_result, query_cond) }
+
+    context 'when raw_result is empty' do
+      let(:raw_result) { [] }
+
+      it 'returns a response having empty records' do
+        expect(subject.first.records).to eq([])
+        expect(subject.size).to eq(1)
+      end
+    end
+
+    context 'when raw_result have records' do
+      context 'when not execeeding the emit_chunk_limit' do
+        it 'returns a response having records' do
+          expect(subject.first.records).to eq([
+            {'1'=>1, '2'=>'a'},
+            {'1'=>2, '2'=>'b'},
+            {'1'=>3, '2'=>'c'},
+          ])
+          expect(subject.size).to eq(1)
+          expect(subject.first.new_source_pos.args).to eq([
+            current_snapshot
+          ])
+        end
+      end
+
+      context 'when execeeding the emit_chunk_limit' do
+        before do
+          context.params[:emit_chunk_limit] = 380
+        end
+        it 'returns responses with splitted records' do
+          expect(subject.size).to eq(2)
+          expect(subject[0].records).to eq([
+            {'1'=>1, '2'=>'a'},
+            {'1'=>2, '2'=>'b'},
+          ])
+          expect(subject[0].new_source_pos.args).to eq([
+            previous_snapshot, current_snapshot, [{'id'=>2}]
+          ])
+          expect(subject[1].records).to eq([
+            {'1'=>3, '2'=>'c'},
+          ])
+          expect(subject[1].new_source_pos.args).to eq([
+            current_snapshot
+          ])
+        end
+      end
+
+      context 'when the number of records is same as the max_num_rows_per_query' do
+        before do
+          table_meta_1[:max_num_rows_per_query] = 3
+        end
+
+        it 'returns a response with a new source pos having pk_values' do
+          expect(subject.first.records).to eq([
+            {'1'=>1, '2'=>'a'},
+            {'1'=>2, '2'=>'b'},
+            {'1'=>3, '2'=>'c'},
+          ])
+          expect(subject.size).to eq(1)
+          expect(subject.first.new_source_pos.args).to eq([
+            previous_snapshot, current_snapshot, [{'id'=>3}],
+          ])
+        end
+      end
+    end
+  end
+end
+
+end
+end

data/spec/flydata/source_mysql/plugin_support/context_spec.rb

@@ -7,11 +7,17 @@ describe ::Flydata::SourceMysql::PluginSupport::Context do
   describe '#initialize' do
     subject { subject_object }
 
+    let(:sync_fm) { double('sync_fm') }
+
+    before do
+      allow(sync_fm).to receive(:get_table_source_raw_pos).and_return('-')
+    end
+
     context 'when no missing params' do
       let(:params) { {
         tables: %w(table_a table_b table_c),
         tag: 'test_tag',
-        sync_fm: 'test_sync_fm',
+        sync_fm: sync_fm,
         omit_events: {'table_c' => %i(delete truncate_table)},
         table_revs: {'table_a' => 1, 'table_b' => 2, 'table_c' => 3},
         database: 'test_db',

data/spec/flydata/source_mysql/plugin_support/dml_record_handler_spec.rb

@@ -2,27 +2,14 @@
 
 require 'fluent_plugins_spec_helper'
 require 'flydata/source_mysql/plugin_support/dml_record_handler'
+require 'flydata/source_mysql/plugin_support/shared_query_handler_context'
 
 module Flydata::SourceMysql::PluginSupport
 
 describe DmlRecordHandler do
+  include_context "query handler context"
   let(:subject_object) { described_class.new(context) }
 
-  let(:table_meta) { double('table_meta') }
-  let(:tables) { ['items', 'orders'] }
-  let(:sync_fm) {
-    sfm = double('sync_fm')
-    allow(sfm).to receive(:get_table_source_raw_pos).and_return nil
-    sfm
-  }
-  let(:context) {
-    c = double('context')
-    allow(c).to receive(:table_meta).and_return(table_meta)
-    allow(c).to receive(:tables).and_return(tables)
-    allow(c).to receive(:sync_fm).and_return(sync_fm)
-    c
-  }
-
   describe '#encode_row_value' do
     subject { subject_object.send(:encode_row_value, value) }
 

data/spec/flydata/source_mysql/plugin_support/drop_database_query_handler_spec.rb

@@ -19,7 +19,7 @@ module Flydata::SourceMysql::PluginSupport
       shared_examples "test different dbs" do
         context "for the target db" do
           let(:database) { target_database }
-          let(:binlog_pos) { "#{context.current_binlog_file}\t#{record['next_position'] - record['event_length']}" }
+          let(:binlog_pos) { "#{context.cur_src_pos_file}\t#{record['next_position'] - record['event_length']}" }
 
           it "shows a error message" do
             expect($log).to receive(:error).with("DROP DATABASE detected. A full re-sync is required to provide sync consistency. - db_name:'#{record["db_name"]}' query:'#{record["query"]}' normalized query:'#{record["normalized_query"]}' binlog_pos:'#{binlog_pos}'")

data/spec/flydata/source_mysql/plugin_support/shared_query_handler_context.rb

@@ -16,21 +16,22 @@ module Flydata::SourceMysql::PluginSupport
       r
     end
     let(:table_meta) { double'table_meta' }
-    let(:current_binlog_file) { "mysql-bin.000066" }
+    let(:cur_src_pos_file) { "mysql-bin.000066" }
     let(:tag) { "some_tag" }
     let(:table_rev) { 1 }
     let(:flydata_record_version) { 2 }
     let(:context) do
-      r = double('context')
-      allow(r).to receive(:sync_fm).and_return(sync_fm)
-      allow(r).to receive(:database).and_return(target_database)
-      allow(r).to receive(:tables).and_return([table])
-      allow(r).to receive(:table_meta).and_return(table_meta)
-      allow(r).to receive(:current_binlog_file).and_return(current_binlog_file)
-      allow(r).to receive(:omit_events).and_return({})
-      allow(r).to receive(:table_revs).and_return({ table => table_rev})
-      allow(r).to receive(:tag).and_return(tag)
-      r
+      require 'flydata/source_mysql/plugin_support/context'
+      Flydata::SourceMysql::PluginSupport::Context.new(
+        sync_fm: sync_fm,
+        database: target_database,
+        tables: [table],
+        table_meta: table_meta,
+        cur_src_pos_file: cur_src_pos_file,
+        omit_events: {},
+        table_revs: {table => table_rev},
+        tag: tag,
+      )
     end
     let(:query) { "a_query" }
     let(:normalized_query) { 'a_query' }

data/spec/flydata/source_mysql/plugin_support/source_position_file_spec.rb

@@ -0,0 +1,53 @@
+require 'fluent_plugins_spec_helper'
+require 'flydata/source_mysql/plugin_support/source_position_file'
+require 'tempfile'
+
+module Flydata::SourceMysql::PluginSupport
+  describe SourcePositionFile do
+    let(:binlog_file) { "mysqlbin-00001" }
+    let(:binlog_pos) { "4" }
+    let(:source_pos_content) { "#{binlog_file}\t#{binlog_pos}" }
+
+    let(:pos_file) { Tempfile.new('source_pos') }
+    let(:file_path) { pos_file.path }
+    let(:subject_object) { described_class.new(file_path) }
+
+    before { File.write(file_path, source_pos_content) }
+    after { FileUtils.rm(file_path) if File.exists?(file_path) }
+
+    describe '#exists?' do
+      subject { subject_object.exists? }
+      context 'when the file exists' do
+        it { is_expected.to eq(true) }
+      end
+      context 'when the file does not exist' do
+        before { FileUtils.rm(file_path) }
+        it { is_expected.to eq(false) }
+      end
+    end
+
+    describe '#read' do
+      subject { subject_object.read }
+      it { is_expected.to eq(source_pos_content) }
+    end
+
+    describe '#pos' do
+      subject { subject_object.pos }
+      it { is_expected.to be_kind_of(FlydataCore::Mysql::BinlogPos) }
+      it { expect(subject.to_s).to eq(source_pos_content) }
+      context 'when the file is missing' do
+        before { FileUtils.rm(file_path) }
+        it { is_expected.to be_nil }
+      end
+    end
+
+    describe '#save' do
+      subject { subject_object.save("mysql-bin.000002", 120)}
+      it { is_expected.to be_kind_of(FlydataCore::Mysql::BinlogPos) }
+      it do
+        subject
+        expect(subject_object.read).to eq("mysql-bin.000002\t120")
+      end
+    end
+  end
+end

data/spec/flydata/source_mysql/plugin_support/truncate_query_handler_spec.rb

@@ -22,7 +22,7 @@ module Flydata::SourceMysql::PluginSupport
             query: truncate_query,
             type: :truncate_table,
             respect_order: true,
-            src_pos: "#{current_binlog_file}\t#{next_position - event_length}",
+            src_pos: "#{cur_src_pos_file}\t#{next_position - event_length}",
             table_rev: table_rev,
             seq: seq,
             v: flydata_record_version

data/spec/flydata/source_mysql/table_ddl_spec.rb

@@ -56,10 +56,10 @@ describe TableDdl do
     allow($log).to receive(:error)
     allow($log).to receive(:trace)
 
-    allow(mysql_tabledef1).to receive(:default_charset_mysql).and_return(table1_charset)
+    allow(mysql_tabledef1).to receive(:default_source_charset).and_return(table1_charset)
     allow(mysql_tabledef1).to receive(:table_name).and_return(table_name1)
     allow(mysql_tabledef1).to receive(:column_def).and_return(column_def1)
-    allow(mysql_tabledef2).to receive(:default_charset_mysql).and_return(table2_charset)
+    allow(mysql_tabledef2).to receive(:default_source_charset).and_return(table2_charset)
     allow(mysql_tabledef2).to receive(:table_name).and_return(table_name2)
     allow(mysql_tabledef2).to receive(:column_def).and_return(column_def2)
   end
@@ -82,9 +82,9 @@ describe TableDdl do
         matcher = table_names.inject(matcher) {|m, tn| m.and_yield(mysql_tabledef[tn], nil) }
         expect(FlydataCore::Mysql::CommandGenerator).to matcher
         expect(File).to receive(:open).with(position_file).and_return(master_binlog_position)
-        expect(context).to receive(:current_binlog_file).and_return(original_current_binlog_file)
-        expect(context).to receive(:current_binlog_file=).with(binlog_file)
-        expect(context).to receive(:current_binlog_file=).with(original_current_binlog_file)
+        expect(context).to receive(:cur_src_pos_file).and_return(original_current_binlog_file)
+        expect(context).to receive(:cur_src_pos_file=).with(binlog_file)
+        expect(context).to receive(:cur_src_pos_file=).with(original_current_binlog_file)
         expect(sync_fm).to receive(:save_generated_ddl).with(table_names, target_version)
 
         expect{|b| subject_object.send(*subject_params, &b) }.to yield_successive_args(*expected_alter_table_charset_events)

data/spec/flydata/source_mysql/{plugin_support/table_meta_spec.rb → table_meta_spec.rb}

@@ -1,8 +1,7 @@
 require 'fluent_plugins_spec_helper'
-require 'flydata/source_mysql/plugin_support/table_meta'
+require 'flydata/source_mysql/table_meta'
 
 module Flydata::SourceMysql
-module PluginSupport
   describe TableMeta do
     let(:db_opts) { { host: 'test-host', port: 3306, username: 'test-user', password: 'test-pswd', database: 'test-db' } }
     let(:database) { 'test-db' }
@@ -19,7 +18,8 @@ module PluginSupport
       allow(Mysql2::Client).to receive(:new).and_return(conn)
     end
 
-    describe '.update' do
+    describe '.reload' do
+      subject { table_meta.reload }
       let(:query_result) {[]}
       before do
         allow(conn).to receive(:query).and_return(query_result)
@@ -31,7 +31,7 @@ module PluginSupport
             {'table_name' => 'a_table', 'character_set_name' => utf8 }
           ]}
           it 'set nil for encoding' do
-            table_meta.update
+            subject
             expect(table_meta['a_table'][:encoding]).to eq Encoding::UTF_8
             expect(table_meta['a_table'][:mysql_charset]).to eq utf8
           end
@@ -43,7 +43,7 @@ module PluginSupport
             {'table_name' => 'b_table', 'character_set_name' => cp932 }
           ]}
           it 'set ruby encoding encoding' do
-            table_meta.update
+            subject
             expect(table_meta['a_table'][:encoding]).to eq Encoding::ISO_8859_1
             expect(table_meta['a_table'][:mysql_charset]).to eq latin1
             expect(table_meta['b_table'][:encoding]).to eq Encoding::CP932
@@ -57,10 +57,9 @@ module PluginSupport
           {'table_name' => 'a_table', 'character_set_name' => 'xxxx' }
         ]}
         it 'raise an error' do
-          expect{table_meta.update}.to raise_error('Unsupported charset:xxxx.')
+          expect{subject}.to raise_error('Unsupported charset:xxxx.')
         end
       end
     end
   end
 end
-end

data/spec/flydata/source_postgresql/generate_source_dump_spec.rb

@@ -17,6 +17,22 @@ describe GenerateSourceDump do
   }
   let(:dp) { double('dp') }
   let(:options) { double('options') }
+  let(:cli) { double('cli') }
+  let(:table_meta) { double('table_meta') }
+  let(:io) { double('io') }
+  let(:source_pos) { double('source_pos') }
+  let(:snapshot) { double('snapshot') }
+  let(:tabledef) { double('tabledef') }
+
+  let(:de_prefs_with_table_meta) { de_prefs.merge(table_meta: table_meta) }
+
+  shared_examples 'source_pos_diff_query params' do
+    let(:table) { double('table') }
+    let(:schema) { double('schema') }
+    let(:num_rows) { double('num_rows') }
+    let(:pk_columns) { [ 'id' ] }
+    let(:last_pks) { nil }
+  end
 
   describe '#dump' do
     subject { subject_object.dump(tables, file_path, &src_pos_callback) }
@@ -26,87 +42,93 @@ describe GenerateSourceDump do
 
     context 'when file_path is given' do
       let(:file_path) { double('file_path') }
-      before do
-        allow(File).to receive(:open).with(file_path, "w").
-          and_return(io)
-        allow(PGClient).to receive(:new).with(de_prefs).and_return(cli)
-        allow(subject_object).to receive(:get_source_pos).
-          with(cli, &src_pos_callback).and_return(source_pos)
-        allow(source).to receive(:sync_generate_table_ddl).with(dp, nil).
-          and_return context
-        allow(subject_object).to receive(:dump_table).
-          with(tabledef1, source_pos, io, cli)
-        allow(subject_object).to receive(:dump_table).
-          with(tabledef2, source_pos, io, cli)
-      end
-      let(:io) { double('io') }
-      before do
-        allow(io).to receive(:close)
-      end
-
-      let(:cli) { double('cli') }
-      let(:source_pos) { double('source_pos') }
       let(:context) { double('context') }
-      let(:tabledef1) { double('tabledef1') }
       let(:tabledef2) { double('tabledef2') }
       let(:missing_tables) { [] }
       let(:error) { double('error') }
 
-      it 'does expected things' do
-        expect(File).to receive(:open).with(file_path, "w").
-          and_return(io)
-        expect(PGClient).to receive(:new).with(de_prefs).and_return(cli)
-        expect(subject_object).to receive(:get_source_pos).
-          with(cli, &src_pos_callback).and_return(source_pos)
-        expect(source).to receive(:sync_generate_table_ddl).with(dp, nil).
-          and_return context
-        expect(context).to receive(:each_source_tabledef).
-          with(tables, de_prefs).
-          and_yield(tabledef1, nil).and_yield(tabledef2, nil).
-          and_return missing_tables
-        expect(subject_object).to receive(:dump_table).
-          with(tabledef1, source_pos, io, cli)
-        expect(subject_object).to receive(:dump_table).
-          with(tabledef2, source_pos, io, cli)
-
-        subject
-      end
-
-      context 'when a table is missing' do
-        let(:missing_tables) { [ "test2" ] }
-        before do
-          allow(context).to receive(:each_source_tabledef).
-            with(tables, de_prefs).
-            and_yield(tabledef1, nil).
+      context 'an ordinary case' do
+        it 'does expected things' do
+          expect(File).to receive(:open).with(file_path, "w").
+            and_return(io)
+          expect(FlydataCore::Postgresql::PGClient).to receive(:new).with(de_prefs).and_return(cli)
+          allow(cli).to receive(:close)
+          expect(Flydata::SourcePostgresql::TableMeta).to receive(:new).with(de_prefs, tables).and_return(table_meta)
+          expect(table_meta).to receive(:reload).with(cli).once
+          expect(table_meta).to receive(:current_snapshot).and_return(snapshot)
+          expect(subject_object).to receive(:get_source_pos).
+            with(snapshot, &src_pos_callback).and_return(source_pos)
+          expect(source).to receive(:sync_generate_table_ddl).with(dp, nil).
+            and_return context
+          expect(context).to receive(:each_source_tabledef).
+            with(tables, de_prefs_with_table_meta).
+            and_yield(tabledef, nil).and_yield(tabledef2, nil).
             and_return missing_tables
-        end
-        it "does nothing for the missing table.  we might need to add an error
-            handling" do
           expect(subject_object).to receive(:dump_table).
-            with(tabledef1, source_pos, io, cli)
-          expect(subject_object).not_to receive(:dump_table).
+            with(tabledef, source_pos, io, cli)
+          expect(subject_object).to receive(:dump_table).
             with(tabledef2, source_pos, io, cli)
+          expect(io).to receive(:close)
 
           subject
         end
       end
 
-      context 'when a table has an error' do
+      context 'various conditions' do
         before do
-          allow(context).to receive(:each_source_tabledef).
-            with(tables, de_prefs).
-            and_yield(nil, error).
-            and_yield(tabledef2, nil).
-            and_return missing_tables
-        end
-        it "does nothing for the error table.  we might need to add an error
-            handling" do
-          expect(subject_object).not_to receive(:dump_table).
-            with(tabledef1, source_pos, io, cli)
-          expect(subject_object).to receive(:dump_table).
+          allow(File).to receive(:open).with(file_path, "w").
+            and_return(io)
+          allow(FlydataCore::Postgresql::PGClient).to receive(:new).with(de_prefs).and_return(cli)
+          allow(cli).to receive(:close)
+          expect(Flydata::SourcePostgresql::TableMeta).to receive(:new).with(de_prefs, tables).and_return(table_meta)
+          expect(table_meta).to receive(:reload).with(cli).once
+          expect(table_meta).to receive(:current_snapshot).and_return(snapshot)
+          expect(subject_object).to receive(:get_source_pos).
+            with(snapshot, &src_pos_callback).and_return(source_pos)
+          allow(source).to receive(:sync_generate_table_ddl).with(dp, nil).
+            and_return context
+          allow(subject_object).to receive(:dump_table).
+            with(tabledef, source_pos, io, cli)
+          allow(subject_object).to receive(:dump_table).
             with(tabledef2, source_pos, io, cli)
+          allow(io).to receive(:close)
+        end
+        context 'when a table is missing' do
+          let(:missing_tables) { [ "test2" ] }
+          before do
+            allow(context).to receive(:each_source_tabledef).
+              with(tables, de_prefs_with_table_meta).
+              and_yield(tabledef, nil).
+              and_return missing_tables
+          end
+          it "does nothing for the missing table.  we might need to add an error
+              handling" do
+            expect(subject_object).to receive(:dump_table).
+              with(tabledef, source_pos, io, cli)
+            expect(subject_object).not_to receive(:dump_table).
+              with(tabledef2, source_pos, io, cli)
+
+            subject
+          end
+        end
 
-          subject
+        context 'when a table has an error' do
+          before do
+            allow(context).to receive(:each_source_tabledef).
+              with(tables, de_prefs_with_table_meta).
+              and_yield(nil, error).
+              and_yield(tabledef2, nil).
+              and_return missing_tables
+          end
+          it "does nothing for the error table.  we might need to add an error
+              handling" do
+            expect(subject_object).not_to receive(:dump_table).
+              with(tabledef, source_pos, io, cli)
+            expect(subject_object).to receive(:dump_table).
+              with(tabledef2, source_pos, io, cli)
+
+            subject
+          end
         end
       end
     end
@@ -118,24 +140,90 @@ describe GenerateSourceDump do
     end
   end
 
-  describe '#pk_conditions' do
-    subject { subject_object.send(:pk_conditions, pk_columns) }
+  describe '#dump_table_chunk' do
+    let(:subject) { subject_object.send(:dump_table_chunk, table, schema, source_pos,
+                                        num_rows, tabledef, pk_columns,
+                                        last_pks, io, cli) }
 
-    context 'with a single primary key' do
-      let(:pk_columns) { [ 'id' ] }
+    include_examples 'source_pos_diff_query params'
 
-      it { is_expected.to eq %Q| AND ("id" > $1)| }
-    end
+    let(:query) { double('query') }
+    let(:query_generator) { double('query_generator') }
 
-    context 'with two primary keys' do
-      let(:pk_columns) { [ 'pk1', 'pk2' ] }
+    before do
+      allow(tabledef).to receive(:columns).and_return(coldefs)
+      allow(source_pos).to receive(:snapshot).and_return(snapshot)
+      allow(query_generator).to receive(:build_query).and_return(query)
+    end
+    let(:coldefs) { [
+      { column: 'id', type: 'int4' },
+      { column: 'url', type: 'varchar' }
+    ] }
+    let(:res) { [
+      { "id" => 10, "url" => "http://foobar.com/", },
+      { "id" => last_pk, "url" => "http://nowhere.org/", },
+    ] }
+    let(:last_pk) { 11 }
+
+    let(:expected_columns) { [ 'id', 'url' ] }
+    let(:expected_types) { [ 'int4', 'varchar' ] }
+    let(:expected_query_params) { [] }
+
+    context 'in an ordinary case' do
+      it 'does what it has to do' do
+        expect(Flydata::SourcePostgresql::QueryBasedSync::DiffQueryGenerator).to receive(:new).with(
+          table, schema,
+          columns: coldefs,
+          to_sid: source_pos.snapshot,
+          pk_columns: pk_columns,
+          last_pks: last_pks,
+          limit:  num_rows,
+        ).and_return(query_generator)
+        expect(cli).to receive(:query).
+         with(query).
+         and_return(res)
+        res.each do |row|
+          expect(subject_object).to receive(:dump_row).
+           with(row, expected_columns, io)
+        end
 
-      it { is_expected.to eq %Q| AND ("pk1" > $1 OR ("pk1" = $1 AND ("pk2" > $2)))| }
+        expect(subject).to eq([res.size, [ last_pk ] ])
+      end
     end
-    context 'with three primary keys' do
-      let(:pk_columns) { [ 'pk1', 'pk2', 'pk3' ] }
 
-      it { is_expected.to eq %Q| AND ("pk1" > $1 OR ("pk1" = $1 AND ("pk2" > $2 OR ("pk2" = $2 AND ("pk3" > $3)))))| }
+    context 'various cases' do
+      before do
+        allow(Flydata::SourcePostgresql::QueryBasedSync::DiffQueryGenerator).to receive(:new).with(
+          table, schema,
+          columns: coldefs,
+          to_sid: source_pos.snapshot,
+          pk_columns: pk_columns,
+          last_pks: last_pks,
+          limit:  num_rows,
+        ).and_return(query_generator)
+        allow(cli).to receive(:query).
+         with(query).
+         and_return(res)
+        res.each do |row|
+          allow(subject_object).to receive(:dump_row).
+           with(row, expected_columns, io)
+        end
+      end
+
+      context 'when last_pks is given' do
+        let(:last_pks) { double('last_pks') }
+        let(:expected_query_params) { last_pks }
+        it 'calls `cli.query` with `last_pks`' do
+          is_expected.to eq([res.size, [ last_pk ]])
+        end
+      end
+      context 'when query returned no result' do
+        let(:res) { [] }
+        it 'does not call #dump_row and returns nil results' do
+          expect(subject_object).not_to receive(:dump_row)
+          is_expected.to eq([0, nil])
+        end
+      end
     end
   end
 end