dohruby 0.2.1 → 0.3

data/test/core/tc_date.rb

@@ -20,6 +20,59 @@ class TC_core_date < Test::Unit::TestCase
     assert_equal(6, Date::short_weekday_to_num('saT'))
     assert_equal(nil, Date::short_weekday_to_num('saTurday'))
   end
+
+  def test_years_since
+    dt = Date.new(2008,2,29)
+    assert_equal(0, dt.years_since(Date.new(2007,3,1)))
+    assert_equal(1, dt.years_since(Date.new(2007,2,28)))
+    assert_equal(2, dt.years_since(Date.new(2006,2,28)))
+    assert_equal(4, dt.years_since(Date.new(2004,2,29)))
+    assert_equal(3, dt.years_since(Date.new(2004,3,1)))
+    dt = Date.new(2009,2,28)
+    assert_equal(0, dt.years_since(Date.new(2008,2,29)))
+    assert_equal(1, dt.years_since(Date.new(2008,2,28)))
+  end
+
+  def test_smart_parse
+    assert_equal(Date.new(2008, 1, 1), Date.smart_parse('01/01/08'))
+    assert_equal(Date.new(1950, 1, 1), Date.smart_parse('01/01/50'))
+    assert_equal(Date.new(2049, 1, 1), Date.smart_parse('01/01/49'))
+  end
+
+  def test_add_seconds
+    assert_equal(DateTime.new(2009, 2, 10, 15, 30, 3), DateTime.new(2009, 2, 10, 15, 30, 2).add_seconds(1))
+  end
+
+  def test_add_months
+    assert_equal(Date.new(2008, 2, 1), Date.new(2008, 1, 1).add_months(1))
+    assert_equal(Date.new(2008, 3, 1), Date.new(2008, 1, 1).add_months(2))
+    assert_equal(Date.new(2008, 4, 1), Date.new(2008, 1, 5).add_months(3, 1))
+    assert_equal(Date.new(2008, 11, 1), Date.new(2008, 1, 1).add_months(10))
+    assert_equal(Date.new(2008, 12, 1), Date.new(2008, 1, 1).add_months(11))
+    assert_equal(Date.new(2009, 1, 1), Date.new(2008, 1, 1).add_months(12))
+    assert_equal(Date.new(2009, 2, 1), Date.new(2008, 1, 1).add_months(13))
+    assert_equal(Date.new(2009, 3, 3), Date.new(2008, 1, 8).add_months(14, 3))
+    assert_equal(Date.new(2008, 3, 5), Date.new(2008, 2, 5).add_months(1))
+    assert_equal(Date.new(2008, 11, 2), Date.new(2008, 10, 5).add_months(1, 2))
+    assert_equal(Date.new(2008, 12, 5), Date.new(2008, 10, 5).add_months(2))
+    assert_equal(Date.new(2008, 12, 1), Date.new(2008, 10, 1).add_months(2))
+    assert_equal(Date.new(2009, 1, 1), Date.new(2008, 10, 1).add_months(3))
+    assert_equal(Date.new(2008, 12, 1), Date.new(2008, 11, 1).add_months(1))
+    assert_equal(Date.new(2009, 1, 1), Date.new(2008, 11, 1).add_months(2))
+    assert_equal(Date.new(2009, 1, 1), Date.new(2008, 12, 1).add_months(1))
+    assert_equal(Date.new(2009, 2, 1), Date.new(2008, 12, 1).add_months(2))
+    assert_equal(Date.new(2009, 12, 1), Date.new(2008, 1, 1).add_months(23))
+    assert_equal(Date.new(2010, 1, 1), Date.new(2008, 1, 1).add_months(24))
+    assert_equal(Date.new(2010, 11, 1), Date.new(2008, 12, 1).add_months(23))
+    assert_equal(Date.new(2010, 12, 1), Date.new(2008, 12, 1).add_months(24))
+    assert_equal(Date.new(2009, 2, 28), Date.new(2009, 1, 31).add_months(1))
+    assert_raise(ArgumentError) {Date.new(2009,1,25).add_months(1, 29)}
+  end
+
+  def test_add_years
+    assert_equal(Date.new(2010, 12, 1), Date.new(2008, 12, 1).add_years(2))
+    assert_equal(Date.new(2010, 2, 28), Date.new(2008, 2, 29).add_years(2))
+  end
 end
 
 end

data/test/core/tc_deep_dup.rb

@@ -0,0 +1,69 @@
+require 'test/unit'
+require 'doh/core/deep_dup'
+
+module Doh
+
+class Parent
+  deep_dup :var1, :var2
+  attr_accessor :var1, :var2
+end
+
+class Child < Parent
+  deep_dup :var3
+  attr_accessor :var3
+end
+
+class ShallowParent
+  attr_accessor :var1, :var2
+end
+
+class TC_core_deep_dup < Test::Unit::TestCase
+  def test_regular_dup
+    parent = ShallowParent.new
+    parent.var1 = ['elem1']
+    parent.var2 = {'key1' => 'val1'}
+    parent2 = parent.dup
+    assert(parent2.var1.equal?(parent.var1))
+    assert(parent2.var2.equal?(parent.var2))
+  end
+
+  def test_deep_dup
+    parent = Parent.new
+    parent.var1 = ['elem1']
+    parent.var2 = {'key1' => 'val1'}
+    parent2 = parent.dup
+    assert(!parent2.var1.equal?(parent.var1))
+    assert(!parent2.var2.equal?(parent.var2))
+
+    parent2.var1.push('elem2')
+    parent2.var2['key2'] = 'val2'
+    assert_equal(['elem1'], parent.var1)
+    assert_equal(['key1'], parent.var2.keys)
+    assert_equal(['val1'], parent.var2.values)
+  end
+
+  def test_deep_dup_inheritance
+    child = Child.new
+    child.var1 = ['elem1']
+    child.var2 = {'key1' => 'val1'}
+    child.var3 = Parent.new
+    child.var3.var1 = ['blah']
+    child2 = child.dup
+    assert(!child2.var1.equal?(child.var1))
+    assert(!child2.var2.equal?(child.var2))
+    assert(!child2.var3.equal?(child.var3))
+
+    child2.var1.push('elem2')
+    child2.var2['key2'] = 'val2'
+    child2.var3.var1.push(['smoe'])
+    child2.var3.var2 = 'val3'
+    assert_equal(['elem1'], child.var1)
+    assert_equal(['key1'], child.var2.keys)
+    assert_equal(['val1'], child.var2.values)
+    assert_equal(['blah'], child.var3.var1)
+    assert_equal(nil, child.var3.var2)
+
+  end
+end
+
+end

data/test/core/tc_hash.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'doh/core/hash'
+
+module Doh
+
+class TC_core_hash < Test::Unit::TestCase
+  def test_setnew
+    h = {}
+    h.setnew('field', 'first_value')
+    h.setnew('field', 'second_value')
+    assert_equal('first_value', h['field'])
+    h = {'field' => 'first'}
+    h.setnew('field', 'second')
+    assert_equal('first', h['field'])
+  end
+
+  def test_merge_with_remove
+    h = {1=>2, 2=>3}
+    orig_h = h.dup
+    assert_equal({1=>2, 3=>4}, h.merge_with_remove({2=>nil, 3=>4}))
+    assert_equal({1=>2, 2=>3, 3=>4}, h.merge_with_remove({3=>4}))
+    assert_equal(orig_h, h)
+    assert_equal({1=>2, 3=>4}, h.merge_with_remove!({2=>nil, 3=>4}))
+    assert_equal({1=>2, 3=>4}, h)
+  end
+end
+
+end

data/test/core/tc_socket.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'doh/core/socket'
+
+module Doh
+
+class TC_core_socket < Test::Unit::TestCase
+  def test_amount_header_and_object
+    verylongmessage = 'long message' * 100000
+    server = TCPServer.new(2479)
+    server_thread = Thread.new do
+      server_sock = server.accept
+      assert_equal('message sent from client', server_sock.read_with_amount_header)
+      assert_equal(verylongmessage, server_sock.read_with_amount_header)
+      object = server_sock.read_object
+      assert_equal({'this is a' => 'hash sent from client'}, object)
+      server_sock.write_with_amount_header('message sent from server')
+      server_sock.write_object(['this', 'is', 'an', 'array', 'sent', 'from', 'the', 'server'])
+    end
+
+    client_sock = TCPSocket.new('127.0.0.1', 2479)
+    client_sock.write_with_amount_header('message sent from client')
+    client_sock.write_with_amount_header(verylongmessage)
+    client_sock.write_object({'this is a' => 'hash sent from client'})
+    assert_equal('message sent from server', client_sock.read_with_amount_header)
+    assert_equal(['this', 'is', 'an', 'array', 'sent', 'from', 'the', 'server'], client_sock.read_object)
+    server_thread.join
+  end
+end
+
+end

data/test/core/tc_string.rb

@@ -82,30 +82,23 @@ class TC_core_string < Test::Unit::TestCase
     assert_equal('blah', str.lastn(100))
   end
 
-  def test_starts_with
-    assert_equal(true, ''.starts_with(''))
-    str = 'blah'
-    assert_equal(false, str.starts_with('blee'))
-    assert_equal(false, str.starts_with('blax'))
-    assert_equal(false, str.starts_with('lah'))
-    assert_equal(true, str.starts_with(''))
-    assert_equal(true, str.starts_with('blah'))
-    assert_equal(true, str.starts_with('bla'))
-    assert_equal(true, str.starts_with('bl'))
-    assert_equal(true, str.starts_with('b'))
+  def test_gsub_between
+    str = 'start smoe blah endstart blah blah blah endstart blah blah blah endstart blah blah blah endstart blah blah blah endstart blah blah blah endstart blah blah blah end '
+    assert_equal('start blah endstart blah endstart blah endstart blah endstart blah endstart blah endstart blah end ', str.gsub_between('start', 'end', ' blah '))
+
+    result = str.gsub_between('start', 'end') do |contents|
+      contents.reverse
+    end
+    assert_equal('start halb eoms endstart halb halb halb endstart halb halb halb endstart halb halb halb endstart halb halb halb endstart halb halb halb endstart halb halb halb end ', result)
   end
 
-  def test_ends_with
-    assert_equal(true, ''.ends_with(''))
-    str = 'blah'
-    assert_equal(false, str.ends_with('blee'))
-    assert_equal(false, str.ends_with('blax'))
-    assert_equal(false, str.ends_with('bla'))
-    assert_equal(true, str.ends_with(''))
-    assert_equal(true, str.ends_with('blah'))
-    assert_equal(true, str.ends_with('lah'))
-    assert_equal(true, str.ends_with('ah'))
-    assert_equal(true, str.ends_with('h'))
+  def test_equals_ignore_whitespace
+    assert_equal(true, "  smoe  ".equals_ignore_whitespace("smoe"))
+    assert_equal(true, "  sm  oe  ".equals_ignore_whitespace("sm oe"))
+    assert_equal(false, "  sm  oe  ".equals_ignore_whitespace("smoe"))
+    assert_equal(true, "  sm\n\noe  ".equals_ignore_whitespace("sm oe"))
+    assert_equal(true, "  sm\n\noe  ".equals_ignore_whitespace(" sm oe "))
+    assert_equal(true, "  s\tm\n\no e  ".equals_ignore_whitespace("s   m o   e"))
   end
 end
 

data/test/local_tests.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+Dir::glob(File.join(Dir.pwd, '**', 'tc_*.rb')).each { |elem| require(elem) }

data/test/local_tests_including_slow.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+Dir::glob(File.join(Dir.pwd, '**', 'tc_*.rb')).each { |elem| require(elem) }
+Dir::glob(File.join(Dir.pwd, '**', 'slow_*.rb')).each { |elem| require(elem) }

data/test/logger/tc_acceptor.rb

@@ -12,7 +12,7 @@ class TC_Acceptor < Test::Unit::TestCase
     @ios = StringIO.new
     @ios2 = StringIO.new
     @sched = DohLogger::DirectScheduler.new
-    @acceptor = DohLogger::IOStreamAcceptor.new(@ios, '%msg', '%msg error')
+    @acceptor = DohLogger::IOStreamAcceptor.new(@ios, '%msg', '%msg error: %call_stack')
     @acceptor2 = DohLogger::IOStreamAcceptor.new(@ios2, '%msg', '%msg error')
     @interface = DohLogger::StandardInterface.new(@sched)
     @interface.add_acceptor(DohLogger::DEBUG, @acceptor)
@@ -20,19 +20,36 @@ class TC_Acceptor < Test::Unit::TestCase
   end
 
   def test_log
+    fake_backtrace = ['/fake/backtrace/location.rb:33:in `some_func\'', '/some/other/location']
+    except = Exception.new('test exception with stack')
+    except.set_backtrace(fake_backtrace)
+
     @interface.info("info1")
     @interface.warn("warn1")
-    @interface.error("error1")
-    @interface.fatal("fatal1")
-    events = @ios.string.split("\n")
+    @interface.error("error1", except)
+    @interface.fatal("fatal1", except)
+    string = @ios.string
+    events = string.split("\n")
     assert_equal('info1', events[0])
     assert_equal('warn1', events[1])
-    assert_equal('error1 error', events[2])
-    assert_equal('fatal1 error', events[3])
+    assert_equal('error1 error: /fake/backtrace/location.rb:33:in `some_func\'', events[2])
+    assert_equal('/some/other/location', events[3])
+    assert_equal('fatal1 error: /fake/backtrace/location.rb:33:in `some_func\'', events[4])
+    assert_equal('/some/other/location', events[5])
     events2 = @ios2.string.split("\n")
     assert_equal('warn1', events2[0])
     assert_equal(1, events2.size)
   end
+
+  def test_literal
+    @interface.info("info\ninfo")
+    @interface.literal = true
+    @interface.info("info\ninfo")
+    events = @ios.string.split("\n")
+    assert_equal('info\ninfo', events[0])
+    assert_equal('info', events[1])
+    assert_equal('info', events[2])
+  end
 end
 
 end

data/test/logger/tc_event.rb

@@ -5,7 +5,7 @@ module Doh
 
 class TC_Event < Test::Unit::TestCase
   def test_call_stack
-    event = DohLogger::Event.new(1, '')
+    event = DohLogger::Event.new(1, '', '')
     stack = event.call_stack
     assert_match(/tc_event\.rb/,  stack[0])
     begin

data/test/logger/tc_formatter.rb

@@ -8,8 +8,8 @@ module Doh
 
 class TC_Formatter < Test::Unit::TestCase
   def setup
-    @formatter = DohLogger::Formatter.new("severity=%severity,msg=%msg,exception=%exception,time=%time,datetime=%datetime,call_stack=%call_stack,source_ip=%source_ip")
-    @event = DohLogger::Event.new(DohLogger::DEBUG, 'testmessage')
+    @formatter = DohLogger::Formatter.new("severity=%severity,msg=%msg,location=%location,exception=%exception,time=%time,datetime=%datetime,call_stack=%call_stack,source_ip=%source_ip")
+    @event = DohLogger::Event.new(DohLogger::DEBUG, 'testmessage', 'testloc')
     @time = '10:20:30'
     @datetime = '2008-01-02 ' + @time
     @event.time = Time.parse(@datetime)
@@ -29,6 +29,7 @@ class TC_Formatter < Test::Unit::TestCase
     hsh = format_output_to_hash(@formatter.replace(@event))
     assert_equal('debug', hsh['severity'])
     assert_equal('testmessage', hsh['msg'])
+    assert_equal('testloc', hsh['location'])
     assert_equal('', hsh['exception'])
     assert_equal(@time + '.000', hsh['time'])
     assert_equal(@datetime + '.000', hsh['datetime'])

data/test/logger/tc_socket_viewer_acceptor.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+require 'doh/logger/socket_viewer.rb'
+require 'doh/logger/socket_acceptor.rb'
+require 'doh/logger/direct_scheduler.rb'
+require 'doh/logger/standard_interface.rb'
+
+module Doh
+
+class TC_SocketViewerAcceptor < Test::Unit::TestCase
+  def setup
+    @port = 12377
+    @sched = DohLogger::DirectScheduler.new
+    @socket_acceptor = DohLogger::SocketAcceptor.new('127.0.0.1', @port)
+    @interface = DohLogger::StandardInterface.new(@sched)
+    @interface.add_acceptor(DohLogger::DEBUG, @socket_acceptor)
+  end
+
+  def test_no_viewer
+    assert_nothing_raised {@interface.debug("debug1")}
+  end
+
+  def test_with_viewer
+    socket_viewer = DohLogger::SocketViewer.new(@port)
+    @socket_acceptor.connect_socket(0)
+    fake_backtrace = ['/fake/backtrace/location.rb:33:in `some_func\'', '/some/other/location']
+    except = Exception.new('test exception with stack')
+    except.set_backtrace(fake_backtrace)
+
+    thread = Thread.new do
+      events = []
+      socket_viewer.handle_events do |event|
+        events.push(event)
+        break if events.size == 2
+      end
+      assert_equal('debug1', events[0].msg)
+      assert_equal('debug2', events[1].msg)
+      assert_equal("Exception(#{except.class}): #{except.to_s}", events[1].exception.to_s)
+      assert_equal(fake_backtrace, events[1].exception.backtrace)
+    end
+    @interface.debug('debug1')
+    @interface.error('debug2', except)
+
+    thread.join
+    socket_viewer.shutdown
+  end
+end
+
+end

data/test/mysql/001_down.sql

@@ -0,0 +1 @@
+DROP TABLE migrate_test_version2;

data/test/mysql/001_up.sql

@@ -0,0 +1,4 @@
+CREATE TABLE migrate_test_version2
+( id INT UNSIGNED NOT NULL AUTO_INCREMENT
+, PRIMARY KEY (id)
+) ENGINE=MyISAM;

data/test/mysql/002_down.sql

@@ -0,0 +1 @@
+ALTER TABLE migrate_test_version2 DROP created_at;

data/test/mysql/002_up.sql

@@ -0,0 +1 @@
+ALTER TABLE migrate_test_version2 ADD created_at DATETIME NOT NULL;

data/test/mysql/tc_connector_instance.rb

@@ -9,20 +9,20 @@ class TC_ConnectorInstance < Test::Unit::TestCase
     assert_equal(1, DohDb::insert("INSERT INTO #{tbl} (id, created_on, created_at, money) VALUES (null, CURDATE(), '2007-01-01 10:30:05', 10.5)"))
     assert_equal(2, DohDb::insert("INSERT INTO #{tbl} (id, created_on) VALUES (null, 0)"))
     assert_equal(1, DohDb::update("UPDATE #{tbl} SET money = 10.8 WHERE id = 1"))
-    assert_equal('10.80', DohDb::select_field("SELECT money FROM #{tbl} WHERE id = 1"))
-    assert_raise(QueryResultError) {DohDb::select_row("SELECT * FROM #{tbl} WHERE id = 7")}
+    assert_equal(BigDecimal('10.80'), DohDb::select_field("SELECT money FROM #{tbl} WHERE id = 1"))
+    assert_raise(UnexpectedQueryResult) {DohDb::select_row("SELECT * FROM #{tbl} WHERE id = 7")}
     assert_equal(nil, DohDb::select_optional_row("SELECT * FROM #{tbl} WHERE id = 7"))
-    assert_raise(QueryResultError){DohDb::select_optional_row("SELECT * FROM #{tbl} WHERE id < 3")}
+    assert_raise(UnexpectedQueryResult){DohDb::select_optional_row("SELECT * FROM #{tbl} WHERE id < 3")}
     assert_equal(nil, DohDb::select_optional_field("SELECT money FROM #{tbl} WHERE id = 7"))
-    assert_raise(QueryResultError) {DohDb::select_field("SELECT money FROM #{tbl} WHERE id = 7")}
+    assert_raise(UnexpectedQueryResult) {DohDb::select_field("SELECT money FROM #{tbl} WHERE id = 7")}
     assert_equal(1, DohDb::update_row("UPDATE #{tbl} SET money = 10.95 WHERE id = 1"))
     assert_raise(Mysql::Error){DohDb::query("some invalid sql here")}
-    assert(Doh::pop_unit_test_error)
-    assert_raise(QueryResultError) {DohDb::update_row("UPDATE #{tbl} SET money = 10.95 WHERE id = 7")}
+    assert(DohTest::pop_error)
+    assert_raise(UnexpectedQueryResult) {DohDb::update_row("UPDATE #{tbl} SET money = 10.95 WHERE id = 7")}
     onerow = DohDb::select_row("SELECT * FROM #{tbl} WHERE id = 1")
-    assert_equal('1', onerow['id'])
+    assert_equal(1, onerow['id'])
     onerow = DohDb::select_optional_row("SELECT * FROM #{tbl} WHERE id = 1")
-    assert_equal('1', onerow['id'])
+    assert_equal(1, onerow['id'])
     rows = DohDb::select("SELECT * FROM #{tbl}")
     rows.each {|row| assert(row['id'] != 0)}
   end

data/test/mysql/tc_convert.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), 'db_unit_test')
+require 'doh/mysql/convert'
+
+module DohDb
+
+class TC_Convert < Test::Unit::TestCase
+  def setup
+    @tbl = "doh_mysql_convert_tests"
+    DohDb::query("DROP TABLE IF EXISTS #@tbl")
+    DohDb::request_handle.query("CREATE TABLE #{@tbl} (not_null_field CHAR(1) NOT NULL, null_ok_field CHAR(1), int_field INT, bool_field TINYINT(1), date_field DATE, datetime_field DATETIME)")
+  end
+
+  def teardown
+    DohDb::query("DROP TABLE IF EXISTS #@tbl")
+  end
+
+  def convert(value)
+    DohDb::convert(@tbl, @field, value)
+  end
+
+  def verify(converted, original)
+    assert_equal(converted, convert(original))
+  end
+
+  def verify_same(value)
+    verify(value, value)
+  end
+
+  def verify_exception(value, exception_class)
+    assert_raise(exception_class) { convert(value) }
+  end
+
+  def test_nil_null
+#    assert_raise(UnknownColumn) { DohDb::convert('some_table_that_doesnt_exist', 'some_column_that_doesnt_exist', 'blah') }
+    assert_equal('blah', DohDb::convert('some_table_that_doesnt_exist', 'some_column_that_doesnt_exist', 'blah'))
+    assert_equal('blah', DohDb::convert('', 'some_column_that_doesnt_exist', 'blah'))
+    assert_raise(CannotBeNull) { DohDb::convert(@tbl, 'not_null_field', nil) }
+    assert_equal(nil, DohDb::convert(@tbl, 'null_ok_field', nil))
+    assert_equal('', DohDb::convert(@tbl, 'not_null_field', ''))
+    assert_equal(nil, DohDb::convert(@tbl, 'null_ok_field', ''))
+    assert_equal(nil, DohDb::convert(@tbl, 'int_field', ''))
+  end
+end
+
+end

data/test/mysql/tc_handle.rb

@@ -1,4 +1,5 @@
 require File.join(File.dirname(__FILE__), 'db_unit_test')
+require 'doh/core/hash'
 
 module DohDb
 
@@ -8,13 +9,104 @@ class TC_MysqlHandle < Test::Unit::TestCase
     tbl = "doh_mysql_handle_stuff_test"
     dbh.query("CREATE TEMPORARY TABLE #{tbl} (id INT UNSIGNED AUTO_INCREMENT NOT NULL KEY, value INT NOT NULL DEFAULT 0, created_on DATE, created_at DATETIME, money DECIMAL(7,2) NOT NULL DEFAULT 0)")
     assert_equal(1, dbh.insert("INSERT INTO #{tbl} (id, created_on, created_at, money) VALUES (null, CURDATE(), '2007-01-01 10:30:05', 10.5)"))
-    assert_equal(2, dbh.insert("INSERT INTO #{tbl} (id, created_on) VALUES (null, 0)"))
+    assert_equal(2, dbh.insert("INSERT INTO #{tbl} (id, created_on, created_at) VALUES (null, 0, 0)"))
     assert_equal(3, dbh.insert("INSERT INTO #{tbl} (id) VALUES (null)"))
     onerow = dbh.select_row("SELECT * FROM #{tbl} WHERE id = 1")
-    assert_equal('1', onerow['id'])
+    assert_equal(1, onerow['id'])
     rows = dbh.select("SELECT * FROM #{tbl}")
     rows.each {|row| assert(row['id'] != 0)}
   end
+
+  def test_select_transpose_2fields
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_handle_select_transpose_2fields_test"
+    DohDb::query("CREATE TEMPORARY TABLE #{tbl} (field CHAR(30) NOT NULL, value CHAR(30) NOT NULL)")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'some_name', value = 'some_value'")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'other_name', value = 'matching_other_value'")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'yet_another_name', value = 'strange_value'")
+    hash = DohDb::select_transpose("SELECT field, value FROM #{tbl}")
+    assert_equal('some_value', hash['some_name'])
+    assert_equal('matching_other_value', hash['other_name'])
+    assert_equal('strange_value', hash['yet_another_name'])
+  end
+
+  def test_select_transpose_3fields
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_handle_select_transpose_3fields_test"
+    DohDb::query("CREATE TEMPORARY TABLE #{tbl} (field CHAR(30), some_value CHAR(30), other_value CHAR(30))")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'some_name', some_value = 'some_value', other_value = 'blah'")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'other_name', some_value = 'matching_other_value', other_value = 'blee'")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'yet_another_name', some_value = 'strange_value', other_value = 'bloo'")
+    hash = DohDb::select_transpose("SELECT field, some_value, other_value FROM #{tbl}")
+    assert_equal(hash['some_name'], {'some_value' => 'some_value', 'other_value' => 'blah'})
+    assert_equal(hash['other_name'], {'some_value' => 'matching_other_value', 'other_value' => 'blee'})
+    assert_equal(hash['yet_another_name'], {'some_value' => 'strange_value', 'other_value' => 'bloo'})
+  end
+
+  def test_select_values
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_handle_select_values_test"
+    DohDb::query("CREATE TEMPORARY TABLE #{tbl} (field CHAR(30), some_value CHAR(30))")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'some_name', some_value = 'some_value'")
+    assert_equal([['some_name', 'some_value']], DohDb::select_values("SELECT field, some_value FROM #{tbl}"))
+    assert_equal([['some_name']], DohDb::select_values("SELECT field FROM #{tbl}"))
+  end
+
+  def test_multi_select
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_handle_multi_select_test"
+    DohDb::query("CREATE TEMPORARY TABLE #{tbl} (value CHAR(30))")
+    DohDb::query("INSERT INTO #{tbl} SET value = 'first'")
+    DohDb::query("INSERT INTO #{tbl} SET value = 'second'")
+
+    stmts = []
+    stmts.push("SELECT * FROM #{tbl}")
+    stmts.push("INSERT INTO #{tbl} SET value = 'third'")
+    stmts.push(["SELECT * FROM #{tbl}", :hash])
+    stmts.push("SELECT * FROM #{tbl}")
+    stmts.push("INSERT INTO #{tbl} SET value = 'fourth'")
+    stmts.push(["SELECT * FROM #{tbl}", :smart])
+    select_results = DohDb::multi_select(stmts)
+    assert_equal(4, select_results.size)
+    assert_equal(4, DohDb::select_field("SELECT COUNT(*) FROM #{tbl}"))
+
+    curr_select = select_results[0]
+    assert_equal(2, curr_select.size)
+    assert_kind_of(ReadOnlyRow, curr_select[0])
+    assert_equal({'value' => 'first'}, curr_select[0].to_h)
+    assert_equal({'value' => 'second'}, curr_select[1].to_h)
+
+    curr_select = select_results[1]
+    assert_equal(3, curr_select.size)
+    assert_kind_of(Hash, curr_select[0])
+    assert_equal({'value' => 'first'}, curr_select[0].to_h)
+    assert_equal({'value' => 'second'}, curr_select[1].to_h)
+    assert_equal({'value' => 'third'}, curr_select[2].to_h)
+
+    curr_select = select_results[2]
+    assert_equal(3, curr_select.size)
+    assert_equal({'value' => 'first'}, curr_select[0].to_h)
+    assert_equal({'value' => 'second'}, curr_select[1].to_h)
+    assert_equal({'value' => 'third'}, curr_select[2].to_h)
+
+    curr_select = select_results[3]
+    assert_equal(4, curr_select.size)
+    assert_kind_of(SmartRow, curr_select[0])
+    assert_equal({'value' => 'first'}, curr_select[0].to_h)
+    assert_equal({'value' => 'second'}, curr_select[1].to_h)
+    assert_equal({'value' => 'third'}, curr_select[2].to_h)
+    assert_equal({'value' => 'fourth'}, curr_select[3].to_h)
+  end
+
+  def test_insert_hash
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_insert_hash_test"
+    dbh.query("CREATE TEMPORARY TABLE #{tbl} (value INT KEY)")
+    hash1 = {'value' => 1}
+    assert_equal(0, dbh.insert_hash(hash1, tbl))
+    assert_raise(Mysql::Error) { dbh.insert_hash(hash1, tbl) }
+    assert_equal(0, dbh.insert_hash(hash1, tbl, true))
+  end
 end
 
 end

data/test/mysql/tc_metadata_util.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), 'db_unit_test')
+require 'doh/mysql/metadata_util'
+
+module DohDb
+
+class TC_metadata_util < Test::Unit::TestCase
+  def tbl
+    "doh_mysql_metadata_util_test"
+  end
+
+  def test_stuff
+    dbh = DohDb::request_handle
+    dbh.query("CREATE TABLE #{tbl} (num INT, str CHAR(7))")
+    column_info = DohDb::column_info(tbl)
+    info = column_info['str']
+    assert_equal('char', info['data_type'])
+    assert_equal(7, info['character_maximum_length'])
+    info = column_info['num']
+    assert_equal('int', info['data_type'])
+    assert_equal(nil, info['character_maximum_length'])
+
+    assert_equal(7, DohDb::field_character_size(tbl, 'str'))
+    assert_equal(nil, DohDb::field_character_size(tbl, 'num'))
+
+    row = {'num' => 'blahblahblah', 'str' => 'blahblahblah'}
+    DohDb::chop_character_fields!(tbl, row)
+    assert_equal('blahblahblah', row['num'])
+    assert_equal('blahbla', row['str'])
+
+    row = {'num' => 'blahblahblah', 'str' => 'blahblahblah'}
+    newrow = DohDb::chop_character_fields(tbl, row)
+    assert_equal('blahblahblah', newrow['num'])
+    assert_equal('blahbla', newrow['str'])
+    assert_equal('blahblahblah', row['num'])
+    assert_equal('blahblahblah', row['str'])
+
+    assert(DohDb::table_exist?(tbl))
+
+    assert_equal('num', DohDb::find_primary_key(tbl))
+    assert_raise(RuntimeError) { DohDb::find_primary_key(tbl, "this_database_doesnt_exist") }
+    assert_raise(RuntimeError) { DohDb::find_primary_key("this table doesn't exist") }
+  end
+
+  def teardown
+    DohDb::query("DROP TABLE IF EXISTS #{tbl}")
+    super
+  end
+end
+
+end