em-pg-client 0.2.0.pre.2 → 0.2.0.pre.3

data/HISTORY.rdoc

@@ -1,3 +1,12 @@
+0.2.0.pre.3
+- #status() returns CONNECTION_BAD for connections with expired query
+- spec: query timeout expiration
+- non-blocking result processing for multiple data query statements sent at once
+- refine code in em-synchrony/pg
+- spec: more detailed tests
+- spec: async_connect
+- spec: autoreconnect
+
 0.2.0.pre.2
 - errors from consume_input fails deferrable
 - query_timeout now measures only network response timeout, 
@@ -5,7 +14,7 @@
 
 0.2.0.pre.1
 - added query_timeout feature for async query commands
-- added connect_timeout property with for async connect/reset
+- added connect_timeout property for async connect/reset
 - fix: async_autoreconnect for tcp/ip connections
 - fix: async_* does not raise errors; errors handled by deferrable
 - rework async_autoreconnect in fully async manner

data/README.rdoc

@@ -52,7 +52,7 @@ based on ruby-pg[https://bitbucket.org/ged/ruby-pg]
 
 === Latest branch (fully-async)
 
-  $ [sudo] gem install em-pg-client --prerelease
+  $ [sudo] gem install em-pg-client --pre
 
 ==== Gemfile
 

data/Rakefile

@@ -4,12 +4,35 @@ task :default => [:test]
 
 $gem_name = "em-pg-client"
 
-desc "Run tests"
-task :test do
+desc "Run spec tests"
+task :test, [:which] do |t, args|
+  args.with_defaults(:which => 'safe')
+
+  env_unix_socket = {'PGDATABASE' => 'test', 'PGHOST' => '/tmp'}
+  env_tcpip = {'PGDATABASE' => 'test', 'PGHOST' => 'localhost'}
+
   puts "WARNING: The test needs to be run with an available local PostgreSQL server"
-  sh "rspec spec/em_release_client.rb"
-  sh "rspec spec/em_devel_client.rb"
-  sh "rspec spec/em_synchrony_client.rb"
+
+  if %w[all safe].include? args[:which]
+    %w[
+      spec/em_release_client.rb
+      spec/em_devel_client.rb
+      spec/em_synchrony_client.rb
+    ].each do |spec|
+      sh env_unix_socket, "rspec #{spec}"
+      sh env_tcpip, "rspec #{spec}"
+    end
+  end
+
+  if %w[all unsafe dangerous autoreconnect].include? args[:which]
+    %w[
+      spec/em_client_autoreconnect.rb
+      spec/em_synchrony_client_autoreconnect.rb
+    ].each do |spec|
+      sh env_unix_socket, "rspec #{spec}"
+      sh env_tcpip, "rspec #{spec}"
+    end
+  end
 end
 
 desc "Build the gem"

data/em-pg-client.gemspec

@@ -2,7 +2,7 @@ $:.unshift "lib"
 
 Gem::Specification.new do |s|
   s.name = "em-pg-client"
-  s.version = "0.2.0.pre.2"
+  s.version = "0.2.0.pre.3"
   s.required_ruby_version = ">= 1.9.1"
   s.date = "#{Time.now.strftime("%Y-%m-%d")}"
   s.summary = "EventMachine PostgreSQL client"

data/lib/em-synchrony/pg.rb

@@ -20,10 +20,10 @@ module PG
         class_eval <<-EOD
           def #{name}(*args, &blk)
             if ::EM.reactor_running?
-              df = #{async_name}(*args)
               f = Fiber.current
-              df.callback { |res| f.resume(res) }
-              df.errback  { |err| f.resume(err) }
+              #{async_name}(*args) do |res|
+                f.resume(res)
+              end
 
               result = Fiber.yield
               raise result if result.is_a?(::Exception)
@@ -49,7 +49,7 @@ module PG
       alias_method :query, :exec
 
       def async_autoreconnect!(deferrable, error, &send_proc)
-         if async_autoreconnect && (@async_command_aborted || self.status != PG::CONNECTION_OK)
+         if async_autoreconnect && self.status != PG::CONNECTION_OK
           reset_df = async_reset
           reset_df.errback { |ex| deferrable.fail(ex) }
           reset_df.callback do

data/lib/pg/em.rb

@@ -1,5 +1,34 @@
 require 'pg'
 module PG
+
+  class Result
+    class << self
+      unless method_defined? :check_result
+        # pg_check_result is internal ext function. I wish it was rubified.
+        # https://bitbucket.org/ged/ruby-pg/issue/123/rubify-pg_check_result
+        def check_result(connection, result)
+          if result.nil?
+            if (error_message = connection.error_message)
+              error = PG::Error.new(error_message)
+            end
+          else
+            case result.result_status
+              when PG::PGRES_BAD_RESPONSE,
+                   PG::PGRES_FATAL_ERROR,
+                   PG::PGRES_NONFATAL_ERROR
+                error = PG::Error.new(result.error_message)
+                error.instance_variable_set('@result', result)
+            end
+          end
+          if error
+            error.instance_variable_set('@connection', connection)
+            raise error 
+          end
+        end
+      end
+    end
+  end
+
   module EM
     class FeaturedDeferrable < ::EM::DefaultDeferrable
       def initialize(&blk)
@@ -131,6 +160,7 @@ module PG
 
       module Watcher
         def initialize(client, deferrable, send_proc)
+          @last_result = nil
           @client = client
           @deferrable = deferrable
           @send_proc = send_proc
@@ -158,21 +188,33 @@ module PG
         end
 
         def notify_readable
-          @notify_timestamp = Time.now if @timer
+          result = false
           @client.consume_input
-          result = if @client.is_busy
-            false
-          else
-            @timer.cancel if @timer
+          until @client.is_busy && !self.error?
+            break if (single_result = @client.get_result).nil?
+            @last_result.clear if @last_result
+            @last_result = single_result
+          end
+          unless @client.is_busy
+            result = @last_result
+            Result.check_result(@client, result)
             detach
-            @client.get_last_result
+            @timer.cancel if @timer
           end
-        rescue PG::Error => e
-          @client.async_autoreconnect!(@deferrable, e, &@send_proc)
         rescue Exception => e
-          @deferrable.fail(e)
+          detach
+          @timer.cancel if @timer
+          if e.is_a?(PG::Error)
+            @client.async_autoreconnect!(@deferrable, e, &@send_proc)
+          else
+            @deferrable.fail(e)
+          end
         else
-          @deferrable.succeed(result) unless result == false
+          if result == false
+            @notify_timestamp = Time.now if @timer
+          else
+            @deferrable.succeed(result) 
+          end
         end
       end
 
@@ -290,9 +332,17 @@ module PG
         super(*args)
       end
 
+      def status
+        if @async_command_aborted
+          PG::CONNECTION_BAD
+        else
+          super
+        end
+      end
+
       # Perform autoreconnect. Used internally.
       def async_autoreconnect!(deferrable, error, &send_proc)
-        if async_autoreconnect && (@async_command_aborted || self.status != PG::CONNECTION_OK)
+        if async_autoreconnect && self.status != PG::CONNECTION_OK
           reset_df = async_reset
           reset_df.errback { |ex| deferrable.fail(ex) }
           reset_df.callback do

data/spec/em_client_autoreconnect.rb

@@ -0,0 +1,124 @@
+$:.unshift "lib"
+require 'date'
+require 'eventmachine'
+require 'pg/em'
+
+$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-pg common' do
+  around(:each) do |testcase|
+    EM.run(&testcase)
+  end
+
+  after(:all) do
+    @client.close
+  end
+end
+
+describe 'em-pg default autoreconnect' do
+  include_context 'em-pg common'
+
+  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
+    @client.query('SELECT pg_database_size(current_database());') do |ex|
+      ex.should be_an_instance_of PG::Error
+      EM.stop
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  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
+        EM.stop
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end
+    @client = PG::EM::Client.new
+    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
+  end
+end
+
+describe 'em-pg autoreconnect with on_autoreconnect' do
+  include_context 'em-pg common'
+
+  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
+        EM.stop
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end
+    on_autoreconnect = proc do |client, ex|
+      df = client.prepare('get_db_size', 'SELECT pg_database_size(current_database());')
+      df.should be_a_kind_of ::EM::DefaultDeferrable
+      df
+    end
+    @client = PG::EM::Client.new(on_autoreconnect: on_autoreconnect)
+    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
+    @client.prepare('get_db_size', 'SELECT pg_database_size(current_database());')
+  end
+end
+
+describe 'em-pg with autoreconnect disabled' do
+  include_context 'em-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
+    @client.query('SELECT pg_database_size(current_database());') do |ex|
+      ex.should be_an_instance_of PG::Error
+      EM.stop
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  it "should get database size using query after async manual connection reset" do
+    @client.async_reset do |conn|
+      conn.should be @client
+      @tested_proc.call
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  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
+        EM.stop
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end
+    @client = PG::EM::Client.new(async_autoreconnect: false)
+    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
+  end
+end

data/spec/em_client_common.rb

@@ -0,0 +1,152 @@
+shared_context 'em-pg common before' do
+
+  around(:each) do |testcase|
+    EM.run &testcase
+  end
+
+  before(:all) do
+    @cdates = []
+    @values = Array(('AA'..'ZZ').each_with_index)
+    @client = described_class.new
+    @client.query 'BEGIN TRANSACTION'
+  end
+
+  after(:all) do
+    @client.query 'ROLLBACK TRANSACTION'
+    @client.close
+  end
+
+  it "should be a client" do
+    @client.should be_an_instance_of described_class
+    EM.stop
+  end
+
+  it "should create simple table `foo`" do
+    @client.query('DROP TABLE IF EXISTS foo') do |result|
+      result.should be_an_instance_of PG::Result
+      @client.query('CREATE TABLE foo (id integer,cdate timestamp with time zone,data varchar)') do |result|
+        result.should be_an_instance_of PG::Result
+        EM.stop
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+end
+
+shared_context 'em-pg common after' do
+
+  it "should read foo table with prepared statement" do
+    @client.prepare('get_foo', 'SELECT * FROM foo order by id') do |result|
+      result.should be_an_instance_of PG::Result
+      @client.exec_prepared('get_foo') do |result|
+        result.should be_an_instance_of PG::Result
+        result.each_with_index do |row, i|
+          row['id'].to_i.should == i
+          DateTime.parse(row['cdate']).should == @cdates[i]
+          row['data'].should == @values[i][0]
+        end
+        EM.stop
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  it "should connect to database asynchronously" do
+    this = :first
+    described_class.async_connect do |conn|
+      this = :second
+      conn.should be_an_instance_of described_class
+      conn.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
+        EM.stop
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+    this.should be :first
+  end
+
+  it "should raise syntax error in misspelled multiple statement" do
+    @client.query('SELECT * from pg_class; SRELECT CURRENT_TIMESTAMP; SELECT 42 number') do |result|
+      result.should be_an_instance_of PG::Error
+      result.to_s.should include "syntax error"
+      @client.query('ROLLBACK') do |result|
+        result.should be_an_instance_of PG::Result
+        @client.query('BEGIN TRANSACTION') do |result|
+          result.should be_an_instance_of PG::Result
+          EM.stop
+        end.should be_a_kind_of ::EM::DefaultDeferrable
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  it "should return only last statement" do
+    @client.query('SELECT * from pg_class; SELECT CURRENT_TIMESTAMP; SELECT 42 number') do |result|
+      result.should be_an_instance_of PG::Result
+      result[0]['number'].should eq "42"
+      EM.stop
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  it "should timeout expire while executing query" do
+    @client.query_timeout.should eq 0
+    @client.query_timeout = 1.5
+    @client.query_timeout.should eq 1.5
+    start_time = Time.now
+    @client.query('SELECT pg_sleep(2)') do |result|
+      (Time.now - start_time).should be < 2
+      result.should be_an_instance_of PG::Error
+      result.to_s.should include "query timeout expired"
+      @client.async_command_aborted.should be_true
+      @client.query_timeout = 0
+      @client.query_timeout.should eq 0
+      @client.query('BEGIN TRANSACTION') do |result|
+        result.should be_an_instance_of PG::Result
+        EM.stop
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  it "should timeout not expire while executing query with partial results" do
+    @client.query_timeout.should eq 0
+    @client.query_timeout = 1.1
+    @client.query_timeout.should eq 1.1
+    start_time = Time.now
+    @client.query(
+        'SELECT * from pg_class;' +
+        'SELECT pg_sleep(1);' +
+        'SELECT * from pg_class;' + 
+        'SELECT pg_sleep(1);' +
+        'SELECT 42 number') do |result|
+      (Time.now - start_time).should be > 2
+      result.should be_an_instance_of PG::Result
+      result[0]['number'].should eq "42"
+      @client.query_timeout = 0
+      @client.query_timeout.should eq 0
+      @client.async_command_aborted.should be_false
+      EM.stop
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  it "should timeout expire while executing query with partial results" do
+    @client.query_timeout.should eq 0
+    @client.query_timeout = 1.1
+    @client.query_timeout.should eq 1.1
+    start_time = Time.now
+    @client.query(
+        'SELECT * from pg_class;' +
+        'SELECT pg_sleep(1);' +
+        'SELECT * from pg_class;' + 
+        'SELECT pg_sleep(2);' +
+        'SELECT 42 number') do |result|
+      (Time.now - start_time).should be > 2
+      result.should be_an_instance_of PG::Error
+      result.to_s.should include "query timeout expired"
+      @client.query_timeout = 0
+      @client.query_timeout.should eq 0
+      @client.query('BEGIN TRANSACTION') do |result|
+        result.should be_an_instance_of PG::Result
+        EM.stop
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+end

data/spec/em_devel_client.rb

@@ -3,61 +3,26 @@ gem 'eventmachine', '>= 1.0.0.beta.1'
 require 'date'
 require 'eventmachine'
 require 'pg/em'
+require 'em_client_common'
 
 describe PG::EM::Client do
 
-  it "should create simple table `foo`" do
-    @client.query('DROP TABLE IF EXISTS foo') do |result|
-      raise result if result.is_a? ::Exception
-      @client.query('CREATE TABLE foo (id integer,cdate timestamp with time zone,data varchar)') do |result|
-        raise result if result.is_a? ::Exception
-        EM.stop
-      end
-    end
-  end
+  include_context 'em-pg common before'
 
   it "should populate foo with some data " do
     EM::Iterator.new(@values).map(proc{ |(data, id), iter|
       @client.query('INSERT INTO foo (id,cdate,data) VALUES($1,$2,$3) returning cdate', [id, DateTime.now, data]) do |result|
-        raise result if result.is_a? ::Exception
+      result.should be_an_instance_of PG::Result
         iter.return(DateTime.parse(result[0]['cdate']))
-      end
+      end.should be_a_kind_of ::EM::DefaultDeferrable
     }, proc{ |results|
       @cdates.replace results
       results.length.should == @values.length
-      results.each {|r| r.class.should == DateTime }
+      results.each {|r| r.should be_an_instance_of DateTime }
       EM.stop
     })
   end
 
-  it "should read foo table with prepared statement" do
-    @client.prepare('get_foo', 'SELECT * FROM foo order by id') do |result|
-      raise result if result.is_a? ::Exception
-      @client.exec_prepared('get_foo') do |result|
-        raise result if result.is_a? ::Exception
-        result.each_with_index do |row, i|
-          row['id'].to_i.should == i
-          DateTime.parse(row['cdate']).should == @cdates[i]
-          row['data'].should == @values[i][0]
-        end
-        EM.stop
-      end
-    end
-  end
-  
-  around(:each) do |testcase|
-    EM.run &testcase
-  end
-
-  before(:all) do
-    @cdates = []
-    @values = Array(('AA'..'ZZ').each_with_index)
-    @client = PG::EM::Client.new(dbname: 'test')
-    @client.query 'BEGIN TRANSACTION'
-  end
+  include_context 'em-pg common after'
 
-  after(:all) do
-    @client.query 'ROLLBACK TRANSACTION'
-    @client.close
-  end
 end

data/spec/em_release_client.rb

@@ -3,18 +3,11 @@ gem 'eventmachine', '= 0.12.10'
 require 'date'
 require 'eventmachine'
 require 'pg/em'
+require 'em_client_common'
 
 describe PG::EM::Client do
 
-  it "should create simple table `foo`" do
-    @client.query('DROP TABLE IF EXISTS foo') do |result|
-      raise result if result.is_a? ::Exception
-      @client.query('CREATE TABLE foo (id integer,cdate timestamp with time zone,data varchar)') do |result|
-        raise result if result.is_a? ::Exception
-        EM.stop
-      end
-    end
-  end
+  include_context 'em-pg common before'
 
   it "should populate foo with some data " do
     values = @values.dup
@@ -22,48 +15,21 @@ describe PG::EM::Client do
     do_query = proc do
       data, id = values.shift
       @client.query('INSERT INTO foo (id,cdate,data) VALUES($1,$2,$3) returning cdate', [id, DateTime.now, data]) do |result|
-        raise result if result.is_a? ::Exception
+        result.should be_an_instance_of PG::Result
         results << DateTime.parse(result[0]['cdate'])
         if values.empty?
           @cdates.replace results
           results.length.should == @values.length
-          results.each {|r| r.class.should == DateTime }
+          results.each {|r| r.should be_an_instance_of DateTime }
           EM.stop
         else
           do_query.call
         end
-      end
+      end.should be_a_kind_of ::EM::DefaultDeferrable
     end
     do_query.call
   end
 
-  it "should read foo table with prepared statement" do
-    @client.prepare('get_foo', 'SELECT * FROM foo order by id') do
-      @client.exec_prepared('get_foo') do |result|
-        raise result if result.is_a? ::Exception
-        result.each_with_index do |row, i|
-          row['id'].to_i.should == i
-          DateTime.parse(row['cdate']).should == @cdates[i]
-          row['data'].should == @values[i][0]
-        end
-        EM.stop
-      end
-    end
-  end
-  
-  around(:each) do |testcase|
-    EM.run &testcase
-  end
-
-  before(:all) do
-    @cdates = []
-    @values = Array(('AA'..'ZZ').each_with_index)
-    @client = PG::EM::Client.new(dbname: 'test')
-    @client.query 'BEGIN TRANSACTION'
-  end
+  include_context 'em-pg common after'
 
-  after(:all) do
-    @client.query 'ROLLBACK TRANSACTION'
-    @client.close
-  end
 end

data/spec/em_synchrony_client.rb

@@ -5,44 +5,155 @@ require 'em-synchrony/pg'
 
 describe PG::EM::Client do
 
+  it "should be client" do
+    @client.should be_an_instance_of described_class
+  end
+
   it "should create simple table `foo`" do
-    @client.query('DROP TABLE IF EXISTS foo')
-    @client.query('CREATE TABLE foo (id integer,cdate timestamp with time zone,data varchar)')
-    EM.stop
+    @client.query(
+      'DROP TABLE IF EXISTS foo'
+    ).should be_an_instance_of PG::Result
+    @client.query(
+      'CREATE TABLE foo (id integer,cdate timestamp with time zone,data varchar)'
+    ).should be_an_instance_of PG::Result
   end
 
   it "should populate foo with some data " do
     results = @values.map do |(data, id)|
       @client.query('INSERT INTO foo (id,cdate,data) VALUES($1,$2,$3) returning cdate', [id, DateTime.now, data]) do |result|
+        result.should be_an_instance_of PG::Result
         DateTime.parse(result[0]['cdate'])
       end
     end
     @cdates.replace results
     results.length.should == @values.length
-    results.each {|r| r.class.should == DateTime }
-    EM.stop
+    results.each {|r| r.should be_an_instance_of DateTime }
   end
 
   it "should read foo table with prepared statement" do
-    @client.prepare('get_foo', 'SELECT * FROM foo order by id')
+    @client.prepare('get_foo', 
+      'SELECT * FROM foo order by id'
+    ).should be_an_instance_of PG::Result
     @client.exec_prepared('get_foo') do |result|
+      result.should be_an_instance_of PG::Result
       result.each_with_index do |row, i|
         row['id'].to_i.should == i
         DateTime.parse(row['cdate']).should == @cdates[i]
         row['data'].should == @values[i][0]
       end
     end
-    EM.stop
+  end
+
+  it "should connect to database asynchronously" do
+    this = :first
+    f = Fiber.current
+    Fiber.new do
+      conn = described_class.new
+      this = :second
+      conn.should be_an_instance_of described_class
+      conn.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
+      conn.close
+      f.resume
+    end.resume
+    this.should be :first
+    Fiber.yield
+    this.should be :second
+  end
+
+  it "should raise syntax error in misspelled multiple statement" do
+    expect {
+      @client.query('SELECT * from pg_class; SRELECT CURRENT_TIMESTAMP; SELECT 42 number')
+    }.to raise_error(PG::Error, /syntax error/)
+    @client.query('ROLLBACK') do |result|
+      result.should be_an_instance_of PG::Result
+    end
+    @client.query('BEGIN TRANSACTION') do |result|
+      result.should be_an_instance_of PG::Result
+    end
+  end
+
+  it "should return only last statement" do
+    @client.query('SELECT * from pg_class; SELECT CURRENT_TIMESTAMP; SELECT 42 number') do |result|
+      result.should be_an_instance_of PG::Result
+      result[0]['number'].should eq "42"
+    end
+  end
+
+  it "should timeout expire while executing query" do
+    @client.query_timeout.should eq 0
+    @client.query_timeout = 1.5
+    @client.query_timeout.should eq 1.5
+    start_time = Time.now
+    expect {
+      @client.query('SELECT pg_sleep(2)')
+    }.to raise_error(PG::Error, /query timeout expired/)
+    (Time.now - start_time).should be < 2
+    @client.query_timeout = 0
+    @client.query_timeout.should eq 0
+    @client.async_command_aborted.should be_true
+    @client.query('BEGIN TRANSACTION') do |result|
+      result.should be_an_instance_of PG::Result
+    end
+  end
+
+  it "should timeout not expire while executing query with partial results" do
+    @client.query_timeout.should eq 0
+    @client.query_timeout = 1.1
+    @client.query_timeout.should eq 1.1
+    start_time = Time.now
+    @client.query(
+        'SELECT * from pg_class;' +
+        'SELECT pg_sleep(1);' +
+        'SELECT * from pg_class;' + 
+        'SELECT pg_sleep(1);' +
+        'SELECT 42 number') do |result|
+      (Time.now - start_time).should be > 2
+      result.should be_an_instance_of PG::Result
+      result[0]['number'].should eq "42"
+      @client.query_timeout = 0
+      @client.query_timeout.should eq 0
+      @client.async_command_aborted.should be_false
+    end
+  end
+
+  it "should timeout expire while executing query with partial results" do
+    @client.query_timeout.should eq 0
+    @client.query_timeout = 1.1
+    @client.query_timeout.should eq 1.1
+    start_time = Time.now
+    expect {
+      @client.query(
+          'SELECT * from pg_class;' +
+          'SELECT pg_sleep(1);' +
+          'SELECT * from pg_class;' + 
+          'SELECT pg_sleep(2);' +
+          'SELECT 42 number')
+    }.to raise_error(PG::Error, /query timeout expired/)
+    (Time.now - start_time).should be > 2
+    @client.query_timeout = 0
+    @client.query_timeout.should eq 0
+    @client.query('BEGIN TRANSACTION') do |result|
+      result.should be_an_instance_of PG::Result
+    end
   end
 
   around(:each) do |testcase|
-    EM.synchrony &testcase
+    EM.synchrony do
+      begin
+        testcase.call
+      ensure
+        EM.stop
+      end
+    end
   end
 
   before(:all) do
     @cdates = []
     @values = Array(('AA'..'ZZ').each_with_index)
-    @client = PG::EM::Client.new(dbname: 'test')
+    @client = described_class.new
     @client.query 'BEGIN TRANSACTION'
   end
 

data/spec/em_synchrony_client_autoreconnect.rb

@@ -0,0 +1,118 @@
+$:.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 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
+    @client = PG::EM::Client.new
+    @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 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
+    @client = PG::EM::Client.new(on_autoreconnect: on_autoreconnect)
+    @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.reset
+    @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(async_autoreconnect: false)
+    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: em-pg-client
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 0.2.0.pre.2
+  version: 0.2.0.pre.3
 platform: ruby
 authors: 
 - Rafal Michalski
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-30 00:00:00 Z
+date: 2012-05-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: pg
@@ -85,9 +85,12 @@ files:
 - em-pg-client.gemspec
 - lib/em-synchrony/pg.rb
 - lib/pg/em.rb
+- spec/em_client_autoreconnect.rb
+- spec/em_client_common.rb
 - spec/em_devel_client.rb
 - spec/em_release_client.rb
 - spec/em_synchrony_client.rb
+- spec/em_synchrony_client_autoreconnect.rb
 homepage: http://github.com/royaltm/ruby-em-pg-client
 licenses: []
 
@@ -121,4 +124,7 @@ summary: EventMachine PostgreSQL client
 test_files: 
 - spec/em_synchrony_client.rb
 - spec/em_devel_client.rb
+- spec/em_client_common.rb
 - spec/em_release_client.rb
+- spec/em_synchrony_client_autoreconnect.rb
+- spec/em_client_autoreconnect.rb