em-pg-client 0.3.3 → 0.3.4

data/spec/em_client.rb

@@ -19,7 +19,7 @@ describe PG::EM::Client do
                                            [id, DateTime.now, data]) do |result|
       result.should be_an_instance_of PG::Result
         iter.return(DateTime.parse(result[0]['cdate']))
-      end.should be_a_kind_of ::EM::DefaultDeferrable
+      end.should be_a_kind_of ::EM::Deferrable
     }, proc{ |results|
       @cdates.replace results
       results.length.should == @values.length

data/spec/em_client_autoreconnect.rb

@@ -12,7 +12,9 @@ DISCONNECTED_ERROR = ENV['PGHOST'].include?('/') ? PG::UnableToSend : PG::Connec
 
 shared_context 'pg-em common' do
   around(:each) do |testcase|
-    EM.run(&testcase)
+    EM.run do
+      EM.stop if testcase.call.is_a? Exception
+    end
   end
 
   after(:all) do
@@ -71,7 +73,7 @@ describe 'pg-em default autoreconnect' do
     @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
       ex.should be_an_instance_of DISCONNECTED_ERROR
       EM.stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should get database size using query after server startup" do
@@ -85,7 +87,7 @@ describe 'pg-em default autoreconnect' do
     @client.query_defer('SELLECT 1') do |ex|
       ex.should be_an_instance_of PG::SyntaxError
       EM.stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should fail when in transaction after server restart" do
@@ -96,12 +98,12 @@ describe 'pg-em default autoreconnect' do
       @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
         ex.should be_an_instance_of DISCONNECTED_ERROR
         @tested_proc.call
-      end.should be_a_kind_of ::EM::DefaultDeferrable
+      end.should be_a_kind_of ::EM::Deferrable
     end
   end
 
   it "should fail to get last result asynchronously after server restart" do
-    @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+    @client.send_query('SELECT pg_sleep(50); SELECT pg_database_size(current_database());')
     system($pgserver_cmd_stop).should be_true
     system($pgserver_cmd_start).should be_true
     @client.get_last_result_defer do |ex|
@@ -111,11 +113,11 @@ describe 'pg-em default autoreconnect' do
         result.should be_nil
         EM.stop
       end
-    end.should be_a_kind_of EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should fail to get each result asynchronously after server restart" do
-    @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+    @client.send_query('SELECT pg_sleep(50); SELECT pg_database_size(current_database());')
     system($pgserver_cmd_stop).should be_true
     system($pgserver_cmd_start).should be_true
     @client.get_result_defer do |result|
@@ -130,18 +132,75 @@ describe 'pg-em default autoreconnect' 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
   end
 
+  it "should fail wait_for_notify while server restarts" do
+    @client.status.should be PG::CONNECTION_OK
+    @client.wait_for_notify_defer do |ex|
+      ex.should be_an_instance_of PG::ConnectionBad
+      @client.status.should be PG::CONNECTION_OK
+      @client.wait_for_notify_defer do |notification|
+        notification.should be_an_instance_of Hash
+        notification[:relname].should eq 'em_client_autoreconnect'
+        @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
+      @client.query_defer('LISTEN em_client_autoreconnect') do |result|
+        result.should be_an_instance_of PG::Result
+        @client.query_defer('NOTIFY em_client_autoreconnect') 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
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+  end
+
+  it "should fail wait_for_notify and finish slow query while server restarts" do
+    @client.status.should be PG::CONNECTION_OK
+    start_time = Time.now
+    query_flag = false
+    @client.query_defer('SELECT pg_sleep(2); SELECT 42') do |result|
+      result.should be_an_instance_of PG::Result
+      result.getvalue(0,0).to_i.should eq 42
+      (Time.now - start_time).should be > 2
+      query_flag = true
+    end.should be_a_kind_of ::EM::Deferrable
+    @client.wait_for_notify_defer do |ex|
+      query_flag.should be_true
+      ex.should be_an_instance_of PG::ConnectionBad
+      @client.status.should be PG::CONNECTION_OK
+      @client.wait_for_notify_defer do |notification|
+        notification.should be_an_instance_of Hash
+        notification[:relname].should eq 'em_client_autoreconnect'
+        @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
+      @client.query_defer('LISTEN em_client_autoreconnect') do |result|
+        result.should be_an_instance_of PG::Result
+        @client.query_defer('NOTIFY em_client_autoreconnect') 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
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+  end
+
   before(:all) do
     @tested_proc = proc do
       @client.query_defer('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::Deferrable
     end
     @options = {async_autoreconnect: true}
     @client = PG::EM::Client.new(@options)
@@ -176,7 +235,7 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
     @client.query_defer('SELLECT 1') do |ex|
       ex.should be_an_instance_of PG::SyntaxError
       EM.stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should fail when in transaction after server restart" do
@@ -187,7 +246,7 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
       @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
         ex.should be_an_instance_of DISCONNECTED_ERROR
         @tested_proc.call
-      end.should be_a_kind_of ::EM::DefaultDeferrable
+      end.should be_a_kind_of ::EM::Deferrable
     end
   end
 
@@ -198,7 +257,7 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
     @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
       ex.should be_an_instance_of DISCONNECTED_ERROR
       EM.stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should complete on true from on_autoreconnect after server restart" do
@@ -209,7 +268,7 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
       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::Deferrable
   end
 
   it "should fail on query with true from on_autoreconnect after restart" do
@@ -219,7 +278,7 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
     @client.query_defer('SELLECT 1') do |ex|
       ex.should be_an_instance_of PG::SyntaxError
       EM.stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should fail on on_autoreconnect deferrable fail after server restart" do
@@ -231,7 +290,7 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
     @client.query_defer('SELECT 1') do |ex|
       ex.should be :boo
       EM.stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should fail on raised error in on_autoreconnect after server restart" do
@@ -243,12 +302,12 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
     @client.query_defer('SELECT 1') do |ex|
       ex.should be_an_instance_of TypeError
       EM.stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should fail to get last result asynchronously after server restart" do
     @client.on_autoreconnect = proc { true }
-    @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+    @client.send_query('SELECT pg_sleep(50); SELECT pg_database_size(current_database());')
     system($pgserver_cmd_stop).should be_true
     system($pgserver_cmd_start).should be_true
     @client.get_last_result_defer do |ex|
@@ -258,14 +317,14 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
         result.should be_nil
         EM.stop
       end
-    end.should be_a_kind_of EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should fail to get each result asynchronously after server restart" do
     @client.on_autoreconnect = proc {
-      EM::DefaultDeferrable.new.tap {|df| df.succeed }
+      ::EM::DefaultDeferrable.new.tap {|df| df.succeed }
     }
-    @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+    @client.send_query('SELECT pg_sleep(50); SELECT pg_database_size(current_database());')
     system($pgserver_cmd_stop).should be_true
     system($pgserver_cmd_start).should be_true
     @client.get_result_defer do |result|
@@ -280,11 +339,70 @@ describe 'pg-em autoreconnect with on_autoreconnect' 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
   end
 
+  it "should fail wait_for_notify while server restarts" do
+    @client.status.should be PG::CONNECTION_OK
+    @client.on_autoreconnect(&@on_autoreconnect)
+    @client.wait_for_notify_defer do |ex|
+      ex.should be_an_instance_of PG::ConnectionBad
+      @client.status.should be PG::CONNECTION_OK
+      @client.wait_for_notify_defer do |notification|
+        notification.should be_an_instance_of Hash
+        notification[:relname].should eq 'em_client_autoreconnect'
+        @client.query_defer('UNLISTEN *') do |result|
+          result.should be_an_instance_of PG::Result
+          @tested_proc.call
+        end.should be_a_kind_of ::EM::Deferrable
+      end.should be_a_kind_of ::EM::Deferrable
+      @client.query_defer('LISTEN em_client_autoreconnect') do |result|
+        result.should be_an_instance_of PG::Result
+        @client.query_defer('NOTIFY em_client_autoreconnect') 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
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+  end
+
+  it "should fail wait_for_notify and finish slow query while server restarts" do
+    @client.status.should be PG::CONNECTION_OK
+    @client.on_autoreconnect = @on_autoreconnect
+    start_time = Time.now
+    query_flag = false
+    @client.query_defer('SELECT pg_sleep(2); SELECT 42') do |result|
+      result.should be_an_instance_of PG::Result
+      result.getvalue(0,0).to_i.should eq 42
+      (Time.now - start_time).should be > 2
+      query_flag = true
+    end.should be_a_kind_of ::EM::Deferrable
+    @client.wait_for_notify_defer do |ex|
+      query_flag.should be_true
+      ex.should be_an_instance_of PG::ConnectionBad
+      @client.status.should be PG::CONNECTION_OK
+      @client.wait_for_notify_defer do |notification|
+        notification.should be_an_instance_of Hash
+        notification[:relname].should eq 'em_client_autoreconnect'
+        @client.query_defer('UNLISTEN *') do |result|
+          result.should be_an_instance_of PG::Result
+          @tested_proc.call
+        end.should be_a_kind_of ::EM::Deferrable
+      end.should be_a_kind_of ::EM::Deferrable
+      @client.query_defer('LISTEN em_client_autoreconnect') do |result|
+        result.should be_an_instance_of PG::Result
+        @client.query_defer('NOTIFY em_client_autoreconnect') 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
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+  end
+
   it "should execute on_connect before on_autoreconnect after server restart" do
     @client.on_connect.should be_nil
     run_on_connect = false
@@ -327,7 +445,7 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
       run_on_connect.should be_true
       run_on_autoreconnect.should be_false
       EM.stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   before(:all) do
@@ -336,11 +454,11 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
         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::Deferrable
     end
     @on_autoreconnect = proc do |client, ex|
       df = client.prepare_defer('get_db_size', 'SELECT pg_database_size(current_database());')
-      df.should be_a_kind_of ::EM::DefaultDeferrable
+      df.should be_a_kind_of ::EM::Deferrable
       df
     end
     @options = {on_autoreconnect: @on_autoreconnect}
@@ -364,7 +482,7 @@ describe 'pg-em with autoreconnect disabled' do
       ex.should be_an_instance_of DISCONNECTED_ERROR
       @client.status.should be PG::CONNECTION_BAD
       EM.stop
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should get database size using query after async manual connection reset" do
@@ -373,10 +491,11 @@ describe 'pg-em with autoreconnect disabled' do
       conn.should be @client
       @client.status.should be PG::CONNECTION_OK
       @tested_proc.call
-    end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::Deferrable
   end
 
   it "should fail to get last result asynchronously after server restart" do
+    @client.status.should be PG::CONNECTION_OK
     check_get_last_result = proc do
       @client.get_last_result_defer do |result|
         result.should be_nil
@@ -384,30 +503,31 @@ describe 'pg-em with autoreconnect disabled' do
           conn.should be @client
           @client.status.should be PG::CONNECTION_OK
           EM.stop
-        end.should be_a_kind_of ::EM::DefaultDeferrable
+        end.should be_a_kind_of ::EM::Deferrable
       end
     end
     system($pgserver_cmd_stop).should be_true
     system($pgserver_cmd_start).should be_true
     begin
-      @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+      @client.send_query('SELECT pg_sleep(50); SELECT pg_database_size(current_database());')
     rescue PG::UnableToSend
       @client.status.should be PG::CONNECTION_BAD
       @client.get_last_result_defer do |ex|
         ex.should be_nil
         @client.status.should be PG::CONNECTION_BAD
         check_get_last_result.call
-      end.should be_a_kind_of EM::DefaultDeferrable
+      end.should be_a_kind_of ::EM::Deferrable
     else
       @client.get_last_result_defer do |ex|
         ex.should be_an_instance_of PG::ConnectionBad
         @client.status.should be PG::CONNECTION_BAD
         check_get_last_result.call
-      end.should be_a_kind_of EM::DefaultDeferrable
+      end.should be_a_kind_of ::EM::Deferrable
     end
   end
 
   it "should fail to get each result asynchronously after server restart" do
+    @client.status.should be PG::CONNECTION_OK
     check_get_result = proc do |expected_class|
       @client.get_result_defer do |result|
         result.should be_an_instance_of expected_class
@@ -416,13 +536,13 @@ describe 'pg-em with autoreconnect disabled' do
           conn.should be @client
           @client.status.should be PG::CONNECTION_OK
           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
     system($pgserver_cmd_stop).should be_true
     system($pgserver_cmd_start).should be_true
     begin
-      @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+      @client.send_query('SELECT pg_sleep(50); SELECT pg_database_size(current_database());')
     rescue PG::UnableToSend
       @client.get_result_defer do |result|
         result.should be_nil
@@ -441,13 +561,110 @@ describe 'pg-em with autoreconnect disabled' do
     end
   end
 
+  it "should fail wait_for_notify while server restarts" do
+    @client.status.should be PG::CONNECTION_OK
+    @client.on_autoreconnect(&@on_autoreconnect)
+    @client.wait_for_notify_defer do |ex|
+      ex.should be_an_instance_of PG::ConnectionBad
+      @client.status.should be PG::CONNECTION_BAD
+      @client.wait_for_notify_defer do |ex|
+        ex.should be_an_instance_of PG::ConnectionBad
+        @client.status.should be PG::CONNECTION_BAD
+        @client.reset_defer do |conn|
+          conn.should be @client
+          @client.status.should be PG::CONNECTION_OK
+          @client.wait_for_notify_defer do |notification|
+            notification.should be_an_instance_of Hash
+            notification[:relname].should eq 'em_client_autoreconnect'
+            @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
+          @client.query_defer('LISTEN em_client_autoreconnect') do |result|
+            result.should be_an_instance_of PG::Result
+            @client.query_defer('NOTIFY em_client_autoreconnect') 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
+      end.should be_a_kind_of ::EM::Deferrable
+    end.should be_a_kind_of ::EM::Deferrable
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+  end
+
+  it "should fail both wait_for_notify and slow query while server restarts" do
+    @client.status.should be PG::CONNECTION_OK
+    @client.on_autoreconnect = @on_autoreconnect
+    query_flag = false
+    @client.query_defer('SELECT pg_sleep(2); SELECT 42') do |ex|
+      ex.should be_an_instance_of PG::ConnectionBad
+      query_flag = true
+    end.should be_a_kind_of ::EM::Deferrable
+    @client.wait_for_notify_defer do |ex|
+      query_flag.should be_true
+      ex.should be_an_instance_of PG::ConnectionBad
+      @client.status.should be PG::CONNECTION_BAD
+      @client.wait_for_notify_defer do |ex|
+        ex.should be_an_instance_of PG::ConnectionBad
+        @client.status.should be PG::CONNECTION_BAD
+        @client.query_defer('SELECT 1') do |ex|
+          ex.should be_an_instance_of PG::UnableToSend
+          @client.reset_defer do |conn|
+            conn.should be @client
+            @client.status.should be PG::CONNECTION_OK
+            @client.wait_for_notify_defer do |notification|
+              notification.should be_an_instance_of Hash
+              notification[:relname].should eq 'em_client_autoreconnect'
+              @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
+            @client.query_defer('LISTEN em_client_autoreconnect') do |result|
+              result.should be_an_instance_of PG::Result
+              @client.query_defer('NOTIFY em_client_autoreconnect') 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
+        end.should be_a_kind_of ::EM::Deferrable
+      end.should be_a_kind_of ::EM::Deferrable
+    end.should be_a_kind_of ::EM::Deferrable
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+  end
+
+  it "should fail wait_for_notify when server was shutdown" do
+    @client.status.should be PG::CONNECTION_OK
+    @client.wait_for_notify_defer(0.1) do |notification|
+      notification.should be_nil
+      system($pgserver_cmd_stop).should be_true
+      @client.wait_for_notify_defer do |ex|
+        ex.should be_an_instance_of PG::ConnectionBad
+        @client.status.should be PG::CONNECTION_BAD
+        @client.wait_for_notify_defer do |ex|
+          ex.should be_an_instance_of PG::ConnectionBad
+          system($pgserver_cmd_start).should be_true
+          @client.status.should be PG::CONNECTION_BAD
+          @client.reset_defer do |client|
+            client.should be @client
+            @client.status.should be PG::CONNECTION_OK
+            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
+
   before(:all) do
     @tested_proc = proc do
       @client.query_defer('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::Deferrable
     end
     @client = PG::EM::Client.new
     @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}