odba 1.0.0

data/lib/odba/stub.rb

@@ -0,0 +1,187 @@
+#!/usr/bin/env ruby
+#-- Stub -- odba -- 29.04.2004 -- hwyss@ywesee.com rwaltert@ywesee.com mwalder@ywesee.com
+
+require 'yaml'
+require 'odba/odba_error'
+
+module ODBA
+	class Stub # :nodoc: all
+		attr_accessor :odba_id, :odba_container
+		def initialize(odba_id, odba_container, receiver)
+			@odba_id = odba_id
+			@odba_container = odba_container
+			@odba_class = receiver.class unless receiver.nil? 
+      @receiver_loaded = true
+		end
+		def class
+			@odba_class ||= odba_instance.class
+		end
+		def eql?(other)
+			@odba_id == other.odba_id || odba_instance.eql?(other)
+		end
+		def inspect
+			"#<ODBA::Stub:#{object_id}##@odba_id @odba_class=#@odba_class @odba_container=#{@odba_container.object_id}##{@odba_container.odba_id}>"
+		end
+		def is_a?(klass)
+      klass == Stub || klass == Persistable || klass == @odba_class \
+				|| odba_instance.is_a?(klass)
+		end
+		def odba_clear_receiver
+			@receiver = nil
+      @receiver_loaded = nil
+		end
+    def odba_dup
+      odba_isolated_stub
+    end
+		def odba_isolated_stub
+			Stub.new(@odba_id, nil, nil)
+		end
+    def odba_prefetch?
+      false
+    end
+		def odba_receiver(name=nil)
+      if(@receiver && !@receiver_loaded)
+        warn "stub for #{@receiver.class}:#{@odba_id} was saved with receiver"
+        @receiver = nil
+      end
+			@receiver || begin
+      #begin
+				@receiver = ODBA.cache.fetch(@odba_id, @odba_container)
+        @receiver_loaded = true
+				if(@odba_container)
+					@odba_container.odba_replace_stubs(@odba_id, @receiver)
+        else 
+          warn "Potential Memory-Leak: stub for #{@receiver.class}##{@odba_id} was saved without container"
+				end
+				@receiver
+			rescue OdbaError => e
+				warn "ODBA::Stub was unable to replace #{@odba_class}##{@odba_id} from #{@odba_container.class}:##{@odba_container.odba_id}"
+			end
+		end
+  alias :odba_instance :odba_receiver
+		# A stub always references a Persistable that has 
+		# already been saved.
+		def odba_unsaved?(snapshot_level=nil)
+			false
+		end
+		def to_yaml_properties
+			['@odba_id', '@odba_container']
+		end
+		def to_yaml_type
+			"!ruby/object:ODBA::Stub"
+		end
+		def yaml_initialize(tag, val)
+      if RUBY_VERSION >= '1.9'
+        val.each { |key, value| instance_variable_set(:"@#{key}", value) }
+      else
+        val.each { |key, value| instance_variable_set("@#{key}", value) }
+      end
+		end
+		no_override = [
+			"class", "is_a?", "__id__", "__send__", "inspect", 
+			"eql?", "nil?", "respond_to?", "object_id", 
+			"instance_variables", "instance_variable_get",
+			"instance_variable_set", "==",
+			## methods defined in persistable.rb:Object
+			"odba_id", "odba_instance", "odba_isolated_stub", "odba_prefetch?",
+			## yaml-methods
+			"to_yaml", "taguri", "to_yaml_style", "to_yaml_type",
+			"to_yaml_properties", "yaml_initialize",
+		]
+		NO_OVERRIDE = no_override.collect { |name| name.to_sym }
+    if RUBY_VERSION >= '1.9'
+      no_override = NO_OVERRIDE
+    end
+		override_methods = Object.public_methods - no_override
+		override_methods.each { |method|
+			src = (method[-1] == ?=) ? <<-EOW : <<-EOS
+				def #{method}(args)
+					odba_instance.#{method}(args)
+				end
+			EOW
+				def #{method}(*args)
+					odba_instance.#{method}(*args)
+				end
+			EOS
+			eval src
+		}
+		def method_missing(meth_symbol, *args, &block)
+			if(NO_OVERRIDE.include?(meth_symbol))
+				super
+			else
+				odba_instance.send(meth_symbol, *args, &block)
+			end
+		end
+		def respond_to?(msg_id, *args)
+			case msg_id
+			when :_dump, :marshal_dump
+				false
+			when *NO_OVERRIDE
+				super
+			else
+				odba_instance.respond_to?(msg_id, *args)
+			end
+		end
+		## FIXME
+		#  implement full hash/array access - separate collection stub?
+		def [](*args, &block)
+			if(@odba_class == Hash \
+				&& !ODBA.cache.include?(@odba_id))
+				ODBA.cache.fetch_collection_element(@odba_id, args.first)
+			end || method_missing(:[], *args, &block)
+		end
+    def ==(other)
+      @odba_id == other.odba_id || odba_instance == other
+    end
+	end
+end
+
+class Array # :nodoc: all
+	alias :_odba_amp :&
+	def &(stub)
+		self._odba_amp(stub.odba_instance)
+	end
+	alias :_odba_plus :+
+	def +(stub)
+		self._odba_plus(stub.odba_instance)
+	end
+	alias :_odba_minus :-
+	def -(stub)
+		self._odba_minus(stub.odba_instance)
+	end
+	alias :_odba_weight :<=>
+	def <=>(stub)
+		self._odba_weight(stub.odba_instance)
+	end
+	alias :_odba_equal? :==
+	def ==(stub)
+		self._odba_equal?(stub.odba_instance)
+	end
+	alias :_odba_union :|
+	def |(stub)
+		self._odba_union(stub.odba_instance)
+	end
+	['concat', 'replace', 'include?'].each { |method|
+	#['concat', 'replace'].each { |method|
+		eval <<-EOS
+			alias :_odba_#{method} :#{method}
+			def #{method}(stub)
+				self._odba_#{method}(stub.odba_instance)
+			end
+		EOS
+	}
+end
+class Hash # :nodoc: all
+	alias :_odba_equal? :==
+	def ==(stub)
+		self._odba_equal?(stub.odba_instance)
+	end
+	['merge', 'merge!', 'replace'].each { |method|
+		eval <<-EOS
+			alias :_odba_#{method} :#{method}
+			def #{method}(stub)
+				self._odba_#{method}(stub.odba_instance)
+			end
+		EOS
+	}
+end

data/sql/collection.sql

@@ -0,0 +1,6 @@
+CREATE TABLE collection (
+		odba_id integer NOT NULL,
+		key text,
+		value text,
+		PRIMARY KEY(odba_id, key)
+);

data/sql/create_tables.sql

@@ -0,0 +1,6 @@
+-- all Tables of the odba project
+\i object.sql
+\i object_connection.sql
+\i collection.sql
+\i update_object.sql
+\i ensure_object_connection.sql

data/sql/object.sql

@@ -0,0 +1,8 @@
+CREATE TABLE object (
+		odba_id integer NOT NULL,
+		content text,
+		name text,
+		prefetchable boolean,
+		PRIMARY KEY(odba_id),
+		UNIQUE(name)
+);

data/sql/object_connection.sql

@@ -0,0 +1,7 @@
+CREATE TABLE object_connection (
+		origin_id integer,
+		target_id integer,
+		PRIMARY KEY(origin_id, target_id)
+);
+CREATE INDEX target_id_index ON object_connection (target_id);
+CREATE INDEX origin_id_index ON object_connection (origin_id);

data/test/suite.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# suite.rb -- oddb -- 20.11.2002 -- hwyss@ywesee.com 
+
+$: << File.expand_path(File.dirname(__FILE__))
+
+Dir.foreach(File.dirname(__FILE__)) { |file|
+	require file if /^test_.*\.rb$/o.match(file)
+}

data/test/test_array.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+# TestArray -- odba -- 30.01.2007 -- hwyss@ywesee.com
+
+$: << File.dirname(__FILE__)
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'flexmock'
+require 'odba/persistable'
+require 'odba/stub'
+require 'odba/odba'
+
+module ODBA
+  class TestArray < Test::Unit::TestCase
+    include FlexMock::TestCase
+    class ODBAContainer
+     include ODBA::Persistable
+     attr_accessor	:non_replaceable, :replaceable, :array, :odba_id
+    end
+    class Container
+      attr_accessor :content
+    end
+    def setup
+      @array = Array.new
+      ODBA.storage = flexmock("storage")
+      ODBA.marshaller = flexmock("marshaller")
+      ODBA.cache = flexmock("cache")
+    end
+    def test_odba_cut_connection
+      remove_obj = Object
+      remove_obj.extend(ODBA::Persistable)
+      remove_obj.instance_variable_set('@odba_id', 2)
+      receiver = ODBA::Stub.new(2,self, remove_obj)
+      array = Array.new
+      array.push(receiver)
+      assert_equal(0, array.odba_cut_connection(remove_obj).size)
+    end
+    def test_odba_unsaved_neighbors_array
+      rep1 = ODBAContainer.new
+      rep2 = ODBAContainer.new
+      @array.push(rep1)
+      @array.push(rep2)
+      result = @array.odba_unsaved_neighbors(1)
+      assert_equal([rep1, rep2], result)
+    end
+    def test_array_replacement
+      replacement = flexmock('replacement')
+      replacement2 = flexmock('replacement2')
+      stub = flexmock('stub')
+      stub2 = flexmock('stub2')
+      foo = flexmock("foo")
+      @array.push(stub)
+      @array.push(stub2)
+      @array.odba_restore([[0,replacement], [1,replacement2]])
+      assert_equal(replacement, @array[0])
+      assert_equal(replacement2, @array[1])
+    end
+    def test_odba_replace_persistables_array
+      replaceable = flexmock("replaceable")
+      replaceable2 = flexmock("replaceable2")
+      @array.push(replaceable)
+      @array.push(replaceable2)
+      @array.odba_replace_persistables
+      #size is 0 because we store empty array in the db
+      # content of the array is in the collection table
+      assert_equal(0, @array.size)
+    end
+    def test_odba_unsaved_array_true
+      val = flexmock("val")
+      @array.instance_variable_set("@odba_persistent", true)
+      @array.push(val)
+      val.should_receive(:is_a?).and_return { |klass| true }
+      val.should_receive(:odba_unsaved?).and_return { true }
+      assert_equal(true, @array.odba_unsaved?)
+    end
+    def test_odba_collection
+      @array.push('foo', 'bar')
+      assert_equal([[0,'foo'], [1, 'bar']], @array.odba_collection)
+    end
+    def test_odba_replace
+      modified = ['foo']
+      reloaded = modified.dup
+      modified.push('bar')
+      modified.odba_replace!(reloaded)
+      assert_equal(reloaded, modified)
+    end
+    def test_odba_target_ids
+      o = ODBAContainer.new
+      o.odba_id = 1
+      p = ODBAContainer.new
+      p.odba_id = 2
+      q = ODBAContainer.new
+      q.odba_id = 3
+      @array.push(p, q)
+      @array.instance_variable_set('@foo', o)
+      assert_equal([1,2,3], @array.odba_target_ids)
+    end
+    def test_stubize
+      item = ODBAContainer.new
+      @array.push(item)
+      @array.odba_stubize(item)
+      first = @array.first
+      assert_equal false, first.is_a?(ODBA::Stub)
+      assert @array.include?(item)
+      assert_equal false, first.is_a?(ODBA::Stub)
+    end
+  end
+end

data/test/test_cache.rb

@@ -0,0 +1,725 @@
+#!/usr/bin/env ruby
+
+$: << File.dirname(__FILE__)
+$: << File.expand_path('../lib/', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'flexmock'
+require 'odba/cache'
+require 'odba/cache_entry'
+require 'odba/persistable'
+require 'odba/index'
+require 'odba/index_definition'
+require 'odba/odba_error'
+require 'odba/odba'
+
+module ODBA
+	class Cache 
+		CLEANING_INTERVAL = 0
+		MAIL_RECIPIENTS = []
+		MAIL_FROM = "test@testfirst.local"
+		attr_accessor :cleaner, :fetched, :cache_entry_factory, :prefetched
+		attr_writer :indices
+		public :load_object
+	end
+	class TestCache < Test::Unit::TestCase
+    include FlexMock::TestCase
+		class ODBAContainer
+		 include ODBA::Persistable
+		 attr_accessor	:odba_connection, :odba_id
+		end
+		def setup
+			@storage = ODBA.storage = flexmock("storage")
+			@marshal = ODBA.marshaller = flexmock("marshaller")
+			ODBA.cache = @cache = ODBA::Cache.instance
+			@cache.fetched = {}
+			@cache.prefetched = {}
+			@cache.indices = {}
+		end
+		def teardown
+      super
+			ODBA.storage = nil
+			ODBA.marshaller = nil
+			@cache.fetched.clear
+			@cache.prefetched.clear
+			@cache.indices.clear
+		end
+		def test_fetch_named_ok
+			obj = flexmock
+			obj.instance_variable_set("@odba_name", 'the_name')
+			obj.instance_variable_set("@odba_id", 2)
+      @marshal.should_receive(:load).with('dump2').and_return(obj)
+			@storage.should_receive(:restore_named).and_return('dump2')
+			@storage.should_receive(:restore_collection).and_return([])
+			load_1 = @cache.fetch_named('the_name', nil)
+			assert_instance_of(FlexMock, load_1)
+			assert_equal('the_name', load_1.odba_name)
+			assert_equal(2, load_1.odba_id)
+			load_2 = @cache.fetch_named('the_name', nil)
+			assert_equal(load_1, load_2)
+			load_3 = @cache.fetch(2, nil)
+			assert_equal(load_1, load_3)
+		end
+		def test_bulk_fetch_load_all
+			old_marshal = ODBA.marshaller
+			ODBA.marshaller = marshal = flexmock('Marshal')
+			array = [2, 3]
+			obj1 = Object.new
+			obj1.instance_variable_set("@odba_id", 2)
+			obj1.instance_variable_set("@odba_prefetch", false)
+			obj1.instance_variable_set("@odba_name", nil)
+			obj2 = Object.new
+			obj2.instance_variable_set("@odba_id", 3)
+			obj2.instance_variable_set("@odba_prefetch", true)
+			obj2.instance_variable_set("@odba_name", nil)
+			dump_1 = Marshal.dump(obj1)
+			dump_2 = Marshal.dump(obj2)
+			@storage.should_receive(:bulk_restore)\
+        .and_return([[2, dump_1],[3, dump_2]])
+      dumps = [dump_1, dump_2]
+      objs = [obj1, obj2]
+			marshal.should_receive(:load).and_return  { |dump|
+				assert_equal(dumps.shift, dump)
+				objs.shift
+			}
+			@storage.should_receive(:restore_collection).and_return([])
+			loaded = @cache.bulk_fetch(array, nil)
+			assert_equal([obj1, obj2], loaded)
+			assert_equal([2], @cache.fetched.keys)
+			assert_equal([3], @cache.prefetched.keys)
+			assert_instance_of(CacheEntry, @cache.fetched[2])
+			assert_instance_of(CacheEntry, @cache.prefetched[3])
+		ensure
+			ODBA.marshaller = old_marshal
+		end
+		def test_bulk_fetch
+			old_marshal = ODBA.marshaller
+			ODBA.marshaller = marshal = flexmock('Marshal')
+			array = [2, 3, 7]
+			baz = flexmock('loaded')
+			baz.should_receive(:odba_add_reference).and_return { |odba_caller| }
+			baz.should_receive(:odba_object).and_return { 'foo' }
+			@cache.fetched = {
+				7 => baz
+			}
+			obj1 = Object.new
+			obj1.instance_variable_set("@odba_id", 2)
+			obj1.instance_variable_set("@odba_prefetch", false)
+			obj1.instance_variable_set("@odba_name", nil)
+			obj2 = Object.new
+			obj2.instance_variable_set("@odba_id", 3)
+			obj2.instance_variable_set("@odba_prefetch", false)
+			obj2.instance_variable_set("@odba_name", nil)
+			dump_1 = Marshal.dump(obj1)
+			dump_2 = Marshal.dump(obj2)
+      dumps = [dump_1, dump_2]
+      objs = [obj1, obj2]
+			marshal.should_receive(:load).and_return  { |dump|
+				assert_equal(dumps.shift, dump)
+				objs.shift
+			}
+			@storage.should_receive(:bulk_restore).and_return([[2, dump_1],[3, dump_2]])
+			@storage.should_receive(:restore_collection).and_return([])
+			@cache.bulk_fetch(array, nil)
+			assert_equal(true, @cache.fetched.has_key?(2))
+			assert_equal(3, @cache.fetched.size)
+			assert_equal(true, @cache.fetched.has_key?(3))
+			ODBA.marshaller = old_marshal
+		end
+		def test_bulk_restore_in_fetchedadd_caller
+			obj = Object.new
+			cache_entry = flexmock('cache_entry')
+			cache_entry.should_receive(:odba_object).and_return {
+				obj
+			}
+			cache_entry.should_receive(:_odba_object).and_return {
+				obj
+			}
+			cache_entry.should_receive(:odba_add_reference).and_return {|caller|
+				#this assert_equal is interesting
+				assert_equal('Reference', caller)
+			}
+			@cache.fetched.store(1, cache_entry)
+			rows = [[1, '']]
+			retrieved = @cache.bulk_restore(rows, 'Reference')
+		end
+		def test_clean
+			obj1 = flexmock
+			obj2 = flexmock
+			@cache.fetched.store(2, obj1)
+			@cache.fetched.store(3, obj2)
+			assert_equal(2, @cache.fetched.size)
+			obj1.should_receive(:odba_old?).and_return  { true }
+			obj1.should_receive(:odba_retire).and_return  { }
+			obj2.should_receive(:odba_old?).and_return  { false }
+			@cache.clean
+			assert_equal(2, @cache.fetched.size)
+		end
+		def test_clean__prefetched
+			obj1 = flexmock
+			obj2 = flexmock
+			@cache.prefetched.store(2, obj1)
+			@cache.prefetched.store(3, obj2)
+			assert_equal(2, @cache.prefetched.size)
+			obj1.should_receive(:ready_to_destroy?).and_return  { false }
+			obj1.should_receive(:odba_old?).and_return  { true }
+			obj1.should_receive(:odba_retire).and_return  { }
+			obj2.should_receive(:ready_to_destroy?).and_return  { false }
+			obj2.should_receive(:odba_old?).and_return  { false }
+			@cache.clean_prefetched
+			assert_equal(2, @cache.prefetched.size)
+		end
+		def test_clear
+			value = flexmock("value")
+			obj = flexmock('object')
+			prefetched = flexmock('prefetched')
+			@cache.fetched.store(12, value)
+			@cache.prefetched.store(13, prefetched)
+			assert_equal(2, @cache.size)
+      @cache.clear
+			assert_equal(0, @cache.size)
+		end
+		def test_fetch_named_block
+			restore = flexmock("restore")
+			caller = flexmock("caller")
+			caller2 = flexmock("caller2")
+			@storage.should_receive(:restore_named).and_return  { |name| }
+			restore.should_receive(:odba_name=).and_return  { |name| }
+			restore.should_receive(:odba_store).and_return { |obj| }
+			result = @cache.fetch_named("foo", caller2) {
+				restore
+			}
+			assert_equal(restore, result)
+		end
+		def prepare_fetch(id, receiver)
+			@storage.should_receive(:restore).and_return { |odba_id|
+				assert_equal(id, odba_id)
+				odba_id
+			}
+			@marshal.should_receive(:load).and_return  { receiver }
+			if(receiver.is_a?(FlexMock))
+				receiver.should_receive(:odba_restore).and_return  {}
+				receiver.should_receive(:odba_name).and_return  {}
+			end
+		end
+		def test_fetch_has_name
+			caller1 = flexmock('Caller1')
+			caller2 = flexmock('Caller2')
+			caller3 = flexmock('Caller3')
+			receiver = flexmock('Receiver')
+			@storage.should_receive(:restore).and_return { |odba_id|
+				assert_equal(23, odba_id)
+				odba_id
+			}
+			@marshal.should_receive(:load).and_return {|dump|
+				receiver
+			}
+			@storage.should_receive(:restore_collection).and_return {|*args| 
+				[]
+			}
+			receiver.instance_variable_set("@odba_id", 23)
+			receiver.instance_variable_set("@odba_name", 'name')
+			first_fetch = @cache.fetch(23, caller1)
+			assert_equal(receiver, first_fetch)
+			assert_equal(2, @cache.fetched.size)
+			assert(@cache.fetched.include?('name'))
+			second_fetch = @cache.fetch(23, caller2)
+			assert_equal(receiver, second_fetch)
+			named_fetch = @cache.fetch_named('name', caller3)
+			assert_equal(receiver, named_fetch)
+		end
+		def test_fetch_error
+			receiver = flexmock
+			@storage.should_receive(:restore).and_return  { |odba_id|
+				nil	
+			}
+			assert_raises(OdbaError) {
+				@cache.load_object(23, receiver)
+			}
+		end
+		def test_fetch__adds_reference
+			obj = flexmock
+			obj.instance_variable_set("@odba_id", 23)
+			obj.instance_variable_set("@odba_prefetch", false)
+			@storage.should_receive(:restore).and_return  { |id|
+				assert_equal(23, id)
+				'dump'
+			}
+			@storage.should_receive(:restore_collection).and_return  { |id|
+				[]
+			}
+			@marshal.should_receive(:load).and_return  { |dump|
+				assert_equal('dump', dump)
+				obj
+			}
+			callr = flexmock
+			res = @cache.fetch(23, callr)
+			cache_entry = @cache.fetched[23]
+			assert_instance_of(CacheEntry, cache_entry)
+      assert_equal([callr.object_id], cache_entry.accessed_by.keys)
+			assert_equal(obj, res)
+      ## test for duplicates
+			@cache.fetch(23, callr)
+      assert_equal([callr.object_id], cache_entry.accessed_by.keys)
+		end
+		def test_store
+      cont = flexmock('CacheEntry')
+      @cache.fetched.store(3, cont)
+			save_obj = flexmock("save_obj")
+      save_obj.should_receive(:odba_target_ids).and_return([3])
+      save_obj.should_receive(:odba_observers).and_return { [] }
+			prepare_store([save_obj])
+      save_obj.should_receive(:odba_add_observer)
+      cont.should_receive(:odba_add_reference).with(save_obj)\
+        .and_return { assert(true) }
+			@cache.store(save_obj)
+		end
+		def test_store_collection_elements
+			old_mar = ODBA.marshaller
+			ODBA.marshaller = Marshal
+
+			old_collection = [['key1', 'val1'], ['key2', 'val2']]
+			new_collection = [['key2', 'val2'], ['key3', 'val3']]
+
+			cache_entry = flexmock('cache_entry')
+			cache_entry.should_receive(:collection).and_return  { old_collection }
+			cache_entry.should_receive(:collection=).and_return  { |col|
+				assert_equal(new_collection, col)
+			}
+
+      @storage.should_receive(:restore_collection).and_return  { 
+        old_collection.collect { |key, val|
+          [Marshal.dump(key.odba_isolated_stub), 
+            Marshal.dump(val.odba_isolated_stub)]
+        }
+      }
+			@storage.should_receive(:collection_remove).and_return  { |odba_id, key| 
+				assert_equal(54, odba_id)
+				assert_equal(Marshal.dump('key1'.odba_isolated_stub), key)
+			}
+			@storage.should_receive(:collection_store).and_return  { |odba_id, key, value| 
+				assert_equal(54, odba_id)
+				assert_equal(Marshal.dump('key3'.odba_isolated_stub), key)
+				assert_equal(Marshal.dump('val3'.odba_isolated_stub), value)
+			}
+
+			@cache.fetched = {
+				54 => cache_entry
+			}
+			
+			obj = flexmock('Obj')
+			obj.should_receive(:odba_id).and_return  { 54 }
+			obj.should_receive(:odba_collection).and_return  { new_collection }
+			@cache.store_collection_elements(obj)
+    ensure
+			ODBA.marshaller = old_mar
+		end
+		def test_store_object_connections
+			@storage.should_receive(:ensure_object_connections).and_return  { |id,target_ids|
+				assert_equal(4, id)
+				assert_equal([1,2], target_ids)
+			}
+			@cache.store_object_connections(4, [1,2])
+		end
+		def test_load__and_restore_object
+			caller1 = flexmock
+			loaded = flexmock
+			@storage.should_receive(:restore).and_return  { |odba_id|
+				assert_equal(23, odba_id)
+				'dump'
+			}
+			@marshal.should_receive(:load).and_return  { |dump|
+				assert_equal('dump', dump)
+				loaded
+			}
+			@storage.should_receive(:restore_collection).and_return  { [] }
+
+      loaded.instance_variable_set('@odba_id', 23)
+			@cache.load_object(23, caller1)
+		end
+		def test_prefetch
+			foo = flexmock("foo")
+			@storage.should_receive(:restore_prefetchable).and_return  {
+				[[2, foo]]
+			}
+			prepare_bulk_restore([foo])
+			assert_nothing_raised {
+				@cache.prefetch
+			}
+		end
+		def test_fill_index
+			foo = flexmock("foo")
+			foo.should_receive(:fill).and_return  { |target| 
+				assert_equal("baz", target)
+			}
+			@cache.indices = { 
+				"foo" => foo
+			}
+			@cache.fill_index("foo", "baz")
+		end
+		def test_create_index
+      df = IndexDefinition.new
+      df.index_name = 'index'
+			indices = flexmock('indices')
+			indices.should_receive(:store).and_return { |key, val|
+				assert_instance_of(Index, val)
+			}
+			indices.should_receive(:odba_store_unsaved).times(1)
+			@cache.instance_variable_set('@indices', indices)
+			@storage.should_receive(:transaction).and_return  { |block| block.call }
+			@storage.should_receive(:create_index).times(1)
+			index = @cache.create_index(df, flexmock)
+			assert_instance_of(Index, index)
+			@cache.instance_variable_set('@indices', {})
+		end
+		def test_create_index__fulltext
+      df = IndexDefinition.new
+      df.index_name = 'index'
+      df.fulltext = true
+			indices = flexmock('indices')
+			indices.should_receive(:store).and_return { |key, val|
+				assert_instance_of(FulltextIndex, val)
+			}
+			indices.should_receive(:odba_store_unsaved).times(1)
+			@cache.instance_variable_set('@indices', indices)
+			@storage.should_receive(:transaction).and_return  { |block| block.call }
+			@storage.should_receive(:create_fulltext_index).times(1)
+			index = @cache.create_index(df, flexmock)
+			assert_instance_of(FulltextIndex, index)
+			@cache.instance_variable_set('@indices', {})
+		end
+		def test_create_index__condition
+      df = IndexDefinition.new
+      df.index_name = 'index'
+      df.resolve_search_term = { }
+			indices = flexmock('indices')
+			indices.should_receive(:store).and_return { |key, val|
+				assert_instance_of(ConditionIndex, val)
+			}
+			indices.should_receive(:odba_store_unsaved).times(1)
+			@cache.instance_variable_set('@indices', indices)
+			@storage.should_receive(:transaction).and_return  { |block| block.call }
+			@storage.should_receive(:create_condition_index).times(1)
+			index = @cache.create_index(df, flexmock)
+			assert_instance_of(ConditionIndex, index)
+			@cache.instance_variable_set('@indices', {})
+		end
+		def prepare_fetch_collection(obj)
+		end
+		def prepare_store(store_array, &block)
+			store_array.each { |mock|
+				# store
+				mock.should_receive(:odba_id).and_return { || }
+				mock.should_receive(:odba_name).and_return { || }
+        mock.should_receive(:odba_notify_observers).and_return  { |key, id1, id2|
+          assert_equal(:store, key)
+        }
+				mock.should_receive(:odba_isolated_dump).and_return { || }
+
+				# store_collection_elements
+				mock.should_receive(:odba_id).and_return { || }
+				mock.should_receive(:odba_collection).and_return {|| []}
+				mock.should_receive(:odba_id).and_return { || }
+
+				# store
+				mock.should_receive(:odba_prefetch?).and_return { || }
+
+				# store_object_connections
+				mock.should_receive(:odba_target_ids).and_return { || [] }
+
+				# update_indices
+				mock.should_receive(:odba_indexable?).and_return {}
+
+				# store_cache_entry
+				mock.should_receive(:odba_prefetch?).and_return { || }
+				mock.should_receive(:odba_collection).and_return { || [] }
+
+				@storage.should_receive(:restore_collection).and_return  { [] }
+				if(block)
+					@storage.should_receive(:store, &block).and_return  
+				else
+					@storage.should_receive(:store).and_return  { 
+						assert(true)
+					}
+				end
+				@storage.should_receive(:ensure_object_connections).and_return {|*args|}
+			}
+		end
+		def test_delete
+			delete_item = ODBAContainer.new
+			delete_item.odba_id = 1
+			origin_obj = ODBAContainer.new
+			origin_obj.odba_id = 2
+			origin_obj.odba_connection = delete_item
+			@cache.fetched.store(1, delete_item)
+			@storage.should_receive(:retrieve_connected_objects).and_return  { |id|
+				[[2]] 
+			}
+			prepare_fetch(2, origin_obj)
+			@storage.should_receive(:restore_collection).and_return  { |*args| 
+				[]
+			}
+			@storage.should_receive(:store).and_return  { |id, dump, name, prefetch, klass| }
+			@storage.should_receive(:ensure_object_connections).and_return  { } 
+			@storage.should_receive(:delete_persistable).and_return  { |id| } 
+			@marshal.should_receive(:dump).and_return  { |ob| "foo"}
+			@cache.delete(delete_item)
+			assert_equal(1, @cache.fetched.size)
+			assert_equal(nil, origin_obj.odba_connection)
+		end
+		def prepare_delete(mock, name, id)
+			mock.should_receive(:odba_id).and_return  { id }
+			mock.should_receive(:odba_name).and_return  { name }
+			mock.should_receive(:odba_notify_observers).and_return  { |key, id1, id2|
+        assert_equal(:delete, key) 
+      }
+			@storage.should_receive(:retrieve_connected_objects).and_return  { |id|
+				[]
+			}
+			mock.should_receive(:origin_class?).and_return  { true }
+			mock.should_receive(:odba_id).and_return  { id }
+			@storage.should_receive(:delete_persistable).and_return  { |id_arg| 
+				assert_equal(id, id_arg)
+			}
+			@storage.should_receive(:delete_index_element).and_return  { }
+		end
+		def prepare_bulk_restore(rows)
+			rows.each { |odba_mock|
+        ## according to recent changes, objects are extended with 
+        #  ODBA::Persistable after loading - this enables ad-hoc storing
+        #  but messes up loads of tests
+				@marshal.should_receive(:load).and_return  { |dump|
+					odba_mock.instance_variable_set('@odba_id', 2)
+					odba_mock.instance_variable_set('@odba_prefetch', true)
+          odba_mock
+				}
+				@storage.should_receive(:restore_collection).and_return {|*args|
+					[]
+				}
+			}
+		end
+		def test_retrieve_from_index
+			foo = flexmock
+			index = flexmock("bar_index")
+			@cache.indices["index_name"] = index
+			index.should_receive(:fetch_ids).and_return  { |search_term, meta|
+				assert_equal('search term', search_term)
+				assert_nil(meta)
+				[2]
+			}
+			@storage.should_receive(:bulk_restore).and_return  {
+				[[2, 'dump']]
+			}
+			prepare_bulk_restore([foo])
+			@cache.retrieve_from_index("index_name", "search term")
+		end
+		def test_update_indices
+			index = flexmock("index")
+			bar = flexmock("bar")
+			bar.should_receive(:odba_indexable?).and_return { true }
+			@cache.indices = {
+				"foo" => index
+			}
+			index.should_receive(:update).and_return { |obj|
+				assert_equal(bar, obj)
+			}
+			@cache.update_indices(bar)
+		end
+		def test_delete_index_element
+			foo = flexmock("foo")
+			bar = flexmock("bar")
+			@cache.indices = {
+				"foo" => foo
+			}
+			foo.should_receive(:delete).with(bar).times(1).and_return {
+        assert(true)
+      }
+			@cache.delete_index_element(bar)
+		end
+		def test_drop_index
+			@storage.should_receive(:transaction).and_return  { |block| block.call }
+			@storage.should_receive(:drop_index).and_return  { |index_name|
+				assert_equal("foo_index", index_name)
+			}
+			index = flexmock("index")
+      index.should_receive(:delete).with(index)
+			prepare_delete(index, "foo", 2)
+			@cache.indices.store("foo_index", index)
+			@cache.drop_index("foo_index")
+		end
+		def test_drop_indices
+			@storage.should_receive(:transaction).and_return  { |block| block.call}
+			@storage.should_receive(:drop_index).and_return {|index_name|
+				assert_equal("foo_index", index_name)
+			}
+			index = flexmock("index")
+      index.should_receive(:delete).with(index)
+			prepare_delete(index, "foo", 2)
+			@cache.indices.store("foo_index", index)
+			@cache.drop_indices
+		end
+		def test_fetch_collection_element
+			key_dump = Marshal.dump('foo')
+			@storage.should_receive(:collection_fetch).and_return  { |odba_id, key|
+				assert_equal(12, odba_id)
+				assert_equal(key_dump, key)
+				'val_dump'
+			}
+			@marshal.should_receive(:dump).and_return  { |key|
+				assert_equal('foo', key)
+				key_dump
+			}
+			@marshal.should_receive(:load).and_return  { |dump|
+				assert_equal('val_dump', dump)
+				'val'
+			}
+			res = @cache.fetch_collection_element(12, 'foo')
+			assert_equal('val', res)
+		end
+    def test_transaction
+      o1 = Object.new
+      o1.instance_variable_set('@odba_id', 1)
+      o2 = Object.new
+      o3 = Object.new
+      o1.extend(ODBA::Persistable)
+      o2.extend(ODBA::Persistable)
+      o2.odba_name = 'name2'
+      o3.extend(ODBA::Persistable)
+      o4 = o1.odba_dup
+      @storage.should_receive(:transaction).and_return  { |block| block.call }
+
+      ## store o1
+      @marshal.should_receive(:dump).times(3).and_return { |obj|
+        "dump%i" % obj.odba_id
+      } 
+      next_id = 1
+      @storage.should_receive(:next_id).and_return { next_id += 1 }
+      @storage.should_receive(:store).with(1,'dump1',nil,nil,Object)\
+        .times(1).and_return { assert(true) }
+      @storage.should_receive(:ensure_object_connections)\
+        .with(1,[2]).times(1).and_return { assert(true) }
+
+      ## store o2
+      @storage.should_receive(:restore_collection).with(2)\
+        .times(1).and_return([])
+      @storage.should_receive(:store)\
+        .with(2,'dump2','name2',nil,Object)\
+        .times(1).and_return { assert(true) }
+      @storage.should_receive(:ensure_object_connections)\
+        .with(2,[3]).times(1).and_return { assert(true) }
+
+      ## store o3 and raise
+      @storage.should_receive(:restore_collection).with(3)\
+        .times(1).and_return([])
+      ## at this stage 1 and 2 (and 'name2') are stored:
+      @storage.should_receive(:store)\
+        .with(3,'dump3',nil,nil,Object)\
+        .times(1).and_return { raise "trigger rollback" }
+
+      ## rollback
+      @storage.should_receive(:restore).with(2)\
+        .times(1).and_return(nil)
+      @storage.should_receive(:restore).with(1)\
+        .times(1).and_return('dump1')
+      @storage.should_receive(:restore_collection).with(1)\
+        .times(2).and_return([])
+      @marshal.should_receive(:load).with('dump1')\
+        .times(1).and_return(o4)
+      @cache.fetched.store(1, ODBA::CacheEntry.new(o1))
+      assert_raises(RuntimeError) {
+        ODBA.transaction { 
+          o2.instance_variable_set('@other', o3)
+          o1.instance_variable_set('@other', o2)
+          o1.odba_store
+        }
+      }
+      assert_equal(1, @cache.size)
+      assert_nil(o1.instance_variable_get('@other'))
+    end
+    def test_extent
+      o1 = flexmock('O1')
+      o1.should_receive(:odba_id).and_return(1)
+      o2 = flexmock('O2')
+      o2.should_receive(:odba_id).and_return(2)
+      clr = flexmock('Caller')
+      @storage.should_receive(:extent_ids).and_return([1,2])
+      @storage.should_receive(:restore_collection).and_return([])
+      @storage.should_receive(:bulk_restore).with([1,2])\
+        .and_return([[1, 'dump1'],[2,'dump2']])
+      @marshal.should_receive(:load).with('dump1')\
+        .times(1).and_return(o1)
+      @marshal.should_receive(:load).with('dump2')\
+        .times(1).and_return(o2)
+      assert_equal([o1, o2], @cache.extent(ODBAContainer, clr))
+    end
+    def test_fetch_collection
+      obj = flexmock('Object')
+      obj.should_receive(:odba_id).and_return(1)
+      restored = flexmock('Restored')
+      restored.should_receive(:odba_id).and_return(7)
+      i1 = flexmock('Item1')
+      i2 = flexmock('Item2')
+      i1.should_receive(:is_a?).with(Stub).and_return(false)
+      i2.should_receive(:is_a?).with(Stub).and_return(true)
+      i2.should_receive(:odba_id).and_return(7)
+      i2.should_receive(:odba_container=).with(obj).times(1)
+      @storage.should_receive(:restore_collection).with(1)\
+        .times(1).and_return([['keydump1','dump1'],['keydump2','dump2']])
+      @storage.should_receive(:restore_collection).with(7).times(1).and_return([])
+      @storage.should_receive(:bulk_restore).with([7]).and_return([[7,'inst']])
+      @marshal.should_receive(:load).with('keydump1').and_return(0)
+      @marshal.should_receive(:load).with('keydump2').and_return(1)
+      @marshal.should_receive(:load).with('dump1').and_return(i1)
+      @marshal.should_receive(:load).with('dump2').and_return(i2)
+      @marshal.should_receive(:load).with('inst').and_return(restored)
+      assert_equal([[0,i1],[1,i2]], @cache.fetch_collection(obj))
+    end
+    def test_include
+      assert(!@cache.include?(1))
+      @cache.fetched.store(1, 'foo')
+      assert(@cache.include?(1))
+      assert(!@cache.include?(2))
+      @cache.prefetched.store(2, 'bar')
+      assert(@cache.include?(2))
+    end
+    def test_index_keys
+      index = flexmock('Index')
+      @cache.indices.store('index', index)
+      index.should_receive(:keys).with(nil).times(1).and_return(['ABC'])
+      index.should_receive(:keys).with(2).times(1).and_return(['AB'])
+      assert_equal(['ABC'], @cache.index_keys('index'))
+      assert_equal(['AB'], @cache.index_keys('index', 2))
+    end
+    def test_setup
+      @storage.should_receive(:setup).times(1).and_return { assert(true)}
+      @storage.should_receive(:ensure_target_id_index)\
+        .with('index').times(1).and_return { assert(true)}
+      df1 = IndexDefinition.new
+      df1.index_name = 'deferred'
+      df2 = IndexDefinition.new
+      df2.index_name = 'index'
+			indices = flexmock('indices')
+      indices.should_receive(:each_key).and_return { |block|
+        block.call('index')
+      }
+      indices.should_receive(:include?).with('index')\
+        .times(1).and_return(true)
+      indices.should_receive(:include?).with('deferred')\
+        .times(1).and_return(false)
+			indices.should_receive(:store).and_return { |key, val|
+        assert_equal('deferred', key)
+				assert_instance_of(Index, val)
+			}
+			indices.should_receive(:odba_store_unsaved).times(1)
+			@cache.instance_variable_set('@indices', indices)
+      @storage.should_receive(:transaction).and_return { |block|
+        block.call
+      }
+      @storage.should_receive(:create_index).with('deferred')\
+        .times(1).and_return { assert(true) }
+      @cache.instance_variable_set('@deferred_indices', [df1, df2])
+      @cache.setup
+			@cache.instance_variable_set('@indices', {})
+    end
+	end
+end