em-pg-client 0.2.1 → 0.3.0

data/spec/em_client_common.rb

@@ -11,17 +11,18 @@ module PGSpecMacros
     end.should be_a_kind_of ::EM::DefaultDeferrable
   end
 
-  def pg_exec_and_check_with_error(client, err_message, method, *args, &additional_checks)
+  def pg_exec_and_check_with_error(client, stop, err_class, err_message, method, *args, &additional_checks)
     client.__send__(method, *args) do |exception|
-      exception.should be_an_instance_of PG::Error
+      exception.should be_an_instance_of err_class
       exception.to_s.should include err_message if err_message
       additional_checks.call(exception) if additional_checks
-      EM.stop
+      EM.next_tick { EM.stop } if stop
     end.should be_a_kind_of ::EM::DefaultDeferrable
   end
 
   def ensure_em_stop
     yield
+  ensure
     EM.stop
   end
 
@@ -32,18 +33,18 @@ module PGSpecMacros
       end
     end
 
-    def it_should_execute_with_error(text, err_message, method, *args)
+    def it_should_execute_with_error(text, err_class, err_message, method, *args)
       it "should #{text}" do
-        pg_exec_and_check_with_error(@client, err_message, method, *args)
+        pg_exec_and_check_with_error(@client, true, err_class, err_message, method, *args)
       end
     end
 
     def it_should_rollback
-      it_should_execute("rollback transaction", :query, 'ROLLBACK')
+      it_should_execute("rollback transaction", :query_defer, 'ROLLBACK')
     end
 
     def it_should_begin
-      it_should_execute("begin transaction", :query, 'BEGIN TRANSACTION')
+      it_should_execute("begin transaction", :query_defer, 'BEGIN TRANSACTION')
     end
   end
 end
@@ -87,36 +88,6 @@ shared_context 'em-pg common before' do
     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
-      args = [on_autoreconnect: on_autoreconnect]
-      async_args = described_class.parse_async_args(args)
-      args.should eq [{}]
-      async_args.should be_an_instance_of Hash
-      async_args[:@on_autoreconnect].should be on_autoreconnect
-      async_args[:@async_autoreconnect].should be_true
-      args = [async_autoreconnect: false,
-        on_autoreconnect: on_autoreconnect]
-      async_args = described_class.parse_async_args(args)
-      args.should eq [{}]
-      async_args.should be_an_instance_of Hash
-      async_args[:@on_autoreconnect].should be on_autoreconnect
-      async_args[:@async_autoreconnect].should be_false
-      args = [on_autoreconnect: on_autoreconnect,
-        async_autoreconnect: false]
-      async_args = described_class.parse_async_args(args)
-      args.should eq [{}]
-      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
@@ -126,20 +97,20 @@ shared_context 'em-pg common before' do
   it_should_begin
 
   it_should_execute("drop table `foo` if exists",
-      :query, 'DROP TABLE IF EXISTS foo')
+      :query_defer, '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)')
+      :query_defer, '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')
+      :prepare_defer, '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|
+    pg_exec_and_check(@client, :describe_prepared_defer, 'get_foo') do |result|
       result.nfields.should eq 3
       result.fname(0).should eq 'id'      
       result.values.should be_empty
@@ -147,7 +118,7 @@ shared_context 'em-pg common after' do
   end
 
   it "should read foo table with prepared statement" do
-    pg_exec_and_check(@client, :exec_prepared, 'get_foo') do |result|
+    pg_exec_and_check(@client, :exec_prepared_defer, 'get_foo') do |result|
       result.each_with_index do |row, i|
         row['id'].to_i.should == i
         DateTime.parse(row['cdate']).should == @cdates[i]
@@ -157,10 +128,10 @@ shared_context 'em-pg common after' do
   end
 
   it_should_execute("declare cursor",
-    :query, 'DECLARE foobar SCROLL CURSOR FOR SELECT * FROM foo')
+    :query_defer, '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|
+    pg_exec_and_check(@client, :query_defer, 'FETCH FORWARD 2 FROM foobar') do |result|
       result.nfields.should eq 3
       result.fname(0).should eq 'id'      
       result.values.length.should eq 2
@@ -168,25 +139,25 @@ shared_context 'em-pg common after' do
   end
   
   it "should describe cursor with describe_portal" do
-    pg_exec_and_check(@client, :describe_portal, 'foobar') do |result|
+    pg_exec_and_check(@client, :describe_portal_defer, '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_execute("close cursor", :query_defer, 'CLOSE foobar')
 
   it "should connect to database asynchronously" do
     this = :first
     Encoding.default_internal = Encoding::ISO_8859_1
-    described_class.async_connect do |conn|
+    described_class.connect_defer do |conn|
       this = :second
       Encoding.default_internal = nil
       conn.should be_an_instance_of described_class
       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|
+      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
@@ -196,7 +167,7 @@ shared_context 'em-pg common after' do
   it "should connect without setting incompatible encoding" do
     this = :first
     Encoding.default_internal = Encoding::Emacs_Mule
-    described_class.async_connect do |conn|
+    described_class.connect_defer do |conn|
       this = :second
       Encoding.default_internal = nil
       conn.should be_an_instance_of described_class
@@ -207,13 +178,14 @@ shared_context 'em-pg common after' do
   end
 
   it_should_execute_with_error("raise syntax error in misspelled multiple statement",
+      PG::SyntaxError,
       "syntax error",
-      :query, 'SELECT * from pg_class; SRELECT CURRENT_TIMESTAMP; SELECT 42 number')
+      :query_defer, 'SELECT * from pg_class; SRELECT CURRENT_TIMESTAMP; SELECT 42 number')
 
   it_should_rollback
 
   it "should return only last statement" do
-    pg_exec_and_check(@client, :query,
+    pg_exec_and_check(@client, :query_defer,
       'SELECT * from pg_class; SELECT CURRENT_TIMESTAMP; SELECT 42 number') do |result|
       result[0]['number'].should eq "42"
     end
@@ -224,12 +196,20 @@ shared_context 'em-pg common after' do
     @client.query_timeout = 1.5
     @client.query_timeout.should eq 1.5
     start_time = Time.now
-    pg_exec_and_check_with_error(@client, "query timeout expired", :query, 'SELECT pg_sleep(2)') do
+    pg_exec_and_check_with_error(@client, false,
+        PG::ConnectionBad, "query timeout expired",
+        :query_defer, 'SELECT pg_sleep(2)') do
       (Time.now - start_time).should be < 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, true,
+        PG::ConnectionBad, "previous query expired",
+        :query_defer, 'SELECT 1') do
+        @client.async_autoreconnect = true
+      end
     end
   end
 
@@ -238,7 +218,7 @@ shared_context 'em-pg common after' do
     @client.query_timeout = 1.1
     @client.query_timeout.should eq 1.1
     start_time = Time.now
-    pg_exec_and_check(@client, :query,
+    pg_exec_and_check(@client, :query_defer,
         'SELECT * from pg_class;' +
         'SELECT pg_sleep(1);' +
         'SELECT * from pg_class;' + 
@@ -258,7 +238,9 @@ shared_context 'em-pg common after' do
     @client.query_timeout = 1.1
     @client.query_timeout.should eq 1.1
     start_time = Time.now
-    pg_exec_and_check_with_error(@client, "query timeout expired", :query,
+    pg_exec_and_check_with_error(@client, true,
+        PG::ConnectionBad, "query timeout expired",
+        :query_defer,
         'SELECT * from pg_class;' +
         'SELECT pg_sleep(1);' +
         'SELECT * from pg_class;' + 
@@ -281,4 +263,23 @@ shared_context 'em-pg common after' do
       @client.status.should be PG::CONNECTION_OK
     end
   end
+
+  it "should not expire after executing erraneous query" do
+    @client.query_timeout.should eq 0
+    @client.query_timeout = 0.1
+    @client.query_timeout.should eq 0.1
+    start_time = Time.now
+    pg_exec_and_check_with_error(@client, false,
+        PG::SyntaxError, "syntax error",
+        :query_defer, 'SELLECT 1') do
+      @client.async_command_aborted.should be_false
+      ::EM.add_timer(0.11) do
+        @client.async_command_aborted.should be_false
+        @client.status.should be PG::CONNECTION_OK
+        @client.query_timeout = 0
+        @client.query_timeout.should eq 0
+        EM.stop
+      end
+    end
+  end
 end

data/spec/em_synchrony_client.rb

@@ -1,8 +1,9 @@
 $:.unshift "lib"
+gem 'eventmachine', '~> 1.0.0'
 gem 'pg', ENV['EM_PG_CLIENT_TEST_PG_VERSION']
 require 'date'
 require 'em-synchrony'
-require 'em-synchrony/pg'
+require 'pg/em'
 
 describe PG::EM::Client do
 
@@ -41,7 +42,7 @@ describe PG::EM::Client do
 
   it "should populate foo with some data " do
     results = @values.map do |(data, id)|
-      @client.query('INSERT INTO foo (id,cdate,data) VALUES($1,$2,$3) returning cdate', [id, DateTime.now, data]) do |result|
+      @client.exec_params('INSERT INTO foo (id,cdate,data) VALUES($1,$2,$3) returning cdate', [id, DateTime.now, data]) do |result|
         result.should be_an_instance_of PG::Result
         DateTime.parse(result[0]['cdate'])
       end
@@ -166,7 +167,7 @@ describe PG::EM::Client do
   it "should raise syntax error in misspelled multiple statement" do
     expect {
       @client.query('SELECT * from pg_class; SRELECT CURRENT_TIMESTAMP; SELECT 42 number')
-    }.to raise_error(PG::Error, /syntax error/)
+    }.to raise_error(PG::SyntaxError, /syntax error/)
   end
   
   it "should rollback transaction" do
@@ -189,12 +190,17 @@ describe PG::EM::Client do
     start_time = Time.now
     expect {
       @client.query('SELECT pg_sleep(2)')
-    }.to raise_error(PG::Error, /query timeout expired/)
+    }.to raise_error(PG::ConnectionBad, /query timeout expired/)
     (Time.now - start_time).should be < 2
     @client.query_timeout = 0
     @client.query_timeout.should eq 0
     @client.async_command_aborted.should be_true
     @client.status.should be PG::CONNECTION_BAD
+    @client.async_autoreconnect = false
+    expect {
+      @client.query('SELECT 1')
+    }.to raise_error(PG::ConnectionBad, /previous query expired/)
+    @client.async_autoreconnect = true
   end
 
   it "should timeout not expire while executing query with partial results" do
@@ -230,7 +236,7 @@ describe PG::EM::Client do
           'SELECT * from pg_class;' + 
           'SELECT pg_sleep(2);' +
           'SELECT 42 number')
-    }.to raise_error(PG::Error, /query timeout expired/)
+    }.to raise_error(PG::ConnectionBad, /query timeout expired/)
     (Time.now - start_time).should be > 2
     @client.async_command_aborted.should be_true
     @client.status.should be PG::CONNECTION_BAD
@@ -248,6 +254,249 @@ describe PG::EM::Client do
     end
   end
 
+  it "should not expire after executing erraneous query" do
+    @client.query_timeout.should eq 0
+    @client.query_timeout = 0.1
+    @client.query_timeout.should eq 0.1
+    expect {
+      @client.query('SELLECT 1')
+    }.to raise_error(PG::SyntaxError, /syntax error/)
+    @client.async_command_aborted.should be_false
+    @client.status.should be PG::CONNECTION_OK
+    ::EM::Synchrony.sleep 0.11
+    @client.async_command_aborted.should be_false
+    @client.status.should be PG::CONNECTION_OK
+  end
+
+  describe 'PG::EM::Client#transaction' do
+
+    it "should raise ArgumentError when there is no block" do
+      expect do
+        @client.transaction
+      end.to raise_error(ArgumentError, /Must supply block for PG::EM::Client#transaction/)
+    end
+
+    it "should commit transaction and return whatever block yields" do
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      @client.transaction do |pg|
+        pg.should be @client
+        @client.transaction_status.should be PG::PQTRANS_INTRANS
+        @client.instance_variable_get(:@client_tran_count).should eq 1
+        @client.query(
+          'DROP TABLE IF EXISTS bar'
+        ).should be_an_instance_of PG::Result
+        @client.query(
+          'CREATE TABLE bar (key integer, value varchar)'
+        ).should be_an_instance_of PG::Result
+        @client.query("INSERT INTO bar (key,value) VALUES(42,'xyz') returning value") do |result|
+          result.should be_an_instance_of PG::Result
+          result[0]['value']
+        end
+      end.should eq 'xyz'
+      @client.query('SELECT * FROM bar') do |result|
+        result.should be_an_instance_of PG::Result
+        result[0]['key'].should eq '42'
+      end
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      @client.instance_variable_get(:@client_tran_count).should eq 0
+    end
+
+    it "should rollback transaction on error and raise that error" do
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      expect do
+        @client.transaction do |pg|
+          pg.should be @client
+          @client.transaction_status.should be PG::PQTRANS_INTRANS
+          @client.instance_variable_get(:@client_tran_count).should eq 1
+          @client.query(
+            "INSERT INTO bar (key,value) VALUES(11,'abc')"
+          ).should be_an_instance_of PG::Result
+          @client.query('SELECT * FROM bar ORDER BY key') do |result|
+            result.should be_an_instance_of PG::Result
+            result[0]['key'].should eq '11'
+          end
+          @client.query('SELECT count(*) AS count FROM bar') do |result|
+            result.should be_an_instance_of PG::Result
+            result[0]['count'].should eq '2'
+          end
+          raise "rollback"
+        end
+      end.to raise_error(RuntimeError, /rollback/)
+      @client.query('SELECT count(*) AS count FROM bar') do |result|
+        result.should be_an_instance_of PG::Result
+        result[0]['count'].should eq '1'
+      end
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      @client.instance_variable_get(:@client_tran_count).should eq 0
+    end
+
+    it "should allow nesting transaction and return whatever innermost block yields" do
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      @client.transaction do |pg|
+        pg.should be @client
+        @client.transaction_status.should be PG::PQTRANS_INTRANS
+        @client.instance_variable_get(:@client_tran_count).should eq 1
+        @client.query(
+          "INSERT INTO bar (key,value) VALUES(100,'hundred') returning value"
+        ).should be_an_instance_of PG::Result
+        @client.transaction do |pg|
+          pg.should be @client
+          @client.transaction_status.should be PG::PQTRANS_INTRANS
+          @client.instance_variable_get(:@client_tran_count).should eq 2
+          @client.query(
+            "INSERT INTO bar (key,value) VALUES(1000,'thousand') returning value"
+          ).should be_an_instance_of PG::Result
+          @client.transaction do |pg|
+            pg.should be @client
+            @client.transaction_status.should be PG::PQTRANS_INTRANS
+            @client.instance_variable_get(:@client_tran_count).should eq 3
+            @client.query("INSERT INTO bar (key,value) VALUES(1000000,'million') returning value")
+          end
+        end
+      end.tap do |result|
+        result.should be_an_instance_of PG::Result
+        result[0]['value'].should eq 'million'
+      end
+      @client.query('SELECT key,value FROM bar ORDER BY key') do |result|
+        result.should be_an_instance_of PG::Result
+        result.column_values(0).should eq ['42','100','1000','1000000']
+        result.column_values(1).should eq ['xyz','hundred','thousand','million']
+      end
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      @client.instance_variable_get(:@client_tran_count).should eq 0
+    end
+
+    it "should allow nesting transaction and rollback on error" do
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      expect do
+        @client.transaction do |pg|
+          pg.should be @client
+          @client.transaction_status.should be PG::PQTRANS_INTRANS
+          @client.instance_variable_get(:@client_tran_count).should eq 1
+          @client.query(
+            "INSERT INTO bar (key,value) VALUES(200,'two hundred') returning value"
+          ).should be_an_instance_of PG::Result
+          @client.transaction do |pg|
+            pg.should be @client
+            @client.transaction_status.should be PG::PQTRANS_INTRANS
+            @client.instance_variable_get(:@client_tran_count).should eq 2
+            @client.query(
+              "INSERT INTO bar (key,value) VALUES(2000,'two thousands') returning value"
+            ).should be_an_instance_of PG::Result
+            @client.transaction do |pg|
+              pg.should be @client
+              @client.transaction_status.should be PG::PQTRANS_INTRANS
+              @client.instance_variable_get(:@client_tran_count).should eq 3
+              @client.query(
+                "INSERT INTO bar (key,value) VALUES(2000000,'two millions') returning value"
+              ).should be_an_instance_of PG::Result
+              raise "rollback from here"
+            end
+          end
+        end
+      end.to raise_error(RuntimeError, /rollback from here/)
+      @client.query('SELECT key,value FROM bar ORDER BY key') do |result|
+        result.should be_an_instance_of PG::Result
+        result.column_values(0).should eq ['42','100','1000','1000000']
+        result.column_values(1).should eq ['xyz','hundred','thousand','million']
+      end
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      @client.instance_variable_get(:@client_tran_count).should eq 0
+    end
+
+    it "should allow rollback on rescued sql error from nested transaction" do
+      flag = false
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      @client.transaction do |pg|
+        pg.should be @client
+        @client.transaction_status.should be PG::PQTRANS_INTRANS
+        @client.instance_variable_get(:@client_tran_count).should eq 1
+        @client.query(
+          "INSERT INTO bar (key,value) VALUES(300,'three hundred') returning value"
+        ).should be_an_instance_of PG::Result
+        @client.transaction do |pg|
+          pg.should be @client
+          @client.transaction_status.should be PG::PQTRANS_INTRANS
+          @client.instance_variable_get(:@client_tran_count).should eq 2
+          @client.query(
+            "INSERT INTO bar (key,value) VALUES(3000,'three thousands') returning value"
+          ).should be_an_instance_of PG::Result
+          @client.transaction do |pg|
+            pg.should be @client
+            @client.transaction_status.should be PG::PQTRANS_INTRANS
+            @client.instance_variable_get(:@client_tran_count).should eq 3
+            expect {
+              @client.query('SRELECT CURRENT_TIMESTAMP')
+            }.to raise_error(PG::SyntaxError, /syntax error/)
+            @client.transaction_status.should be PG::PQTRANS_INERROR
+            @client.instance_variable_get(:@client_tran_count).should eq 3
+            expect {
+              @client.query('SELECT CURRENT_TIMESTAMP')
+            }.to raise_error(PG::InFailedSqlTransaction, /transaction is aborted/)
+            @client.transaction_status.should be PG::PQTRANS_INERROR
+            @client.instance_variable_get(:@client_tran_count).should eq 3
+            expect do
+              @client.transaction { 'foo' }
+            end.to raise_error(PG::InFailedSqlTransaction, /transaction is aborted/)
+            @client.transaction_status.should be PG::PQTRANS_INERROR
+            @client.instance_variable_get(:@client_tran_count).should eq 3
+            flag = :was_here
+          end
+          @client.transaction_status.should be PG::PQTRANS_INERROR
+          @client.instance_variable_get(:@client_tran_count).should eq 2
+          expect {
+            @client.query('SELECT CURRENT_TIMESTAMP')
+          }.to raise_error(PG::InFailedSqlTransaction, /transaction is aborted/)
+          expect do
+            @client.transaction { 'foo' }
+          end.to raise_error(PG::InFailedSqlTransaction, /transaction is aborted/)
+          @client.transaction_status.should be PG::PQTRANS_INERROR
+          @client.instance_variable_get(:@client_tran_count).should eq 2
+        end
+        @client.transaction_status.should be PG::PQTRANS_INERROR
+        @client.instance_variable_get(:@client_tran_count).should eq 1
+        expect {
+          @client.query('SELECT CURRENT_TIMESTAMP')
+        }.to raise_error(PG::InFailedSqlTransaction, /transaction is aborted/)
+        expect do
+          @client.transaction { 'foo' }
+        end.to raise_error(PG::InFailedSqlTransaction, /transaction is aborted/)
+        @client.transaction_status.should be PG::PQTRANS_INERROR
+        @client.instance_variable_get(:@client_tran_count).should eq 1
+      end
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      @client.instance_variable_get(:@client_tran_count).should eq 0
+      @client.transaction { 'foo' }.should eq 'foo'
+      @client.query('SELECT key,value FROM bar ORDER BY key') do |result|
+        result.should be_an_instance_of PG::Result
+        result.column_values(0).should eq ['42','100','1000','1000000']
+        result.column_values(1).should eq ['xyz','hundred','thousand','million']
+      end
+      flag.should be :was_here
+    end
+
+    it "should detect premature transaction state change" do
+      flag = false
+      @client.transaction_status.should be PG::PQTRANS_IDLE
+      @client.instance_variable_get(:@client_tran_count).should eq 0
+      @client.transaction do |pg|
+        pg.should be @client
+        @client.transaction_status.should be PG::PQTRANS_INTRANS
+        @client.query('ROLLBACK')
+        @client.instance_variable_get(:@client_tran_count).should eq 1
+        @client.transaction_status.should be PG::PQTRANS_IDLE
+        @client.transaction do
+          @client.transaction_status.should be PG::PQTRANS_INTRANS
+          @client.instance_variable_get(:@client_tran_count).should eq 1
+          'foo'
+        end.should eq 'foo'
+        @client.transaction_status.should be PG::PQTRANS_IDLE
+        @client.instance_variable_get(:@client_tran_count).should eq 0
+      end
+      @client.instance_variable_get(:@client_tran_count).should eq 0
+    end
+  end
+
   around(:each) do |testcase|
     @after_em_stop = nil
     EM.synchrony do