em-pg-client 0.2.1 → 0.3.0

data/spec/em_synchrony_client_autoreconnect.rb

@@ -1,130 +1,154 @@
-$:.unshift "lib"
-require 'date'
-require 'em-synchrony'
-require 'em-synchrony/pg'
-
-$pgserver_cmd_stop = %Q[sudo su - postgres -c 'pg_ctl stop -m fast']
-$pgserver_cmd_start = %Q[sudo su - postgres -c 'pg_ctl -l $PGDATA/postgres.log start -w']
-
-shared_context 'em-synchrony-pg common' do
-  around(:each) do |testcase|
-    EM.synchrony do
-      testcase.call
-      EM.stop
-    end
-  end
-
-  after(:all) do
-    @client.close
-  end
-end
-
-describe 'em-synchrony-pg default autoreconnect' do
-  include_context 'em-synchrony-pg common'
-
-  it "should not have modified argument Hash" do
-    @options.should eq(async_autoreconnect: true)
-  end
-
-  it "should get database size using query" do
-    @tested_proc.call
-  end
-
-  it "should get database size using query after server restart" do
-    system($pgserver_cmd_stop).should be_true
-    system($pgserver_cmd_start).should be_true
-    @tested_proc.call
-  end
-
-  it "should not get database size using query after server shutdown" do
-    system($pgserver_cmd_stop).should be_true
-    expect {
-      @tested_proc.call
-    }.to raise_error(PG::Error)
-  end
-
-  it "should get database size using query after server startup" do
-    system($pgserver_cmd_start).should be_true
-    @tested_proc.call
-  end
-
-  before(:all) do
-    @tested_proc = proc do
-      @client.query('SELECT pg_database_size(current_database());') do |result|
-        result.should be_an_instance_of PG::Result
-        result[0]['pg_database_size'].to_i.should be > 0
-      end
-    end
-    @options = {async_autoreconnect: true}
-    @client = PG::EM::Client.new(@options)
-    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
-  end
-end
-
-describe 'em-synchrony-pg autoreconnect with on_autoreconnect' do
-  include_context 'em-synchrony-pg common'
-
-  it "should not have modified argument Hash" do
-    @options.should eq(on_autoreconnect: @on_autoreconnect)
-  end
-
-  it "should get database size using prepared statement" do
-    @tested_proc.call
-  end
-
-  it "should get database size using prepared statement after server restart" do
-    system($pgserver_cmd_stop).should be_true
-    system($pgserver_cmd_start).should be_true
-    @tested_proc.call
-  end
-
-  before(:all) do
-    @tested_proc = proc do
-      @client.exec_prepared('get_db_size') do |result|
-        result.should be_an_instance_of PG::Result
-        result[0]['pg_database_size'].to_i.should be > 0
-      end
-    end
-    @on_autoreconnect = proc do |client, ex|
-      client.prepare('get_db_size', 'SELECT pg_database_size(current_database());')
-    end
-    @options = {on_autoreconnect: @on_autoreconnect}
-    @client = PG::EM::Client.new(@options)
-    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
-    @on_autoreconnect.call @client
-  end
-end
-
-describe 'em-synchrony-pg with autoreconnect disabled' do
-  include_context 'em-synchrony-pg common'
-
-  it "should get database size using query" do
-    @tested_proc.call
-  end
-
-  it "should not get database size using query after server restart" do
-    system($pgserver_cmd_stop).should be_true
-    system($pgserver_cmd_start).should be_true
-    expect {
-      @tested_proc.call
-    }.to raise_error(PG::Error)
-  end
-
-  it "should get database size using query after manual connection reset" do
-    @client.status.should be PG::CONNECTION_BAD
-    @client.reset
-    @client.status.should be PG::CONNECTION_OK
-    @tested_proc.call
-  end
-
-  before(:all) do
-    @tested_proc = proc do
-      @client.query('SELECT pg_database_size(current_database());') do |result|
-        result.should be_an_instance_of PG::Result
-        result[0]['pg_database_size'].to_i.should be > 0
-      end
-    end
-    @client = PG::EM::Client.new
-    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
-  end
-end
+$:.unshift "lib"
+gem 'eventmachine', '~> 1.0.0'
+gem 'pg', ENV['EM_PG_CLIENT_TEST_PG_VERSION']
+require 'date'
+require 'em-synchrony'
+require 'pg/em'
+
+$pgserver_cmd_stop = %Q[sudo -i -u postgres pg_ctl -D "#{ENV['PGDATA']}" stop -s -m fast]
+$pgserver_cmd_start = %Q[sudo -i -u postgres pg_ctl -D "#{ENV['PGDATA']}" start -s -w]
+
+shared_context 'em-synchrony-pg common' do
+  around(:each) do |testcase|
+    EM.synchrony do
+      testcase.call
+      EM.stop
+    end
+  end
+
+  after(:all) do
+    @client.close
+  end
+end
+
+describe 'em-synchrony-pg default autoreconnect' do
+  include_context 'em-synchrony-pg common'
+
+  it "should not have modified argument Hash" do
+    @options.should eq(async_autoreconnect: true)
+  end
+
+  it "should get database size using query" do
+    @tested_proc.call
+  end
+
+  it "should get database size using query after server restart" do
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @tested_proc.call
+  end
+
+  it "should not get database size using query after server shutdown" do
+    system($pgserver_cmd_stop).should be_true
+    expect {
+      @tested_proc.call
+    }.to raise_error(@client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad)
+  end
+
+  it "should get database size using query after server startup" do
+    system($pgserver_cmd_start).should be_true
+    @tested_proc.call
+  end
+
+  it "should raise an error when in transaction after server restart" do
+    expect do
+      @client.transaction do
+        system($pgserver_cmd_stop).should be_true
+        system($pgserver_cmd_start).should be_true
+        @tested_proc.call
+      end
+    end.to raise_error(@client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad)
+    @tested_proc.call
+  end
+
+  before(:all) do
+    @tested_proc = proc do
+      @client.query('SELECT pg_database_size(current_database());') do |result|
+        result.should be_an_instance_of PG::Result
+        result[0]['pg_database_size'].to_i.should be > 0
+      end
+    end
+    @options = {async_autoreconnect: true}
+    @client = PG::EM::Client.new(@options)
+    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
+  end
+end
+
+describe 'em-synchrony-pg autoreconnect with on_autoreconnect' do
+  include_context 'em-synchrony-pg common'
+
+  it "should not have modified argument Hash" do
+    @options.should eq(on_autoreconnect: @on_autoreconnect)
+  end
+
+  it "should get database size using prepared statement" do
+    @tested_proc.call
+  end
+
+  it "should get database size using prepared statement after server restart" do
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @tested_proc.call
+  end
+
+  it "should raise an error when in transaction after server restart" do
+    expect do
+      @client.transaction do
+        system($pgserver_cmd_stop).should be_true
+        system($pgserver_cmd_start).should be_true
+        @tested_proc.call
+      end
+    end.to raise_error(@client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad)
+    @tested_proc.call
+  end
+
+  before(:all) do
+    @tested_proc = proc do
+      @client.exec_prepared('get_db_size') do |result|
+        result.should be_an_instance_of PG::Result
+        result[0]['pg_database_size'].to_i.should be > 0
+      end
+    end
+    @on_autoreconnect = proc do |client, ex|
+      client.prepare('get_db_size', 'SELECT pg_database_size(current_database());')
+    end
+    @options = {on_autoreconnect: @on_autoreconnect}
+    @client = PG::EM::Client.new(@options)
+    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
+    @on_autoreconnect.call @client
+  end
+end
+
+describe 'em-synchrony-pg with autoreconnect disabled' do
+  include_context 'em-synchrony-pg common'
+
+  it "should get database size using query" do
+    @tested_proc.call
+  end
+
+  it "should not get database size using query after server restart" do
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    expect {
+      @tested_proc.call
+    }.to raise_error(@client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad)
+  end
+
+  it "should get database size using query after manual connection reset" do
+    @client.status.should be PG::CONNECTION_BAD
+    @client.reset
+    @client.status.should be PG::CONNECTION_OK
+    @tested_proc.call
+  end
+
+  before(:all) do
+    @tested_proc = proc do
+      @client.query('SELECT pg_database_size(current_database());') do |result|
+        result.should be_an_instance_of PG::Result
+        result[0]['pg_database_size'].to_i.should be > 0
+      end
+    end
+    @client = PG::EM::Client.new
+    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
+  end
+end

data/spec/pg_em_client_connect_finish.rb

@@ -0,0 +1,54 @@
+$:.unshift "lib"
+gem 'eventmachine', '~> 1.0.0'
+gem 'pg', ENV['EM_PG_CLIENT_TEST_PG_VERSION']
+require 'eventmachine'
+require 'em-synchrony'
+require 'pg/em'
+
+shared_context 'test deferred' do
+  it "should not finish connection on deferred connection failure" do
+    EM.run do
+      subject.connect_defer(options) do |ex|
+        ex.should be_an_instance_of PG::ConnectionBad
+        ex.connection.should be_an_instance_of subject
+        ex.connection.finished?.should be_false
+        EM.stop
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end
+  end
+end
+
+shared_context 'test blocking' do
+  it "should not finish connection on blocking connection failure" do
+    EM.synchrony do
+      expect do
+        subject.new(options)
+      end.to raise_error(PG::ConnectionBad)
+      begin
+        subject.new(options)
+      rescue => ex
+        ex.should be_an_instance_of PG::ConnectionBad
+        ex.connection.should be_an_instance_of subject
+        ex.connection.finished?.should be_false
+      end
+      EM.stop
+    end
+  end
+end
+
+describe 'connect failure and finished? status' do
+  subject          { PG::EM::Client }
+  let(:bogus_port) { 1 }
+
+  describe 'with localhost'  do
+    let(:options)  { {host: 'localhost', port: bogus_port} }
+    include_context 'test deferred'
+    include_context 'test blocking'
+  end
+
+  describe 'with unix socket' do
+    let(:options)  { {host: '/tmp', port: bogus_port} }
+    include_context 'test deferred'
+    include_context 'test blocking'
+  end unless RSpec.windows_os?
+end

data/spec/pg_em_client_connect_timeout.rb

@@ -0,0 +1,91 @@
+$:.unshift "lib"
+gem 'eventmachine', '~> 1.0.0'
+gem 'pg', ENV['EM_PG_CLIENT_TEST_PG_VERSION']
+require 'eventmachine'
+require 'em-synchrony'
+require 'pg/em'
+
+shared_context 'test async connect timeout' do
+  it "should timeout expire while connecting" do
+    this = :first
+    start = Time.now
+    subject.connect_defer(options) do |ex|
+      this = :second
+      ex.should be_an_instance_of PG::ConnectionBad
+      ex.message.should include 'timeout expired (async)'
+      (Time.now - start).should be > timeout
+      EM.stop
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+    this.should be :first
+  end
+
+  around(:each) do |testcase|
+    EM.run(&testcase)
+  end
+end
+
+shared_context 'test synchrony connect timeout' do
+  it "should timeout expire while connecting" do
+    start = Time.now
+    this = nil
+    EM.next_tick { this = :that }
+    expect do
+      subject.new(options)
+    end.to raise_error(PG::ConnectionBad, 'timeout expired (async)')
+    this.should be :that
+    (Time.now - start).should be > timeout
+  end
+
+  around(:each) do |testcase|
+    EM.synchrony do
+      begin
+        testcase.call
+      ensure
+        EM.stop
+      end
+    end
+  end
+end
+
+describe 'connect timeout expire' do
+  subject          { PG::EM::Client }
+  let(:black_hole) { '192.168.255.254' }
+  let(:timeout)    { 1 }
+  let(:envvar)     { 'PGCONNECT_TIMEOUT' }
+
+  describe 'asynchronously using connect_timeout option'  do
+    let(:options)  { {host: black_hole, connect_timeout: timeout} }
+
+    before(:each) { ENV[envvar] = nil }
+
+    include_context 'test async connect timeout'
+  end
+
+  describe 'asynchronously using PGCONNECT_TIMEOUT env var'  do
+    let(:options)  { {host: black_hole} }
+
+    before(:each) { ENV[envvar] = timeout.to_s }
+
+    include_context 'test async connect timeout'
+
+    after(:each) { ENV[envvar] = nil }
+  end
+
+  describe 'sync-to-fiber using connect_timeout option'  do
+    let(:options)  { {host: black_hole, connect_timeout: timeout} }
+
+    before(:each) { ENV[envvar] = nil }
+
+    include_context 'test synchrony connect timeout'
+  end
+
+  describe 'sync-to-fiber using PGCONNECT_TIMEOUT env var'  do
+    let(:options)  { {host: black_hole} }
+
+    before(:each) { ENV[envvar] = timeout.to_s }
+
+    include_context 'test synchrony connect timeout'
+
+    after(:each) { ENV[envvar] = nil }
+  end
+end

data/spec/pg_em_client_options.rb

@@ -0,0 +1,85 @@
+$:.unshift "lib"
+gem 'eventmachine', '~> 1.0.0'
+gem 'pg', ENV['EM_PG_CLIENT_TEST_PG_VERSION']
+require 'date'
+require 'eventmachine'
+require 'pg/em'
+
+describe 'em-pg-client options' do
+  subject                   { PG::EM::Client }
+
+  let(:callback)            { proc {|c, e| false } }
+  let(:args)                { [{async_autoreconnect: true, connect_timeout: 10, host: 'foo'}] }
+  let(:str_key_args)        { [{'async_autoreconnect'=>true, 'connect_timeout'=>10, 'host'=>'foo'}] }
+  let(:pgconn_args)         { [{connect_timeout: 10, host: 'foo'}] }
+  let(:str_key_pgconn_args) { [{'connect_timeout'=>10, 'host'=>'foo'}] }
+  let(:async_options)       { {
+                                :@async_autoreconnect => true,
+                                :@connect_timeout => 10,
+                                :@query_timeout=>0,
+                                :@on_autoreconnect=>nil,
+                                :@async_command_aborted=>false} }
+
+  it "should parse options and not modify original hash" do
+    orig_args = args.dup
+    orig_options = orig_args.first.dup
+    options = subject.parse_async_options orig_args
+    options.should eq async_options
+    orig_args.should eq pgconn_args
+    args.first.should eq orig_options
+  end
+
+  it "should parse options with keys as strings" do
+    orig_args = str_key_args.dup
+    orig_options = orig_args.first.dup
+    options = subject.parse_async_options orig_args
+    options.should eq async_options
+    orig_args.should eq str_key_pgconn_args
+    str_key_args.first.should eq orig_options
+  end
+
+  it "should set async_autoreconnect according to on_autoreconnect" do
+    options = subject.parse_async_options []
+    options.should be_an_instance_of Hash
+    options[:@on_autoreconnect].should be_nil
+    options[:@async_autoreconnect].should be_false
+
+    args = [on_autoreconnect: callback]
+    options = subject.parse_async_options args
+    args.should eq [{}]
+    options.should be_an_instance_of Hash
+    options[:@on_autoreconnect].should be callback
+    options[:@async_autoreconnect].should be_true
+
+    args = [async_autoreconnect: false,
+      on_autoreconnect: callback]
+    options = subject.parse_async_options args
+    args.should eq [{}]
+    options.should be_an_instance_of Hash
+    options[:@on_autoreconnect].should be callback
+    options[:@async_autoreconnect].should be_false
+
+    args = [on_autoreconnect: callback,
+      async_autoreconnect: false]
+    options = subject.parse_async_options args
+    args.should eq [{}]
+    options.should be_an_instance_of Hash
+    options[:@on_autoreconnect].should be callback
+    options[:@async_autoreconnect].should be_false
+  end
+
+  it "should set only callable on_autoreconnect" do
+    expect do
+      subject.parse_async_options [on_autoreconnect: true]
+    end.to raise_error(ArgumentError, /must respond to/)
+
+    expect do
+      subject.parse_async_options [on_autoreconnect: Object.new]
+    end.to raise_error(ArgumentError, /must respond to/)
+
+    options = subject.parse_async_options [on_autoreconnect: callback]
+    options.should be_an_instance_of Hash
+    options[:@on_autoreconnect].should be callback
+  end
+
+end