flydata 0.6.14 → 0.7.0

data/flydata-core/spec/postgresql/config_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'flydata-core/postgresql/config'
+
+module FlydataCore
+  module Postgresql
+    describe Config do
+      let(:base_conf) do
+        {
+          'host' => 'localhost',
+          'port' => 1234,
+          'username' => 'testuser',
+          'password' => 'password',
+          'database' => 'testdb',
+        }
+      end
+
+      let(:conf) { base_conf }
+
+      describe '.build_db_opts' do
+        subject { described_class.build_db_opts(conf) }
+
+        context 'with basic conf' do
+          it { is_expected.to eq(
+            host: 'localhost',
+            port: 1234,
+            username: 'testuser',
+            password: 'password',
+            database: 'testdb',
+            user: 'testuser',
+            dbname: 'testdb',
+          ) }
+        end
+
+        context 'with conf having dbname' do
+          let(:conf) { base_conf.merge('dbname' => 'testdb2') }
+          it { is_expected.to eq(
+            host: 'localhost',
+            port: 1234,
+            username: 'testuser',
+            password: 'password',
+            database: 'testdb',
+            user: 'testuser',
+            dbname: 'testdb2',
+          ) }
+        end
+      end
+
+      describe '.opts_for_pg' do
+        subject { described_class.opts_for_pg(conf) }
+
+        context 'with basic conf' do
+          it { is_expected.to eq(
+            host: 'localhost',
+            port: 1234,
+            password: 'password',
+            user: 'testuser',
+            dbname: 'testdb',
+          ) }
+        end
+
+        context 'with conf having dbname' do
+          let(:conf) { base_conf.merge('dbname' => 'testdb2') }
+          it { is_expected.to eq(
+            host: 'localhost',
+            port: 1234,
+            password: 'password',
+            user: 'testuser',
+            dbname: 'testdb2',
+          ) }
+        end
+
+        context 'with conf having schema' do
+          let(:conf) { base_conf.merge('schema' => 'dev_schema') }
+          it { is_expected.to eq(
+            host: 'localhost',
+            port: 1234,
+            password: 'password',
+            user: 'testuser',
+            dbname: 'testdb',
+          ) }
+        end
+      end
+    end
+  end
+end

data/flydata-core/spec/postgresql/pg_client_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+require 'flydata-core/postgresql/pg_client'
+
+module FlydataCore
+  module Postgresql
+    describe PGClient do
+      let(:dbconf) do
+        { host: 'localhost', port: 5555, username: 'testuser',
+          password: 'testpassword', dbname: 'testdb' }
+      end
+      let(:subject_object) { described_class.new(dbconf) }
+
+
+
+      let(:pg_conn) { double('pg_conn') }
+      let(:socket) { double('socket') }
+
+      before do
+        allow(PG::Connection).to receive(:connect_start).and_return(pg_conn)
+        allow(pg_conn).to receive(:connect_poll).and_return(PG::PGRES_POLLING_OK)
+        allow(pg_conn).to receive(:status).and_return(PG::CONNECTION_OK)
+        allow(pg_conn).to receive(:socket_io).and_return(socket)
+        allow(IO).to receive(:select).with(nil, [socket], nil, PGClient::PG_CONNECT_TIMEOUT).and_return(true)
+      end
+
+      describe '#establish_connection' do
+        subject { subject_object.establish_connection }
+
+        context 'without errors' do
+          it { is_expected.to eq(pg_conn) }
+          it 'sets @conn' do
+            subject
+            expect(subject_object.instance_variable_get(:@conn)).to eq(pg_conn)
+          end
+          it 'reuses @conn until closes' do
+            subject_object.establish_connection
+            subject
+            expect(subject_object.instance_variable_get(:@conn)).to eq(pg_conn)
+          end
+        end
+
+        context 'when getting an async writing timeout error' do
+          before do
+            expect(IO).to receive(:select).with(nil, [socket], nil, PGClient::PG_CONNECT_TIMEOUT).and_return(nil)
+          end
+          it { expect{subject}.to raise_error(PG::Error, /Asynchronous.+\(WRITING\)/) }
+        end
+
+        context 'when getting an async reading timeout error' do
+          before do
+            expect(pg_conn).to receive(:connect_poll).and_return(PG::PGRES_POLLING_READING)
+            expect(IO).to receive(:select).with(nil, [socket], nil, PGClient::PG_CONNECT_TIMEOUT).and_return(true)
+            expect(IO).to receive(:select).with([socket], nil, nil, PGClient::PG_CONNECT_TIMEOUT).and_return(false)
+          end
+          it { expect{subject}.to raise_error(PG::Error, /Asynchronous.+\(READING\)/) }
+        end
+
+        context 'when getting socket error' do
+          before do
+            expect(IPSocket).to receive(:getaddress).with('localhost').and_raise(SocketError, 'getaddrinfo: nodename nor servname provided, or not known')
+          end
+          it { expect{subject}.to raise_error(PG::Error, /Connection failed: FATAL:  unknown host\(localhost\)\./) }
+        end
+      end
+
+      describe '#query' do
+        subject { subject_object.query(query) }
+
+        context 'when query is a string' do
+          let(:query) { 'test query;' }
+          let(:result) { double('result') }
+
+          it do
+            expect(pg_conn).to receive(:query).with(query, []).
+              and_return(result)
+            expect(subject).to eq(result)
+          end
+        end
+        context 'when query has overriders' do
+          let(:query) { PGQuery.new(query_text, value_overriders:{"value" => -> (v) { "#{v}!" } }) }
+          let(:query_text) { "test_query" }
+          let(:result) { [{"id" => 1, "value" => "hi"},
+                          {"id" => 2, "value" => "ho"}] }
+          let(:expected_values) { ["hi!", "ho!"] }
+          it do
+            expect(pg_conn).to receive(:query).with(query_text, []).
+              and_return(result)
+            subject.each_with_index do |row, i|
+              expect(row["value"]).to eq expected_values[i]
+            end
+          end
+        end
+
+        context 'when query has binding_params' do
+          let(:binding_params) { ['1000', '2000'] }
+          let(:query) { PGQuery.new(query_text, binding_params: binding_params) }
+          let(:query_text) { "test_query" }
+          let(:result) { double('result') }
+          it do
+            expect(pg_conn).to receive(:query).with(query_text, binding_params).
+              and_return(result)
+            expect(subject).to eq(result)
+          end
+        end
+      end
+
+      describe '#close' do
+        subject { subject_object.close }
+
+        context 'when conn exists' do
+          before { subject_object.establish_connection }
+          it do
+            expect(pg_conn).to receive(:finish).once
+            subject
+            expect(subject_object.instance_variable_get(:@conn)).to be_nil
+          end
+        end
+
+        context 'when conn does not exist' do
+          it do
+            expect(pg_conn).to receive(:finish).never
+            expect{subject}.not_to raise_error
+            expect(subject_object.instance_variable_get(:@conn)).to be_nil
+          end
+        end
+      end
+    end
+
+    describe PGClient::HashValueOverrider do
+      let(:subject_object) { described_class.new(delegate, overriders) }
+
+      let(:delegate) { { "salute" => saluteval, "id" => idval } }
+      let(:idval) { 1 }
+      let(:saluteval) { "hello" }
+      let(:overriders) { {"salute" => ->(v) { "#{v}!" } } }
+
+      describe '#[]' do
+        subject { subject_object[key] }
+
+        context 'when no overrider for the key' do
+          let(:key) { "id" }
+          it { is_expected.to eq idval }
+        end
+
+        context 'when key has an overrider' do
+          let(:key) { "salute" }
+          it { is_expected.to eq "#{saluteval}!" }
+        end
+      end
+
+      describe '#values' do
+        subject { subject_object.values }
+
+        it { is_expected.to eq [ "#{saluteval}!", idval ] }
+      end
+
+      describe '#first' do
+        subject { subject_object.first }
+
+        it { is_expected.to eq [ "salute", "#{saluteval}!" ] }
+      end
+
+      describe '#kind_of?' do
+        subject { subject_object.kind_of?(klass) }
+
+        context 'when klass is of delegate' do
+          let(:klass) { delegate.class }
+
+          it { is_expected.to be_truthy }
+        end
+
+        context 'when klass is of self' do
+          let(:klass) { described_class }
+
+          it { is_expected.to be_falsey }
+        end
+      end
+
+      describe '#has_key?' do
+        subject { subject_object.has_key?(key) }
+
+        context 'when delegate has the key' do
+          let(:key) { "id" }
+
+          it { is_expected.to be_truthy }
+        end
+        context 'when delegate does not have the key' do
+          let(:key) { "random_stuff" }
+
+          it { is_expected.to be_falsey }
+        end
+      end
+    end
+  end
+end

data/flydata-core/spec/postgresql/snapshot_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'flydata-core/postgresql/snapshot'
+
+module FlydataCore
+  module Postgresql
+    describe Snapshot do
+      let(:snapshot_text) { '10:18:11,12,15' }
+      let(:subject_object) { described_class.new(snapshot_text) }
+
+      describe '#initialize' do
+        subject {  subject_object }
+
+        context 'when xip_list is empty' do
+          let(:snapshot_text) { '10:18:' }
+          it { expect(subject.xmin).to eq(10) }
+          it { expect(subject.xmax).to eq(18) }
+          it { expect(subject.xip_list).to eq([]) }
+          it { expect(subject.to_s).to eq('10:18:') }
+        end
+
+        context 'when xip_list is not empty' do
+          let(:snapshot_text) { '10:18:11,12,15' }
+          it { expect(subject.xmin).to eq(10) }
+          it { expect(subject.xmax).to eq(18) }
+          it { expect(subject.xip_list).to eq([11, 12, 15]) }
+          it { expect(subject.to_s).to eq('10:18:11,12,15') }
+        end
+      end
+
+      describe '#<=>' do
+        def new_ss(txt)
+          Snapshot.new(txt)
+        end
+
+        it { expect(new_ss("10:10:") == new_ss("10:10:")).to be(true) }
+        it { expect(new_ss("10:10:") == new_ss("11:11:")).to be(false) }
+        it { expect(new_ss("10:10:") == new_ss("9:9:")).to be(false) }
+        it { expect(new_ss("10:10:") == new_ss("10:11:")).to be(false) }
+        it { expect(new_ss("10:18:") == new_ss("10:18:10,11,12")).to be(false) }
+        it { expect(new_ss("10:18:10,11,12") == new_ss("10:18:10,11,12")).to be(true) }
+        it { expect(new_ss("10:18:10,11,12") == new_ss("10:18:11,12")).to be(false) }
+
+        it { expect(new_ss("10:10:") > new_ss("10:10:")).to be(false) }
+        it { expect(new_ss("10:10:") > new_ss("11:11:")).to be(false) }
+        it { expect(new_ss("11:11:") > new_ss("10:10:")).to be(true) }
+        it { expect(new_ss("10:10:") > new_ss("9:9:")).to be(true) }
+        it { expect(new_ss("10:10:") > new_ss("10:11:")).to be(false) }
+        it { expect(new_ss("10:11:") > new_ss("10:10:")).to be(true) }
+        it { expect(new_ss("10:18:") > new_ss("10:18:10,11,12")).to be(true) }
+        it { expect(new_ss("10:18:10,11,12") > new_ss("10:18:10,11,12")).to be(false) }
+        it { expect(new_ss("10:18:10,11,12") > new_ss("10:18:11,12")).to be(false) }
+      end
+    end
+  end
+end

data/flydata-core/spec/postgresql/source_pos_spec.rb

@@ -4,21 +4,42 @@ module FlydataCore
 module Postgresql
 
 describe SourcePos do
-  let(:subject_object) { described_class.new(snapshot_id, pk_values) }
+  let(:subject_object) { described_class.new(snapshot, to_snapshot, pk_values) }
 
-  let(:snapshot_id) { "1234:1234:" }
+  let(:snapshot) { "1234:1234:" }
+  let(:to_snapshot) { nil }
   let(:pk_values) { nil }
 
+  describe '#initialize' do
+    context 'with snapshot and pk_values' do
+      it { expect(subject_object.snapshot).to eq(Snapshot.new(snapshot)) }
+      it { expect(subject_object.pk_values).to eq(pk_values) }
+    end
+
+    context 'with source pos object' do
+      let(:snapshot) { '1111:1111:' }
+      let(:to_snapshot) { '2222:2222:' }
+      let(:pk_values) { [{'id' => '1000'}] }
+      let(:obj) { described_class.new(snapshot, to_snapshot, pk_values) }
+      subject { described_class.new(obj) }
+
+      it { expect(subject.snapshot).to eq(Snapshot.new(snapshot)) }
+      it { expect(subject.to_snapshot).to eq(Snapshot.new(to_snapshot)) }
+      it { expect(subject.pk_values).to eq(pk_values) }
+    end
+  end
+
   describe '#to_s' do
     subject { subject_object.to_s }
 
     context 'when pk_values is nil' do
       let(:pk_values) { nil }
-      it { is_expected.to eq %Q|#{snapshot_id}\t| }
+      it { is_expected.to eq %Q|#{snapshot}\t\t| }
     end
     context 'when pk_values is not nil' do
+      let(:to_snapshot) { '1234:1234:' }
       let(:pk_values) { { "user_id" => 1, "address_id" => 3 } }
-      it { is_expected.to eq %Q|#{snapshot_id}\t{"user_id":1,"address_id":3}| }
+      it { is_expected.to eq %Q|#{snapshot}\t#{to_snapshot}\t{"user_id":1,"address_id":3}| }
     end
   end
 
@@ -26,17 +47,58 @@ describe SourcePos do
     subject { described_class.load(str) }
 
     context 'without pk_values' do
-      let(:str) { %Q|#{snapshot_id}\t| }
-      it { is_expected.to eq described_class.new(snapshot_id) }
+      let(:str) { %Q|#{snapshot}\t\t| }
+      it { is_expected.to eq described_class.new(snapshot) }
     end
     context 'with pk_values' do
-      let(:str) { %Q|#{snapshot_id}\t{"user_id":1,"address_id":3}| }
+      let(:str) { %Q|#{snapshot}\t\t{"user_id":1,"address_id":3}| }
       it do
-        is_expected.to eq described_class.new(snapshot_id,
+        is_expected.to eq described_class.new(snapshot, nil,
                                            "user_id" => 1, "address_id" => 3)
       end
     end
   end
+
+  describe '#<=>' do
+    def src_pos(snapshot, pk_values = nil)
+      described_class.new(snapshot, '2222:2222:', pk_values)
+    end
+    context 'when both have no pk_values' do
+      it { expect(src_pos('1111:1111:') == src_pos('1111:1111:')).to be(true) }
+      it { expect(src_pos('1111:1111:') == src_pos('1112:1112:')).to be(false) }
+      it { expect(src_pos('1111:1111:') < src_pos('1112:1112:')).to be(true) }
+      it { expect(src_pos('1111:1111:') < src_pos('1110:1110:')).to be(false) }
+      it { expect(src_pos('1111:1111:') > src_pos('1110:1110:')).to be(true) }
+      it { expect(src_pos('1111:1111:') > src_pos('1112:1112:')).to be(false) }
+      it { expect(src_pos('1111:1111:') > src_pos('999:999')).to be(true) }
+    end
+
+    context 'when one of them has pk_values' do
+      let(:pkv) { [{'id'=>'10'}] }
+      it { expect(src_pos('1111:1111:',pkv) == src_pos('1111:1111:')).to be(false) }
+      it { expect(src_pos('1111:1111:',pkv) == src_pos('1112:1112:')).to be(false) }
+      it { expect(src_pos('1111:1111:',pkv) < src_pos('1111:1111:')).to be(true) }
+      it { expect(src_pos('1111:1111:',pkv) < src_pos('1112:1112:')).to be(true) }
+      it { expect(src_pos('1111:1111:',pkv) < src_pos('1110:1110:')).to be(false) }
+      it { expect(src_pos('1111:1111:',pkv) > src_pos('1110:1110:')).to be(true) }
+      it { expect(src_pos('1111:1111:',pkv) > src_pos('1112:1112:')).to be(false) }
+    end
+
+    context 'when both have pk_values' do
+      let(:pkv1) { [{'id'=>'10'}] }
+      let(:pkv2) { [{'name'=>'akira'}] }
+      it { expect(src_pos('1111:1111:',pkv1) == src_pos('1111:1111:',pkv1)).to be(true) }
+      it { expect(src_pos('1111:1111:',pkv1) == src_pos('1111:1111:',pkv2)).to be(false) }
+      it { expect(src_pos('1111:1111:',pkv1) == src_pos('1112:1112:',pkv2)).to be(false) }
+      it { expect(src_pos('1111:1111:',pkv1) < src_pos('1111:1111:',pkv2)).to be(true) }
+      it { expect(src_pos('1111:1111:',pkv1) < src_pos('1111:1111:',pkv1)).to be(false) }
+      it { expect(src_pos('1111:1111:',pkv1) < src_pos('1112:1112:',pkv2)).to be(true) }
+      it { expect(src_pos('1111:1111:',pkv1) < src_pos('1110:1110:',pkv2)).to be(false) }
+      it { expect(src_pos('1111:1111:',pkv1) > src_pos('1110:1110:',pkv2)).to be(true) }
+      it { expect(src_pos('1111:1111:',pkv1) > src_pos('1112:1112:',pkv2)).to be(false) }
+      it { expect(src_pos('1111:1111:',pkv1) > src_pos('1111:1111:',pkv2)).to be(false) }
+    end
+  end
 end
 
 end

data/flydata-core/spec/table_def/postgresql_table_def_spec.rb

@@ -27,7 +27,7 @@ describe PostgresqlTableDef do
       information_schema_columns["data_type"] = data_type
     end
 
-    let(:type_hash) { double('type_hash') }
+    let(:type_hash) { PostgresqlTableDef::TYPE_MAP_P2F[data_type] }
     let(:numeric_precision) { nil }
     let(:numeric_scale) { nil }
     let(:width_values) do
@@ -49,40 +49,101 @@ describe PostgresqlTableDef do
         information_schema_columns["numeric_scale"] = numeric_scale
       end
 
-      let(:type_hash) { PostgresqlTableDef::TYPE_MAP_P2F[data_type] }
-
       context "with precision nil" do
         let(:numeric_precision) { nil }
         context "with scale nil" do
           let(:numeric_scale) { nil }
           it { is_expected.to eq "numeric" }
         end
-        context "with scale 2" do
-          let(:numeric_scale) { 2 }
-          it do
-            expect(described_class).to receive(:get_width_values).
-              with(information_schema_columns, type_hash).and_raise("test")
-
-            expect{subject}.to raise_error("test")
-          end
-        end
       end
-      context "with precision 23" do
-        let(:numeric_precision) { 23 }
-        context "with scale nil" do
-          let(:numeric_scale) { nil }
-          it { is_expected.to eq "numeric(23)" }
+      context "with precision 1000" do
+        let(:numeric_precision) { 1000 }
+        context "with scale 0 (default value given by PostgreSQL)" do
+          let(:numeric_scale) { 0 }
+          it { is_expected.to eq "numeric(1000,0)" }
         end
         context "with scale 2" do
           let(:numeric_scale) { 2 }
-          it { is_expected.to eq "numeric(23,2)" }
+          it { is_expected.to eq "numeric(1000,2)" }
         end
       end
     end
     # TODO Add data type specific specs here
+    context "with data type money" do
+      let(:data_type) { "money" }
+
+      before do
+        # Note that PostgreSQL's information_schema table does not have these
+        # values for the money type.  The user of this method has to populate
+        # these values manually.
+        information_schema_columns["numeric_precision"] = numeric_precision
+        information_schema_columns["numeric_scale"] = numeric_scale
+      end
+
+      let(:numeric_precision) { 19 }
+
+      context 'when the money scale is 0' do
+        let(:numeric_scale) { 0 }
+
+        it { is_expected.to eq "money(19,0)" }
+      end
+      context 'when the moeny scale is 2' do
+        let(:numeric_scale) { 2 }
+
+        it { is_expected.to eq "money(19,2)" }
+      end
+    end
+    context "with time data type" do
+      let(:data_type) { "time" }
+
+      it { is_expected.to eq "time" }
+    end
+    context "with time without time zone data type" do
+      let(:data_type) { "time without time zone" }
+
+      it { is_expected.to eq "time" }
+    end
+    context "with time with time zone data type" do
+      let(:data_type) { "time with time zone" }
+
+      it { is_expected.to eq "timetz" }
+    end
+    context "with timestamp data type" do
+      let(:data_type) { "timestamp" }
+
+      it { is_expected.to eq "datetime" }
+    end
+    context "with timestamp without time zone data type" do
+      let(:data_type) { "timestamp without time zone" }
+
+      it { is_expected.to eq "datetime" }
+    end
+    context "with timestamp with time zone data type" do
+      let(:data_type) { "timestamp with time zone" }
+
+      it { is_expected.to eq "datetimetz" }
+    end
+    context "with bit data type" do
+      let(:data_type) { "bit" }
+
+      it { is_expected.to eq "bit" }
+    end
+    context "with bit varying data type" do
+      let(:data_type) { "bit varying" }
+
+      it { is_expected.to eq "varbit" }
+    end
+    context "with varbit data type" do
+      let(:data_type) { "varbit" }
+
+      it { is_expected.to eq "varbit" }
+    end
     context "with unknown data type" do
       let(:data_type) { "duck" }
-      it { expect{subject}.to raise_error /Unknown PostgreSQL type/ }
+
+      let(:type_hash) { PostgresqlTableDef::TYPE_MAP_P2F[:default] }
+
+      it { is_expected.to eq "_unsupported" }
     end
     context "with no data type" do
       let(:data_type) { nil }