momomoto 0.1.0

data/test/test_procedure.rb

@@ -0,0 +1,75 @@
+
+class TestProcedure < Test::Unit::TestCase
+
+  def test_sql_function_parameter
+    a = Class.new(Momomoto::Procedure)
+    a.procedure_name("test_parameter_sql")
+    assert_equal( 1, a.parameters.length )
+    assert_equal( [:param1], a.parameters[0].keys )
+  end
+
+  def test_plpqsql_function_parameter
+    a = Class.new(Momomoto::Procedure)
+    a.procedure_name("test_parameter_plpgsql")
+    assert_equal( 2, a.parameters.length )
+    assert_equal( [:param1], a.parameters[0].keys )
+    assert_equal( [:param2], a.parameters[1].keys )
+  end
+
+  def test_procedure_name
+    self.class.const_set( :Proc1, Class.new( Momomoto::Procedure ) )
+    assert_equal( 'proc1', Proc1.procedure_name )
+    self.class.const_set( :Proc2, Class.new( Momomoto::Procedure ) )
+    assert_equal( 'proc2', Proc2.procedure_name )
+    Proc2.procedure_name( 'proc3' )
+    assert_equal( 'proc3', Proc2.procedure_name )
+    Proc2.procedure_name = 'proc4'
+    assert_equal( 'proc4', Proc2.procedure_name )
+    assert_equal( 'proc1', Proc1.procedure_name )
+  end
+
+  def test_columns_fetching
+    p = Class.new( Momomoto::Procedure )
+    p.procedure_name = 'fetch_procedure_columns'
+    p.schema_name = 'momomoto'
+    assert_equal( 2, p.columns.length )
+  end
+
+  def test_columns
+    p = Class.new( Momomoto::Procedure )
+    p2 = Class.new( Momomoto::Procedure )
+    p.columns = :chunky
+    p2.columns = :alice
+    assert_equal( :chunky, p.columns )
+    p.columns = :bacon
+    assert_equal( :bacon, p.columns )
+    p.columns( :chunky )
+    assert_equal( :chunky, p.columns )
+    assert_equal( :alice, p2.columns )
+  end
+
+  def test_parameters
+    p = Class.new( Momomoto::Procedure )
+    p2 = Class.new( Momomoto::Procedure )
+    p.parameters = { :chunky => :bacon }
+    p2.parameters = { :bacon => :chunky }
+    assert_equal( [{:chunky=>:bacon}], p.parameters )
+    assert_equal( [{:bacon=>:chunky}], p2.parameters )
+    p.parameters( {:alice=>:bob},{:eve=>:mallory})
+    assert_equal( [{:alice=>:bob},{:eve=>:mallory}], p.parameters )
+    assert_equal( [{:bacon=>:chunky}], p2.parameters )
+  end
+
+  def test_call
+    self.class.const_set(:Test_set_returning, Class.new( Momomoto::Procedure ) )
+    assert_equal( "test_set_returning", Test_set_returning.procedure_name )
+    Test_set_returning.parameters(:person_id => Momomoto::Datatype::Integer.new)
+    assert_not_nil( Test_set_returning.parameters )
+    assert_not_nil( Test_set_returning.columns )
+    assert( Test_set_returning.columns.length > 1 )
+    Test_set_returning.call( :person_id => 5 )
+    Test_set_returning.call({:person_id => 5},{:person_id => 5},{:order=>:person_id,:limit=>10} )
+  end
+
+end
+

data/test/test_real.rb

@@ -0,0 +1,17 @@
+
+class TestReal < Test::Unit::TestCase
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_real'
+    [nil,1.0,2.0,2.3,-1.2].each do | number |
+      r = c.new( :data => number )
+      assert_equal( number, r.data )
+      r.write
+      r2 = c.select(:id=>r.id).first
+      assert_equal( number, r2.data )
+    end
+  end
+
+end
+

data/test/test_row.rb

@@ -0,0 +1,47 @@
+
+class TestRow < Test::Unit::TestCase
+
+  class Person < Momomoto::Table; end
+
+  def test_table
+    Momomoto::Information_schema::Columns.select(:table_schema => 'pg_catalog', :table_name => 'pg_tables')
+    Momomoto::Information_schema::Key_column_usage.select(:table_schema => 'pg_catalog', :table_name => 'pg_class')
+    assert_equal( Momomoto::Information_schema::Columns, Momomoto::Information_schema::Columns::Row.table )
+    assert_equal( Momomoto::Information_schema::Key_column_usage, Momomoto::Information_schema::Key_column_usage::Row.table )
+  end
+
+  def test_inheritence
+    self.class.const_set( :Event, Class.new( Momomoto::Table ) )
+    Event.const_set( :Row, Class.new )
+    assert_raise( Momomoto::CriticalError ) do Event.select end
+  end
+
+  def test_setter
+    a = Class.new( Momomoto::Table )
+    a.table_name = 'person'
+    r = a.select_or_new( :person_id => 13 )
+    r.write
+    assert_raise( Momomoto::Error ) do r.person_id = 14 end
+  end
+
+  def test_bracket
+    a = Person.new
+    assert_nil( a.person_id )
+    assert_equal( a.person_id, a[:person_id])
+    assert_equal( a.person_id, a['person_id'])
+    a.person_id = 23
+    assert_equal( 23, a.person_id)
+    assert_equal( a.person_id, a[:person_id])
+    assert_equal( a.person_id, a['person_id'])
+    a[:person_id] = 42
+    assert_equal( 42, a.person_id)
+    assert_equal( a.person_id, a[:person_id])
+    assert_equal( a.person_id, a['person_id'])
+    a['person_id'] = 5
+    assert_equal( 5, a.person_id)
+    assert_equal( a.person_id, a[:person_id])
+    assert_equal( a.person_id, a['person_id'])
+  end
+
+end
+

data/test/test_smallint.rb

@@ -0,0 +1,26 @@
+
+class TestSmallint < Test::Unit::TestCase
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_smallint'
+    [nil,1,2,32767].each do | number |
+      r = c.new( :data => number )
+      assert_equal( number, r.data )
+      r.write
+      r2 = c.select(:id=>r.id).first
+      assert_equal( number, r2.data )
+    end
+  end
+
+  def test_compile_rule
+    t = Momomoto::Datatype::Smallint.new
+    input = [ 1, '1', [1], ['1'], [1,2,3],['1','2','3'], {:eq=>1}, {:eq=>'1'}, {:lt=>10, :gt=>5}, {:lt=>'10', :gt=>'5'} ]
+
+    input.each do | test_input |
+      assert_instance_of( String, t.compile_rule( :field, test_input ) )
+    end
+  end
+
+end
+

data/test/test_table.rb

@@ -0,0 +1,233 @@
+
+class TestTable < Test::Unit::TestCase
+
+  class Person < Momomoto::Table
+    def self.person_id=( row , newvalue )
+      newvalue
+    end
+
+    def self.nick_name=( row, newvalue )
+      row.first_name + newvalue
+    end
+  end
+
+  class Conference < Momomoto::Table
+  end
+
+  def test_columns_getter
+    c1 = Class.new( Momomoto::Table )
+    c1.columns =  {:a=>Momomoto::Datatype::Text}
+    assert_equal( {:a=>Momomoto::Datatype::Text}, c1.columns )
+  end
+
+  def test_columns_setter
+    c1 = Class.new( Momomoto::Table )
+    c1.columns =  {:a=>Momomoto::Datatype::Text}
+    assert_equal( {:a=>Momomoto::Datatype::Text}, c1.columns )
+    c1.columns =  {:b=>Momomoto::Datatype::Text}
+    assert_equal( {:b=>Momomoto::Datatype::Text}, c1.columns )
+    c1.columns({:c=>Momomoto::Datatype::Text})
+    assert_equal( {:c=>Momomoto::Datatype::Text}, c1.columns )
+  end
+
+  def test_primary_key_getter
+    a = Class.new( Momomoto::Table )
+    a.primary_keys( [:pk] )
+    assert_equal( [:pk], a.primary_keys )
+    p = Class.new( Momomoto::Table )
+    p.table_name = 'person'
+    p.schema_name = 'public'
+    assert_nothing_raised do p.primary_keys end
+  end
+
+  def test_primary_key_setter
+    a = Class.new( Momomoto::Table )
+    a.primary_keys( [:pk] )
+    assert_equal( [:pk], a.primary_keys )
+    a.primary_keys= [:pk2]
+    assert_equal( [:pk2], a.primary_keys )
+  end
+
+  def test_schema_name_getter
+    self.class.const_set( :S, Class.new( Momomoto::Table ) )
+    assert_equal( 'public', S.schema_name )
+    S.schema_name = "chunky"
+    assert_equal( "chunky", S.schema_name )
+  end
+
+  def test_schema_name_setter
+    a = Class.new( Momomoto::Table )
+    b = Class.new( Momomoto::Table )
+    a.schema_name = :chunky
+    b.schema_name = :bacon
+    assert_equal( :chunky, a.schema_name )
+    assert_equal( :bacon, b.schema_name )
+    a.schema_name( :ratbert )
+    assert_equal( :ratbert, a.schema_name )
+    assert_equal( :bacon, b.schema_name )
+  end
+
+  def test_table_name_getter
+    t = Class.new( Momomoto::Table )
+    t.table_name = "chunky"
+    assert_equal( "chunky", t.table_name )
+  end
+
+  def test_table_name_setter
+    t = Class.new( Momomoto::Table )
+    t.table_name = "chunky"
+    assert_equal( "chunky", t.table_name )
+    t.table_name = "bacon"
+    assert_equal( "bacon", t.table_name )
+    t.table_name( "fox" )
+    assert_equal( "fox", t.table_name )
+  end
+
+  def test_full_name
+    a = Class.new( Momomoto::Table )
+    a.table_name( 'abc' )
+    assert_equal( 'public.abc', a.full_name )
+    a.schema_name( 'def' )
+    assert_equal( 'def.abc', a.full_name )
+  end
+
+  def test_custom_setter
+    p = Person.new
+    p.first_name = 'bacon'
+    p.nick_name = 'abc'
+    assert_equal( p.first_name + 'abc', p.nick_name )
+  end
+
+  def test_new
+    anonymous = Person.new
+    assert_equal(Person::Row, anonymous.class)
+    assert_equal( true, anonymous.new_record? )
+    assert_nil( anonymous.first_name )
+    sven = Person.new(:first_name=>'Sven',:last_name=>'Klemm')
+    assert_equal( 'Klemm', sven.last_name )
+    assert_equal( 'Sven', sven.first_name )
+    assert_equal( true, sven.new_record? )
+  end
+
+  def test_select
+    r = Person.select( nil, {:limit => 3})
+    assert_equal( 3, r.length )
+    Person.select( nil, {:limit => 3, :order => :person_id})
+    Person.select( nil, {:limit => 3, :order => "person_id"})
+    Person.select( nil, {:limit => 3, :order => ["person_id"]})
+    Person.select( nil, {:limit => 3, :order => [:first_name, :last_name]} )
+    Person.select( nil, {:limit => 3, :order => ['first_name', :last_name]} )
+    Person.select( nil, {:limit => 3, :order => ['first_name', 'last_name']} )
+    Person.select( nil, {:order => Momomoto::lower(:first_name)})
+    Person.select( nil, {:order => Momomoto::lower(:first_name, :last_name)})
+    Person.select( nil, {:order => Momomoto::asc( [:first_name, :last_name] )} )
+    Person.select( nil, {:order => [:first_name, Momomoto::lower(:last_name )]} )
+    Person.select( nil, {:order => [:first_name, Momomoto::desc(:last_name )]} )
+    Person.select( nil, {:order => Momomoto::asc(Momomoto::lower(:first_name))})
+    Person.select( nil, {:order => Momomoto::desc(Momomoto::lower(:first_name))})
+    assert_raise( Momomoto::Error ) do
+      Person.select( nil, {:order => Momomoto::lower(Momomoto::asc(:first_name))})
+    end
+    assert_raise( Momomoto::Error ) do
+      Person.select( nil, {:order => Momomoto::lower(Momomoto::desc(:first_name))})
+    end
+    assert_raise( Momomoto::Error ) do
+      Person.select( nil, {:limit=>'4f4'} )
+    end
+    assert_raise( Momomoto::Error ) do
+      Person.select( nil, {:order=>:chunky})
+    end
+    assert_raise( Momomoto::Error ) do
+      Person.select( nil, {:order=>[:chunky,:bacon]})
+    end
+    assert_raise( Momomoto::Error ) do
+      Person.select( nil, {:order=>Object.new})
+    end
+    assert_raise( Momomoto::Error ) do
+      Person.select( nil, {:order=>[Object.new, Object.new]})
+    end
+  end
+
+  def test_select_or_new
+    r = Person.select_or_new({:person_id => 7})
+    r.first_name = 'Sven'
+    r.write
+    assert_equal( 1, Person.select(:person_id => 7).length )
+    r.delete
+    assert_equal( 0, Person.select(:person_id => 7).length )
+    r2 = Person.select_or_new do | field_name |
+      assert( Person.columns.keys.member?( field_name ))
+      r.send( field_name )
+    end
+    r2.write
+    assert_equal( 1, Person.select(:person_id => 7).length )
+    r2.delete
+    assert_equal( 0, Person.select(:person_id => 7).length )
+  end
+
+  def test_select_single
+    # delete existing test_select_single entries
+    Person.select(:first_name=>'test_select_single').each do | p | p.delete end
+
+    assert_raise( Momomoto::Nothing_found ) do
+      Person.select_single(:first_name=>'test_select_single')
+    end
+
+    p1 = Person.new(:first_name=>'test_select_single')
+    p1.write
+    p2 = Person.new(:first_name=>'test_select_single')
+    p2.write
+
+    assert_raise( Momomoto::Too_many_records ) do
+      Person.select_single(:first_name=>'test_select_single')
+    end
+    p1.delete
+    p2.delete
+  end
+
+  def test_defaults
+    conf = Conference.select_or_new(:conference_id=>1)
+    conf.acronym = 'Pentabarf'
+    conf.title = 'Pentabarf Developer Conference'
+    conf.start_date = '2007-08-07'
+    conf.write
+  end
+
+  def test_write
+    r = Person.new
+    r.first_name = 'Chunky'
+    r.last_name = 'Bacon'
+    r.write
+    assert_not_nil( r.person_id )
+    assert_nothing_raised do
+      r.delete
+      r.write
+      r.delete
+    end
+  end
+
+  def test_write2
+    self.class.const_set(:Test_nodefault, Class.new( Momomoto::Table ) )
+    Test_nodefault.schema_name = nil
+    a = Test_nodefault.new
+    a.data = 'chunky bacon'
+    assert_equal( [:id], Test_nodefault.primary_keys )
+    assert_raise( Momomoto::Error ) do
+      a.write
+    end
+  end
+
+  def test_dirty
+    r = Person.new
+    assert_equal( false, r.dirty?, "New empty rows should not be dirty" )
+    r.first_name = 'Chunky'
+    assert_equal( true, r.dirty?, "Modified rows must be dirty" )
+    r.write
+    assert_equal( false, r.dirty?, "Written rows should not be dirty" )
+    r.delete
+    r = Person.new(:first_name => 'Chunky')
+    assert_equal( true, r.dirty? )
+  end
+
+end
+

data/test/test_text.rb

@@ -0,0 +1,25 @@
+
+class TestText < Test::Unit::TestCase
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_text'
+    [nil,'a',"'","''","\\","a'b"].each do | value |
+      r = c.new( :data => value )
+      assert_equal( value, r.data )
+      r.write
+      r2 = c.select(:id=>r.id).first
+      assert_equal( value, r2.data )
+      r.delete
+    end
+  end
+
+  def test_operator_sign
+    type = Momomoto::Datatype::Text
+      assert_equal( 'LIKE', type.operator_sign( :like ) )
+      assert_equal( 'ILIKE', type.operator_sign( :ilike ) )
+      assert_raise( Momomoto::CriticalError ) { type.operator_sign( :foo ) }
+  end
+
+end
+

data/test/test_time_with_time_zone.rb

@@ -0,0 +1,17 @@
+
+class TestTimeWithTimeZone < Test::Unit::TestCase
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_time_with_time_zone'
+    [Time.parse("00:00:00"),Time.parse("01:00:00"),Time.parse("23:00")].each do | value |
+      r = c.new( :data => value )
+      assert_equal( value, r.data )
+      r.write
+      r2 = c.select(:id=>r.id).first
+      assert_equal( value, r2.data )
+    end
+  end
+
+end
+