Rubernate 0.1.0

data/tests/rubernate/impl/memory_test.rb

@@ -0,0 +1,188 @@
+$:.unshift(File.expand_path('../../..', __FILE__)) unless 
+  $:.include?(File.expand_path('../../..', __FILE__))
+
+require 'rubernate/fixtures' 
+
+class Rubernate::Memory::RuntimeTest < Test::Unit::TestCase   
+  include Rubernate
+  include Memory
+  include FixtureClasses
+  
+  def setup
+    @factory = RuntimeFactory.new
+    @runtime = @factory.create
+    Rubernate.runtime_factory = @factory
+  end
+  
+  # Runtime Interface Tests
+  def test_integration
+    k1, k2 = nil
+    Rubernate.session {|runtime|
+      o1, o2 = C1.new.attach, C2.new.attach
+      o1.p1, o2.p1 = 'o1.p1', o1
+      k1, k2 = o1.primary_key, o2.primary_key
+    }
+    Rubernate.session {|runtime|
+      o1, o2 = runtime.find_by_pk(k1), runtime.find_by_pk(k2)
+      assert_equal C1, o1.class
+      assert_equal 'o1.p1', o1.p1
+      assert_equal 'o1.p1', o2.p1.p1
+    }
+  end
+  
+  # Interface Tests
+  def test_load_by_pk
+    assert_nil @runtime.load_by_pk(1)
+    o, o.peer = C4.new(1), Peer.new
+    @runtime.save o
+    o = @runtime.load_by_pk(1)
+    assert_equal C4, o.class
+    assert_equal 1, o.primary_key
+    assert_nil @runtime.load_by_pk(2)
+  end
+  
+  def test_load_by_query_all
+    o1, o1.peer, o1.p1 = C1.new, Peer.new, 'o1.p1'
+    o2, o2.peer, o2.p1, o2.p2 = C2.new, Peer.new, 'o2.p1', o1        
+    @runtime.create o1
+    @runtime.create o2
+    result = @runtime.load_by_query "all"
+    assert_equal 2, result.size
+    l1 = result.find {|item| item.class == C1}
+    l2 = result.find {|item| item.class == C2}
+    assert_not_nil l1
+    assert_not_nil l2
+    assert_equal o1.primary_key, l1.primary_key
+    assert_equal o2.primary_key, l2.primary_key
+    assert_equal 'o1.p1', l1.p1
+    assert_equal 'o2.p1', l2.p1
+    assert_equal l1, l2.p2
+    assert_equal 'o1.p1', l2.p2.p1
+    assert l1.equal?(l2.p2)
+  end
+  
+  def test_create
+    o, o.peer = C2.new, Peer.new
+    assert_nil o.primary_key
+    @runtime.create o
+    assert_not_nil o.primary_key
+    assert_not_nil o.peer
+  end
+  
+  def test_create_find
+    o, o.p1 = C2.new, 'o.p1'
+    @runtime.create o
+    o = @runtime.find_by_pk o.primary_key
+    assert_equal 'o.p1', o.p1
+  end
+  
+  def test_load_created
+    o, o.peer = C2.new, Peer.new
+    @runtime.create o
+    o = @runtime.load_by_pk o.primary_key
+    assert_not_nil o
+    assert !o.peer.dirty?
+    assert !o.dirty?
+  end
+  
+  def test_create_dirty
+    o1, o1.peer = C2.new, Peer.new
+    @runtime.create o1
+    assert_not_nil o1.peer
+    assert !o1.peer.dirty?
+  end
+  
+  def test_save
+    o,  o.peer = C4.new(1), Peer.new
+    o.p1, o.p2 = C4.new(2), {'k1' => C4.new(3)}
+    @runtime.save o
+    o = @runtime.load_by_pk 1
+    assert_not_nil o
+    assert_not_nil o.peer
+    assert_equal 2, o.peer.size
+    assert_equal 2, o.p1.primary_key
+    assert_equal 3, o.p2['k1'].primary_key
+  end
+  
+  def test_delete
+    o, o.peer = C1.new, Peer.new
+    @runtime.create o
+    pk = o.primary_key
+    @runtime.delete o
+    assert_nil @runtime.load_by_pk(pk)        
+  end
+  
+  
+  # Internal Tests
+  def test_reference_eq
+    r1, r2, r3 = ref(1, C1), ref(1, C1), ref(1, C2)
+    assert_equal r1, r1
+    assert_equal r1, r2
+    assert_not_equal r1, r3
+  end
+  
+  def test_save_peer
+    obj, obj.peer = C4.new(1), Peer.new
+    obj.p1, obj.p2 = 2, [C4.new(2)]
+    data = @runtime.save_peer obj.peer
+    assert_equal({:p1 => 2, :p2 => [ref(2, C4)]}, data)
+  end
+  
+  def test_save_param_simple
+    p = @runtime.save_param "test"
+    assert_equal "test", p
+    
+    p = @runtime.save_param 1
+    assert_equal 1, p
+    
+    p = @runtime.save_param C4.new(3)
+    assert_equal Reference, p.class
+    assert_equal 3, p.primary_key
+    assert_equal C4, p.object_class
+  end
+  
+  def test_save_param_array
+    p = @runtime.save_param [C4.new(1), C4.new(2)]
+    assert_equal [ref(1, C4), ref(2, C4)], p
+    p = @runtime.save_param []
+    assert_equal [], p
+  end
+  
+  def test_save_param_hash
+    p = @runtime.save_param('k1' => C4.new(1), 2 => C4.new(2))
+    assert_equal({'k1' => ref(1, C4), 2 => ref(2, C4)}, p)
+    assert_not_equal({'k1' => ref(2, C4), 2 => ref(2, C4)}, p)
+    p = @runtime.save_param({})
+    assert_equal({}, p)
+  end
+  
+  def test_load_peer_simple
+    peer = @runtime.load_peer(:p1 => 2)
+    assert_equal  1, peer.size
+    assert_equal  2, peer[:p1]
+  end
+  
+  def test_load_peer_hash
+    peer = @runtime.load_peer(:p1 => 2, :p2 => {'key', ref(3, C1)})
+    assert_equal  1, peer[:p2].size
+    assert_equal C1, peer[:p2]['key'].class
+    assert_equal  3, peer[:p2]['key'].primary_key
+  end
+  
+  def test_load_peer_array
+    peer = @runtime.load_peer(:p1 => 2, :p2 => [ref(3, C1)])
+    assert_equal  1, peer[:p2].size
+    assert_equal C1, peer[:p2][0].class
+    assert_equal  3, peer[:p2][0].primary_key
+  end
+  
+  def test_find_by_pk_dirty
+    pk = nil
+    Rubernate.session {o = C1.new.attach; o.p1 = 'v'; pk = o.primary_key}
+    Rubernate.session {o = find_by_pk pk; assert !o.dirty?; assert_equal 'v', o.p1}
+  end
+  
+  def ref pk, klass
+    Reference.new pk, klass
+  end
+end

data/tests/rubernate/queries_test.rb

@@ -0,0 +1,176 @@
+$:.unshift(File.expand_path('../..', __FILE__)) unless 
+  $:.include?(File.expand_path('../..', __FILE__))
+
+require 'rubernate/fixtures'
+
+class Rubernate::QueriesGenericTest < Test::Unit::TestCase
+  include Rubernate::Queries
+  include FixtureClasses
+  
+  def setup
+    @factory = Factory.new
+  end
+  
+  def query *q_text, &q_block
+    if block_given?
+      @factory.query(&q_block)
+    else
+      @factory.query q_text[0]
+    end
+  end
+    
+  def once str, substr
+    lidx, ridx = str.index(substr), str.rindex(substr)
+    lidx and lidx == ridx
+  end
+
+  def assert_once string, tokens
+    tokens = [tokens] unless tokens.is_a? Array
+    for token in tokens
+      assert once(string, token), "'#{token}' must occurse only once in \n'#{string}'"
+    end
+  end
+  
+  def test_query_simplest
+    q = query 'Select :o; Where o.p1.int == 1'
+    sql = q.to_sql.downcase
+    assert_once sql, [ 'select o_.* from', 'r_objects o_', 'r_params o_p1', 
+        'o_.object_pk = o_p1.object_pk', 'o_p1.name = \'p1\'']
+  end
+     
+  def test_query_join_by_int
+    q = query "Select :o, :p; Where(o.p1.int == p.p2.int)"
+    sql = q.to_sql.downcase
+    assert_once sql, [ 'r_objects p_', 'r_params p_p2', 'r_objects o_', 'r_params o_p1',
+      'o_.object_pk = o_p1.object_pk', 'p_.object_pk = p_p2.object_pk',
+      'o_p1.int_value = p_p2.int_value', 'o_p1.name = \'p1\'',
+      'p_p2.name = \'p2\'' ]
+  end
+  
+  def test_query_filter_by_int
+    q = query {Select :o; Where(o.p1.int == 1)}
+    sql = q.to_sql.downcase        
+    assert_once sql, ['o_p1.int_value = 1', 'o_p1.name = \'p1\'']
+  end
+
+  def test_query_filter_by_nil
+    q = query 'Select :o; Where(o.p1.int.is_nil)'
+    sql = q.to_sql.downcase
+    assert_once sql, ['o_p1.int_value is null', 'o_p1.name = \'p1\'']
+    q = query 'Select :o; Where(o.p1.int.is_not_nil)'
+    sql = q.to_sql.downcase
+    assert_once sql, ['o_p1.int_value is not null']
+  end
+  
+  def test_query_and
+    q = query 'Select :o; Where And(o.p1.int == 1, o.p2.int == 2)'
+    sql = q.to_sql.downcase
+    assert_once sql, ['o_p1.int_value = 1', 'o_.object_pk = o_p2.object_pk']
+  end
+
+  def test_query_less_greater
+    q = query 'Select :o; Where And(o.p1.int < 1, o.p2.int > 2)'
+    sql = q.to_sql.downcase
+    assert_once sql, ['o_p1.int_value < 1', 'o_p2.int_value > 2']
+  end
+
+  def test_query_or
+    q = query 'Select :o; Where (Or o.p1.int == 1, o.p2.int == 2)'
+    sql = q.to_sql.downcase
+    assert_once sql, ['o_p1.int_value = 1', 'o_p1.int_value = 1', 'or']  
+  end
+  
+  def test_query_and_or
+    q = query 'Select :o; Where Or((And o.p1.int == 1, o.p2.int == 2), (o.p1.int == 3))'
+    sql = q.to_sql.downcase      
+    assert_once sql, ['o_p1.int_value = 1', 'o_p2.int_value = 2', 'o_p1.int_value = 3', 'or']
+  end
+  
+  def test_query_ref_equality
+    q = query 'Select :o, :t; Where Or(o.p1 == t, t.p2.int > 10)'
+    sql = q.to_sql.downcase
+    assert_once sql, 'o_p1.ref_value = t_.object_pk'
+  end
+  
+  def test_query_is_int
+    q = query {Select :o; Where o.p1.is_int}
+    sql = q.to_sql.downcase
+    assert_once sql, 'o_p1.flags = 1'
+  end
+  
+  def test_array_index
+    q = query {Select :o, :t; Where(o.p[3] == t)}
+    sql = q.to_sql.downcase
+    assert_once sql, ['o_.object_pk = o_p.object_pk', 'o_p.int_value = 3', 
+      'o_p.ref_value = t_.object_pk']
+  end
+
+  def test_array_param_index
+    q = query {Select :o, :t; Where(o.p[:index] == t)}
+    sql = q.to_sql.downcase
+    assert_once sql, ['o_.object_pk = o_p.object_pk', 'o_p.int_value = ?', 
+      'o_p.ref_value = t_.object_pk']
+  end
+  
+  def test_not_expr
+    q = query {Select :o; Where(Not(o.p.int == 1))}
+    sql = q.to_sql.downcase
+    assert_once sql, 'not (o_p.int_value = 1)'
+  end
+  
+  def test_markers
+    q = query {Select :o; Where(o.p1.int == :v1, o.p2 == :r2)}
+    sql = q.to_sql.downcase
+    assert_once sql, ['o_p1.int_value = ?', 'o_p2.ref_value = ?']
+    assert_equal [:v1, :r2], q.markers
+  end  
+  
+  def test_no_markers
+    q = query {Select :o; Where(o.p1.int == 1)}
+    assert_equal [], q.markers
+  end
+  
+  def test_class_equal
+    q = query {Select :o; Where(o.klass == C1)}
+    sql = q.to_sql
+    assert_once sql, ['r_objects o', 'o_.object_class = \'FixtureClasses::C1\'']  
+  end
+  
+  def test_expr_in
+    q = query {Select :o; Where(In(o.p1.int, [1, 2, 3]))}
+    sql = q.to_sql.downcase
+    assert_once sql, 'o_p1.int_value in (1, 2, 3)'
+  end
+  
+  def test_order_by
+    q = query {Select :o; Where o.klass == C1; OrderBy o.p1.int}
+    sql = q.to_sql.downcase
+    assert_once sql, 'order by o_p1.int_value'
+  end
+  
+  def test_in_subclasses
+    q = query 'Select :o; Where In(o.klass, FixtureClasses::C1.subclasses)'
+    assert_once q.to_sql, %w{o_.object_class FixtureClasses::C2 FixtureClasses::C4}
+  end
+  
+  def test_derived
+    q = query 'Select :o; Where o.derived(FixtureClasses::C1)'
+    q.to_sql
+    assert_once q.to_sql, %w{FixtureClasses::C1 FixtureClasses::C2 FixtureClasses::C4}
+    
+    q = query 'Select :o; Where o.derived(FixtureClasses::C4)'
+    assert_once q.to_sql, %w{FixtureClasses::C4}
+  end
+  
+  def test_param_name
+    q = query {Select :o; Where o.name.str == :name}
+    assert_once q.to_sql, ["o_name.name = 'name'", 'o_name.str_value = ?']
+  end
+  
+  def test_eq_equivalence
+    q0 = query {Select :o; Where o.p1 == :ref}
+    q1 = query {Select :o; Where Eq(o.p1, :ref)}
+    assert_equal q0.to_sql, q1.to_sql
+    assert_equal q0.markers, q1.markers
+  end  
+end

data/tests/rubernate/rubernate_test.rb

@@ -0,0 +1,326 @@
+$:.unshift(File.expand_path('../..', __FILE__)) unless 
+  $:.include?(File.expand_path('../..', __FILE__))
+
+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::RuntimeFactory.new
+    @runtime = @factory.create
+    Rubernate.runtime_factory = @factory
+    Thread.current[:on_save] = Thread.current[:on_load] = nil
+  end
+  
+  def test_include
+    assert !C0.include?(Entity)
+    assert  C1.include?(Entity)
+    assert  C2.include?(Entity)
+    assert  C3.include?(Entity)
+    assert !C0.new.kind_of?(Entity)
+    assert  C1.new.kind_of?(Entity)
+  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] = 'passed'
+      end
+    }
+    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_nil 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
+    
+    @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
+  
+  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 { |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|
+      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!
+    }
+  end
+end
+
+class Rubernate::PeerTest < Test::Unit::TestCase
+  include Rubernate
+  include FixtureClasses
+  
+  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
+  
+  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] 
+  end
+end
+
+class Rubernate::BaseRuntimeTest < Test::Unit::TestCase
+  include Rubernate
+  include FixtureClasses
+  
+  def setup
+    @factory = Rubernate::Memory::RuntimeFactory.new
+    @runtime = @factory.create
+    Rubernate.runtime_factory = @factory
+    Thread.current[:on_save] = Thread.current[:on_load] = nil
+  end    
+  
+  def test_instantiate
+    object = @runtime.instantiate 1, C1
+    assert object
+    assert_equal  1, object.primary_key
+    assert_equal C1, object.class
+  end
+  
+  def test_instantiate_existing
+    o0 = @runtime.instantiate 1, C1
+    o1 = @runtime.instantiate 1, C1
+
+    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 
+    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
+  
+  def test_instantiate_invalid_class
+    @runtime.instantiate 1, C1
+    assert_raise(RuntimeError) { @runtime.instantiate 1, C2 }
+  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(NoMethodError) {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