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

data/lib/pg/em.rb

@@ -1,4 +1,16 @@
-require 'pg'
+begin
+  require 'pg'
+rescue LoadError => error
+  raise 'Missing pg driver: gem install pg'
+end
+unless defined? EventMachine
+  begin
+    require 'eventmachine'
+  rescue LoadError => error
+    raise 'Missing EventMachine: gem install eventmachine'
+  end
+end
+
 module PG
 
   class Result
@@ -61,96 +73,108 @@ module PG
     # Licence:: MIT License
     #
     #
-    # PG::EM::Client is a wrapper for PG::Connection which (re)defines methods:
+    # PG::EM::Client is a wrapper for PG::Connection[http://deveiate.org/code/pg/PG/Connection.html]
+    # which (re)defines methods:
     #
     # - +async_exec+ (alias: +async_query+)
     # - +async_prepare+
     # - +async_exec_prepared+
+    # - +async_describe_prepared+
+    # - +async_describe_portal+
+    #
+    # which are suitable to run in EM event loop (they return +Deferrable+)
     #
     # and following:
     #
     # - +exec+ (alias: +query+)
-    # - +exec_prepared+
     # - +prepare+
+    # - +exec_prepared+
+    # - +describe_prepared+
+    # - +describe_portal+
     #
-    # which autodetects if EventMachine is running and uses appropriate
+    # autodetecting if EventMachine is running and using the appropriate
     # (async or sync) method version.
     #
     # Additionally to the above, there are asynchronous methods defined for
-    # establishing connection and reseting it:
+    # establishing connection and re-connecting:
     #
     # - +Client.async_connect+
     # - +async_reset+
     #
-    # They are async equivalents of +Client.connect+ (which is also aliased
-    # by PG::Connection as +new+, +open+, +setdb+, +setdblogin+) and +reset+.
+    # They are async equivalents of PG::Connection.connect (which is also
+    # aliased by PG::Connection as +new+, +open+, +setdb+, +setdblogin+) and
+    # +reset+.
     #
-    # Async methods might try to reset connection on connection error.
-    # You won't even notice that (except for warning message from PG).
-    # If you want to detect such event use +on_autoreconnect+ property.
+    # When #async_autoreconnect is +true+, async methods might try to
+    # re-connect after a connection error. You won't even notice that
+    # (except for warning message from PG).
+    # If you want to detect such event use #on_autoreconnect property.
     #
-    # To disable such behavior set:
-    #   client.async_autoreconnect = false
+    # To enable auto-reconnecting set:
+    #   client.async_autoreconnect = true
     #
     # or pass as new() hash argument:
-    #   PG::EM::Client.new database: 'bar', async_autoreconnect: false
+    #   ::new database: 'bar', async_autoreconnect: true
     #
-    # Otherwise nothing changes in PG::Connect API.
-    # See PG::Connect docs for arguments to above methods.
+    # Otherwise nothing changes in PG::Connection API.
+    # See PG::Connection[http://deveiate.org/code/pg/PG/Connection.html] docs
+    # for arguments to above methods.
     #
     # *Warning:*
     #
-    # +async_exec_prepared+ after +async_prepare+ should only be invoked on
-    # the *same* connection.
-    # If you are using connection pool, make sure to acquire single connection first.
+    # +describe_prepared+ and +exec_prepared+ after
+    # +prepare+ should only be invoked on the *same* connection.
+    # If you are using a connection pool, make sure to acquire single connection first.
     #
     class Client < PG::Connection
 
 
       # Connection timeout. Changing this property only affects
-      # +Client.async_connect+ and +async_reset+.
-      # However if passed as initialization option also affects blocking
-      # +Client.connect+ and +reset+.
+      # ::async_connect and #async_reset.
+      # However if passed as initialization option, it also affects blocking
+      # ::new and #reset.
       attr_accessor :connect_timeout
 
-      # (EXPERIMENTAL)
       # Aborts async command processing if waiting for response from server
       # exceedes +query_timeout+ seconds. This does not apply to
-      # +Client.async_connect+ and +async_reset+. For those two use
-      # +connect_timeout+ instead.
+      # ::async_connect and #async_reset. For them
+      # use +connect_timeout+ instead.
       #
       # To enable it set to seconds (> 0). To disable: set to 0.
       # You can also specify this as initialization option.
       attr_accessor :query_timeout
 
       # Enable/disable auto-reconnect feature (+true+/+false+).
-      # Default is +true+.
+      # Defaults to +false+. However it is implicitly set to +true+
+      # if #on_autoreconnect is specified as initialization option.
+      # Changing #on_autoreconnect with accessor method doesn't change
+      # #async_autoreconnect.
       attr_accessor :async_autoreconnect
 
       # +on_autoreconnect+ is a user defined Proc that is called after a connection
       # with the server has been re-established.
-      # It's invoked with +connection+ as first argument and original
-      # +exception+ that caused the reconnecting process as second argument.
+      # It's invoked with two arguments. First one is the +connection+.
+      # The second is the original +exception+ that caused the reconnecting process.
       #
-      # Certain rules should apply to on_autoreconnect proc:
+      # Certain rules should apply to #on_autoreconnect proc:
       #
-      # - If proc returns +false+ (explicitly, +nil+ is ignored)
-      #   the original +exception+ is passed to +Defferable#fail+ and the send
-      #   query command is not invoked at all.
-      # - If return value is an instance of exception it is passed to
-      #   +Defferable#fail+ and the send query command is not invoked at all.
-      # - If return value responds to +callback+ and +errback+ methods
-      #   (like +Deferrable+), the send query command will be bound to this
-      #   deferrable's success callback. Otherwise the send query command is
-      #   called immediately after on_autoreconnect proc is executed.
+      # - If proc returns +false+ (explicitly, +nil+ is ignored),
+      #   the original +exception+ is passed to Defferable's +errback+ and
+      #   the send query command is not invoked at all.
+      # - If return value is an instance of exception, it is passed to
+      #   Defferable's +errback+ and the send query command is not invoked at all.
+      # - If return value responds to +callback+ and +errback+ methods,
+      #   the send query command will be bound to value's success +callback+
+      #   and the original Defferable's +errback+ or value's +errback+.
       # - Other return values are ignored and the send query command is called
-      #   immediately after on_autoreconnect proc is executed.
+      #   immediately after #on_autoreconnect proc is executed.
       #
-      # You may pass this proc as +:on_autoreconnect+ option to PG::EM::Client.new.
+      # You may pass this proc as +:on_autoreconnect+ option to ::new.
       #
       # Example:
       #   pg.on_autoreconnect = proc do |conn, ex|
-      #     conn.prepare("birds_by_name", "select id, name from animals order by name where species=$1", ['birds'])
+      #     conn.prepare("species_by_name", 
+      #      "select id, name from animals where species=$1 order by name")
       #   end
       #
       attr_accessor :on_autoreconnect
@@ -171,13 +195,12 @@ module PG
             @timer = nil
           end
         end
-        
+
         def setup_timer(timeout, adjustment = 0)
           @timer = ::EM::Timer.new(timeout - adjustment) do
             if (last_interval = Time.now - @notify_timestamp) >= timeout
               detach
               @client.async_command_aborted = true
-              IO.for_fd(@client.socket).close # break connection now (hack)
               @deferrable.protect do
                 raise PG::Error, "query timeout expired (async)"
               end
@@ -190,17 +213,17 @@ module PG
         def notify_readable
           result = false
           @client.consume_input
-          until @client.is_busy && !self.error?
-            break if (single_result = @client.get_result).nil?
+          until @client.is_busy
+            if (single_result = @client.get_result).nil?
+              result = @last_result
+              Result.check_result(@client, result)
+              detach
+              @timer.cancel if @timer
+              break
+            end
             @last_result.clear if @last_result
             @last_result = single_result
           end
-          unless @client.is_busy
-            result = @last_result
-            Result.check_result(@client, result)
-            detach
-            @timer.cancel if @timer
-          end
         rescue Exception => e
           detach
           @timer.cancel if @timer
@@ -225,14 +248,22 @@ module PG
           @poll_method = :"#{poll_method}_poll"
           if (timeout = client.connect_timeout) > 0
             @timer = ::EM::Timer.new(timeout) do
-              detach
-              @deferrable.protect do
-                raise PG::Error, "timeout expired (async)"
+              begin
+                detach
+                @deferrable.protect do
+                  raise PG::Error, "timeout expired (async)"
+                end
+              ensure
+                @client.finish unless reconnecting?
               end
             end
           end
         end
 
+        def reconnecting?
+          @poll_method == :reset_poll
+        end
+
         def notify_writable
           poll_connection_and_check
         end
@@ -254,7 +285,19 @@ module PG
             detach
             success = @deferrable.protect_and_succeed do
               unless @client.status == PG::CONNECTION_OK
-                raise PG::Error, @client.error_message
+                begin
+                  raise PG::Error, @client.error_message
+                ensure
+                  @client.finish unless reconnecting?
+                end
+              end
+              # mimic blocking connect behavior
+              unless Encoding.default_internal.nil? || reconnecting?
+                begin
+                  @client.internal_encoding = Encoding.default_internal
+                rescue EncodingError
+                  warn "warning: Failed to set the default_internal encoding to #{Encoding.default_internal}: '#{@client.error_message}'"
+                end
               end
               @client
             end
@@ -264,7 +307,7 @@ module PG
 
       def self.parse_async_args(*args)
         async_args = {
-          :@async_autoreconnect => true,
+          :@async_autoreconnect => nil,
           :@connect_timeout => 0,
           :@query_timeout => 0,
           :@on_autoreconnect => nil,
@@ -279,7 +322,10 @@ module PG
             when 'on_reconnect'
               raise ArgumentError.new("on_reconnect is no longer supported, use on_autoreconnect")
             when 'on_autoreconnect'
-              async_args[:@on_autoreconnect] = value if value.respond_to? :call
+              if value.respond_to? :call
+                async_args[:@on_autoreconnect] = value
+                async_args[:@async_autoreconnect] = true if async_args[:@async_autoreconnect].nil?
+              end
               true
             when 'connect_timeout'
               async_args[:@connect_timeout] = value.to_f
@@ -290,16 +336,21 @@ module PG
             end
           end
         end
+        async_args[:@async_autoreconnect] = false if async_args[:@async_autoreconnect].nil?
         async_args
       end
 
-      # Attempt connection asynchronously.
-      # Pass the same arguments as to +Client.new+.
+      # Attempts to establish the connection asynchronously.
+      # For args see PG::Connection.new[http://deveiate.org/code/pg/PG/Connection.html#method-c-new].
+      # Returns +Deferrable+. Use its +callback+ to obtain newly created and
+      # already connected PG::EM::Client object.
+      # If block is provided, it's bound to +callback+ and +errback+ of returned
+      # +Deferrable+.
       #
-      # Returns +deferrable+. Use it's +callback+ to obtain newly created and
-      # already connected +Client+ object.
-      # If block is provided it's bound to +callback+ and +errback+ of returned
-      # +deferrable+.
+      # Special PG::EM::Client options (e.g.: +async_autoreconnect+) must be provided
+      # as +connection_hash+ argument variant. They will be ignored in +connection_string+.
+      # 
+      # +client_encoding+ *will* be set for you according to Encoding.default_internal.
       def self.async_connect(*args, &blk)
         df = PG::EM::FeaturedDeferrable.new(&blk)
         async_args = parse_async_args(*args)
@@ -311,12 +362,12 @@ module PG
         df
       end
 
-      # Attempt connection reset asynchronously.
-      # There are no arguments.
+      # Attempts to reset the connection asynchronously.
+      # There are no arguments, except block argument.
       #
-      # Returns +deferrable+. Use it's +callback+ to handle success.
-      # If block is provided it's bound to +callback+ and +errback+ of returned
-      # +deferrable+.
+      # Returns +Deferrable+. Use it's +callback+ to handle success.
+      # If block is provided, it's bound to +callback+ and +errback+ of returned
+      # +Deferrable+.
       def async_reset(&blk)
         @async_command_aborted = false
         df = PG::EM::FeaturedDeferrable.new(&blk)
@@ -327,11 +378,28 @@ module PG
         df
       end
 
+      # Uncheck #async_command_aborted on blocking reset.
+      def reset
+        @async_command_aborted = false
+        super
+      end
+
+      # Creates new instance of PG::EM::Client and attempts to establish connection.
+      # See PG::Connection.new[http://deveiate.org/code/pg/PG/Connection.html#method-c-new].
+      #
+      # Special PG::EM::Client options (e.g.: +async_autoreconnect+) must be provided
+      # as +connection_hash+ argument variant. They will be ignored in +connection_string+.
+      # 
+      # +em-synchrony+ version *will* do set +client_encoding+ for you according to
+      # Encoding.default_internal.
       def initialize(*args)
         Client.parse_async_args(*args).each {|k, v| self.instance_variable_set(k, v) }
         super(*args)
       end
 
+      # Return +CONNECTION_BAD+ for connections with +async_command_aborted+
+      # flag set by expired query timeout. Otherwise return whatever
+      # PG::Connection#status[http://deveiate.org/code/pg/PG/Connection.html#method-i-status] provides.
       def status
         if @async_command_aborted
           PG::CONNECTION_BAD
@@ -368,9 +436,11 @@ module PG
       end
 
       %w(
-        exec          send_query
-        prepare       send_prepare
-        exec_prepared send_query_prepared
+        exec              send_query
+        prepare           send_prepare
+        exec_prepared     send_query_prepared
+        describe_prepared send_describe_prepared
+        describe_portal   send_describe_portal
           ).each_slice(2) do |name, send_name|
 
         class_eval <<-EOD

data/spec/em_client_autoreconnect.rb

@@ -50,7 +50,7 @@ describe 'em-pg default autoreconnect' do
         EM.stop
       end.should be_a_kind_of ::EM::DefaultDeferrable
     end
-    @client = PG::EM::Client.new
+    @client = PG::EM::Client.new(async_autoreconnect: true)
     @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
   end
 end
@@ -104,8 +104,10 @@ describe 'em-pg with autoreconnect disabled' do
   end
 
   it "should get database size using query after async manual connection reset" do
+    @client.status.should be PG::CONNECTION_BAD
     @client.async_reset do |conn|
       conn.should be @client
+      @client.status.should be PG::CONNECTION_OK
       @tested_proc.call
     end.should be_a_kind_of ::EM::DefaultDeferrable
   end
@@ -118,7 +120,7 @@ describe 'em-pg with autoreconnect disabled' do
         EM.stop
       end.should be_a_kind_of ::EM::DefaultDeferrable
     end
-    @client = PG::EM::Client.new(async_autoreconnect: false)
+    @client = PG::EM::Client.new
     @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
   end
 end

data/spec/em_client_common.rb

@@ -1,89 +1,216 @@
+module PGSpecMacros
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def pg_exec_and_check(client, method, *args, &additional_checks)
+    client.__send__(method, *args) do |result|
+      result.should be_an_instance_of PG::Result
+      additional_checks.call(result) if additional_checks
+      EM.stop
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  def pg_exec_and_check_with_error(client, err_message, method, *args, &additional_checks)
+    client.__send__(method, *args) do |exception|
+      exception.should be_an_instance_of PG::Error
+      exception.to_s.should include err_message if err_message
+      additional_checks.call(exception) if additional_checks
+      EM.stop
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  def ensure_em_stop
+    yield
+    EM.stop
+  end
+
+  module ClassMethods
+    def it_should_execute(text, method, *args)
+      it "should #{text}" do
+        pg_exec_and_check(@client, method, *args)
+      end
+    end
+
+    def it_should_execute_with_error(text, err_message, method, *args)
+      it "should #{text}" do
+        pg_exec_and_check_with_error(@client, err_message, method, *args)
+      end
+    end
+
+    def it_should_rollback
+      it_should_execute("rollback transaction", :query, 'ROLLBACK')
+    end
+
+    def it_should_begin
+      it_should_execute("begin transaction", :query, 'BEGIN TRANSACTION')
+    end
+  end
+end
+
 shared_context 'em-pg common before' do
 
   around(:each) do |testcase|
-    EM.run &testcase
+    EM.run do
+      EM.stop if testcase.call.is_a? Exception
+    end
   end
 
   before(:all) do
     @cdates = []
     @values = Array(('AA'..'ZZ').each_with_index)
+    ENV['PGCLIENTENCODING'] = nil
+    Encoding.default_internal = nil
     @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
+    ensure_em_stop do
+      @client.should be_an_instance_of described_class
+    end
   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
+  it "should have disabled async_autoreconnect" do
+    ensure_em_stop do
+      @client.async_autoreconnect.should be_false
+    end
+  end
+  
+  it "should enable async_autoreconnect" do
+    ensure_em_stop do
+      @client.async_autoreconnect = true
+      @client.async_autoreconnect.should be_true
+    end
   end
 
+  it "should set async_autoreconnect according to on_autoreconnect" do
+    ensure_em_stop do
+      on_autoreconnect = proc {|c, e| false }
+      async_args = described_class.parse_async_args
+      async_args.should be_an_instance_of Hash
+      async_args[:@on_autoreconnect].should be_nil
+      async_args[:@async_autoreconnect].should be_false
+      async_args = described_class.parse_async_args(on_autoreconnect: on_autoreconnect)
+      async_args.should be_an_instance_of Hash
+      async_args[:@on_autoreconnect].should be on_autoreconnect
+      async_args[:@async_autoreconnect].should be_true
+      async_args = described_class.parse_async_args(async_autoreconnect: false,
+        on_autoreconnect: on_autoreconnect)
+      async_args.should be_an_instance_of Hash
+      async_args[:@on_autoreconnect].should be on_autoreconnect
+      async_args[:@async_autoreconnect].should be_false
+      async_args = described_class.parse_async_args(on_autoreconnect: on_autoreconnect,
+        async_autoreconnect: false)
+      async_args.should be_an_instance_of Hash
+      async_args[:@on_autoreconnect].should be on_autoreconnect
+      async_args[:@async_autoreconnect].should be_false
+    end
+  end
+
+  it "should have same internal and external encoding" do
+    ensure_em_stop do
+      @client.external_encoding.should be @client.internal_encoding
+    end
+  end
+
+  it_should_begin
+
+  it_should_execute("drop table `foo` if exists",
+      :query, 'DROP TABLE IF EXISTS foo')
+
+  it_should_execute("create simple table `foo`",
+      :query, 'CREATE TABLE foo (id integer,cdate timestamp with time zone,data varchar)')
+
 end
 
 shared_context 'em-pg common after' do
 
+  it_should_execute("create prepared statement",
+      :prepare, 'get_foo', 'SELECT * FROM foo order by id')
+
+  it "should describe prepared statement" do
+    pg_exec_and_check(@client, :describe_prepared, 'get_foo') do |result|
+      result.nfields.should eq 3
+      result.fname(0).should eq 'id'      
+      result.values.should be_empty
+    end
+  end
+
   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
+    pg_exec_and_check(@client, :exec_prepared, 'get_foo') do |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
+  end
+
+  it_should_execute("declare cursor",
+    :query, 'DECLARE foobar SCROLL CURSOR FOR SELECT * FROM foo')
+
+  it "should fetch two rows from table" do
+    pg_exec_and_check(@client, :query, 'FETCH FORWARD 2 FROM foobar') do |result|
+      result.nfields.should eq 3
+      result.fname(0).should eq 'id'      
+      result.values.length.should eq 2
+    end
   end
+  
+  it "should describe cursor with describe_portal" do
+    pg_exec_and_check(@client, :describe_portal, 'foobar') do |result|
+      result.nfields.should eq 3
+      result.fname(0).should eq 'id'
+    end
+  end
+
+  it_should_execute("close cursor", :query, 'CLOSE foobar')
 
   it "should connect to database asynchronously" do
     this = :first
+    Encoding.default_internal = Encoding::ISO_8859_1
     described_class.async_connect do |conn|
       this = :second
+      Encoding.default_internal = nil
       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
+      conn.external_encoding.should_not eq(conn.internal_encoding)
+      conn.internal_encoding.should be Encoding::ISO_8859_1
+      conn.get_client_encoding.should eq "LATIN1"
+      pg_exec_and_check(conn, :query, 'SELECT pg_database_size(current_database());') do |result|
         result[0]['pg_database_size'].to_i.should be > 0
-        EM.stop
-      end.should be_a_kind_of ::EM::DefaultDeferrable
+      end
     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
+  it "should connect without setting incompatible encoding" do
+    this = :first
+    Encoding.default_internal = Encoding::Emacs_Mule
+    described_class.async_connect do |conn|
+      this = :second
+      Encoding.default_internal = nil
+      conn.should be_an_instance_of described_class
+      conn.external_encoding.should be conn.internal_encoding
+      EM.stop
     end.should be_a_kind_of ::EM::DefaultDeferrable
+    this.should be :first
   end
 
+  it_should_execute_with_error("raise syntax error in misspelled multiple statement",
+      "syntax error",
+      :query, 'SELECT * from pg_class; SRELECT CURRENT_TIMESTAMP; SELECT 42 number')
+
+  it_should_rollback
+
   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
+    pg_exec_and_check(@client, :query,
+      'SELECT * from pg_class; SELECT CURRENT_TIMESTAMP; SELECT 42 number') do |result|
       result[0]['number'].should eq "42"
-      EM.stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end
   end
 
   it "should timeout expire while executing query" do
@@ -91,18 +218,13 @@ shared_context 'em-pg common after' do
     @client.query_timeout = 1.5
     @client.query_timeout.should eq 1.5
     start_time = Time.now
-    @client.query('SELECT pg_sleep(2)') do |result|
+    pg_exec_and_check_with_error(@client, "query timeout expired", :query, 'SELECT pg_sleep(2)') do
       (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.status.should be PG::CONNECTION_BAD
       @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
 
   it "should timeout not expire while executing query with partial results" do
@@ -110,20 +232,19 @@ shared_context 'em-pg common after' do
     @client.query_timeout = 1.1
     @client.query_timeout.should eq 1.1
     start_time = Time.now
-    @client.query(
+    pg_exec_and_check(@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
+      @client.status.should be PG::CONNECTION_OK
+    end
   end
 
   it "should timeout expire while executing query with partial results" do
@@ -131,22 +252,27 @@ shared_context 'em-pg common after' do
     @client.query_timeout = 1.1
     @client.query_timeout.should eq 1.1
     start_time = Time.now
-    @client.query(
+    pg_exec_and_check_with_error(@client, "query timeout expired", :query,
         'SELECT * from pg_class;' +
         'SELECT pg_sleep(1);' +
         'SELECT * from pg_class;' + 
         'SELECT pg_sleep(2);' +
-        'SELECT 42 number') do |result|
+        'SELECT 42 number') do
       (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.status.should be PG::CONNECTION_BAD
       @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
 
+  it "should clear connection with blocking reset" do
+    ensure_em_stop do
+      @client.async_command_aborted.should be_true
+      @client.status.should be PG::CONNECTION_BAD
+      @client.reset
+      @client.async_command_aborted.should be_false
+      @client.status.should be PG::CONNECTION_OK
+    end
+  end
 end