em-pg-client 0.2.1 → 0.3.0

data/lib/pg/em/featured_deferrable.rb

@@ -0,0 +1,43 @@
+module PG
+  module EM
+
+    # Deferrable with error protectors
+    #
+    # Author:: Rafal Michalski
+    class FeaturedDeferrable < ::EM::DefaultDeferrable
+
+      def initialize(&blk)
+        completion(&blk) if block_given?
+      end
+
+      def completion(&blk)
+        callback(&blk)
+        errback(&blk)
+      end
+
+      def protect(fail_value = nil)
+        yield
+      rescue Exception => e
+        ::EM.next_tick { fail e }
+        fail_value
+      end
+
+      def protect_and_succeed(fail_value = nil)
+        ret = yield
+      rescue Exception => e
+        ::EM.next_tick { fail e }
+        fail_value
+      else
+        ::EM.next_tick { succeed ret }
+        ret
+      end
+
+      # bind deferred status of this deferrable to other +df+
+      def bind_status(df)
+        df.callback { |*a| succeed(*a) }
+        df.errback  { |*a| fail(*a) }
+      end
+    end
+
+  end
+end

data/spec/connection_pool_helpers.rb

@@ -0,0 +1,89 @@
+module ConnectionPoolHelpers
+  def sleep_one_tick
+    f = Fiber.current
+    EM.next_tick { f.resume }
+    Fiber.yield
+  end
+
+  def create_connection
+    client.allocate.tap do |conn|
+      conn.stub(:query) do |query|
+        query.should start_with 'f'
+        checkpoint.check_defer
+        f = Fiber.current
+        conn.instance_eval { @fiber = f }
+        EM.next_tick {
+          conn.instance_variable_get(:@fiber).should be f
+          f.resume
+        }
+        Fiber.yield
+        if query == 'fee'
+          conn.should_receive(:status).once.and_return(PG::CONNECTION_BAD)
+          conn.should_receive(:finished?).once.and_return(false)
+          conn.should_receive(:finish).once
+          raise PG::ConnectionBad
+        else
+          :result
+        end
+      end
+      conn.stub(:query_defer) do |query|
+        query.should start_with 'b'
+        checkpoint.check_fiber
+        deferrable.new.tap do |df|
+          conn.instance_eval { @defer = df }
+          EM.next_tick {
+            conn.instance_variable_get(:@defer).should be df
+            if query == 'bzz'
+              conn.should_receive(:status).once.and_return(PG::CONNECTION_BAD)
+              conn.should_receive(:finished?).once.and_return(false)
+              conn.should_receive(:finish).once
+              df.fail pgerror
+            else
+              df.succeed :result
+            end
+          }
+        end
+      end
+    end
+  end
+
+  def test_queries(pool, queries)
+    EM.synchrony do
+      EM.add_timer(2) { raise 'timeout' }
+      progress = Set.new
+      queries.each_with_index do |query, i|
+        case query
+        when 'foo'
+          Fiber.new do
+            pool.query(query).should be :result
+            progress.delete i
+          end.resume
+        when 'bar'
+          pool.query_defer(query).callback do |result|
+            result.should be :result
+            progress.delete i
+          end.should_not_receive(:fail)
+        when 'fee'
+          Fiber.new do
+            expect do
+              pool.query(query)
+            end.to raise_error(PG::ConnectionBad)
+            progress.delete i
+          end.resume
+        when 'bzz'
+          pool.query_defer(query).errback do |err|
+            err.should be pgerror
+            progress.delete i
+          end.should_not_receive(:succeed)
+        end
+        progress << i
+      end
+      progress.should eq Set.new(0...queries.length)
+      begin
+        yield progress
+        sleep_one_tick
+      end until progress.empty?
+      EM.stop
+    end
+  end
+end

data/spec/{em_devel_client.rb → em_client.rb}

@@ -1,5 +1,5 @@
 $:.unshift "lib"
-gem 'eventmachine', '>= 1.0.0.beta.1'
+gem 'eventmachine', '~> 1.0.0'
 gem 'pg', ENV['EM_PG_CLIENT_TEST_PG_VERSION']
 require 'date'
 require 'eventmachine'
@@ -15,7 +15,8 @@ describe PG::EM::Client do
 
   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|
+      @client.query_defer('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
         iter.return(DateTime.parse(result[0]['cdate']))
       end.should be_a_kind_of ::EM::DefaultDeferrable

data/spec/em_client_autoreconnect.rb

@@ -1,144 +1,268 @@
-$:.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 not have modified argument Hash" do
-    begin
-      @options.should eq(async_autoreconnect: true)
-    ensure
-      EM.stop
-    end
-  end
-
-  it "should get database size using query" do
-    @tested_proc.call
-  end
-
-  it "should get database size using query after server restart" do
-    system($pgserver_cmd_stop).should be_true
-    system($pgserver_cmd_start).should be_true
-    @tested_proc.call
-  end
-
-  it "should not get database size using query after server shutdown" do
-    system($pgserver_cmd_stop).should be_true
-    @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
-    @options = {async_autoreconnect: true}
-    @client = PG::EM::Client.new(@options)
-    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
-  end
-end
-
-describe 'em-pg autoreconnect with on_autoreconnect' do
-  include_context 'em-pg common'
-
-  it "should not have modified argument Hash" do
-    begin
-      @options.should eq(on_autoreconnect: @on_autoreconnect)
-    ensure
-      EM.stop
-    end
-  end
-
-  it "should get database size using prepared statement"do
-    @tested_proc.call
-  end
-
-  it "should get database size using prepared statement after server restart" do
-    system($pgserver_cmd_stop).should be_true
-    system($pgserver_cmd_start).should be_true
-    @tested_proc.call
-  end
-
-  before(:all) do
-    @tested_proc = proc do
-      @client.exec_prepared('get_db_size') do |result|
-        result.should be_an_instance_of PG::Result
-        result[0]['pg_database_size'].to_i.should be > 0
-        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
-    @options = {on_autoreconnect: @on_autoreconnect}
-    @client = PG::EM::Client.new(@options)
-    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
-    @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.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
-
-  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
+$:.unshift "lib"
+gem 'eventmachine', '~> 1.0.0'
+gem 'pg', ENV['EM_PG_CLIENT_TEST_PG_VERSION']
+require 'date'
+require 'eventmachine'
+require 'pg/em'
+
+$pgserver_cmd_stop = %Q[sudo -i -u postgres pg_ctl -D "#{ENV['PGDATA']}" stop -s -m fast]
+$pgserver_cmd_start = %Q[sudo -i -u postgres pg_ctl -D "#{ENV['PGDATA']}" start -s -w]
+
+shared_context 'pg-em common' do
+  around(:each) do |testcase|
+    EM.run(&testcase)
+  end
+
+  after(:all) do
+    @client.close
+  end
+end
+
+describe 'pg-em async connect fail' do
+  around(:each) do |testcase|
+    begin
+      system($pgserver_cmd_stop).should be_true
+      testcase.call
+    ensure
+      system($pgserver_cmd_start).should be_true
+    end
+  end
+
+  it "should not connect when server is down" do
+    error = nil
+    EM.run do
+      EM.add_timer(1) { EM.stop }
+      df = PG::EM::Client.async_connect
+      df.callback {|c| c.close }
+      df.errback do |err|
+        error = err
+        EM.stop
+      end
+    end
+    error.should be_an_instance_of PG::ConnectionBad
+  end
+end
+
+describe 'pg-em default autoreconnect' do
+  include_context 'pg-em common'
+
+  it "should not have modified argument Hash" do
+    begin
+      @options.should eq(async_autoreconnect: true)
+    ensure
+      EM.stop
+    end
+  end
+
+  it "should get database size using query" do
+    @tested_proc.call
+  end
+
+  it "should get database size using query after server restart" do
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @tested_proc.call
+  end
+
+  it "should not get database size using query after server shutdown" do
+    system($pgserver_cmd_stop).should be_true
+    @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
+      ex.should be_an_instance_of @client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad
+      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
+
+  it "should fail on invalid query after server restart" do
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @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
+
+  it "should fail when in transaction after server restart" do
+    @client.query_defer('BEGIN') do |result|
+      result.should be_an_instance_of PG::Result
+      system($pgserver_cmd_stop).should be_true
+      system($pgserver_cmd_start).should be_true
+      @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
+        ex.should be_an_instance_of @client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad
+        @tested_proc.call
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end
+  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
+    @options = {async_autoreconnect: true}
+    @client = PG::EM::Client.new(@options)
+    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
+  end
+end
+
+describe 'pg-em autoreconnect with on_autoreconnect' do
+  include_context 'pg-em common'
+
+  it "should not have modified argument Hash" do
+    begin
+      @options.should eq(on_autoreconnect: @on_autoreconnect)
+    ensure
+      EM.stop
+    end
+  end
+
+  it "should get database size using prepared statement"do
+    @tested_proc.call
+  end
+
+  it "should get database size using prepared statement after server restart" do
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @tested_proc.call
+  end
+
+  it "should fail on invalid query after server restart" do
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @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
+
+  it "should fail when in transaction after server restart" do
+    @client.query_defer('BEGIN') do |result|
+      result.should be_an_instance_of PG::Result
+      system($pgserver_cmd_stop).should be_true
+      system($pgserver_cmd_start).should be_true
+      @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
+        ex.should be_an_instance_of @client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad
+        @tested_proc.call
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end
+  end
+
+  it "should fail on false from on_autoreconnect after server restart" do
+    @client.on_autoreconnect = proc { false }
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
+      ex.should be_an_instance_of @client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad
+      EM.stop
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  it "should complete on true from on_autoreconnect after server restart" do
+    @client.on_autoreconnect = proc { true }
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @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
+
+  it "should fail on query with true from on_autoreconnect after restart" do
+    @client.on_autoreconnect = proc { true }
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @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
+
+  it "should fail on on_autoreconnect deferrable fail after server restart" do
+    @client.on_autoreconnect = proc do
+      ::EM::DefaultDeferrable.new.tap {|df| df.fail :boo }
+    end
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @client.query_defer('SELECT 1') do |ex|
+      ex.should be :boo
+      EM.stop
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  it "should fail on raised error in on_autoreconnect after server restart" do
+    @client.on_autoreconnect = proc do
+      raise TypeError
+    end
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @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
+
+  before(:all) do
+    @tested_proc = proc do
+      @client.exec_prepared_defer('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_defer('get_db_size', 'SELECT pg_database_size(current_database());')
+      df.should be_a_kind_of ::EM::DefaultDeferrable
+      df
+    end
+    @options = {on_autoreconnect: @on_autoreconnect}
+    @client = PG::EM::Client.new(@options)
+    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
+    @client.prepare('get_db_size', 'SELECT pg_database_size(current_database());')
+  end
+end
+
+describe 'pg-em with autoreconnect disabled' do
+  include_context 'pg-em 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_defer('SELECT pg_database_size(current_database());') do |ex|
+      ex.should be_an_instance_of @client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad
+      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.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
+
+  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
+    @client = PG::EM::Client.new
+    @client.set_notice_processor {|msg| puts "warning from pgsql: #{msg.to_s.chomp.inspect}"}
+  end
+end