odba 1.1.9 → 1.2.1

data/test/test_cache_entry.rb

@@ -1,113 +1,93 @@
 #!/usr/bin/env ruby
 # TestCacheEntry -- odba-- 29.04.2004 -- hwyss@ywesee.com mwalder@ywesee.com
-
-$: << File.dirname(__FILE__)
-$: << File.expand_path("../lib", File.dirname(__FILE__))
-
-require 'minitest/autorun'
-require 'flexmock/test_unit'
-require 'flexmock'
-require 'odba/cache_entry'
-require 'odba/odba'
-require 'odba/persistable'
+require_relative "helper"
+require "odba/cache_entry"
+require "odba/odba"
+require "odba/persistable"
 
 module ODBA
-	class CacheEntry
-		attr_accessor :accessed_by
-	end
-	class TestCacheEntry < Minitest::Test
+  class CacheEntry
+    attr_accessor :accessed_by
+  end
+
+  class TestCacheEntry < Test::Unit::TestCase
     include FlexMock::TestCase
-		def setup
-			@mock = flexmock
+    def setup
+      @mock = flexmock
       @mock.should_receive(:odba_add_observer)
-			@mock.should_receive(:odba_observers).and_return { [] }
-			@mock.should_receive(:odba_id).and_return { 123 }
-			@cache_entry = ODBA::CacheEntry.new(@mock)
-			ODBA.cache = flexmock("cache")
+      @mock.should_receive(:odba_observers).and_return { [] }
+      @mock.should_receive(:odba_id).and_return { 123 }
+      @cache_entry = ODBA::CacheEntry.new(@mock)
+      ODBA.cache = flexmock("cache")
       ODBA.cache.should_receive(:retire_age).and_return(0.9)
       ODBA.cache.should_receive(:destroy_age).and_return(0.9)
-		end
+    end
+
     def teardown
       super
     end
-		def test_retire_check
-			@mock.should_receive(:odba_unsaved?).and_return { false }
-			@mock.should_receive(:odba_unsaved?).and_return { false }
-			assert_equal(false, @cache_entry.odba_old?(Time.now - 1))
-			assert_equal(true, @cache_entry.odba_old?(Time.now + 1))
-		end
-		def test_retire
-			obj_1 = Object.new
-      obj_1.extend(Persistable)
-			obj_1.instance_variable_set('@odba_id', 36)
-			obj_2 = Object.new
-      obj_2.extend(Persistable)
-			obj_2.instance_variable_set('@odba_id', 34)
-      ODBA.cache.should_receive(:include?).with(34).and_return(false)
-      ODBA.cache.should_receive(:include?).with(35).and_return(false)
-      ODBA.cache.should_receive(:include?).with(36).and_return(true)
-      ODBA.cache.should_receive(:fetch).with(36).and_return(obj_1)
-			hash = {}
-			hash.instance_variable_set('@odba_id', 35)
-			hash.instance_variable_set('@odba_persistent', true)
-			@cache_entry.accessed_by = {
-        obj_1.object_id => 36, 
-        obj_2.object_id => 34, 
-        hash.object_id  => 35,
-      }
-			@cache_entry.odba_retire
-			assert_equal({hash.object_id => 35}, @cache_entry.accessed_by)
-		end
-		def test_odba_add_reference
-			mock = flexmock
-			@cache_entry.odba_add_reference(mock)
+
+    def test_retire_check
+      @mock.should_receive(:odba_unsaved?).and_return { false }
+      @mock.should_receive(:odba_unsaved?).and_return { false }
+      assert_equal(false, @cache_entry.odba_old?(Time.now - 1))
+      assert_equal(true, @cache_entry.odba_old?(Time.now + 1))
+    end
+
+    def test_odba_add_reference
+      mock = flexmock
+      @cache_entry.odba_add_reference(mock)
       id = mock.object_id
       assert_equal({id => nil}, @cache_entry.accessed_by)
       mock2 = flexmock
       mock2.should_receive(:odba_id).and_return(123)
-			@cache_entry.odba_add_reference(mock2)
+      @cache_entry.odba_add_reference(mock2)
       assert_equal({mock2.object_id => 123, id => nil}, @cache_entry.accessed_by)
-		end
-		def test_odba_id
-			assert_equal(123, @cache_entry.odba_id)
-		end
+    end
+
+    def test_odba_id
+      assert_equal(123, @cache_entry.odba_id)
+    end
+
     def test_odba_cut_connections
       ## transaction-rollback for unsaved items
-      item1 = flexmock('Item1', :odba_id => 145)
-      item2 = flexmock('Item2', :odba_id => 148)
+      item1 = flexmock("Item1", odba_id: 145)
+      item2 = flexmock("Item2", odba_id: 148)
       ODBA.cache.should_receive(:include?).with(145).and_return(false)
       ODBA.cache.should_receive(:include?).with(148).and_return(true)
       ODBA.cache.should_receive(:fetch).with(148).and_return(item2)
       @cache_entry.accessed_by.store(item1.object_id, 145)
       @cache_entry.accessed_by.store(item2.object_id, 148)
-      item1.should_receive(:respond_to?).with(:odba_cut_connection)\
+      item1.should_receive(:respond_to?).with(:odba_cut_connection)
         .and_return(false)
-      item2.should_receive(:respond_to?).with(:odba_cut_connection)\
+      item2.should_receive(:respond_to?).with(:odba_cut_connection)
         .and_return(true)
-      item2.should_receive(:odba_cut_connection).with(@mock)\
+      item2.should_receive(:odba_cut_connection).with(@mock)
         .times(1).and_return { assert(true) }
       @cache_entry.odba_cut_connections!
     end
+
     def test_odba_replace
       ## transaction-rollback for saved items
       modified = Object.new
       modified.extend(ODBA::Persistable)
-      modified.instance_variable_set('@data', 'foo')
-      modified.instance_variable_set('@odba_id', 124)
+      modified.instance_variable_set(:@data, "foo")
+      modified.instance_variable_set(:@odba_id, 124)
       cache_entry = CacheEntry.new(modified)
 
       reloaded = modified.dup
 
-      modified.instance_variable_set('@data', 'bar')
-      assert_equal('bar', modified.instance_variable_get('@data'))
-      
+      modified.instance_variable_set(:@data, "bar")
+      assert_equal("bar", modified.instance_variable_get(:@data))
+
       cache_entry.odba_replace!(reloaded)
-      assert_equal('foo', modified.instance_variable_get('@data'))
+      assert_equal("foo", modified.instance_variable_get(:@data))
     end
+
     def test_odba_notify_observers
-      @mock.should_receive(:odba_notify_observers).with(:foo, 2, 'bar')\
+      @mock.should_receive(:odba_notify_observers).with(:foo, 2, "bar")
         .and_return { assert(true) }
-      @cache_entry.odba_notify_observers(:foo, 2, 'bar')
+      @cache_entry.odba_notify_observers(:foo, 2, "bar")
     end
-	end
+  end
 end

data/test/test_connection_pool.rb

@@ -1,12 +1,7 @@
 #!/usr/bin/env ruby
 # TestConnectionPool -- odba -- 03.08.2005 -- hwyss@ywesee.com
-
-$: << File.expand_path('../lib', File.dirname(__FILE__))
-
-require 'minitest/autorun'
-require 'flexmock/test_unit'
-require 'flexmock'
-require 'odba/connection_pool'
+require_relative "helper"
+require "odba/connection_pool"
 ## connection_pool requires 'dbi', which unshifts the site_ruby dir
 #  to the first position in $LOAD_PATH ( == $: ). As a result, files are
 #  loaded from site_ruby if they are installed there, and thus ignored
@@ -14,64 +9,114 @@ require 'odba/connection_pool'
 # $:.shift
 
 module ODBA
-  class TestConnectionPool < Minitest::Test
+  class TestConnectionPool < Test::Unit::TestCase
     include FlexMock::TestCase
     def test_survive_error
-      flexstub(DBI).should_receive(:connect).times(10).and_return { 
+      flexstub(DBI).should_receive(:connect).times(10).and_return {
         conn = FlexMock.new("Connection")
         conn.should_ignore_missing
         conn
       }
-      pool = ConnectionPool.new()
+      pool = ConnectionPool.new
       pool.connections.each { |conn|
-        conn.should_receive(:execute).and_return { 
-          raise DBI::InterfaceError.new 
+        conn.should_receive(:execute).and_return {
+          raise DBI::InterfaceError.new
           ## after the first error is raised, ConnectionPool reconnects.
         }
       }
-      pool.execute('statement')
+      pool.execute("statement")
     end
+
     def test_multiple_errors__give_up
-      flexstub(DBI).should_receive(:connect).times(20).and_return { 
+      flexstub(DBI).should_receive(:connect).times(20).and_return {
         conn = FlexMock.new("Connection")
-        conn.should_receive(:execute).and_return { 
-          raise DBI::InterfaceError.new 
+        conn.should_receive(:execute).and_return {
+          raise DBI::InterfaceError.new
         }
         conn
       }
-      pool = ConnectionPool.new()
-      assert_raises(DBI::InterfaceError) { pool.execute('statement') }
+      pool = ConnectionPool.new
+      assert_raises(DBI::InterfaceError) { pool.execute("statement") }
     end
+
+    # ydbd-pg reports a lost connection as DBI::ProgrammingError, which used
+    # to be excluded from the retry - so a database restart broke the pool
+    # for good.
+    def test_survive_lost_connection_reported_as_programming_error
+      flexstub(DBI).should_receive(:connect).times(10).and_return {
+        conn = FlexMock.new("Connection")
+        conn.should_ignore_missing
+        conn
+      }
+      pool = ConnectionPool.new
+      pool.connections.each { |conn|
+        conn.should_receive(:execute).and_return {
+          raise DBI::ProgrammingError.new("PQsocket() can't get socket descriptor")
+        }
+      }
+      ## after the first error is raised, ConnectionPool reconnects.
+      assert_nothing_raised { pool.execute("statement") }
+    end
+
+    def test_genuine_programming_error__give_up_at_once
+      flexstub(DBI).should_receive(:connect).times(5).and_return {
+        conn = FlexMock.new("Connection")
+        conn.should_receive(:execute).and_return {
+          raise DBI::ProgrammingError.new('syntax error at or near "selct"')
+        }
+        conn
+      }
+      pool = ConnectionPool.new
+      ## a broken statement must not be retried on a fresh connection
+      assert_raises(DBI::ProgrammingError) { pool.execute("selct 1") }
+    end
+
+    def test_retryable
+      flexstub(DBI).should_receive(:connect).times(5).and_return {
+        conn = FlexMock.new("Connection")
+        conn.should_ignore_missing
+        conn
+      }
+      pool = ConnectionPool.new
+      assert(pool.retryable?(DBI::InterfaceError.new("anything")))
+      assert(pool.retryable?(NoMethodError.new("undefined method")))
+      assert(pool.retryable?(DBI::ProgrammingError.new("PQsocket() can't get socket descriptor")))
+      assert(pool.retryable?(DBI::ProgrammingError.new("no connection to the server")))
+      assert(!pool.retryable?(DBI::ProgrammingError.new("relation does not exist")))
+    end
+
     def test_size
-      flexstub(DBI).should_receive(:connect).times(5).and_return { 
+      flexstub(DBI).should_receive(:connect).times(5).and_return {
         conn = FlexMock.new("Connection")
         conn.should_ignore_missing
         conn
       }
-      pool = ConnectionPool.new()
+      pool = ConnectionPool.new
       assert_equal(5, pool.size)
     end
+
     def test_disconnect
-      flexstub(DBI).should_receive(:connect).times(5).and_return { 
+      flexstub(DBI).should_receive(:connect).times(5).and_return {
         conn = FlexMock.new("Connection")
         conn.should_ignore_missing
         conn
       }
-      pool = ConnectionPool.new()
+      pool = ConnectionPool.new
       pool.connections.each { |conn|
         conn.should_receive(:disconnect).and_return { assert(true) }
       }
       pool.disconnect
     end
+
     def test_disconnect_error
-      flexstub(DBI).should_receive(:connect).times(5).and_return { 
+      flexstub(DBI).should_receive(:connect).times(5).and_return {
         conn = FlexMock.new("Connection")
-        conn.should_receive(:disconnect).times(1).and_return { 
+        conn.should_receive(:disconnect).times(1).and_return {
           raise DBI::InterfaceError.new
         }
         conn
       }
-      pool = ConnectionPool.new()
+      pool = ConnectionPool.new
       pool.disconnect
     end
   end

data/test/test_drbwrapper.rb

@@ -1,15 +1,10 @@
 #!/usr/bin/env ruby
 # TestDRbWrapper -- odba -- 13.06.2006 -- hwyss@ywesee.com
-
-$: << File.expand_path('../lib', File.dirname(__FILE__))
-
-require 'minitest/autorun'
-require 'flexmock/test_unit'
-require 'flexmock'
-require 'odba/drbwrapper'
+require_relative "helper"
+require "odba/drbwrapper"
 
 module ODBA
-  class TestDRbWrapper < Minitest::Test
+  class TestDRbWrapper < Test::Unit::TestCase
     include FlexMock::TestCase
     def test_include
       obj = FlexMock.new
@@ -22,6 +17,7 @@ module ODBA
       assert_equal(true, arr.include?(DRbWrapper.new(obj)))
       assert_equal(false, arr.include?(DRbWrapper.new(obj2)))
     end
+
     def test_respond_to
       obj = FlexMock.new
       wrap = DRbWrapper.new(obj)
@@ -30,12 +26,13 @@ module ODBA
       assert_equal(true, wrap.respond_to?(:foo))
       assert_equal(false, wrap.respond_to?(:bar))
     end
+
     def test_method_missing
       obj = FlexMock.new
       wrap = DRbWrapper.new(obj)
-      obj.should_receive(:foo).with(:arg1, :arg2).times(1).and_return('result_foo')
-      assert_equal('result_foo', wrap.foo(:arg1, :arg2))
-      pers = flexmock('Persistable')
+      obj.should_receive(:foo).with(:arg1, :arg2).times(1).and_return("result_foo")
+      assert_equal("result_foo", wrap.foo(:arg1, :arg2))
+      pers = flexmock("Persistable")
       pers.should_receive(:is_a?).with(Persistable).and_return(true)
       obj.should_receive(:bar).with(:arg1).times(1).and_return([pers])
       res = wrap.bar(:arg1)
@@ -53,50 +50,64 @@ module ODBA
       }
     end
   end
-  class TestDRbIdConv < Minitest::Test
+
+  class TestDRbIdConv < Test::Unit::TestCase
     include FlexMock::TestCase
     def setup
-      ODBA.cache = flexmock('cache')
+      ODBA.cache = flexmock("cache")
       @idconv = ODBA::DRbIdConv.new
     end
+
     def test_to_id
       ODBA.cache.should_receive(:store)
       o = Object.new
       assert_equal(o.object_id, @idconv.to_id(o))
       o.extend(ODBA::Persistable)
-      o.instance_variable_set('@odba_id', 4)
+      o.instance_variable_set(:@odba_id, 4)
       o.odba_isolated_store
-      assert_equal('4', @idconv.to_id(o))
+      assert_equal("4", @idconv.to_id(o))
     end
+
     def test_to_id__odba_unsaved
       o = Object.new
       o.extend(ODBA::Persistable)
       assert_equal(o.object_id, @idconv.to_id(o))
       assert_equal([@idconv], o.odba_observers)
     end
+
     def test_to_obj
       ODBA.cache.should_receive(:store)
       o = Object.new
-      assert_equal(o, @idconv.to_obj(o.object_id))
+      ## drb >= 2.2 resolves only those ids it handed out itself: DRbIdConv
+      ## keeps a DRbObjectSpace WeakMap that to_id populates, and to_obj raises
+      ## RangeError for anything absent from it. Older drb looked the id up
+      ## with ObjectSpace._id2ref, which resolved any live object. Register the
+      ## object first, as real DRb traffic does - an id only reaches to_obj
+      ## after to_id produced it.
+      assert_equal(o, @idconv.to_obj(@idconv.to_id(o)))
       o.extend(ODBA::Persistable)
-      o.instance_variable_set('@odba_id', 4)
+      o.instance_variable_set(:@odba_id, 4)
       o.odba_isolated_store
       ODBA.cache.should_receive(:fetch).with(4).times(1)
-      @idconv.to_obj('4')
+      @idconv.to_obj("4")
     end
+
     def test_to_obj__error
-      ODBA.cache.should_receive(:fetch).with(4).times(1).and_return { 
+      ODBA.cache.should_receive(:fetch).with(4).times(1).and_return {
         raise "some error"
       }
-      assert_raises(RangeError) { @idconv.to_obj('4') }
+      assert_raises(RangeError) { @idconv.to_obj("4") }
     end
+
     def test_odba_update
       id = Object.new.object_id
       @idconv.odba_update(:store, 4, id)
       ODBA.cache.should_receive(:fetch).with(4).times(1)
       @idconv.to_obj(id)
       @idconv.odba_update(:clean, 4, id)
+      return if RUBY_VERSION.to_f >= 3.3
       GC.start
+      assert_raises { @idconv.to_obj(id) }
       assert_raises(RangeError) { @idconv.to_obj(id) }
     end
   end