odba 1.0.0

data/test/test_index.rb

@@ -0,0 +1,371 @@
+#!/usr/bin/env ruby
+# TestIndex -- oddb -- 13.05.2004 -- hwyss@ywesee.com mwalder@ywesee.com
+
+$: << File.dirname(__FILE__)
+$: << File.expand_path("../lib", File.dirname(__FILE__))
+
+require 'test/unit'
+require 'odba/index'
+require 'odba/index_definition'
+require 'odba/odba'
+require 'flexmock'
+
+module ODBA
+  class Origin
+    attr_accessor :term, :odba_id
+  end
+  class OriginSubclass < Origin
+  end
+  class Target
+    attr_accessor :origin, :odba_id
+  end
+  class TargetSubclass < Target
+  end
+  class TestIndexCommon < Test::Unit::TestCase
+    include FlexMock::TestCase
+    def setup
+      @storage = flexmock('Storage')
+      ODBA.storage = @storage
+      df = IndexDefinition.new
+      df.index_name = 'index'
+      df.origin_klass = :Origin
+      df.target_klass = :Target
+      df.resolve_origin = :origin
+      df.resolve_search_term = :term
+      @index = IndexCommon.new(df, ODBA)
+    end
+    def test_delete
+      handle = flexmock('DB-Handle')
+      @storage.should_receive(:delete_index_element)\
+        .with('index', 15, 'origin_id')\
+        .times(1).and_return {assert(true) }
+      origin = Origin.new
+      origin.odba_id = 15
+      @index.delete(origin)
+      @storage.should_receive(:delete_index_element)\
+        .with('index', 16, 'target_id')\
+        .times(1).and_return {assert(true) }
+      target = Target.new
+      target.odba_id = 16
+      @index.delete(target)
+    end
+    def test_do_update_index
+      @storage.should_receive(:update_index)\
+        .with('index', 12, 'foo', nil).and_return {
+        assert(true)
+      }
+      @index.do_update_index(12, 'foo')
+    end
+    def test_fill
+      df = IndexDefinition.new
+      df.index_name = 'index'
+      df.resolve_origin = 'get_origin'
+      df.resolve_search_term = 'the_search_term'
+      index = IndexCommon.new(df, self)
+
+      origin = flexmock('origin')
+      origin.should_receive(:the_search_term).and_return('tst')
+      origin.should_receive(:odba_id).and_return(4)
+      target = flexmock('target')
+      target.should_receive(:get_origin).and_return(origin)
+      target.should_receive(:odba_id).and_return(3)
+
+      targets = [target, [target]]
+
+      @storage.should_receive(:update_index)\
+        .with('index', 4, 'tst', 3).times(2).and_return { assert(true) }
+
+      index.fill(targets)
+    end
+    def test_keys
+      @storage.should_receive(:index_fetch_keys).with('index', nil)\
+        .and_return { ['key1', 'key2', ''] }
+      assert_equal(%w{key1 key2}, @index.keys)
+      @storage.should_receive(:index_fetch_keys).with('index', 2)\
+        .and_return { ['k1', 'k2', ''] }
+      assert_equal(%w{k1 k2}, @index.keys(2))
+      @storage.should_receive(:index_fetch_keys).with('index', 1)\
+        .and_return { ['1', '2', ''] }
+      assert_equal(%w{1 2}, @index.keys(1))
+    end
+    def test_origin_class
+      df = IndexDefinition.new
+      df.index_name = 'index'
+      df.origin_klass = :Origin
+      index = IndexCommon.new(df, self)
+      assert_equal(true, index.origin_class?(Origin))
+      assert_equal(false, index.origin_class?(Target))
+    end
+    def test_proc_instance_origin
+      df = IndexDefinition.new
+      df.index_name = 'index'
+      index = IndexCommon.new(df, self)
+      pr = index.proc_instance_origin
+      stub = Object.new
+      assert_equal([stub], pr.call(stub))
+    end
+    def test_proc_resolve_search_term
+      df = IndexDefinition.new
+      df.index_name = 'index'
+      index = IndexCommon.new(df, self)
+      pr = index.proc_resolve_search_term
+      stub = Object.new
+      assert_equal(stub.to_s.downcase, pr.call(stub))
+    end
+    def test_search_term
+      idf = IndexDefinition.new
+      idf.index_name = 'index'
+      idf.resolve_search_term = 'resolve_it'
+      origin = flexmock('origin')
+      origin.should_receive(:resolve_it).times(1).and_return('myterm')
+      index = IndexCommon.new(idf, ODBA)
+      assert_equal('myterm', index.search_term(origin))
+    end
+    def test_set_relevance
+      meta = flexmock('Meta')
+      meta.should_receive(:respond_to?).with(:set_relevance).and_return(true)
+      meta.should_receive(:set_relevance).with('foo', 'bar').and_return {
+        assert(true) }
+      meta.should_receive(:set_relevance).with('baz', 'fro').and_return {
+        assert(true) }
+      @index.set_relevance(meta, [%w{foo bar}, %w{baz fro}])
+    end
+    def test_update__origin
+      origin = Origin.new
+      origin.odba_id = 1
+      origin.term = "search-term"
+      @storage.should_receive(:index_target_ids).with('index', 1)\
+        .and_return([[3, 'old-term'], [4, 'old-term']])
+      @storage.should_receive(:index_delete_origin).with('index', 1, "old-term")
+      @storage.should_receive(:update_index)\
+        .with('index', 1, 'search-term', 3).and_return { 
+        assert(true) }
+      @storage.should_receive(:update_index)\
+        .with('index', 1, 'search-term', 4).and_return { 
+        assert(true) }
+      @index.update(origin)
+    end
+    def test_update__target
+      origin = Origin.new
+      origin.odba_id = 1
+      origin.term = "search-term"
+      target = Target.new
+      target.odba_id = 2
+      target.origin = origin
+      @storage.should_receive(:index_origin_ids).with('index', 2)\
+        .and_return([[1, 'old-term'], [4, 'obsolete-term']])
+      @storage.should_receive(:index_delete_target)\
+        .with('index', 1, 'old-term', 2).and_return { assert(true) }
+      @storage.should_receive(:index_delete_target)\
+        .with('index', 4, 'obsolete-term', 2).and_return { assert(true) }
+      @storage.should_receive(:update_index)\
+        .with('index', 1, 'search-term', 2).and_return { 
+        assert(true) }
+      @index.update(target)
+    end
+    def test_update__subclass
+      origin = OriginSubclass.new
+      target = TargetSubclass.new
+      assert_nothing_raised { 
+        @index.update(origin)
+      }
+      assert_nothing_raised { 
+        @index.update(target)
+      }
+    end
+  end
+  class TestIndex < Test::Unit::TestCase
+    include FlexMock::TestCase
+    def setup
+      @storage = flexmock('Storage')
+      @storage.should_receive(:create_index).with('index')
+      ODBA.storage = @storage
+      df = IndexDefinition.new
+      df.index_name = 'index'
+      df.origin_klass = :Origin
+      df.target_klass = :Target
+      df.resolve_origin = :origin
+      df.resolve_search_term = :term
+      @index = Index.new(df, self)
+    end
+    def test_fetch_ids
+      rows = [[1,3], [2,2], [3,1]]
+      @storage.should_receive(:retrieve_from_index)\
+        .with('index', 'search-term', false, false).and_return rows
+      assert_equal([1,2,3], @index.fetch_ids('search-term'))
+    end
+    def test_search_terms
+      origin = Origin.new
+      origin.term = 'resolved'
+      assert_equal(['resolved'], @index.search_terms(origin))
+      origin.term = ['resolved']
+      assert_equal(['resolved'], @index.search_terms(origin))
+    end
+  end
+  class TestConditionIndex < Test::Unit::TestCase
+    include FlexMock::TestCase
+    def setup
+      @storage = flexmock('Storage')
+      @storage.should_receive(:create_condition_index)\
+        .with('index', {'crit1' => 'text', 'crit2' => 'Integer'})
+      ODBA.storage = @storage
+      df = IndexDefinition.new
+      df.index_name = 'index'
+      df.origin_klass = :Origin
+      df.target_klass = :Target
+      df.resolve_origin = :origin
+      df.resolve_search_term = [
+        ['crit1', 'term'],
+        ['crit2', {'type' => 'Integer', 'resolve' => 'odba_id'}],
+      ]
+      @index = ConditionIndex.new(df, self)
+    end
+    def test_do_update_index
+      data = {'crit1' => 'foo', 'condition' => 'like'}
+      @storage.should_receive(:update_condition_index)\
+        .with('index', 2, data, 3)
+      @index.do_update_index(2, data, 3)
+    end
+    def test_fetch_ids
+      rows = [[1,3], [2,2], [3,1]]
+      data = {'crit1' => 'foo', 'condition' => 'like'}
+      @storage.should_receive(:retrieve_from_condition_index)\
+        .with('index', data, false).and_return rows
+      assert_equal([1,2,3], @index.fetch_ids(data))
+    end
+    def test_proc_resolve_search_term
+      pr = @index.proc_resolve_search_term
+      origin = Origin.new
+      origin.term = 'search_term'
+      origin.odba_id = 15
+      expected = {
+        'crit1' => 'search_term',
+        'crit2' => 15,
+      }
+      assert_equal(expected, pr.call(origin))
+    end
+    def test_update_target
+      @storage.should_receive(:condition_index_ids)\
+        .with('index', 4, 'target_id').and_return {
+        [
+          {'origin_id' => 1, 'crit1' => '1st', 
+          'crit2' => 1, 'target_id' => 5},
+          {'origin_id' => 1, 'crit1' => '1st', 
+          'crit2' => 2, 'target_id' => 5},
+        ]
+      }
+      target = Target.new
+      target.odba_id = 4
+      origin1 = Origin.new
+      origin1.odba_id = 1
+      origin1.term = '1st'
+      origin2 = Origin.new
+      origin2.term = '2nd'
+      origin2.odba_id = 2
+      target.origin = [origin1, origin2]
+      @storage.should_receive(:condition_index_delete)\
+        .with('index', 1, [['crit1', '1st'], ['crit2', 2]], 4)\
+        .and_return { assert(true) }
+      @storage.should_receive(:update_condition_index)\
+        .with('index', 2, [['crit1', '2nd'], ['crit2', 2]], 4)\
+        .and_return { assert(true) }
+      @index.update_target(target)
+    end
+    def test_update_origin
+      @storage.should_receive(:condition_index_ids)\
+        .with('index', 1, 'origin_id').and_return {
+        [
+          {'origin_id' => 1, 'crit1' => '1st', 
+          'crit2' => 1, 'target_id' => 5},
+          {'origin_id' => 1, 'crit1' => '1st', 
+          'crit2' => 2, 'target_id' => 5},
+        ]
+      }
+      target = Target.new
+      target.odba_id = 4
+      origin1 = Origin.new
+      origin1.odba_id = 1
+      origin1.term = '1st'
+      origin2 = Origin.new
+      origin2.term = '2nd'
+      origin2.odba_id = 2
+      target.origin = [origin1, origin2]
+      @storage.should_receive(:condition_index_delete)\
+        .with('index', 1, [['crit1', '1st'], ['crit2', 2]])\
+        .and_return { assert(true) }
+      @storage.should_receive(:update_condition_index)\
+        .with('index', 2, [['crit1', '2nd'], ['crit2', 2]])\
+        .and_return { assert(true) }
+      @index.update_origin(origin1)
+    end
+  end
+  class TestFulltextIndex < Test::Unit::TestCase
+    include FlexMock::TestCase
+    def setup
+      @storage = flexmock('Storage')
+      @storage.should_receive(:create_fulltext_index).with('index')
+      ODBA.storage = @storage
+      df = IndexDefinition.new
+      df.index_name = 'index'
+      df.dictionary = 'german'
+      df.origin_klass = :Origin
+      df.target_klass = :Target
+      df.resolve_origin = :origin
+      df.resolve_search_term = 'term'
+      @index = FulltextIndex.new(df, self)
+    end
+    def test_fetch_ids
+      rows = [[1,3], [2,2], [3,1]]
+      @storage.should_receive(:retrieve_from_fulltext_index)\
+        .with('index', 'search-term', 'german', false).and_return rows
+      assert_equal([1,2,3], @index.fetch_ids('search-term'))
+    end
+    def test_do_update_index
+      @storage.should_receive(:update_fulltext_index)\
+        .with('index', 3, 'some full text', 4, 'german')
+      @index.do_update_index(3, 'some full text', 4)
+    end
+    def test_update_target
+      ## only deletes entries for the current target, and inserts from
+      #  all origins
+      @storage.should_receive(:fulltext_index_delete)\
+        .with('index', 4, 'target_id')
+      @storage.should_receive(:update_fulltext_index)\
+        .with('index', 1, 'fulltext term', 4, 'german')
+      @storage.should_receive(:update_fulltext_index)\
+        .with('index', 2, 'fulltext term', 4, 'german')
+      target = Target.new
+      target.odba_id = 4
+      origin1 = Origin.new
+      origin1.odba_id = 1
+      origin1.term = ['fulltext term']
+      origin2 = Origin.new
+      origin2.term = ['fulltext term']
+      origin2.odba_id = 2
+      target.origin = [origin1, origin2]
+      @index.update(target)
+    end
+    def test_update_origin
+      ## deletes all entries for the current origin and must restore
+      #  entries for all targets!
+      @storage.should_receive(:fulltext_index_target_ids)\
+        .times(1).with('index', 1).and_return([[4],[5]])
+      @storage.should_receive(:fulltext_index_delete)\
+        .times(1).with('index', 1, 'origin_id')
+      @storage.should_receive(:update_fulltext_index)\
+        .times(1).with('index', 1, 'fulltext term', 4, 'german')
+      @storage.should_receive(:update_fulltext_index)\
+        .times(1).with('index', 1, 'fulltext term', 5, 'german')
+      target = Target.new
+      target.odba_id = 4
+      origin1 = Origin.new
+      origin1.odba_id = 1
+      origin1.term = ['fulltext term']
+      origin2 = Origin.new
+      origin2.term = ['fulltext term']
+      origin2.odba_id = 2
+      target.origin = [origin1, origin2]
+      @index.update(origin1)
+    end
+  end
+end

data/test/test_marshal.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'odba/marshal'
+
+module ODBA
+	class TestMarshal < Test::Unit::TestCase
+		def setup
+			@foo = Array.new
+		end
+		def test_dump
+			assert_equal("04085b00",ODBA::Marshal.dump(@foo))
+		end
+		def test_load
+			assert_equal(@foo, ODBA::Marshal.load("04085b00"))
+		end
+    def test_load_18_in_19
+      if RUBY_VERSION >= '1.9'
+        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)
+        assert_equal Date.new(2009,5,27), date
+      end
+    end
+	end
+end

data/test/test_persistable.rb

@@ -0,0 +1,625 @@
+#!/usr/bin/env ruby
+# TestPersistable -- odba -- ??.??.???? -- hwyss@ywesee.com
+
+$: << File.dirname(__FILE__)
+$: << File.expand_path('../lib/', File.dirname(__FILE__))
+
+require 'odba/persistable'
+require 'odba/stub'
+require 'odba/cache'
+require 'odba/odba'
+require 'odba/storage'
+require 'odba/marshal'
+require 'test/unit'
+require 'flexmock'
+require 'yaml'
+
+module ODBA
+	module Persistable
+		attr_accessor :odba_references
+		attr_writer :odba_id
+		public :odba_replace_excluded!
+	end
+	class TestPersistable < Test::Unit::TestCase
+    include FlexMock::TestCase
+		class ODBAExcluding
+			include ODBA::Persistable
+			ODBA_EXCLUDE_VARS = ["@excluded"]
+			attr_accessor :included, :excluded
+		end
+		class ODBAContainer
+		 include ODBA::Persistable
+		 ODBA_SERIALIZABLE = ['@serializable']
+		 attr_accessor	:non_replaceable, :replaceable, :replaceable2, 
+			:array, :odba_persistent, :serializable
+		 attr_accessor	:odba_snapshot_level
+		end
+		class Hash
+			include ODBA::Persistable
+			attr_accessor :odba_persistent
+		end
+    class IndexedStub
+      include Persistable
+      #attr_accessor :origin
+      odba_index :name
+      odba_index :foo, :bar
+      odba_index :origin, :origin, :non_replaceable, ODBAContainer
+      odba_index :redirect, 'redirect.name'
+    end
+		def setup
+			ODBA.storage = flexmock("storage")
+			ODBA.marshaller = flexmock("marshaller")
+			ODBA.cache = flexmock("cache")
+			@odba  = ODBAContainer.new
+		end
+		def teardown
+			ODBA.storage.mock_verify
+			ODBA.marshaller.mock_verify
+			ODBA.cache.mock_verify
+			ODBA.storage = nil
+			ODBA.marshaller = nil
+			ODBA.cache = nil
+		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|}
+			@odba.odba_take_snapshot(1)
+			assert_equal(2, @odba.odba_id)
+			ODBA.storage.mock_verify
+			ODBA.marshaller.mock_verify
+		end
+		def test_odba_delete
+			odba_container = ODBAContainer.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_container.odba_delete
+		end
+		def test_odba_replace_excluded
+			odba = ODBAExcluding.new
+			odba.included = "here to stay"
+			odba.excluded = "easy come easy go"
+			odba.odba_replace_excluded!
+			assert_equal("here to stay", odba.included)
+			assert_nil(odba.excluded)
+		end
+		def test_odba_replace_stubs
+			stub = flexmock
+      stub.should_receive(:odba_id).and_return(6)
+      stub.should_receive(:is_a?).with(Stub).and_return(true)
+			@odba.replaceable = stub
+			substitution = flexmock
+      substitution.should_receive(:odba_id).and_return(6)
+			@odba.odba_replace_stubs(6, substitution)
+			assert_equal(@odba.replaceable, substitution)
+		end
+		def test_odba_take_snapshot
+			level1 = ODBAContainer.new
+			level2 = ODBAContainer.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.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
+		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}
+			result = @odba.odba_unsaved_neighbors(2)
+			assert_equal([replaceable], result)
+			replaceable.mock_verify
+		end
+		def test_odba_unsaved_neighbors_2
+			odba = ODBAExcluding.new
+			included = flexmock
+			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 }
+			result = odba.odba_unsaved_neighbors(2)
+			assert_equal([included], result)
+			excluded.mock_verify
+			included.mock_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
+			non_rep.odba_id = 32
+			replaceable.odba_id = 24
+			@odba.replaceable = replaceable
+			@odba.non_replaceable = non_rep
+			@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))
+		end
+		def test_odba_replace_persistables
+			replaceable = ODBAContainer.new
+			replaceable.odba_id = 12
+			non_replaceable = flexmock
+			@odba.non_replaceable = non_replaceable
+			@odba.replaceable = replaceable
+			non_replaceable.should_receive(:is_a?).with(Stub)\
+        .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
+		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'
+			}
+			@odba.odba_replace_persistables
+			assert_equal('serialize this', @odba.serializable)
+			non_replaceable.mock_verify
+		end
+		def test_odba_store_unsaved
+			level1 = ODBAContainer.new
+			level2 = ODBAContainer.new
+			saved = ODBAContainer.new
+			@odba.replaceable = level1
+			@odba.non_replaceable = saved
+			level1.replaceable = level2
+
+			saved.odba_persistent = true
+			ODBA.cache.should_receive(:store).times(3).and_return { 
+        assert(true)
+        2
+      }
+			
+			@odba.odba_store_unsaved
+		end
+		def test_odba_store_unsaved_hash
+			level1 = ODBAContainer.new
+			hash_element = ODBAContainer.new
+			hash = Hash.new
+			non_rep_hash = Hash.new
+			level1.replaceable = hash
+			level1.non_replaceable = non_rep_hash
+			non_rep_hash.odba_persistent = true
+			
+			ODBA.cache.should_receive(:store).times(2).and_return { 
+        assert(true)
+        2
+      }
+			
+			level1.odba_store_unsaved
+		end
+    def test_dup
+      twin = @odba.dup
+      assert_nil(twin.instance_variable_get('@odba_id'))
+    end
+		def test_odba_dup
+			stub = flexmock("stub")
+			stub2 = flexmock("stub2")
+			@odba.replaceable = stub
+			@odba.replaceable2 = stub2
+			@odba.non_replaceable = 4
+			stub.mock_handle(:is_a?) { true }
+			stub.mock_handle(:odba_dup) { 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_container2 = nil
+			stub2.mock_handle(:odba_container=) { |obj|
+				stub_container2 = obj
+			}
+			odba_twin = @odba.odba_dup
+			odba_twin.replaceable.mock_verify
+			odba_twin.replaceable2.mock_verify
+			assert_equal(odba_twin, stub_container)	
+			assert_equal(odba_twin, stub_container2)	
+		end
+		def test_odba_unsaved_true
+			@odba.instance_variable_set("@odba_persistent", false)
+			assert_equal(true, @odba.odba_unsaved?)
+		end
+		def test_odba_target_ids
+			replaceable = flexmock("rep")
+			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 }
+			expected = [12]
+			assert_equal(expected, @odba.odba_target_ids.sort)
+			replaceable.mock_verify
+			replaceable2.mock_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 }
+
+      ### from odba_dup and odba_replace_persistables
+			replaceable2.should_receive(:is_a?).with(Stub)\
+        .times(2).and_return(false)
+			replaceable2.should_receive(:is_a?).with(Persistable)\
+        .times(1).and_return(true)
+			replaceable2.should_receive(:odba_id).times(1).and_return(12)
+
+      ### from odba_dup
+      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_container=).with(@odba.class).times(1)
+			ODBA.marshaller.mock_handle(:dump) { |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
+		end
+		def test_odba_isolated_dump_2
+			tmp = ODBA.marshaller
+			ODBA.marshaller = ODBA::Marshal
+			odba = ODBAExcluding.new
+			odba.excluded = "foo"
+			odba.included = "baz"
+			ODBA.cache.mock_handle(:next_id) { 1 }
+			dump, hash = odba.odba_isolated_dump
+			obj = ODBA.marshaller.load(dump)
+			assert_equal(nil, obj.excluded)
+			assert_equal("baz", obj.included)
+			ODBA.marshaller = tmp
+		end
+		def test_odba_id
+			@odba.odba_id = nil
+			ODBA.cache.mock_handle(:next_id) { 1 }
+			assert_equal(1, @odba.odba_id)
+			ODBA.storage.mock_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.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|
+				raise DBI::ProgrammingError
+			}
+			assert_raises(DBI::ProgrammingError) {
+				@odba.odba_store('baz')
+			}
+			assert_equal("foo", @odba.odba_name)
+		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.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.instance_variable_set('@contents', [content])
+			twin = @odba.odba_isolated_twin
+			assert_not_nil(/@contents=#<ODBA::Stub:/.match(twin.inspect))
+			ODBA.storage.mock_verify
+		end
+		def test_to_yaml
+			yaml = ''
+			assert_nothing_raised { 
+				yaml = @odba.to_yaml
+			}
+			loaded = YAML.load(yaml)
+			assert_instance_of(ODBAContainer, loaded)
+		end
+    def test_extend
+			ODBA.cache.mock_handle(:store) { |obj| assert_equal('foo', obj) } 
+      str = 'foo'
+      str.extend(Persistable)
+      assert_nothing_raised { 
+        str.odba_store
+      }
+      ODBA.cache.mock_verify
+    end
+    def test_odba_index__simple
+      stub = IndexedStub.new
+      assert_respond_to(stub, :name)
+      assert_respond_to(stub, :name=)
+      assert_respond_to(IndexedStub, :find_by_name)
+      result = flexmock('Result')
+
+      ## search by one key
+      name = 'odba_testpersistable_indexedstub_name'
+      args = 'xan'
+      ODBA.cache.should_receive(:retrieve_from_index).with(name, args)\
+        .times(1).and_return([result])
+      assert_equal([result], IndexedStub.search_by_name('xan'))
+
+      ## exact search by one key
+      ODBA.cache.should_receive(:retrieve_from_index)\
+        .with(name, args, ODBA::Persistable::Exact)\
+        .times(1).and_return([result])
+      assert_equal([result], IndexedStub.search_by_exact_name('xan'))
+
+      ## find by one key
+      ODBA.cache.should_receive(:retrieve_from_index)\
+        .with(name, args, ODBA::Persistable::Find)\
+        .times(1).and_return([result])
+      assert_equal(result, IndexedStub.find_by_name('xan'))
+
+      ## list available keys
+      ODBA.cache.should_receive(:index_keys).with(name, nil)\
+        .times(1).and_return(['key1', 'key2'])
+      assert_equal(['key1', 'key2'], IndexedStub.name_keys)
+      ODBA.cache.should_receive(:index_keys).with(name, 2)\
+        .times(1).and_return(['k1', 'k2'])
+      assert_equal(['k1', 'k2'], IndexedStub.name_keys(2))
+    end
+    def test_odba_index__multikey
+      stub = IndexedStub.new
+      assert_respond_to(stub, :foo)
+      assert_respond_to(stub, :bar)
+      assert_respond_to(IndexedStub, :find_by_foo_and_bar)
+      result = flexmock('Result')
+
+      ## search by multiple keys
+      name = 'odba_testpersistable_indexedstub_foo_and_bar'
+      args = {
+        :foo => { 'condition' => 'like', 'value' => 'oof'},
+        :bar => { 'condition' => 'like', 'value' => 'rab'},
+      }
+      ODBA.cache.should_receive(:retrieve_from_index).with(name, args)\
+        .times(1).and_return([result])
+      assert_equal([result], 
+                   IndexedStub.search_by_foo_and_bar('oof', 'rab'))
+
+      ## exact search by multiple keys
+      args = {:foo => 'oof', :bar => 'rab'}
+      ODBA.cache.should_receive(:retrieve_from_index)\
+        .with(name, args, Persistable::Exact)\
+        .times(1).and_return([result])
+      assert_equal([result], 
+                   IndexedStub.search_by_exact_foo_and_bar('oof', 'rab'))
+
+      ## find by multiple keys
+      args = {:foo => {'value' => 7,'condition' => '='}, 
+              :bar => {'value' => 'rab','condition' => 'like'}}
+      ODBA.cache.should_receive(:retrieve_from_index)\
+        .with(name, args, Persistable::Find)\
+        .times(1).and_return([result])
+      assert_equal(result, IndexedStub.find_by_foo_and_bar(7, 'rab'))
+    end
+    def test_odba_index__directional
+      stub = IndexedStub.new
+      assert_respond_to(stub, :origin)
+      assert_respond_to(stub, :origin=)
+      assert_respond_to(IndexedStub, :find_by_origin)
+      result = flexmock('Result')
+
+      ## search by one key
+      name = 'odba_testpersistable_indexedstub_origin'
+      args = 'xan'
+      ODBA.cache.should_receive(:retrieve_from_index).with(name, args)\
+        .times(1).and_return([result])
+      assert_equal([result], IndexedStub.search_by_origin('xan'))
+
+      ## exact search by one key
+      ODBA.cache.should_receive(:retrieve_from_index)\
+        .with(name, args, ODBA::Persistable::Exact)\
+        .times(1).and_return([result])
+      assert_equal([result], IndexedStub.search_by_exact_origin('xan'))
+
+      ## find by one key
+      ODBA.cache.should_receive(:retrieve_from_index)\
+        .with(name, args, ODBA::Persistable::Find)\
+        .times(1).and_return([result])
+      assert_equal(result, IndexedStub.find_by_origin('xan'))
+
+      ## list available keys
+      ODBA.cache.should_receive(:index_keys).with(name, nil)\
+        .times(1).and_return(['key1', 'key2'])
+      assert_equal(['key1', 'key2'], IndexedStub.origin_keys)
+      ODBA.cache.should_receive(:index_keys).with(name, 2)\
+        .times(1).and_return(['k1', 'k2'])
+      assert_equal(['k1', 'k2'], IndexedStub.origin_keys(2))
+    end
+    def test_odba_index__redirected
+      stub = IndexedStub.new
+      assert_respond_to(stub, :redirect)
+      assert_respond_to(stub, :redirect=)
+      assert_respond_to(IndexedStub, :find_by_redirect)
+      result = flexmock('Result')
+
+      ## search by one key
+      name = 'odba_testpersistable_indexedstub_redirect'
+      args = 'xan'
+      ODBA.cache.should_receive(:retrieve_from_index).with(name, args)\
+        .times(1).and_return([result])
+      assert_equal([result], IndexedStub.search_by_redirect('xan'))
+
+      ## exact search by one key
+      ODBA.cache.should_receive(:retrieve_from_index)\
+        .with(name, args, ODBA::Persistable::Exact)\
+        .times(1).and_return([result])
+      assert_equal([result], IndexedStub.search_by_exact_redirect('xan'))
+
+      ## find by one key
+      ODBA.cache.should_receive(:retrieve_from_index)\
+        .with(name, args, ODBA::Persistable::Find)\
+        .times(1).and_return([result])
+      assert_equal(result, IndexedStub.find_by_redirect('xan'))
+
+      ## list available keys
+      ODBA.cache.should_receive(:index_keys).with(name, nil)\
+        .times(1).and_return(['key1', 'key2'])
+      assert_equal(['key1', 'key2'], IndexedStub.redirect_keys)
+      ODBA.cache.should_receive(:index_keys).with(name, 2)\
+        .times(1).and_return(['k1', 'k2'])
+      assert_equal(['k1', 'k2'], IndexedStub.redirect_keys(2))
+    end
+    def test_odba_extent
+      stub = IndexedStub.new
+      assert_respond_to(IndexedStub, :odba_extent)
+      ODBA.cache.mock_handle(:extent) { |klass|
+        assert_equal(IndexedStub, klass)
+        []
+      }
+      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']
+      }
+      IndexedStub.odba_extent { |obj|
+        assert_equal('foo', obj)
+      }
+    end
+    def test_odba_replace__in_object
+      ## in rollback, replace instance_variables of modified instances with
+      #  newly loaded unmodified ones
+      modified = Object.new
+      modified.extend(ODBA::Persistable)
+      modified.instance_variable_set('@data', 'foo')
+
+      reloaded = modified.dup
+
+      modified.instance_variable_set('@data', 'bar')
+      assert_equal('bar', modified.instance_variable_get('@data'))
+      
+      modified.odba_replace!(reloaded)
+      assert_equal('foo', modified.instance_variable_get('@data'))
+    end
+    def test_odba_add_observer
+      assert_nil(@odba.instance_variable_get('@odba_observers'))
+      obs = flexmock('Observer')
+      @odba.odba_add_observer(obs)
+      assert_equal([obs], @odba.instance_variable_get('@odba_observers'))
+    end
+    def test_odba_delete_observer
+      obs = flexmock('Observer')
+      @odba.instance_variable_set('@odba_observers', [obs])
+      @odba.odba_delete_observer(obs)
+      assert_equal([], @odba.instance_variable_get('@odba_observers'))
+    end
+    def test_odba_delete_observers
+      obs = flexmock('Observer')
+      @odba.instance_variable_set('@odba_observers', [obs])
+      @odba.odba_delete_observers
+      assert_nil(@odba.instance_variable_get('@odba_observers'))
+    end
+    def test_odba_notify_observers
+      obs = flexmock('Observer')
+      @odba.odba_id = 14
+      @odba.instance_variable_set('@odba_observers', [obs])
+      obs.should_receive(:odba_update).with(:key, 'foo', 'bar')\
+        .and_return { assert(true) }
+      @odba.odba_notify_observers(:key, 'foo', 'bar')
+    end
+    def test_odba_dup
+      o = Object.new
+      stub = ODBA::Stub.new(15, o, nil)
+      o.extend(ODBA::Persistable)
+      o.instance_variable_set('@stub', stub)
+      p = o.odba_dup
+      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)
+      assert_equal(15, stub2.odba_id)
+    end
+    def test_odba_isolated_stub
+      @odba.odba_id = 14
+      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_equal(@odba, stub.odba_instance)
+    end
+    def test_odba_collection
+      o = ODBAContainer.new
+      assert_equal([], o.odba_collection)
+    end
+	end	
+end