momomoto 0.1.0

data/test/test_bytea.rb

@@ -0,0 +1,35 @@
+
+class TestBytea < Test::Unit::TestCase
+
+  def test_escaping_null
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_bytea'
+    data = ''
+    data.concat 0
+    data.concat "'"
+    r = c.new
+    r.data = data
+    r.write
+    r2 = c.select(:id=>r.id)
+    assert_equal( 1, r2.length )
+    assert_equal( data, r2[0].data )
+  end
+
+  def test_escaping_file
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_bytea'
+    r = c.new
+    data = File.new('test/bytea-test-file').read
+    r.data = data
+    assert_equal( data.length, r.data.length )
+    assert_equal( data, r.data )
+    r.write
+    r2 = c.select(:id=>r.id)
+    assert_equal( 1, r2.length )
+    assert_equal( data.length , r2[0].data.length )
+    assert_equal( data, r2[0].data )
+  end
+
+end
+
+

data/test/test_character.rb

@@ -0,0 +1,27 @@
+
+class TestCharacter < Test::Unit::TestCase
+
+  def test_nil
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_character'
+    r = c.new( :data => nil )
+    assert_equal( nil, r.data )
+    r.write
+    r2 = c.select( :id => r.id ).first
+    assert_equal( nil, r2.data )
+  end
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_character'
+    ['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.rstrip )
+    end
+  end
+
+end
+

data/test/test_character_varying.rb

@@ -0,0 +1,17 @@
+
+class TestCharacter_varying < Test::Unit::TestCase
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_character_varying'
+    [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 )
+    end
+  end
+
+end
+

data/test/test_database.rb

@@ -0,0 +1,63 @@
+
+class TestDatabase < Test::Unit::TestCase
+
+  def test_begin
+    db = Momomoto::Database.instance
+    assert_nothing_raised do db.begin end
+  end
+
+  def test_commit
+    db = Momomoto::Database.instance
+    db.begin
+    assert_nothing_raised do db.commit end
+    assert_raise( Momomoto::Error ) do db.commit end
+  end
+
+  def test_connect
+    db = Momomoto::Database.instance
+    db.disconnect
+    old_config = db.send( :instance_variable_get, :@config )
+    db.config( :port => 65535 )
+    assert_raise( Momomoto::CriticalError ) do
+      db.connect
+    end
+    db.config( old_config )
+    db.connect
+  end
+
+  def test_execute
+    db = Momomoto::Database.instance
+    db.execute("SELECT version();")
+    assert_raise( Momomoto::CriticalError ) do
+      db.execute( "chunky bacon;")
+    end
+  end
+
+  def test_fetch_primary_keys
+    db = Momomoto::Database.instance
+    pk = db.fetch_primary_keys( 'test_nodefault' )
+    assert_equal( 1, pk.length )
+  end
+
+  def test_rollback
+    db = Momomoto::Database.instance
+    db.begin
+    assert_nothing_raised do db.rollback end
+    assert_raise( Momomoto::Error ) do db.rollback end
+  end
+
+  def test_transaction
+    db = Momomoto::Database.instance
+    assert_nothing_raised do 
+      db.transaction do end
+    end
+    assert_raise( Momomoto::CriticalError ) do
+      db.transaction do
+        db.execute( "chunky bacon;")
+      end
+    end
+
+  end
+
+end
+

data/test/test_datatype.rb

@@ -0,0 +1,62 @@
+
+class TestDatatype < Test::Unit::TestCase
+
+  DATATYPES = Momomoto::Datatype.constants.map do | t | 
+    Momomoto::Datatype.const_get( t ) 
+  end
+
+  def test_default
+    DATATYPES.each do | type |
+      row = Momomoto::Information_schema::Columns.new
+      row.column_default = 'default-value'
+      a = type.new( row )
+      assert_equal( 'default-value', a.default )
+      assert_equal( false, type.new.default )
+    end
+  end
+
+  def test_not_null
+    DATATYPES.each do | type |
+      row = Momomoto::Information_schema::Columns.new
+      row.is_nullable = "YES"
+      assert_equal( false, type.new( row ).not_null? )
+      row.is_nullable = "NO"
+      assert_equal( true, type.new( row ).not_null? )
+      row.is_nullable = nil
+      assert_equal( false, type.new( row ).not_null? )
+    end
+  end
+
+  def test_compile_rule
+    DATATYPES.each do | type |
+      t = type.new
+      tests = [ nil, [], [nil], [nil,nil], {}, {:eq=>nil}, {nil=>nil}]
+      tests.each do | test |
+        assert_raise( Momomoto::Error ) do
+          t.compile_rule( :field_name, test )
+        end
+      end
+    end
+  end
+
+  def test_operator_sign
+    DATATYPES.each do | type |
+      assert_equal( '<=', type.operator_sign( :le ) )
+      assert_equal( '<', type.operator_sign( :lt ) )
+      assert_equal( '>=', type.operator_sign( :ge ) )
+      assert_equal( '>', type.operator_sign( :gt ) )
+      assert_equal( '=', type.operator_sign( :eq ) )
+      assert_equal( '<>', type.operator_sign( :ne ) )
+      assert_raise( Momomoto::CriticalError ) { type.operator_sign( :foo ) }
+    end
+  end
+
+  def test_escape
+    DATATYPES.each do | type |
+      t = type.new
+      assert_equal( 'NULL', t.escape( nil ))
+    end
+  end
+
+end
+

data/test/test_date.rb

@@ -0,0 +1,50 @@
+
+class TestDate < Test::Unit::TestCase
+
+  def test_nil
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_date'
+    r = c.new( :data => nil )
+    assert_equal( nil, r.data )
+    r.write
+    r2 = c.select( :id => r.id ).first
+    assert_equal( nil, r2.data )
+  end
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_date'
+    [ Date.parse("2005-5-23"), ::Date.today].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
+
+  def test_string_conversion
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_date'
+    [ "2005-5-23", "2006-06-06"].each do | value |
+      r = c.new( :data => value )
+      assert_equal( Date.parse( value ), r.data )
+      r.write
+      r2 = c.select(:id=>r.id).first
+      assert_equal( Date.parse( value ), r2.data )
+    end
+  end
+
+  def test_invalid_dates
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_date'
+    [ "2005-5-43", "2006-16-06"].each do | value |
+      r = c.new
+      assert_raise( Momomoto::ConversionError ) do
+        r.data = value
+      end
+    end
+  end
+
+end
+

data/test/test_inet.rb

@@ -0,0 +1,27 @@
+
+class TestInet < Test::Unit::TestCase
+
+  def test_nil
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_inet'
+    r = c.new( :data => nil )
+    assert_equal( nil, r.data )
+    r.write
+    r2 = c.select( :id => r.id ).first
+    assert_equal( nil, r2.data )
+  end
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_inet'
+    [ '127.0.0.1', '172.22.64.1', '::1' ].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
+

data/test/test_information_schema.rb

@@ -0,0 +1,27 @@
+
+class TestInformationSchema < Test::Unit::TestCase
+
+  # test for working information_schema.columns class
+  def test_information_schema_columns
+    a = Momomoto::Information_schema::Columns.select(:table_schema => 'pg_catalog', :table_name => 'pg_tables')
+    assert_operator( 0, :<, a.length )
+  end
+
+  # test for working information_schema.key_column_usage class
+  def test_information_schema_key_column_usage
+    a = Momomoto::Information_schema::Key_column_usage.select(:table_schema => 'pg_catalog', :table_name => 'pg_class')
+    assert_equal( 0, a.length )
+    a = Momomoto::Information_schema::Key_column_usage.select(:table_schema => 'public')
+    assert_operator( 0, :<, a.length )
+  end
+
+  # test for working information_schema.table_constraints class
+  def test_information_schema_table_constraints
+    a = Momomoto::Information_schema::Table_constraints.select(:table_schema => 'pg_catalog', :table_name => 'pg_class')
+    assert_equal( 0, a.length )
+    a = Momomoto::Information_schema::Table_constraints.select(:table_schema => 'public')
+    assert_operator( 0, :<, a.length )
+  end
+
+end
+

data/test/test_integer.rb

@@ -0,0 +1,37 @@
+
+class TestInteger < Test::Unit::TestCase
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_integer'
+    [nil,1,2,2147483647].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_invalid
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_integer'
+    [ "2005-5-43", "a"].each do | value |
+      r = c.new
+      assert_raise( Momomoto::ConversionError ) do
+        r.data = value
+      end
+    end
+  end
+
+  def test_compile_rule
+    t = Momomoto::Datatype::Integer.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_interval.rb

@@ -0,0 +1,38 @@
+
+class TestInterval < Test::Unit::TestCase
+
+  def test_nil
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_interval'
+    r = c.new( :data => nil )
+    assert_equal( nil, r.data )
+    r.write
+    r2 = c.select( :id => r.id ).first
+    assert_equal( nil, r2.data )
+  end
+
+  def test_invalid
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_interval'
+    [ :x, 2.3 ].each do | value |
+      r = c.new
+      assert_raise( Momomoto::ConversionError ) do
+        r.data = value
+      end
+    end
+  end
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_interval'
+    [Time.parse("00:00:00"), Time.parse("01:00:00"), Time.parse("23:00:00")].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_join.rb

@@ -0,0 +1,19 @@
+
+class Person < Momomoto::Table; end
+class Event_Person < Momomoto::Table; end
+
+class TestJoin < Test::Unit::TestCase
+
+  def test_initialize
+    a = Momomoto::Join.new( Person, {Event_Person=>:person_id})
+    assert_equal( true, a.respond_to?( :event_person ) )
+    assert_equal( true, a.respond_to?( :person ) )
+  end
+
+  def test_select
+    a = Momomoto::Join.new( Person, {Event_Person=>:person_id})
+    a.select
+  end
+
+end
+

data/test/test_numeric.rb

@@ -0,0 +1,30 @@
+
+class TestNumeric < Test::Unit::TestCase
+
+  def test_samples
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_numeric'
+    [nil,1.0,1.5,2.0,2.3].each do | number |
+      number = BigDecimal.new(number.to_s)
+      r = c.new( :data => number )
+      assert_equal( number, r.data )
+      r.write
+      r2 = c.select(:id=>r.id).first
+      assert_equal( number, r2.data )
+      assert( number == r2.data )
+    end
+  end
+
+  def test_invalid
+    c = Class.new( Momomoto::Table )
+    c.table_name = 'test_numeric'
+    [ "2005-5-43", "a"].each do | value |
+      r = c.new
+      assert_raise( Momomoto::ConversionError ) do
+        r.data = value
+      end
+    end
+  end
+
+end
+