odba 1.0.0

data/test/test_cache_entry.rb

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

data/test/test_connection_pool.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+# TestConnectionPool -- odba -- 03.08.2005 -- hwyss@ywesee.com
+
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'flexmock'
+require 'odba/connection_pool'
+## connection_pool requires 'dbi', which unshifts the site_ruby dir
+#  to the first position in $LOAD_PATH ( == $: ). As a result, files are
+#  loaded from site_ruby if they are installed there, and thus ignored
+#  by rcov. Workaround:
+$:.shift
+
+module ODBA
+  class TestConnectionPool < Test::Unit::TestCase
+    include FlexMock::TestCase
+    def test_survive_error
+      flexstub(DBI).should_receive(:connect).times(10).and_return { 
+        conn = FlexMock.new("Connection")
+        conn.should_ignore_missing
+        conn
+      }
+      pool = ConnectionPool.new()
+      pool.connections.each { |conn|
+        conn.should_receive(:execute).and_return { 
+          raise DBI::InterfaceError.new 
+          ## after the first error is raised, ConnectionPool reconnects.
+        }
+      }
+      assert_nothing_raised { pool.execute('statement') }
+    end
+    def test_multiple_errors__give_up
+      flexstub(DBI).should_receive(:connect).times(20).and_return { 
+        conn = FlexMock.new("Connection")
+        conn.should_receive(:execute).and_return { 
+          raise DBI::InterfaceError.new 
+        }
+        conn
+      }
+      pool = ConnectionPool.new()
+      assert_raises(DBI::InterfaceError) { pool.execute('statement') }
+    end
+    def test_size
+      flexstub(DBI).should_receive(:connect).times(5).and_return { 
+        conn = FlexMock.new("Connection")
+        conn.should_ignore_missing
+        conn
+      }
+      pool = ConnectionPool.new()
+      assert_equal(5, pool.size)
+    end
+    def test_disconnect
+      flexstub(DBI).should_receive(:connect).times(5).and_return { 
+        conn = FlexMock.new("Connection")
+        conn.should_ignore_missing
+        conn
+      }
+      pool = ConnectionPool.new()
+      pool.connections.each { |conn|
+        conn.should_receive(:disconnect).and_return { assert(true) }
+      }
+      pool.disconnect
+    end
+    def test_disconnect_error
+      flexstub(DBI).should_receive(:connect).times(5).and_return { 
+        conn = FlexMock.new("Connection")
+        conn.should_receive(:disconnect).times(1).and_return { 
+          raise DBI::InterfaceError.new
+        }
+        conn
+      }
+      pool = ConnectionPool.new()
+      assert_nothing_raised { pool.disconnect }
+    end
+  end
+end

data/test/test_drbwrapper.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+# TestDRbWrapper -- odba -- 13.06.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'odba/drbwrapper'
+require 'flexmock'
+
+module ODBA
+  class TestDRbWrapper < Test::Unit::TestCase
+    include FlexMock::TestCase
+    def test_include
+      obj = FlexMock.new
+      obj2 = FlexMock.new
+      arr = [obj]
+      assert_equal(false, arr.include?(obj2))
+      assert_equal(true, arr.include?(DRbWrapper.new(obj)))
+      assert_equal(false, arr.include?(DRbWrapper.new(obj2)))
+      arr = [DRbWrapper.new(obj)]
+      assert_equal(true, arr.include?(DRbWrapper.new(obj)))
+      assert_equal(false, arr.include?(DRbWrapper.new(obj2)))
+    end
+    def test_respond_to
+      obj = FlexMock.new
+      wrap = DRbWrapper.new(obj)
+      obj.should_receive(:respond_to?).with(:foo).times(1).and_return(true)
+      obj.should_receive(:respond_to?).with(:bar).times(1).and_return(false)
+      assert_equal(true, wrap.respond_to?(:foo))
+      assert_equal(false, wrap.respond_to?(:bar))
+    end
+    def test_method_missing
+      obj = FlexMock.new
+      wrap = DRbWrapper.new(obj)
+      obj.should_receive(:foo).with(:arg1, :arg2).times(1).and_return('result_foo')
+      assert_equal('result_foo', wrap.foo(:arg1, :arg2))
+      pers = flexmock('Persistable')
+      pers.should_receive(:is_a?).with(Persistable).and_return(true)
+      obj.should_receive(:bar).with(:arg1).times(1).and_return([pers])
+      res = wrap.bar(:arg1)
+      assert_instance_of(Array, res)
+      assert_equal(1, res.size)
+      wrapped_res = res.first
+      assert_respond_to(wrapped_res, :__wrappee)
+      assert_equal(pers, wrapped_res.__wrappee)
+      obj.should_receive(:baz).times(1).and_return { |block|
+        block.call(pers)
+      }
+      wrap.baz { |res|
+        assert_respond_to(wrapped_res, :__wrappee)
+        assert_equal(pers, wrapped_res.__wrappee)
+      }
+    end
+  end
+  class TestDRbIdConv < Test::Unit::TestCase
+    include FlexMock::TestCase
+    def setup
+      ODBA.cache = flexmock('cache')
+      @idconv = ODBA::DRbIdConv.new
+    end
+    def test_to_id
+      ODBA.cache.should_receive(:store)
+      o = Object.new
+      assert_equal(o.object_id, @idconv.to_id(o))
+      o.extend(ODBA::Persistable)
+      o.instance_variable_set('@odba_id', 4)
+      o.odba_isolated_store
+      assert_equal('4', @idconv.to_id(o))
+    end
+    def test_to_id__odba_unsaved
+      o = Object.new
+      o.extend(ODBA::Persistable)
+      assert_equal(o.object_id, @idconv.to_id(o))
+      assert_equal([@idconv], o.odba_observers)
+    end
+    def test_to_obj
+      ODBA.cache.should_receive(:store)
+      o = Object.new
+      assert_equal(o, @idconv.to_obj(o.object_id))
+      o.extend(ODBA::Persistable)
+      o.instance_variable_set('@odba_id', 4)
+      o.odba_isolated_store
+      ODBA.cache.should_receive(:fetch).with(4).times(1)
+      @idconv.to_obj('4')
+    end
+    def test_to_obj__error
+      ODBA.cache.should_receive(:fetch).with(4).times(1).and_return { 
+        raise "some error"
+      }
+      assert_raises(RangeError) { @idconv.to_obj('4') }
+    end
+    def test_odba_update
+      id = Object.new.object_id
+      @idconv.odba_update(:store, 4, id)
+      ODBA.cache.should_receive(:fetch).with(4).times(1)
+      @idconv.to_obj(id)
+      @idconv.odba_update(:clean, 4, id)
+      GC.start
+      assert_raises(RangeError) { @idconv.to_obj(id) }
+    end
+  end
+end

data/test/test_hash.rb

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

data/test/test_id_server.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# TestIdServer -- odba -- 10.11.2004 -- hwyss@ywesee.com
+
+$: << File.dirname(__FILE__)
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'flexmock'
+require 'odba/id_server'
+require 'odba/odba'
+require 'odba/marshal'
+
+module ODBA
+	class TestIdServer < Test::Unit::TestCase
+    include FlexMock::TestCase
+		def setup
+			@cache = ODBA.cache = flexmock('cache')
+			@id_server = IdServer.new
+			@id_server.instance_variable_set('@odba_id', 1)
+		end
+		def test_first
+      @cache.should_receive(:store).with(@id_server).times(3)
+			assert_equal(1, @id_server.next_id(:foo))
+			assert_equal(1, @id_server.next_id(:bar))
+			assert_equal(1, @id_server.next_id(:baz))
+		end
+		def test_consecutive
+      @cache.should_receive(:store).with(@id_server).times(3)
+			assert_equal(1, @id_server.next_id(:foo))
+			assert_equal(2, @id_server.next_id(:foo))
+			assert_equal(3, @id_server.next_id(:foo))
+		end
+		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 
+			}
+			assert_instance_of(ODBA::IdServer, ODBA.marshaller.load(dump))
+		end
+	end
+end