odba 1.1.0 → 1.1.1

data/test/test_hash.rb

@@ -7,13 +7,13 @@ $: << File.expand_path('../lib/', File.dirname(__FILE__))
 require 'odba/persistable'
 require 'odba/stub'
 require 'odba/odba'
-require 'test/unit'
+require 'minitest/autorun'
 require 'flexmock'
 
 module ODBA
-	class TestHash < Test::Unit::TestCase
+	class TestHash < Minitest::Test
     include FlexMock::TestCase
-		class ODBAContainer
+		class ODBAContainerInHash
 			include Persistable
 			attr_accessor	:non_replaceable, :replaceable, :odba_id
 		end
@@ -32,11 +32,14 @@ module ODBA
 			ODBA.storage = flexmock("storage")
 			@hash.clear
 		end
+    def teardown
+      super
+    end
 		def test_odba_unsaved_neighbors_hash
-			repkey1 = ODBAContainer.new
-			repkey2 = ODBAContainer.new
-			repvalue1 = ODBAContainer.new
-			repvalue2 = ODBAContainer.new
+			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)
@@ -104,11 +107,11 @@ module ODBA
       assert_equal({:foo => 'bar', :trouble => 'not'}, @hash)
     end
     def test_odba_target_ids
-      o = ODBAContainer.new
+      o = ODBAContainerInHash.new
       o.odba_id = 1
-      p = ODBAContainer.new
+      p = ODBAContainerInHash.new
       p.odba_id = 2
-      q = ODBAContainer.new
+      q = ODBAContainerInHash.new
       q.odba_id = 3
       @hash.store('foo', p)
       @hash.store(p, 'bar')

data/test/test_id_server.rb

@@ -4,20 +4,24 @@
 $: << File.dirname(__FILE__)
 $: << File.expand_path('../lib', File.dirname(__FILE__))
 
-require 'test/unit'
+require 'minitest/autorun'
 require 'flexmock'
 require 'odba/id_server'
 require 'odba/odba'
 require 'odba/marshal'
 
 module ODBA
-	class TestIdServer < Test::Unit::TestCase
+	class TestIdServer < Minitest::Test
     include FlexMock::TestCase
 		def setup
 			@cache = ODBA.cache = flexmock('cache')
 			@id_server = IdServer.new
 			@id_server.instance_variable_set('@odba_id', 1)
 		end
+    def teardown
+      @id_server = nil
+      super
+    end
 		def test_first
       @cache.should_receive(:store).with(@id_server).times(3)
 			assert_equal(1, @id_server.next_id(:foo))
@@ -33,10 +37,7 @@ module ODBA
 		def test_dumpable
       @cache.should_receive(:store).with(@id_server).times(1)
 			@id_server.next_id(:foo)
-			dump = nil
-			assert_nothing_raised { 
-				dump = @id_server.odba_isolated_dump 
-			}
+			dump = @id_server.odba_isolated_dump 
 			assert_instance_of(ODBA::IdServer, ODBA.marshaller.load(dump))
 		end
 	end

data/test/test_index.rb

@@ -4,7 +4,7 @@
 $: << File.dirname(__FILE__)
 $: << File.expand_path("../lib", File.dirname(__FILE__))
 
-require 'test/unit'
+require 'minitest/autorun'
 require 'odba/index'
 require 'odba/index_definition'
 require 'odba/odba'
@@ -21,7 +21,7 @@ module ODBA
   end
   class TargetSubclass < Target
   end
-  class TestIndexCommon < Test::Unit::TestCase
+  class TestIndexCommon < Minitest::Test
     include FlexMock::TestCase
     def setup
       @storage = flexmock('Storage')
@@ -34,6 +34,12 @@ module ODBA
       df.resolve_search_term = :term
       @index = IndexCommon.new(df, ODBA)
     end
+    def teardown
+      @storage = nil
+      ODBA.storage = nil
+      load = File.expand_path(File.join(File.dirname(__FILE__), '../lib/odba/storage.rb'))
+      super
+    end
     def test_delete
       handle = flexmock('DB-Handle')
       @storage.should_receive(:delete_index_element)\
@@ -166,15 +172,12 @@ module ODBA
     def test_update__subclass
       origin = OriginSubclass.new
       target = TargetSubclass.new
-      assert_nothing_raised { 
-        @index.update(origin)
-      }
-      assert_nothing_raised { 
-        @index.update(target)
-      }
+      @storage.should_receive(:index_target_ids).and_return(3)
+      @index.update(origin)
+      @index.update(target)
     end
   end
-  class TestIndex < Test::Unit::TestCase
+  class TestIndex < Minitest::Test
     include FlexMock::TestCase
     def setup
       @storage = flexmock('Storage')
@@ -202,7 +205,7 @@ module ODBA
       assert_equal(['resolved'], @index.search_terms(origin))
     end
   end
-  class TestConditionIndex < Test::Unit::TestCase
+  class TestConditionIndex < Minitest::Test
     include FlexMock::TestCase
     def setup
       @storage = flexmock('Storage')
@@ -299,7 +302,7 @@ module ODBA
       @index.update_origin(origin1)
     end
   end
-  class TestFulltextIndex < Test::Unit::TestCase
+  class TestFulltextIndex < Minitest::Test
     include FlexMock::TestCase
     def setup
       @storage = flexmock('Storage')

data/test/test_marshal.rb

@@ -2,14 +2,17 @@
 
 $: << File.expand_path('../lib', File.dirname(__FILE__))
 
-require 'test/unit'
+require 'minitest/autorun'
 require 'odba/marshal'
 
 module ODBA
-	class TestMarshal < Test::Unit::TestCase
+	class TestMarshal < Minitest::Test
 		def setup
 			@foo = Array.new
 		end
+    def teardown
+      super
+    end
 		def test_dump
 			assert_equal("04085b00",ODBA::Marshal.dump(@foo))
 		end
@@ -17,7 +20,7 @@ module ODBA
 			assert_equal(@foo, ODBA::Marshal.load("04085b00"))
 		end
     def test_load_18_in_19
-      if RUBY_VERSION >= '1.9'
+      if RUBY_VERSION >= '1.9' and false
         require 'odba/18_19_loading_compatibility'
         binary = "\004\bu:\tDate=\004\b[\bo:\rRational\a:\017@numeratori\003\205\353J:\021@denominatori\ai\000i\003\031\025#".unpack('H*').first
         date = Marshal.load(binary)

data/test/test_persistable.rb

@@ -10,7 +10,7 @@ require 'odba/cache'
 require 'odba/odba'
 require 'odba/storage'
 require 'odba/marshal'
-require 'test/unit'
+require 'minitest/autorun'
 require 'flexmock'
 require 'yaml'
 
@@ -20,14 +20,14 @@ module ODBA
 		attr_writer :odba_id
 		public :odba_replace_excluded!
 	end
-	class TestPersistable < Test::Unit::TestCase
+	class TestPersistable < Minitest::Test
     include FlexMock::TestCase
 		class ODBAExcluding
 			include ODBA::Persistable
 			ODBA_EXCLUDE_VARS = ["@excluded"]
 			attr_accessor :included, :excluded
 		end
-		class ODBAContainer
+		class ODBAContainerInPersistable
 		 include ODBA::Persistable
 		 ODBA_SERIALIZABLE = ['@serializable']
 		 attr_accessor	:non_replaceable, :replaceable, :replaceable2, 
@@ -43,43 +43,37 @@ module ODBA
       #attr_accessor :origin
       odba_index :name
       odba_index :foo, :bar
-      odba_index :origin, :origin, :non_replaceable, ODBAContainer
+      odba_index :origin, :origin, :non_replaceable, ODBAContainerInPersistable
       odba_index :redirect, 'redirect.name'
     end
 		def setup
 			ODBA.storage = flexmock("storage")
-			ODBA.marshaller = flexmock("marshaller")
+			ODBA.marshaller = flexmock("marshaller_persistable")
 			ODBA.cache = flexmock("cache")
-			@odba  = ODBAContainer.new
+			@odba  = ODBAContainerInPersistable.new
 		end
 		def teardown
-			ODBA.storage.mock_verify
-			ODBA.marshaller.mock_verify
-			ODBA.cache.mock_verify
+			ODBA.storage.flexmock_verify
+			ODBA.marshaller.flexmock_verify
+			ODBA.cache.flexmock_verify
 			ODBA.storage = nil
 			ODBA.marshaller = nil
 			ODBA.cache = nil
+      super
 		end
 		def test_odba_id
-			ODBA.cache.mock_handle(:next_id) { ||
-				2
-			}
-			ODBA.marshaller.mock_handle(:dump) { |obj|
-				"foo"
-			}
-			ODBA.storage.mock_handle(:store) { |id,obj|}
+      DBA.cache.should_receive(:next_id).with().and_return(2)
+      ODBA.marshaller.should_receive(:dump).and_return('foo')
+      ODBA.storage.should_receive(:store)
 			@odba.odba_take_snapshot(1)
 			assert_equal(2, @odba.odba_id)
-			ODBA.storage.mock_verify
-			ODBA.marshaller.mock_verify
+			ODBA.storage.flexmock_verify
+			ODBA.marshaller.flexmock_verify
 		end
 		def test_odba_delete
-			odba_container = ODBAContainer.new
+			odba_container = ODBAContainerInPersistable.new
 			odba_container.odba_id = 2
-			#ODBA.storage.mock_handle(:transaction) { |block| block.call}
-			ODBA.cache.mock_handle(:delete) { |object|
-				assert_equal(odba_container, object)
-			}
+      ODBA.cache.should_receive(:delete).with(odba_container)
 			odba_container.odba_delete
 		end
 		def test_odba_replace_excluded
@@ -101,37 +95,25 @@ module ODBA
 			assert_equal(@odba.replaceable, substitution)
 		end
 		def test_odba_take_snapshot
-			level1 = ODBAContainer.new
-			level2 = ODBAContainer.new
+			level1 = ODBAContainerInPersistable.new
+			level2 = ODBAContainerInPersistable.new
 			@odba.replaceable = level1
 			level1.replaceable = level2
-
-			ODBA.cache.mock_handle(:store) { |obj| 2} 
-			ODBA.cache.mock_handle(:store) { |obj| 2}
-
-			ODBA.cache.mock_handle(:store) { |obj| 2}
-			
+      ODBA.cache.should_receive(:store).with(FlexMock.any).times(3).and_return(2)
 			@odba.odba_take_snapshot
 			assert_equal(1, @odba.odba_snapshot_level)
 			assert_equal(1, level1.odba_snapshot_level)
 			assert_equal(1, level2.odba_snapshot_level)
-			ODBA.cache.mock_verify
+			ODBA.cache.flexmock_verify
 		end
 		def test_odba_unsaved_neighbors
 			replaceable = flexmock
 			@odba.replaceable = replaceable
-=begin
-			replaceable.mock_handle(:is_a?) { |arg| false }
-			replaceable.mock_handle(:is_a?) { |arg| false }
-=end
-			replaceable.mock_handle(:is_a?) { |arg| 
-				assert_equal(Persistable, arg)
-				true 
-			}
-			replaceable.mock_handle(:odba_unsaved?){ |level| true}
+      replaceable.should_receive(:is_a?).with(Persistable).and_return(true)
+      replaceable.should_receive(:odba_unsaved?).with(FlexMock.any).and_return(true)
 			result = @odba.odba_unsaved_neighbors(2)
 			assert_equal([replaceable], result)
-			replaceable.mock_verify
+			replaceable.flexmock_verify
 		end
 		def test_odba_unsaved_neighbors_2
 			odba = ODBAExcluding.new
@@ -139,37 +121,22 @@ module ODBA
 			excluded = flexmock
 			odba.excluded  = excluded
 			odba.included = included
-=begin
-			included.mock_handle(:is_a?) { |klass|
-				assert_equal(Hash, klass)
-				false 
-			}
-			included.mock_handle(:is_a?) { |klass|
-				assert_equal(Array, klass)
-				false 
-			}
-=end
-			included.mock_handle(:is_a?) { |klass|
-				assert_equal(ODBA::Persistable, klass)
-				true
-			}
-			included.mock_handle(:odba_unsaved?) { true }
+      included.should_receive(:is_a?).with(Persistable).and_return(true)
+      included.should_receive(:odba_unsaved?).with(FlexMock.any).and_return(true)
 			result = odba.odba_unsaved_neighbors(2)
 			assert_equal([included], result)
-			excluded.mock_verify
-			included.mock_verify
+			excluded.flexmock_verify
+			included.flexmock_verify
 		end
 		def test_extend_enumerable
 			hash = Hash.new
 			array = Array.new
-			#@odba.odba_extend_enumerable(hash)
-			#@odba.odba_extend_enumerable(array)
 			assert_equal(true, hash.is_a?(Persistable))
 			assert_equal(true, array.is_a?(Persistable))
 		end
 		def test_odba_stubize
-			replaceable = ODBAContainer.new
-			non_rep = ODBAContainer.new
+			replaceable = ODBAContainerInPersistable.new
+			non_rep = ODBAContainerInPersistable.new
 			non_rep.odba_id = 32
 			replaceable.odba_id = 24
 			@odba.replaceable = replaceable
@@ -177,10 +144,10 @@ module ODBA
 			@odba.odba_stubize(replaceable)
 			assert_equal(24, @odba.replaceable.odba_id)
 			assert_equal(true, @odba.replaceable.is_a?(Stub))
-			assert_equal(true, @odba.non_replaceable.is_a?(ODBAContainer))
+			assert_equal(true, @odba.non_replaceable.is_a?(ODBAContainerInPersistable))
 		end
 		def test_odba_replace_persistables
-			replaceable = ODBAContainer.new
+			replaceable = ODBAContainerInPersistable.new
 			replaceable.odba_id = 12
 			non_replaceable = flexmock
 			@odba.non_replaceable = non_replaceable
@@ -189,32 +156,26 @@ module ODBA
         .times(1).and_return(false)
 			non_replaceable.should_receive(:is_a?).with(Persistable)\
         .times(1).and_return(false)
-			#ODBA.cache.mock_handle(:next_id){ 13 }
 			@odba.odba_replace_persistables
 			assert_instance_of(FlexMock, @odba.non_replaceable)
 			assert_equal(12, @odba.replaceable.odba_id)
 			assert_equal(true, @odba.replaceable.is_a?(Stub))
-			non_replaceable.mock_verify
-			ODBA.cache.mock_verify
+			non_replaceable.flexmock_verify
+			ODBA.cache.flexmock_verify
 		end
 		def test_odba_replace_persistables__stubised_serialisable
 			non_replaceable = flexmock
 			@odba.serializable = non_replaceable
-			non_replaceable.mock_handle(:is_a?) { |arg|
-				assert_equal(Stub, arg)
-				true
-			}
-			non_replaceable.mock_handle(:odba_instance) { 
-				'serialize this'
-			}
+      non_replaceable.should_receive(:is_a?).with(Stub).and_return(true)
+      non_replaceable.should_receive(:odba_instance).and_return('serialize this')
 			@odba.odba_replace_persistables
 			assert_equal('serialize this', @odba.serializable)
-			non_replaceable.mock_verify
+			non_replaceable.flexmock_verify
 		end
 		def test_odba_store_unsaved
-			level1 = ODBAContainer.new
-			level2 = ODBAContainer.new
-			saved = ODBAContainer.new
+			level1 = ODBAContainerInPersistable.new
+			level2 = ODBAContainerInPersistable.new
+			saved = ODBAContainerInPersistable.new
 			@odba.replaceable = level1
 			@odba.non_replaceable = saved
 			level1.replaceable = level2
@@ -228,8 +189,8 @@ module ODBA
 			@odba.odba_store_unsaved
 		end
 		def test_odba_store_unsaved_hash
-			level1 = ODBAContainer.new
-			hash_element = ODBAContainer.new
+			level1 = ODBAContainerInPersistable.new
+			hash_element = ODBAContainerInPersistable.new
 			hash = Hash.new
 			non_rep_hash = Hash.new
 			level1.replaceable = hash
@@ -253,21 +214,17 @@ module ODBA
 			@odba.replaceable = stub
 			@odba.replaceable2 = stub2
 			@odba.non_replaceable = 4
-			stub.mock_handle(:is_a?) { true }
-			stub.mock_handle(:odba_dup) { stub }
+      stub.should_receive(:is_a?).with_no_args.and_return(true)
+      stub.should_receive(:odba_dup).with_no_args.and_return(stub)
 			stub_container = nil
-			stub.mock_handle(:odba_container=) { |obj| 
-				stub_container = obj
-			}
-			stub2.mock_handle(:is_a?) { true }
-			stub2.mock_handle(:odba_dup) { stub2 }
+      stub.should_receive(:odba_container=).with_no_args.and_return(stub_container)
+      stub2.should_receive(:is_a?).with_no_args.and_return(true)
+      stub2.should_receive(:odba_dup).with_no_args.and_return(stub2)
 			stub_container2 = nil
-			stub2.mock_handle(:odba_container=) { |obj|
-				stub_container2 = obj
-			}
+      stub2.should_receive(:odba_container=).with_no_args.and_return(stub_container2)
 			odba_twin = @odba.odba_dup
-			odba_twin.replaceable.mock_verify
-			odba_twin.replaceable2.mock_verify
+			odba_twin.replaceable.flexmock_verify
+			odba_twin.replaceable2.flexmock_verify
 			assert_equal(odba_twin, stub_container)	
 			assert_equal(odba_twin, stub_container2)	
 		end
@@ -280,22 +237,20 @@ module ODBA
 			replaceable2 = flexmock("rep2")
 			@odba.replaceable = replaceable
 			@odba.replaceable2 = replaceable2
-			replaceable.mock_handle(:is_a?) { |arg| 
-				true # is_a?(Persistable) 
-			}
-			replaceable.mock_handle(:odba_id) { 12 }
-			replaceable2.mock_handle(:is_a?) { |arg| false }
+      replaceable.should_receive(:is_a?).with(ODBA::Persistable).and_return(true)
+      replaceable.should_receive(:odba_id).with_no_args.and_return(12)
+      replaceable2.should_receive(:is_a?).with(ODBA::Persistable).and_return(false)
 			expected = [12]
 			assert_equal(expected, @odba.odba_target_ids.sort)
-			replaceable.mock_verify
-			replaceable2.mock_verify
+			replaceable.flexmock_verify
+			replaceable2.flexmock_verify
 		end
 		def test_odba_isolated_dump
 			replaceable = flexmock("Replaceable")
 			replaceable2 = flexmock("Replaceable2")
 			@odba.replaceable = replaceable
 			@odba.replaceable2 = replaceable2
-			ODBA.cache.mock_handle(:next_id){ 11 }
+      ODBA.cache.should_receive(:next_id).with_no_args.and_return(11)
 
       ### from odba_dup and odba_replace_persistables
 			replaceable2.should_receive(:is_a?).with(Stub)\
@@ -308,18 +263,15 @@ module ODBA
       responses = [false, true]
 			replaceable.should_receive(:is_a?).with(Stub)\
         .times(2).and_return { responses.shift }
-			replaceable.should_receive(:odba_clear_receiver).times(1)
+      replaceable.should_receive(:odba_clear_receiver).times(1)
 			replaceable.should_receive(:odba_container=).with(@odba.class).times(1)
-			ODBA.marshaller.mock_handle(:dump) { |twin|
-        assert(twin.replaceable2.is_a?(ODBA::Stub))
-				"TheDump"
-			}
+      ODBA.marshaller.should_receive(:dump).and_return{ |twin| assert(twin.replaceable2.is_a?(ODBA::Stub)); "TheDump" }
 			result = @odba.odba_isolated_dump
 			assert_equal(replaceable, @odba.replaceable)
 			assert_equal(replaceable2, @odba.replaceable2)
 			assert_equal("TheDump", result)
-			replaceable.mock_verify
-			replaceable2.mock_verify
+			replaceable.flexmock_verify
+			replaceable2.flexmock_verify
 		end
 		def test_odba_isolated_dump_2
 			tmp = ODBA.marshaller
@@ -327,7 +279,7 @@ module ODBA
 			odba = ODBAExcluding.new
 			odba.excluded = "foo"
 			odba.included = "baz"
-			ODBA.cache.mock_handle(:next_id) { 1 }
+      ODBA.cache.should_receive(:next_id).and_return(1)
 			dump, hash = odba.odba_isolated_dump
 			obj = ODBA.marshaller.load(dump)
 			assert_equal(nil, obj.excluded)
@@ -336,22 +288,19 @@ module ODBA
 		end
 		def test_odba_id
 			@odba.odba_id = nil
-			ODBA.cache.mock_handle(:next_id) { 1 }
+      ODBA.cache.should_receive(:next_id).and_return(1)
 			assert_equal(1, @odba.odba_id)
-			ODBA.storage.mock_verify
+			ODBA.storage.flexmock_verify
 		end
 		def test_odba_dump_has_id
 			@odba.odba_id = nil
-			ODBA.cache.mock_handle(:store) { |obj|
-			ODBA.cache.mock_handle(:next_id) { 1 }
-				assert_equal(1, obj.odba_id)
-			}
+      ODBA.cache.should_receive(:store).with(FlexMock.any)
+      ODBA.cache.should_receive(:next_id).with(1).and_return(1)
 			@odba.odba_store
 		end
 		def test_odba_store_error_raised
 			@odba.odba_name = "foo"
-			#ODBA.storage.mock_handle(:transaction) { |block| block.call}
-			ODBA.cache.mock_handle(:store) { |dump|
+      ODBA.cache.should_receive(:store).with(FlexMock.any).and_return { |dump|
 				raise DBI::ProgrammingError
 			}
 			assert_raises(DBI::ProgrammingError) {
@@ -361,38 +310,31 @@ module ODBA
 		end
 		def test_odba_store_no_error_raised
 			@odba.odba_name = "foo"
-			#ODBA.storage.mock_handle(:transaction) { |block| block.call}
-			ODBA.cache.mock_handle(:store) { |obj| 
-				assert_equal(@odba, obj)
-			}
+      ODBA.cache.should_receive(:store).with(@odba)
 			@odba.odba_store('bar')
 			assert_equal("bar", @odba.odba_name)
 		end
 		def test_inspect_with_stub_in_array
-			ODBA.cache.mock_handle(:next_id) { 12 }
-			ODBA.cache.mock_handle(:next_id) { 13 }
-			content = ODBAContainer.new
+      ODBA.cache.should_receive(:next_id).with_no_args.and_return(12)
+      ODBA.cache.should_receive(:next_id).with_no_args.and_return(13)
+			content = ODBAContainerInPersistable.new
 			@odba.instance_variable_set('@contents', [content])
 			twin = @odba.odba_isolated_twin
-			assert_not_nil(/@contents=#<ODBA::Stub:/.match(twin.inspect))
-			ODBA.storage.mock_verify
+			refute_nil(/@contents=#<ODBA::Stub:/.match(twin.inspect))
+			ODBA.storage.flexmock_verify
 		end
 		def test_to_yaml
 			yaml = ''
-			assert_nothing_raised { 
-				yaml = @odba.to_yaml
-			}
+      yaml = @odba.to_yaml
 			loaded = YAML.load(yaml)
-			assert_instance_of(ODBAContainer, loaded)
+			assert_instance_of(ODBAContainerInPersistable, loaded)
 		end
     def test_extend
-			ODBA.cache.mock_handle(:store) { |obj| assert_equal('foo', obj) } 
+      ODBA.cache.should_receive(:store).with('foo')
       str = 'foo'
       str.extend(Persistable)
-      assert_nothing_raised { 
-        str.odba_store
-      }
-      ODBA.cache.mock_verify
+      str.odba_store
+      ODBA.cache.flexmock_verify
     end
     def test_odba_index__simple
       stub = IndexedStub.new
@@ -533,19 +475,13 @@ module ODBA
     def test_odba_extent
       stub = IndexedStub.new
       assert_respond_to(IndexedStub, :odba_extent)
-      ODBA.cache.mock_handle(:extent) { |klass|
-        assert_equal(IndexedStub, klass)
-        []
-      }
+      ODBA.cache.should_receive(:extent).with(IndexedStub).and_return([])
       assert_equal([], IndexedStub.odba_extent)
     end
     def test_odba_extent__with_block
       stub = IndexedStub.new
       assert_respond_to(IndexedStub, :odba_extent)
-      ODBA.cache.mock_handle(:extent) { |klass|
-        assert_equal(IndexedStub, klass)
-        ['foo']
-      }
+      ODBA.cache.should_receive(:extent).with(IndexedStub).and_return(['foo'])
       IndexedStub.odba_extent { |obj|
         assert_equal('foo', obj)
       }
@@ -585,7 +521,7 @@ module ODBA
     end
     def test_odba_notify_observers
       obs = flexmock('Observer')
-      @odba.odba_id = 14
+      @odba.odba_id = 218
       @odba.instance_variable_set('@odba_observers', [obs])
       obs.should_receive(:odba_update).with(:key, 'foo', 'bar')\
         .and_return { assert(true) }
@@ -600,25 +536,21 @@ module ODBA
       assert(p.is_a?(ODBA::Persistable))
       stub2 = p.instance_variable_get('@stub')
       assert(stub2.is_a?(ODBA::Stub))
-      assert_not_equal(stub.object_id, stub2.object_id)
+      refute_equal(stub.object_id, stub2.object_id)
       assert_equal(15, stub2.odba_id)
     end
     def test_odba_isolated_stub
-      @odba.odba_id = 14
+      @odba.odba_id = 214
       stub = @odba.odba_isolated_stub
       assert(stub.is_a?(ODBA::Stub))
-      assert(stub.is_a?(ODBAContainer))
-      assert_equal(14, stub.odba_id)
-      assert_equal(ODBAContainer, stub.class)
-      ODBA.cache.mock_handle(:fetch) { |id, clr|
-        assert_equal(14, id)
-        assert_equal(nil, clr)
-        @odba
-      }
+      assert(stub.is_a?(ODBAContainerInPersistable))
+      assert_equal(214, stub.odba_id)
+      assert_equal(ODBAContainerInPersistable, stub.class)
+      ODBA.cache.should_receive(:fetch).with(214, nil).times(1).and_return(@odba)
       assert_equal(@odba, stub.odba_instance)
     end
     def test_odba_collection
-      o = ODBAContainer.new
+      o = ODBAContainerInPersistable.new
       assert_equal([], o.odba_collection)
     end
 	end