odba 1.1.9 → 1.2.0

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,58 @@ 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))
       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

data/test/test_hash.rb

@@ -1,112 +1,119 @@
 #!/usr/bin/env ruby
 # TestHash -- odba -- ??.??.???? -- hwyss@ywesee.com
-
-$: << File.dirname(__FILE__)
-$: << File.expand_path('../lib/', File.dirname(__FILE__))
-
-require 'minitest/autorun'
-require 'flexmock/test_unit'
-require 'flexmock'
-require 'odba/persistable'
-require 'odba/stub'
-require 'odba/odba'
+require_relative "helper"
+require "odba/persistable"
+require "odba/stub"
+require "odba/odba"
 
 module ODBA
-	class TestHash < Minitest::Test
+  class TestHash < Test::Unit::TestCase
     include FlexMock::TestCase
-		class ODBAContainerInHash
-			include Persistable
-			attr_accessor	:non_replaceable, :replaceable, :odba_id
-		end
+    class ODBAContainerInHash
+      include Persistable
+      attr_accessor	:non_replaceable, :replaceable, :odba_id
+    end
+
     class Container
       attr_accessor :content
     end
-		class TestStub
-			attr_accessor :receiver, :odba_replace
-			def is_a?(arg)
-				true
-			end
-		end
-		def setup
-			@hash = Hash.new
-			ODBA.cache = flexmock("cache")
-			ODBA.storage = flexmock("storage")
-			@hash.clear
-		end
+
+    class TestStub
+      attr_accessor :receiver, :odba_replace
+      def is_a?(arg)
+        true
+      end
+    end
+
+    def setup
+      @hash = {}
+      ODBA.cache = flexmock("cache")
+      ODBA.storage = flexmock("storage")
+      @hash.clear
+    end
+
     def teardown
       super
     end
-		def test_odba_unsaved_neighbors_hash
-			repkey1 = ODBAContainerInHash.new
-			repkey2 = ODBAContainerInHash.new
-			repvalue1 = ODBAContainerInHash.new
-			repvalue2 = ODBAContainerInHash.new
-			@hash.store(repkey1, repvalue1)
-			@hash.store(repkey2, repvalue2)
-			result = @hash.odba_unsaved_neighbors(1)
-			assert_equal(true, result.include?(repkey1))
-			assert_equal(true, result.include?(repkey2))
-			assert_equal(true, result.include?(repvalue1))
-			assert_equal(true, result.include?(repvalue2))
-		end
-		def test_odba_replace_persistables_hash
-			key1 = flexmock("key")
-			value1 = flexmock("value")
-			@hash.store(key1, value1)
-			@hash.odba_replace_persistables
-			assert_equal(@hash, {})
-		end
-		def test_odba_prefetch
-			key1  = flexmock("key")
-			val1 = flexmock("val1")
-			@hash.store(key1, val1)
-			assert_equal(false, @hash.odba_prefetch?)
-		end
-		def test_odba_unsaved_true
-			key = flexmock("key")
-			val = flexmock("val")
-			@hash.instance_variable_set("@odba_persistent", true)
-			@hash.store(key, val)
-			val.should_receive(:is_a?).and_return { |klass| true }
-			val.should_receive(:odba_unsaved?).and_return { true }
-
-			assert_equal(true, @hash.odba_unsaved?)
-		end
+
+    def test_odba_unsaved_neighbors_hash
+      repkey1 = ODBAContainerInHash.new
+      repkey2 = ODBAContainerInHash.new
+      repvalue1 = ODBAContainerInHash.new
+      repvalue2 = ODBAContainerInHash.new
+      @hash.store(repkey1, repvalue1)
+      @hash.store(repkey2, repvalue2)
+      result = @hash.odba_unsaved_neighbors(1)
+      assert_equal(true, result.include?(repkey1))
+      assert_equal(true, result.include?(repkey2))
+      assert_equal(true, result.include?(repvalue1))
+      assert_equal(true, result.include?(repvalue2))
+    end
+
+    def test_odba_replace_persistables_hash
+      key1 = flexmock("key")
+      value1 = flexmock("value")
+      @hash.store(key1, value1)
+      @hash.odba_replace_persistables
+      assert_equal(@hash, {})
+    end
+
+    def test_odba_prefetch
+      key1 = flexmock("key")
+      val1 = flexmock("val1")
+      @hash.store(key1, val1)
+      assert_equal(false, @hash.odba_prefetch?)
+    end
+
+    def test_odba_unsaved_true
+      key = flexmock("key")
+      val = flexmock("val")
+      @hash.instance_variable_set(:@odba_persistent, true)
+      @hash.store(key, val)
+      val.should_receive(:is_a?).and_return { |klass| true }
+      val.should_receive(:odba_unsaved?).and_return { true }
+
+      assert_equal(true, @hash.odba_unsaved?)
+    end
+
     def test_odba_cut_connection
       remove_obj = Object.new
       remove_obj.extend(ODBA::Persistable)
-      remove_obj.instance_variable_set('@odba_id', 2)
+      remove_obj.instance_variable_set(:@odba_id, 2)
       other = Object.new
       other.extend(ODBA::Persistable)
-      other.instance_variable_set('@odba_id', 3)
+      other.instance_variable_set(:@odba_id, 3)
       receiver = ODBA::Stub.new(2, nil, remove_obj)
-      ODBA.cache.should_receive(:fetch).with(2,nil).and_return(remove_obj)
-      @hash.store('foo', receiver)
-      @hash.store(receiver, 'bar')
-      @hash.store('bar', other)
-      @hash.store(other, 'baz')
+      ODBA.cache.should_receive(:fetch).with(2, nil).and_return(remove_obj)
+      @hash.store("foo", receiver)
+      @hash.store(receiver, "bar")
+      @hash.store("bar", other)
+      @hash.store(other, "baz")
       @hash.odba_cut_connection(remove_obj)
-      assert_equal({'bar' => other, other => 'baz'}, @hash)
+      assert_equal({"bar" => other, other => "baz"}, @hash)
     end
+
     def test_odba_collection
-      @hash.update('foo' => 'bar', 'trouble' => 'not')
-      assert_equal([['foo', 'bar'],['trouble', 'not']], 
-                   @hash.odba_collection.sort)
+      @hash.update("foo" => "bar", "trouble" => "not")
+      assert_equal([["foo", "bar"], ["trouble", "not"]],
+        @hash.odba_collection.sort)
     end
+
     def test_odba_replace
-      modified = { 'foo' => 'bar' }
+      modified = {"foo" => "bar"}
       reloaded = modified.dup
-      modified.update('foo' => 'baz', 'han' => 'solo')
+      modified.update("foo" => "baz", "han" => "solo")
 
       modified.odba_replace!(reloaded)
 
       assert_equal(reloaded, modified)
     end
+
     def test_odba_restore
-      collection = [[:foo, 'bar'],[:trouble, 'not']]
+      collection = [[:foo, "bar"], [:trouble, "not"]]
       @hash.odba_restore(collection)
-      assert_equal({:foo => 'bar', :trouble => 'not'}, @hash)
+      assert_equal({foo: "bar", trouble: "not"}, @hash)
     end
+
     def test_odba_target_ids
       o = ODBAContainerInHash.new
       o.odba_id = 1
@@ -114,13 +121,14 @@ module ODBA
       p.odba_id = 2
       q = ODBAContainerInHash.new
       q.odba_id = 3
-      @hash.store('foo', p)
-      @hash.store(p, 'bar')
-      @hash.store('bar', q)
-      @hash.store(q, 'baz')
-      @hash.instance_variable_set('@var', o)
-      assert_equal([1,2,3], @hash.odba_target_ids.sort)
+      @hash.store("foo", p)
+      @hash.store(p, "bar")
+      @hash.store("bar", q)
+      @hash.store(q, "baz")
+      @hash.instance_variable_set(:@var, o)
+      assert_equal([1, 2, 3], @hash.odba_target_ids.sort)
     end
+
     def test_odba_stubize
       obj = Object.new
       obj.extend(ODBA::Persistable)
@@ -129,20 +137,21 @@ module ODBA
       assert_equal(11, obj.odba_id)
       hash = {1 => obj}
       assert_equal(12, hash.odba_id)
-      assert_equal(true, hash.odba_stubize(obj, :force => true))
+      assert_equal(true, hash.odba_stubize(obj, force: true))
       assert_equal([1], hash.keys)
       assert_equal false, hash.values.first.is_a?(ODBA::Stub)
     end
+
     def test_odba_stubize__key
       obj = Object.new
       obj.extend(ODBA::Persistable)
       id = 10
       ODBA.cache.should_receive(:next_id).times(2).and_return { id += 1 }
       assert_equal(11, obj.odba_id)
-      hash = {obj => 'foo'}
+      hash = {obj => "foo"}
       assert_equal(12, hash.odba_id)
-      assert_equal(true, hash.odba_stubize(obj, :force => true))
-      assert_equal({obj => 'foo'}, hash)
+      assert_equal(true, hash.odba_stubize(obj, force: true))
+      assert_equal({obj => "foo"}, hash)
     end
-	end
+  end
 end