Rubernate 0.1.5 → 0.1.6

data/tests/rubernate/rubernate_test.rb

@@ -3,329 +3,379 @@ $:.unshift(File.expand_path('../..', __FILE__)) unless
 
 require 'rubernate/fixtures'
 
-# Make methods instantiate and modified visible for test purposes.
-class Rubernate::Runtime
-  public :instantiate, :modified
-end
-
-class Rubernate::RubernateTest < Test::Unit::TestCase
-  include FixtureClasses
-  include Rubernate
-  include Rubernate::DBI
-  
-  def setup
-    @factory = Rubernate::Memory::Configuration.new
-    @runtime = @factory.create
-    Rubernate.configuration = @factory
-    Thread.current[:on_save] = Thread.current[:on_load] = nil
-  end
-  
-  def test_include
-    assert !C0.include?(Persistent)
-    assert  C1.include?(Persistent)
-    assert  C2.include?(Persistent)
-    assert  C3.include?(Persistent)
-    assert !C0.new.kind_of?(Persistent)
-    assert  C1.new.kind_of?(Persistent)
-  end
-  
-  def test_properties
-    assert !C1.method_defined?(:p2)
-    assert  C1.method_defined?(:p1)
-    assert  C1.method_defined?(:p1=)
-    assert  C2.method_defined?(:p2)
-    assert  C2.method_defined?(:p2=)
-    assert  C3.method_defined?(:p0)
-    assert  C3.method_defined?(:p0=)
+module Rubernate
+  # Make methods instantiate and modified visible for test purposes.
+  class Runtime
+    public :instantiate, :modified, :lazy_factory
   end
-  
-  def test_objects_eq
-    o1, o2, o3, o4 = C4.new(1), C4.new(1), C4.new(2), C1.new
-    assert_equal o1, o1
-    assert_equal o1, o2
-    assert_not_equal o1, o3
-    assert_not_equal o1, o4
-    assert_equal o4, o4
-  end
-  
-  def test_session 
-    assert !Rubernate.session?
-    Rubernate.session{ assert Rubernate.runtime; assert Rubernate.session? }
-    Rubernate.session{ |runtime| 
-      assert runtime 
-      def runtime.close
-        Thread.current[:close_test] = 'passed'
-      end
-    }
-    assert_equal 'passed', Thread.current[:close_test]        
-    assert_raise(Rubernate::ObjectNotFoundException) { 
-      Rubernate.session { |runtime|
-        assert runtime             
+
+  class RubernateTest < Test::Unit::TestCase
+    include FixtureClasses
+    include Rubernate
+    include Rubernate::DBI
+    
+    def setup
+      @factory = Rubernate::Memory::Configuration.new
+      @runtime = @factory.create
+      Rubernate.configuration = @factory
+      Thread.current[:on_save] = Thread.current[:on_load] = nil
+    end
+    
+    def test_include
+      assert !C0.include?(Persistent)
+      assert  C1.include?(Persistent)
+      assert  C2.include?(Persistent)
+      assert  C3.include?(Persistent)
+      assert !C0.new.kind_of?(Persistent)
+      assert  C1.new.kind_of?(Persistent)
+    end
+    
+    def test_properties
+      assert !C1.method_defined?(:p2)
+      assert  C1.method_defined?(:p1)
+      assert  C1.method_defined?(:p1=)
+      assert  C2.method_defined?(:p2)
+      assert  C2.method_defined?(:p2=)
+      assert  C3.method_defined?(:p0)
+      assert  C3.method_defined?(:p0=)
+    end
+    
+    def test_objects_eq
+      o1, o2, o3, o4 = C4.new(1), C4.new(1), C4.new(2), C1.new
+      assert_equal o1, o1
+      assert_equal o1, o2
+      assert_not_equal o1, o3
+      assert_not_equal o1, o4
+      assert_equal o4, o4
+    end
+    
+    def test_session 
+      assert !Rubernate.session?
+      Rubernate.session{ assert Rubernate.runtime; assert Rubernate.session? }
+      Rubernate.session{ |runtime| 
+        assert runtime 
         def runtime.close
-          Thread.current[:close_test] = 'not_passed'
-        end
-        def runtime.failed
-          Thread.current[:failed_test] = 'passed'
+          Thread.current[:close_test] = 'passed'
         end
-        raise Rubernate::ObjectNotFoundException.new(1)
       }
-    }
-    assert_equal 'passed', Thread.current[:close_test]
-    assert_equal 'passed', Thread.current[:failed_test]         
-    assert_raise(RuntimeError) {Rubernate.runtime}
-  end
-  
-  def test_find_and_load
-    o1, o1.peer, o1.p1 = C1.new, Peer.new, 'o1.p1'
-    o2, o2.peer, o2.p1 = C2.new, Peer.new, o1
+      assert_equal 'passed', Thread.current[:close_test]        
+      assert_raise(Rubernate::ObjectNotFoundException) { 
+        Rubernate.session { |runtime|
+          assert runtime             
+          def runtime.close
+            Thread.current[:close_test] = 'not_passed'
+          end
+          def runtime.failed
+            Thread.current[:failed_test] = 'passed'
+          end
+          raise Rubernate::ObjectNotFoundException.new(1)
+        }
+      }
+      assert_equal 'passed', Thread.current[:close_test]
+      assert_equal 'passed', Thread.current[:failed_test]         
+      assert_raise(RuntimeError) {Rubernate.runtime}
+    end
     
-    @runtime.create o1
-    @runtime.create o2
+    def test_find_and_load
+      o1, o1.__peer, o1.p1 = C1.new, Peer.new, 'o1.p1'
+      o2, o2.__peer, o2.p1 = C2.new, Peer.new, o1
+      
+      @runtime.create o1
+      @runtime.create o2
+      
+      Rubernate.session { |runtime|
+        o2 = runtime.find_by_pk o2.primary_key
+        o1 = o2.p1
+        assert o1.equal?(runtime.find_by_pk(o1.primary_key))
+        runtime.find_by_pk o1.primary_key, true
+        assert_not_nil o1.__peer            
+      }
+    end
     
-    Rubernate.session { |runtime|
-      o2 = runtime.find_by_pk o2.primary_key
-      o1 = o2.p1
-      assert o1.equal?(runtime.find_by_pk(o1.primary_key))
-      runtime.find_by_pk o1.primary_key, true
-      assert_not_nil o1.peer            
-    }
-  end
-  
-  def test_ensure_loaded
-    o1, o1.p1 = C1.new, 'o1.p1'
-    o2, o2.p1 = C2.new, o1
+    def test_ensure_loaded
+      o1, o1.p1 = C1.new, 'o1.p1'
+      o2, o2.p1 = C2.new, o1
+      
+      @runtime.create o1
+      @runtime.create o2
+      
+      Rubernate.session do |runtime|
+        o2 = runtime.find_by_pk o2.primary_key
+        o1 = o2.p1
+        assert_equal 'o1.p1', o1.p1
+      end
+    end
+
+    def test_peer_creation
+      o = C1.new
+      assert_nil o.__peer
+      o.p1 = 'o.p1'
+      p = o.__peer
+      assert p
+      assert_equal 'o.p1', o.p1
+      assert p.equal?(o.__peer) # Peer must not  be changed
+    end
     
-    @runtime.create o1
-    @runtime.create o2
+    def test_peer_assign
+      o = C1.new
+      l1, l2 = LazyLoader.new, LazyLoader.new
+      o.__peer = l1
+      o.__peer = l2
+      assert_equal l1, o.__peer
+      
+      p1, p2 = Peer.new, Peer.new
+      o.__peer = p1
+      assert_equal p1, o.__peer
+      o.__peer = p2
+      assert_equal p2, o.__peer
+      o.__peer = l1
+      assert_equal p2, o.__peer 
+    end
     
-    Rubernate.session { |runtime|
-      o2 = runtime.find_by_pk o2.primary_key
-      o1 = o2.p1
-      assert_equal 'o1.p1', o1.p1
-    }
-  end
-  
-  def test_attach
-    o1 = C1.new
-    Rubernate.session {|runtime|
-      runtime.attach o1
-      f1 = runtime.find_by_pk(o1.primary_key)
-      assert o1.equal?(f1)
-    }
-  end
-  
-  def test_equal
-    o1, o1.primary_key = C1.new, 1
-    o2, o2.primary_key = C1.new, 1
-    assert_equal o1, o2    
-  end
-  
-  def test_ensure_attach
-    Rubernate.session {|runtime|
+    def test_attach
       o1 = C1.new
-      runtime.attach o1
-      o1.p1 = 'o1.p1'
-      assert o1.peer.dirty?
-    }
-  end
-  
-  def test_on_load
-    pk = Rubernate.session {o = C3.new.attach; o.primary_key}
-    assert_nil Thread.current[:on_load]
-    Rubernate.session {
-      o = find_by_pk pk
-      assert_not_nil Thread.current[:on_load]
-    }  
-  end
-  
-  def test_on_load_session
-    pk = nil
-    Rubernate.session{|runtime| o = C3.new.attach; pk = o.primary_key}
-    Rubernate.session{|runtime|
-      o = runtime.find_by_pk pk
-      assert_equal o, Thread.current[:on_load]
-    }        
-  end
-  
-  def test_on_save
-    o = nil
-    Rubernate.session{|runtime| 
-      o = C3.new.attach
-      assert_nil Thread.current[:on_save]
-      o.p0 = 'o.p0'
-    }
-    assert_equal o, Thread.current[:on_save]
-  end
+      Rubernate.session {|runtime|
+        runtime.attach o1
+        f1 = runtime.find_by_pk(o1.primary_key)
+        assert o1.equal?(f1)
+      }
+    end
+    
+    def test_equal
+      o1, o1.primary_key = C1.new, 1
+      o2, o2.primary_key = C1.new, 1
+      assert_equal o1, o2    
+    end
+    
+    def test_ensure_attach
+      Rubernate.session {|runtime|
+        o1 = C1.new
+        runtime.attach o1
+        o1.p1 = 'o1.p1'
+        assert o1.__peer.dirty?
+      }
+    end
+    
+    def test_on_load
+      pk = Rubernate.session {o = C3.new.attach; o.primary_key}
+      assert_nil Thread.current[:on_load]
+      Rubernate.session {
+        o = find_by_pk pk
+        assert_not_nil Thread.current[:on_load]
+      }  
+    end
+    
+    def test_on_load_session
+      pk = nil
+      Rubernate.session{|runtime| o = C3.new.attach; pk = o.primary_key}
+      Rubernate.session{|runtime|
+        o = runtime.find_by_pk pk
+        assert_equal o, Thread.current[:on_load]
+      }        
+    end
+    
+    def test_on_save
+      o = nil
+      Rubernate.session{|runtime| 
+        o = C3.new.attach
+        assert_nil Thread.current[:on_save]
+        o.p0 = 'o.p0'
+      }
+      assert_equal o, Thread.current[:on_save]
+    end
 
-  def test_attach_remove # TODO:...
-    Rubernate.session {
-      o = C1.new.attach
-      o.remove!
-    }
+    def test_attach_remove # TODO:...
+      Rubernate.session {
+        o = C1.new.attach
+        o.remove!
+      }
+    end
   end
-end
 
-class Rubernate::PeerTest < Test::Unit::TestCase
-  include Rubernate
-  include FixtureClasses
-  
-  def test_peer_dirty
-    p = Peer.new
-    assert_equal false, p.dirty?
+  class PeerTest < Test::Unit::TestCase
+    include Rubernate
+    include FixtureClasses
     
-    p[:p1] = 'test'
-    assert p.dirty?
+    def test_peer_dirty
+      p = Peer.new
+      assert_equal false, p.dirty?
+      
+      p[:p1] = 'test'
+      assert p.dirty?
+      
+      p.dirty = false
+      assert_equal false, p.dirty?
+      
+      p[:p1] = nil
+      assert p.dirty?
+    end
     
-    p.dirty = false
-    assert_equal false, p.dirty?
+    def test_peer_dirty_array
+      peer = Peer.new
+      assert !peer.dirty?
+      peer[:a] = []
+      assert peer.dirty?
+      peer.dirty = false
+      peer[:a] << C4.new(1)
+      assert  peer.dirty?
+      peer.dirty = false
+      assert !peer.dirty?
+    end
     
-    p[:p1] = nil
-    assert p.dirty?
-  end
-  
-  def test_peer_dirty_array
-    peer = Peer.new
-    assert !peer.dirty?
-    peer[:a] = []
-    assert peer.dirty?
-    peer.dirty = false
-    peer[:a] << C4.new(1)
-    assert  peer.dirty?
-    peer.dirty = false
-    assert !peer.dirty?
-  end
-  
-  def test_peer_dirty_hash
-    peer = Peer.new
-    peer[:h] = {'key1' => 'value1'}
-    assert  peer.dirty?
-    peer.dirty = false
-    assert !peer.dirty?
-    peer[:h]['key2'] = 'value2'
-    assert  peer.dirty?
-    peer[:h]['key2'] = 'value2.1'
-    assert  peer.dirty?
-    peer.dirty = false
-    peer[:h]['key2'] = nil
-    assert  peer.dirty?
-    peer.dirty = false
-    peer[:h].delete 'key2'
-    assert  peer.dirty?
-  end
-  
-  def test_peer_dirty_hash2
-    peer = Peer.new
-    peer[:h] = {'key1' => C4.new(1)}
-    peer.dirty = false
-    peer[:h]['key1'] = C4.new 1
-    assert !peer.dirty?
-    peer.dirty = false
-    peer[:h] = {'key1' => C4.new(1)}
-    assert !peer.dirty?        
-  end
-  
-  def test_peer_container
-    a = [1]
-    a.extend Peer::Container
-    a.memorize!
-    assert_nil a.recall
-    a << 2  
-    assert_not_nil a.recall
-    a.memorize!
-    assert_nil a.recall
-    a.collect! { |i| i * 2 }
-    assert_not_nil a.recall
-    assert_equal 4, a[1] 
+    def test_peer_dirty_hash
+      peer = Peer.new
+      peer[:h] = {'key1' => 'value1'}
+      assert  peer.dirty?
+      peer.dirty = false
+      assert !peer.dirty?
+      peer[:h]['key2'] = 'value2'
+      assert  peer.dirty?
+      peer[:h]['key2'] = 'value2.1'
+      assert  peer.dirty?
+      peer.dirty = false
+      peer[:h]['key2'] = nil
+      assert  peer.dirty?
+      peer.dirty = false
+      peer[:h].delete 'key2'
+      assert  peer.dirty?
+    end
+    
+    def test_peer_dirty_hash2
+      peer = Peer.new
+      peer[:h] = {'key1' => C4.new(1)}
+      peer.dirty = false
+      peer[:h]['key1'] = C4.new 1
+      assert !peer.dirty?
+      peer.dirty = false
+      peer[:h] = {'key1' => C4.new(1)}
+      assert !peer.dirty?        
+    end
+    
+    def test_peer_container
+      a = [1]
+      a.extend Peer::Container
+      a.memorize!
+      assert_nil a.recall
+      a << 2  
+      assert_not_nil a.recall
+      a.memorize!
+      assert_nil a.recall
+      a.collect! { |i| i * 2 }
+      assert_not_nil a.recall
+      assert_equal 4, a[1] 
+    end
   end
-end
 
-class Rubernate::BaseRuntimeTest < Test::Unit::TestCase
-  include Rubernate
-  include FixtureClasses
-  
-  def setup
-    @factory = Rubernate::Memory::Configuration.new
-    @runtime = @factory.create
-    Rubernate.configuration = @factory
-    Thread.current[:on_save] = Thread.current[:on_load] = nil
-  end    
-  
-  def test_instantiate
-    object = @runtime.instantiate 1, C1.name
-    assert object
-    assert_equal  1, object.primary_key
-    assert_equal C1, object.class
-  end
-  
-  def test_instantiate_existing
-    o0 = @runtime.instantiate 1, C1.name
-    o1 = @runtime.instantiate 1, C1.name
+  class Rubernate::BaseRuntimeTest < Test::Unit::TestCase
+    include Rubernate
+    include FixtureClasses
+    
+    def setup
+      @factory = Rubernate::Memory::Configuration.new
+      @runtime = @factory.create
+      Rubernate.configuration = @factory
+      Thread.current[:on_save] = Thread.current[:on_load] = nil
+    end    
+    
+    def test_instantiate
+      object = @runtime.instantiate 1, C1.name
+      assert object
+      assert_equal  1, object.primary_key
+      assert_equal C1, object.class
+    end
+    
+    def test_instantiate_existing
+      o0 = @runtime.instantiate 1, C1.name
+      o1 = @runtime.instantiate 1, C1.name
 
-    assert o0.equal?(o1)
-    assert_equal o0, o1
-  end
+      assert o0.equal?(o1)
+      assert_equal o0, o1
+    end
 
-  def test_instantiate_by_finder
-    pk = nil
-    Rubernate.session do
-      o = C1.new.attach
-      pk = o.primary_key
-      o_ = find_by_pk pk
-      assert_equal o, o_
-      assert_equal o.object_id, o_.object_id
-      o__ = find_by_query('all')[0]
-      assert_equal o, o__
-      assert_equal o.object_id, o__.object_id 
+    def test_instantiate_by_finder
+      pk = nil
+      Rubernate.session do
+        o = C1.new.attach
+        pk = o.primary_key
+        o_ = find_by_pk pk
+        assert_equal o, o_
+        assert_equal o.object_id, o_.object_id
+        o__ = find_by_query('all')[0]
+        assert_equal o, o__
+        assert_equal o.object_id, o__.object_id 
+      end
+      Rubernate.session do
+        o_  = find_by_pk pk
+        o__ = find_by_query('all')[0]
+        assert_equal o_, o__
+        assert_equal o_.object_id, o__.object_id       
+      end
     end
-    Rubernate.session do
-      o_ = find_by_pk pk
-      o__ = find_by_query('all')[0]
-      assert_equal o_, o__
-      assert_equal o_.object_id, o__.object_id       
+      
+    def test_instantiate_fake_class
+      @factory.database = {27 => ['NoSuchClass', {}]}
+      Rubernate.session do 
+        o = find_by_pk 27
+        assert_equal DummyPersistent, o.class
+        assert_equal 27, o.primary_key
+        assert_raise(ObjectLoadError) {o.test}
+      end
     end
-  end
     
-  def test_instantiate_fake_class
-    @factory.database = {27 => ['NoSuchClass', {}]}
-    Rubernate.session do 
-      o = find_by_pk 27
-      assert_equal DummyPersistent, o.class
-      assert_equal 27, o.primary_key
-      assert_raise(ObjectLoadError) {o.test}
+    def test_modified
+      Rubernate.session do |runtime| 
+        assert_equal 0, runtime.modified.size
+        o, o.p1 = C1.new.attach, 'o.p1'
+        assert_equal [o], runtime.modified
+      end
+    end
+    
+    def test_flush_modified_find
+      Rubernate.session do |runtime|
+        o1, o1.p1 = C1.new.attach, 'o1.p1'
+        assert_equal [o1], runtime.modified
+        runtime.find_by_query "all"
+        assert_equal 0, runtime.modified.size
+      end       
+    end
+    
+    def test_fluch_modified_close
+      Rubernate.session {|runtime| o, o.p1 = C1.new.attach, 'o.p1' }
+      Rubernate.session do |runtime| 
+        o = * runtime.find_by_query("sql: all")
+        assert_equal 'o.p1', o.p1
+      end
+    end
+    
+    def test_settings
+      assert Rubernate.settings
+      Rubernate.settings[:g_prop] = 'g0'
+      Rubernate.session do |runtime|
+        assert_equal 'g0', Rubernate.settings[:g_prop]
+        assert_equal 'g0', Rubernate.runtime.settings[:g_prop]
+        Rubernate.settings[:g_prop] = 'g1'
+        assert_equal 'g0', Rubernate.runtime.settings[:g_prop]
+        Rubernate.runtime.settings[:r_prop] = 'r0'
+      end
+      Rubernate.session do |runtime|
+        assert_equal 'g1', Rubernate.settings[:g_prop]
+        assert_equal 'g1', Rubernate.runtime.settings[:g_prop]
+        assert_nil Rubernate.runtime.settings[:r_prop]
+      end
+    end
+    
+    def test_lazy_factory
+      Rubernate.settings[:lazy_load] = :collection
+      Rubernate.session do |rt|
+        lf = rt.lazy_factory
+        f1 = lf.create 1, :p
+        assert f1
+        f2 = lf.create 2, :p
+        f3 = lf.create 1, :p
+        assert_equal f1, f3
+        assert_not_equal f1, f2
+        assert f1.is_a?(ParamLazyLoader)
+      end
     end
   end
-  
-  def test_modified
-    Rubernate.session {|runtime| 
-      assert_equal 0, runtime.modified.size
-      o, o.p1 = C1.new.attach, 'o.p1'
-      assert_equal [o], runtime.modified
-    }
-  end
-  
-  def test_ensure
-    o = C1.new
-    assert_nothing_raised() {o.p1}
-    o, o.peer = C1.new, nil
-    assert_raise(RuntimeError) {o.p1}
-    o, o.peer = C1.new, Peer.new
-    assert_nothing_raised() {o.p1}
-  end
-  
-  def test_flush_modified_find
-    Rubernate.session {|runtime|
-      o1, o1.p1 = C1.new.attach, 'o1.p1'
-      assert_equal [o1], runtime.modified
-      runtime.find_by_query "all"
-      assert_equal 0, runtime.modified.size
-    }       
-  end
-  
-  def test_fluch_modified_close
-    Rubernate.session {|runtime| o, o.p1 = C1.new.attach, 'o.p1' }
-    Rubernate.session {|runtime| 
-      o = * runtime.find_by_query("sql: all")
-      assert_equal 'o.p1', o.p1
-    }
-  end
-end
+end