em-pg-client 0.3.3 → 0.3.4

data/spec/em_client_common.rb

@@ -1,3 +1,6 @@
+NOTIFY_PAYLOAD = defined?(PG.library_version) && PG.library_version >= 90000
+NOTIFY_PAYLOAD_QUERY = NOTIFY_PAYLOAD ? %q[NOTIFY "ruby-em-pg-client", 'foo'] : %q[NOTIFY "ruby-em-pg-client"]
+
 module PGSpecMacros
   def self.included(base)
     base.extend(ClassMethods)
@@ -8,7 +11,7 @@ module PGSpecMacros
       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.should be_a_kind_of ::EM::Deferrable
   end
 
   def pg_exec_and_check_with_error(client, stop, err_class, err_message, method, *args, &additional_checks)
@@ -17,7 +20,7 @@ module PGSpecMacros
       exception.to_s.should include err_message if err_message
       additional_checks.call(exception) if additional_checks
       EM.next_tick { EM.stop } if stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   def ensure_em_stop
@@ -123,7 +126,7 @@ shared_context 'em-pg common after' do
             value.should eq [{'data' => data, 'id' => id.to_s}]
             result.clear
             iter.return value
-          end.should be_a_kind_of ::EM::DefaultDeferrable
+          end.should be_a_kind_of ::EM::Deferrable
         }, proc{ |results|
           results.length.should eq @values.length
           @client.get_result_defer do |result|
@@ -135,10 +138,10 @@ shared_context 'em-pg common after' do
             @client.get_result_defer do |result|
               result.should be_nil
               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::Deferrable
+          end.should be_a_kind_of ::EM::Deferrable
         })
-      end.should be_a_kind_of ::EM::DefaultDeferrable
+      end.should be_a_kind_of ::EM::Deferrable
     end
 
   end
@@ -197,7 +200,7 @@ shared_context 'em-pg common after' do
       pg_exec_and_check(conn, :query_defer, 'SELECT pg_database_size(current_database());') do |result|
         result[0]['pg_database_size'].to_i.should be > 0
       end
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
     this.should be :first
   end
 
@@ -210,7 +213,7 @@ shared_context 'em-pg common after' do
       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
+    end.should be_a_kind_of ::EM::Deferrable
     this.should be :first
   end
 
@@ -332,8 +335,8 @@ shared_context 'em-pg common after' do
           result.should be_nil
           EM.stop
         end
-      end.should be_a_kind_of ::EM::DefaultDeferrable
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+      end.should be_a_kind_of ::EM::Deferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should get each result asynchronously" do
@@ -348,15 +351,15 @@ shared_context 'em-pg common after' do
           result.getvalue(0,0).should eq value
           result.clear
           iter.return value
-        end.should be_a_kind_of ::EM::DefaultDeferrable
+        end.should be_a_kind_of ::EM::Deferrable
       }, proc{ |results|
         results.should eq %w[4 5 6]
         @client.get_result_defer do |result|
           result.should be_nil
           EM.stop
-        end.should be_a_kind_of ::EM::DefaultDeferrable
+        end.should be_a_kind_of ::EM::Deferrable
       })
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should raise connection reset on connection breakdown" do
@@ -399,4 +402,218 @@ shared_context 'em-pg common after' do
     end
   end
 
+  it "should receive notification while waiting for it" do
+    sender = described_class.new
+    sender_pid = nil
+    wait_over = false
+    @client.query_defer('LISTEN "ruby-em-pg-client"') do |result|
+      result.should be_an_instance_of PG::Result
+      @client.wait_for_notify_defer do |notification|
+        notification.should be_an_instance_of Hash
+        notification[:relname].should eq 'ruby-em-pg-client'
+        notification[:be_pid].should eq sender_pid
+        notification[:extra].should eq (NOTIFY_PAYLOAD ? 'foo' : '')
+        @client.query_defer('UNLISTEN *') do |result|
+          result.should be_an_instance_of PG::Result
+          EM.stop unless sender
+          wait_over = true
+        end
+      end.should be_a_kind_of ::EM::Deferrable
+      EM.next_tick do
+        sender.query_defer('SELECT pg_backend_pid()') do |result|
+          result.should be_an_instance_of PG::Result
+          sender_pid = result.getvalue(0,0).to_i
+          sender.query_defer(NOTIFY_PAYLOAD_QUERY) do |result|
+            result.should be_an_instance_of PG::Result
+            sender.finish
+            sender = nil
+            EM.stop if wait_over
+          end.should be_a_kind_of ::EM::Deferrable
+        end.should be_a_kind_of ::EM::Deferrable
+      end
+    end.should be_a_kind_of ::EM::Deferrable
+  end
+
+  it "should receive previously sent notification" do
+    @client.query_defer('LISTEN "ruby-em-pg-client"') do |result|
+      result.should be_an_instance_of PG::Result
+      @client.query_defer('SELECT pg_backend_pid()') do |result|
+        result.should be_an_instance_of PG::Result
+        sender_pid = result.getvalue(0,0).to_i
+        @client.query_defer(%q[NOTIFY "ruby-em-pg-client"]) do |result|
+          result.should be_an_instance_of PG::Result
+          @client.wait_for_notify_defer(1) do |notification|
+            notification.should be_an_instance_of Hash
+            notification[:relname].should eq 'ruby-em-pg-client'
+            notification[:be_pid].should eq sender_pid
+            notification[:extra].should eq ''
+            @client.query_defer('UNLISTEN *') do |result|
+              result.should be_an_instance_of PG::Result
+              EM.stop
+            end.should be_a_kind_of ::EM::Deferrable
+          end.should be_a_kind_of ::EM::Deferrable
+        end.should be_a_kind_of ::EM::Deferrable
+      end.should be_a_kind_of ::EM::Deferrable
+    end.should be_a_kind_of ::EM::Deferrable
+  end
+
+  it "should perform queries and receive own notification while waiting for it" do
+    sender_pid = nil
+    @client.query_defer('SELECT pg_backend_pid()') do |result|
+      sender_pid = result.getvalue(0,0).to_i
+      @client.query_defer('LISTEN "ruby-em-pg-client"') do |result|
+        result.should be_an_instance_of PG::Result
+        @client.query_defer(NOTIFY_PAYLOAD_QUERY) do |result|
+          result.should be_an_instance_of PG::Result
+        end.should be_a_kind_of ::EM::Deferrable
+      end.should be_a_kind_of ::EM::Deferrable
+    end.should be_a_kind_of ::EM::Deferrable
+    @client.wait_for_notify_defer do |notification|
+      notification.should be_an_instance_of Hash
+      notification[:relname].should eq 'ruby-em-pg-client'
+      notification[:be_pid].should eq sender_pid
+      notification[:extra].should eq (NOTIFY_PAYLOAD ? 'foo' : '')
+      @client.query_defer('UNLISTEN *') do |result|
+        result.should be_an_instance_of PG::Result
+        EM.stop
+      end.should be_a_kind_of ::EM::Deferrable
+    end.should be_a_kind_of ::EM::Deferrable
+  end
+
+  it "should reach timeout while waiting for notification" do
+    start_time = Time.now
+    async_flag = false
+    @client.wait_for_notify_defer(0.2) do |notification|
+      notification.should be_nil
+      (Time.now - start_time).should be >= 0.2
+      async_flag.should be_true
+      EM.stop
+    end.should be_a_kind_of ::EM::Deferrable
+    async_flag = true
+  end
+
+  it "should reach timeout while waiting for notification and executing query" do
+    start_time = Time.now
+    async_flag = false
+    @client.query_defer('SELECT pg_sleep(0.5)') do |result|
+      result.should be_an_instance_of PG::Result
+      (Time.now - start_time).should be >= 0.5
+      async_flag.should be_true
+      EM.stop
+    end
+    @client.wait_for_notify_defer(0.1) do |notification|
+      notification.should be_nil
+      (Time.now - start_time).should be_between(0.1, 0.5)
+      async_flag.should be_true
+    end.should be_a_kind_of ::EM::Deferrable
+    async_flag = true
+  end
+
+  it "should timeout expire while executing query and waiting for notification" do
+    @client.query_timeout.should eq 0
+    @client.query_timeout = 0.2
+    @client.query_timeout.should eq 0.2
+    visit_counter = 0
+    start_time = Time.now
+    pg_exec_and_check_with_error(@client, false,
+        PG::ConnectionBad, "query timeout expired (async)",
+        :wait_for_notify_defer) do
+      (Time.now - start_time).should be >= 0.2
+      (visit_counter+=1).should eq 2
+      @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.async_autoreconnect = false
+      pg_exec_and_check_with_error(@client, false,
+          PG::ConnectionBad, "previous query expired",
+          :wait_for_notify_defer) do
+        @client.reset_defer do |conn|
+          conn.should be @client
+          @client.async_autoreconnect = true
+          EM.stop
+        end
+      end
+    end
+    pg_exec_and_check_with_error(@client, false,
+        PG::ConnectionBad, "query timeout expired (async)",
+        :query_defer, 'SELECT pg_sleep(1)') do
+      (Time.now - start_time).should be_between(0.2, 1)
+      (visit_counter+=1).should eq 1
+    end
+  end
+
+  it "should fail wait_for_notify on connection reset" do
+    @client.status.should be PG::CONNECTION_OK
+    visit_counter = 0
+    pg_exec_and_check_with_error(@client, false,
+        PG::ConnectionBad, "connection reset",
+        :wait_for_notify_defer) do
+      pg_exec_and_check_with_error(@client, false,
+          PG::ConnectionBad, "connection reset",
+          :wait_for_notify_defer) do
+        (visit_counter+=1).should eq 2
+      end
+      @client.reset_defer do |conn|
+        conn.should be @client
+        (visit_counter+=1).should eq 3
+        EM.stop
+      end
+    end
+    @client.reset
+    (visit_counter+=1).should eq 1
+  end
+
+  it "should fail wait_for_notify and slow query on connection reset" do
+    @client.status.should be PG::CONNECTION_OK
+    visit_counter = 0
+    pg_exec_and_check_with_error(@client, false,
+        PG::ConnectionBad, "connection reset",
+        :query_defer, 'SELECT pg_sleep(10)') do
+      (visit_counter+=1).should eq 2
+    end
+    pg_exec_and_check_with_error(@client, false,
+        PG::ConnectionBad, "connection reset",
+        :wait_for_notify_defer) do
+      (visit_counter+=1).should eq 3
+      pg_exec_and_check_with_error(@client, false,
+          PG::ConnectionBad, "connection reset",
+          :wait_for_notify_defer) do
+        (visit_counter+=1).should eq 5
+      end
+      @client.reset_defer do |conn|
+        conn.should be @client
+        (visit_counter+=1).should eq 6
+        EM.stop
+      end
+    end
+    @client.reset
+    (visit_counter+=1).should eq 1
+    pg_exec_and_check_with_error(@client, false,
+        PG::ConnectionBad, "connection reset",
+        :query_defer, 'SELECT pg_sleep(10)') do
+      (visit_counter+=1).should eq 4
+    end
+  end
+
+  it "should fail wait_for_notify on another wait_for_notify" do
+    @client.status.should be PG::CONNECTION_OK
+    visit_counter = 0
+    @client.wait_for_notify_defer(0.5).errback do |ex|
+      ex.should be_nil
+      (visit_counter+=1).should eq 2
+    end.callback do
+      raise "This should never be called"
+    end.should be_a_kind_of ::EM::Deferrable
+    (visit_counter+=1).should eq 1
+    @client.wait_for_notify_defer(0.1).callback do |notification|
+      notification.should be_nil
+      (visit_counter+=1).should eq 4
+      EM.stop
+    end.errback do
+      raise "This should never be called"
+    end.should be_a_kind_of ::EM::Deferrable
+    (visit_counter+=1).should eq 3
+  end
+
 end

data/spec/em_client_on_connect.rb

@@ -52,11 +52,11 @@ shared_context 'test on_connect' do
             client.exec_prepared_defer(query_name) do |result|
               result.should be_an_instance_of PG::Result
               result[0]['pg_database_size'].to_i.should be > 0
-            end.should be_a_kind_of ::EM::DefaultDeferrable
-            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
+              EM.stop
+            end.should be_a_kind_of ::EM::Deferrable
+          end.should be_a_kind_of ::EM::Deferrable
+        end.should be_a_kind_of ::EM::Deferrable
+      end.should be_a_kind_of ::EM::Deferrable
     end
   end
 
@@ -81,9 +81,9 @@ shared_context 'test on_connect error' do
           client.reset_defer do |ex|
             ex.should be_an_instance_of on_connect_exception
             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.should be_a_kind_of ::EM::Deferrable
+        end.should be_a_kind_of ::EM::Deferrable
+      end.should be_a_kind_of ::EM::Deferrable
     end
   end
 
@@ -162,7 +162,7 @@ describe 'on_connect option' do
 
   describe 'with on_connect deferrable failure' do
     let(:on_connect) { proc {|client|
-      EM::DefaultDeferrable.new.tap {|df| df.fail on_connect_exception.new }
+      ::EM::DefaultDeferrable.new.tap {|df| df.fail on_connect_exception.new }
     } }
 
     include_context 'test on_connect error'

data/spec/em_connection_pool.rb

@@ -181,17 +181,19 @@ describe 'connection pool' do
     end
 
     it 'should lock transaction connection to fiber' do
+      over_count = 2
       @pool.transaction do |pg|
         @pool.hold {|c| c.should be pg }
         Fiber.new do
           @pool.size.should eq 1
           @pool.hold {|c| c.should_not be pg }
           @pool.size.should eq 2
-          EM.stop
+          EM.stop if (over_count-=1).zero?
         end.resume
         @pool.hold {|c| c.should be pg }
         @pool.size.should eq 2
       end
+      EM.stop if (over_count-=1).zero?
     end
 
   end

data/spec/em_synchrony_client.rb

@@ -5,6 +5,9 @@ require 'date'
 require 'em-synchrony'
 require 'pg/em'
 
+NOTIFY_PAYLOAD = defined?(PG.library_version) && PG.library_version >= 90000
+NOTIFY_PAYLOAD_QUERY = NOTIFY_PAYLOAD ? %q[NOTIFY "ruby-em-pg-client", 'foo'] : %q[NOTIFY "ruby-em-pg-client"]
+
 describe PG::EM::Client do
 
   it "should be client #{PG::VERSION}" do
@@ -135,7 +138,6 @@ describe PG::EM::Client do
       result.to_a.should eq []
       result.clear
       @client.get_result.should be_nil
-      EM.stop
     end
 
   end
@@ -293,6 +295,8 @@ describe PG::EM::Client do
     ::EM::Synchrony.sleep 1.5
     @client.async_command_aborted.should be_false
     @client.status.should be PG::CONNECTION_OK
+    @client.query_timeout = 0
+    @client.query_timeout.should eq 0
   end
 
   it "should get last result asynchronously" do
@@ -336,6 +340,192 @@ describe PG::EM::Client do
     asynchronous.should be true
   end
 
+  it "should receive notification while waiting for it" do
+    sender = described_class.new
+    notify_flag = false
+    result = sender.query('SELECT pg_backend_pid()')
+    result.should be_an_instance_of PG::Result
+    sender_pid = result.getvalue(0,0).to_i
+    @client.query('LISTEN "ruby-em-pg-client"').should be_an_instance_of PG::Result
+    f = nil
+    EM::Synchrony.next_tick do
+      begin
+        sender.query(NOTIFY_PAYLOAD_QUERY).should be_an_instance_of PG::Result
+        sender.finish
+      ensure
+        sender = nil
+        f.resume if f
+      end
+    end
+    @client.wait_for_notify do |name, pid, payload|
+      name.should eq 'ruby-em-pg-client'
+      pid.should eq sender_pid
+      payload.should eq (NOTIFY_PAYLOAD ? 'foo' : '')
+      @client.query('UNLISTEN *').should be_an_instance_of PG::Result
+      notify_flag = true
+    end.should eq 'ruby-em-pg-client'
+    notify_flag.should be_true
+    f = Fiber.current
+    Fiber.yield if sender
+  end
+
+  it "should receive previously sent notification" do
+    notify_flag = false
+    @client.query('LISTEN "ruby-em-pg-client"').should be_an_instance_of PG::Result
+    result = @client.query('SELECT pg_backend_pid()')
+    result.should be_an_instance_of PG::Result
+    sender_pid = result.getvalue(0,0).to_i
+    @client.query(%q[NOTIFY "ruby-em-pg-client"]).should be_an_instance_of PG::Result
+    @client.wait_for_notify(1) do |name, pid, payload|
+      name.should eq 'ruby-em-pg-client'
+      pid.should eq sender_pid
+      payload.should eq ''
+      @client.query('UNLISTEN *').should be_an_instance_of PG::Result
+      notify_flag = true
+    end.should eq 'ruby-em-pg-client'
+    notify_flag.should be_true
+  end
+
+  it "should perform queries and receive own notification while waiting for it" do
+    f = nil
+    sender_pid = nil
+    notify_flag = false
+    Fiber.new do
+      begin
+        @client.wait_for_notify do |name, pid, payload|
+          name.should eq 'ruby-em-pg-client'
+          pid.should eq sender_pid
+          payload.should eq (NOTIFY_PAYLOAD ? 'foo' : '')
+          notify_flag = true
+        end.should eq 'ruby-em-pg-client'
+        notify_flag.should be_true
+        @client.query('UNLISTEN *').should be_an_instance_of PG::Result
+      ensure
+        sender_pid = nil
+        f.resume if f
+      end
+    end.resume
+    result = @client.query('SELECT pg_backend_pid()')
+    result.should be_an_instance_of PG::Result
+    sender_pid = result.getvalue(0,0).to_i
+    @client.query('LISTEN "ruby-em-pg-client"').should be_an_instance_of PG::Result
+    @client.query(NOTIFY_PAYLOAD_QUERY).should be_an_instance_of PG::Result
+    f = Fiber.current
+    Fiber.yield if sender_pid
+  end
+
+  it "should reach timeout while waiting for notification" do
+    start_time = Time.now
+    async_flag = false
+    EM.next_tick do
+      async_flag = true
+    end
+    @client.wait_for_notify(0.2) do
+      raise "This block should not be called"
+    end.should be_nil
+    (Time.now - start_time).should be >= 0.2
+    async_flag.should be_true
+  end
+
+  it "should reach timeout while waiting for notification and executing query" do
+    start_time = Time.now
+    async_flag = false
+    EM.next_tick do
+      async_flag = true
+    end
+    f = Fiber.current
+    Fiber.new do
+      begin
+        @client.query('SELECT pg_sleep(0.5)').should be_an_instance_of PG::Result
+        (Time.now - start_time).should be >= 0.5
+        async_flag.should be_true
+      ensure
+        f.resume
+      end
+    end.resume
+    @client.wait_for_notify(0.1) do
+      raise "This block should not be called"
+    end.should be_nil
+    delta = Time.now - start_time
+    delta.should be >= 0.1
+    delta.should be < 0.5
+    async_flag.should be_true
+    Fiber.yield
+  end
+
+  it "should timeout expire while executing query and waiting for notification" do
+    @client.query_timeout.should eq 0
+    @client.query_timeout = 0.2
+    @client.query_timeout.should eq 0.2
+    f = Fiber.current
+    visit_counter = 0
+    start_time = Time.now
+    Fiber.new do
+      expect {
+        @client.wait_for_notify do
+          raise "This block should not be called"
+        end
+      }.to raise_error(PG::ConnectionBad, /query timeout expired/)
+      (Time.now - start_time).should be >= 0.2
+      (visit_counter+=1).should eq 2
+      @client.query_timeout = 0
+      @client.query_timeout.should eq 0
+      @client.async_command_aborted.should be_true
+      @client.status.should be PG::CONNECTION_BAD
+      @client.async_autoreconnect = false
+      expect {
+        @client.wait_for_notify do
+          raise "This block should not be called"
+        end
+      }.to raise_error(PG::ConnectionBad, /previous query expired/)
+      @client.async_autoreconnect = true
+      f.resume
+    end.resume
+    expect {
+      @client.query('SELECT pg_sleep(1)')
+    }.to raise_error(PG::ConnectionBad, /query timeout expired/)
+    (Time.now - start_time).should be_between(0.2, 1)
+    (visit_counter+=1).should eq 1
+    Fiber.yield
+    @client.reset
+  end
+
+  it "should fail wait_for_notify on connection reset" do
+    @client.status.should be PG::CONNECTION_OK
+    visit_counter = 0
+    Fiber.new do
+      expect {
+        @client.wait_for_notify do
+          raise "This block should not be called"
+        end
+      }.to raise_error(PG::ConnectionBad, /connection reset/)
+      (visit_counter+=1).should eq 1
+    end.resume
+    @client.reset
+    (visit_counter+=1).should eq 2
+  end
+
+  it "should fail wait_for_notify and slow query on connection reset" do
+    @client.status.should be PG::CONNECTION_OK
+    visit_counter = 0
+    Fiber.new do
+      expect {
+        @client.query('SELECT pg_sleep(10)')
+      }.to raise_error(PG::ConnectionBad, /connection reset/)
+      (visit_counter+=1).should eq 1
+    end.resume
+    Fiber.new do
+      expect {
+        @client.wait_for_notify do
+          raise "This block should not be called"
+        end
+      }.to raise_error(PG::ConnectionBad, /connection reset/)
+      (visit_counter+=1).should eq 2
+    end.resume
+    @client.reset
+    (visit_counter+=1).should eq 3
+  end
+
   describe 'PG::EM::Client#transaction' do
 
     before(:all) do