ydbi 0.5.0

data/test/dbi/tc_time.rb

@@ -0,0 +1,77 @@
+##############################################################################
+# tc_time.rb
+#
+# Test case for the DBI::Time class (currently) located in the utils.rb file.
+##############################################################################
+$LOAD_PATH.unshift(Dir.pwd)
+$LOAD_PATH.unshift(File.dirname(Dir.pwd))
+$LOAD_PATH.unshift("../../lib")
+$LOAD_PATH.unshift("../../lib/dbi")
+$LOAD_PATH.unshift("lib")
+
+require 'dbi'
+require 'test/unit'
+
+Deprecate.set_action(proc { })
+
+class TC_DBI_Time < Test::Unit::TestCase
+   def setup
+      @time     = Time.new
+      @dbi_time = DBI::Time.new
+   end
+
+   def test_constructor
+      assert_nothing_raised{ DBI::Time.new(9) }
+      assert_nothing_raised{ DBI::Time.new(9, 41) }
+      assert_nothing_raised{ DBI::Time.new(9, 41, 20) }
+      assert_nothing_raised{ DBI::Time.new(Date.new) }
+      assert_nothing_raised{ DBI::Time.new(Time.now) }
+   end
+
+   def test_hour
+      assert_respond_to(@dbi_time, :hour)
+      assert_respond_to(@dbi_time, :hour=)
+      assert_equal(0, @dbi_time.hour)
+   end
+
+   def test_minute
+      assert_respond_to(@dbi_time, :minute)
+      assert_respond_to(@dbi_time, :minute=)
+      assert_equal(0, @dbi_time.minute)
+   end
+
+   # Alias for minute
+   def test_min
+      assert_respond_to(@dbi_time, :min)
+      assert_respond_to(@dbi_time, :min=)
+      assert_equal(0, @dbi_time.min)
+   end
+
+   def test_second
+      assert_respond_to(@dbi_time, :second)
+      assert_respond_to(@dbi_time, :second=)
+      assert_equal(0, @dbi_time.second)
+   end
+
+   def test_sec
+      assert_respond_to(@dbi_time, :sec)
+      assert_respond_to(@dbi_time, :sec=)
+      assert_equal(0, @dbi_time.sec)
+   end
+
+   def test_to_time
+      assert_respond_to(@dbi_time, :to_time)
+      assert_equal(@time, DBI::Time.new(@time).to_time)
+      #assert_equal(@time.object_id, DBI::Time.new(@time).object_id) # Fails ??
+   end
+
+   def test_to_s
+      assert_respond_to(@dbi_time, :to_s)
+      assert_equal("00:00:00", @dbi_time.to_s)
+   end
+
+   def teardown
+      @time     = nil
+      @dbi_time = nil
+   end
+end

data/test/dbi/tc_timestamp.rb

@@ -0,0 +1,142 @@
+##############################################################################
+# tc_timestamp.rb
+#
+# Test case for the DBI::Timestamp class (currently) located in the
+# utils.rb file.
+##############################################################################
+$LOAD_PATH.unshift(Dir.pwd)
+$LOAD_PATH.unshift(File.dirname(Dir.pwd))
+$LOAD_PATH.unshift("../../lib")
+$LOAD_PATH.unshift("../../lib/dbi")
+$LOAD_PATH.unshift("lib")
+
+require 'date'
+require 'dbi'
+require 'test/unit'
+
+Deprecate.set_action(proc { })
+
+class TC_DBI_Date < Test::Unit::TestCase
+   def setup
+      @date   = Date.new
+      @time   = Time.now
+      @dbi_ts = DBI::Timestamp.new(2006, 1, 31, 10, 23, 22, 45)
+   end
+
+   def test_constructor
+      assert_nothing_raised{ DBI::Timestamp.new }
+      assert_nothing_raised{ DBI::Timestamp.new(2006) }
+      assert_nothing_raised{ DBI::Timestamp.new(2006, 1) }
+      assert_nothing_raised{ DBI::Timestamp.new(2006, 1, 31) }
+      assert_nothing_raised{ DBI::Timestamp.new(2006, 1, 31, 10) }
+      assert_nothing_raised{ DBI::Timestamp.new(2006, 1, 31, 10, 23) }
+      assert_nothing_raised{ DBI::Timestamp.new(2006, 1, 31, 10, 23, 22) }
+      assert_nothing_raised{ DBI::Timestamp.new(2006, 1, 31, 10, 23, 22, 45) }
+   end
+
+   def test_to_date
+      assert_respond_to(@dbi_ts, :to_date)
+      assert_kind_of(Date, @dbi_ts.to_date)
+   end
+
+   def test_to_time
+      assert_respond_to(@dbi_ts, :to_time)
+      assert_kind_of(Time, @dbi_ts.to_time)
+   end
+
+   def test_to_s
+      assert_respond_to(@dbi_ts, :to_s)
+      assert_equal("2006-01-31 10:23:22.000000045", @dbi_ts.to_s)
+      assert_equal("2008-03-08 10:39:01.0045",
+                   DBI::Timestamp.new(2008, 3, 8, 10, 39, 1, 4500000).to_s)
+      assert_equal("2008-03-08 10:39:01.0",
+                   DBI::Timestamp.new(2008, 3, 8, 10, 39, 1, 0).to_s)
+      assert_equal("2008-03-08 10:39:01",
+                   DBI::Timestamp.new(2008, 3, 8, 10, 39, 1, nil).to_s)
+      assert_equal("0000-00-00 00:00:00", DBI::Timestamp.new.to_s)
+   end
+
+   def test_equality
+      assert_equal(true, @dbi_ts == DBI::Timestamp.new(2006,1,31,10,23,22,45))
+      assert_equal(false, @dbi_ts == DBI::Timestamp.new(2006,1,31,10,23,22,46))
+      assert_equal(false, @dbi_ts == nil)
+      assert_equal(false, @dbi_ts == 1)
+      assert_equal(false, @dbi_ts == "hello")
+   end
+
+   def test_fraction
+      assert_respond_to(@dbi_ts, :fraction)
+      assert_respond_to(@dbi_ts, :fraction=)
+      assert_equal(45, @dbi_ts.fraction)
+   end
+
+   def test_second
+      assert_respond_to(@dbi_ts, :second)
+      assert_respond_to(@dbi_ts, :second=)
+      assert_equal(22, @dbi_ts.second)
+   end
+
+   # Alias for second
+   def test_sec
+      assert_respond_to(@dbi_ts, :sec)
+      assert_respond_to(@dbi_ts, :sec=)
+      assert_equal(22, @dbi_ts.sec)
+   end
+
+   def test_minute
+      assert_respond_to(@dbi_ts, :minute)
+      assert_respond_to(@dbi_ts, :minute=)
+      assert_equal(23, @dbi_ts.minute)
+   end
+
+   # Alias for minute
+   def test_min
+      assert_respond_to(@dbi_ts, :min)
+      assert_respond_to(@dbi_ts, :min=)
+      assert_equal(23, @dbi_ts.min)
+   end
+
+   def test_hour
+      assert_respond_to(@dbi_ts, :hour)
+      assert_respond_to(@dbi_ts, :hour=)
+      assert_equal(10, @dbi_ts.hour)
+   end
+
+   def test_day
+      assert_respond_to(@dbi_ts, :day)
+      assert_respond_to(@dbi_ts, :day=)
+      assert_equal(31, @dbi_ts.day)
+   end
+
+   # Alias for day
+   def test_mday
+      assert_respond_to(@dbi_ts, :mday)
+      assert_respond_to(@dbi_ts, :mday=)
+      assert_equal(31, @dbi_ts.mday)
+   end
+
+   def test_month
+      assert_respond_to(@dbi_ts, :month)
+      assert_respond_to(@dbi_ts, :month=)
+      assert_equal(1, @dbi_ts.month)
+   end
+
+   # Alias for month
+   def test_mon
+      assert_respond_to(@dbi_ts, :mon)
+      assert_respond_to(@dbi_ts, :mon=)
+      assert_equal(1, @dbi_ts.mon)
+   end
+
+   def test_year
+      assert_respond_to(@dbi_ts, :year)
+      assert_respond_to(@dbi_ts, :year=)
+      assert_equal(2006, @dbi_ts.year)
+   end
+
+   def teardown
+      @date = nil
+      @time = nil
+      @dbi_ts = nil
+   end
+end

data/test/dbi/tc_types.rb

@@ -0,0 +1,268 @@
+$LOAD_PATH.unshift(Dir.pwd)
+$LOAD_PATH.unshift(File.dirname(Dir.pwd))
+$LOAD_PATH.unshift("../../lib")
+$LOAD_PATH.unshift("../../lib/dbi")
+$LOAD_PATH.unshift("lib")
+
+require "dbi"
+require "test/unit"
+
+class MyType
+    def initialize(obj)
+        @obj = obj
+    end
+
+    def to_s
+        @obj.to_s
+    end
+end
+
+class TC_DBI_Type < Test::Unit::TestCase
+    def test_null
+        # all types except Varchar need to appropriately handle NULL
+        [
+            DBI::Type::Null,
+            DBI::Type::Integer,
+            DBI::Type::Float,
+            DBI::Type::Timestamp,
+            DBI::Type::Boolean
+        ].each do |klass|
+            assert_equal(nil, klass.parse("NULL"))
+            assert_equal(nil, klass.parse("null"))
+            assert_equal(nil, klass.parse("Null"))
+        end
+    end
+
+    def test_boolean
+        klass = DBI::Type::Boolean
+        assert_kind_of(NilClass, klass.parse(nil))
+        assert_kind_of(NilClass, klass.parse("NULL"))
+        assert_kind_of(TrueClass, klass.parse('t'))
+        assert_kind_of(TrueClass, klass.parse(1))
+        assert_kind_of(TrueClass, klass.parse('1'))
+        assert_kind_of(FalseClass, klass.parse('f'))
+        assert_kind_of(FalseClass, klass.parse(0))
+        assert_kind_of(FalseClass, klass.parse('0'))
+    end
+
+    def test_varchar
+        klass = DBI::Type::Varchar
+        assert_kind_of(String, klass.parse("hello"))
+        assert_kind_of(String, klass.parse("1"))
+        assert_kind_of(String, klass.parse("1.23"))
+
+        assert_equal("NULL", klass.parse("NULL"))
+        assert_equal("1", klass.parse("1"))
+        assert_equal("hello", klass.parse("hello"))
+        assert_equal("1.23", klass.parse("1.23"))
+    end
+
+    def test_integer
+        klass = DBI::Type::Integer
+        assert_kind_of(Integer, klass.parse("1.23"))
+        assert_kind_of(Integer, klass.parse("-1.23"))
+        assert_kind_of(Integer, klass.parse("1.0"))
+        assert_kind_of(Integer, klass.parse("1"))
+        assert_kind_of(Integer, klass.parse("-1"))
+        assert_kind_of(Integer, klass.parse("0"))
+
+        assert_equal(nil, klass.parse("NULL"))
+        assert_equal(1, klass.parse("1.23"))
+        assert_equal(-1, klass.parse("-1.23"))
+        assert_equal(1, klass.parse("1.0"))
+        assert_equal(1, klass.parse("1"))
+        assert_equal(-1, klass.parse("-1"))
+        assert_equal(0, klass.parse("0"))
+    end
+
+    def test_float
+        klass = DBI::Type::Float
+        assert_kind_of(Float, klass.parse("1.23"))
+        assert_kind_of(Float, klass.parse("-1.23"))
+        assert_kind_of(Float, klass.parse("1.0"))
+        assert_kind_of(Float, klass.parse("1"))
+        assert_kind_of(Float, klass.parse("-1"))
+        assert_kind_of(Float, klass.parse("0"))
+
+        assert_equal(nil, klass.parse("NULL"))
+        assert_equal(1.23, klass.parse("1.23"))
+        assert_equal(-1.23, klass.parse("-1.23"))
+        assert_equal(1, klass.parse("1.0"))
+        assert_equal(1, klass.parse("1"))
+        assert_equal(-1, klass.parse("-1"))
+        assert_equal(0, klass.parse("0"))
+    end
+
+    def test_timestamp
+        klass = DBI::Type::Timestamp
+        assert_kind_of(DateTime, klass.parse(Time.now))
+        assert_kind_of(DateTime, klass.parse(Date.today))
+        assert_kind_of(DateTime, klass.parse(DateTime.now))
+        assert_kind_of(DateTime, klass.parse(Time.now.to_s))
+        assert_kind_of(DateTime, klass.parse(Date.today.to_s))
+        assert_kind_of(DateTime, klass.parse(DateTime.now.to_s))
+
+        assert_equal(nil, klass.parse("NULL"))
+
+        # string coercion
+        dt = DateTime.now
+        assert_equal(dt.to_s, klass.parse(dt).to_s)
+        
+        t = Time.now
+        assert_equal(DateTime.parse(t.to_s).to_s, klass.parse(t).to_s)
+
+        d = Date.today
+        assert_equal(DateTime.parse(d.to_s).to_s, klass.parse(d).to_s)
+
+        md = "10-11"
+
+        if RUBY_VERSION !~ /^1\.8/
+            md = "11-10"
+        end
+
+        # be sure we're actually getting the right data back
+        assert_equal(
+            "2008-#{md}",
+            klass.parse(Date.parse("10/11/2008")).strftime("%Y-%m-%d")
+        )
+
+        assert_equal(
+            "10:01:02",
+            klass.parse(Time.parse("10:01:02")).strftime("%H:%M:%S")
+        )
+
+        assert_equal(
+            "#{md}-2008 10:01:02",
+            klass.parse(DateTime.parse("10/11/2008 10:01:02")).strftime("%m-%d-%Y %H:%M:%S")
+        )
+
+        # precision tests, related to ticket #27182
+      
+        # iso8601 (bypasses regex)
+        [
+            '2009-09-27T19:41:00-05:00',
+            '2009-09-27T19:41:00.123-05:00'
+        ].each do |string|
+            assert_equal(DateTime.parse(string), klass.parse(string))
+        end
+
+        # offset comparison check
+        assert_equal(
+            DateTime.parse('2009-09-27T19:41:00.123-05:00'),
+            klass.parse('2009-09-28T00:41:00.123+00:00')
+        )
+
+        assert_equal(
+            DateTime.parse('2009-09-28T00:41:00.123+00:00'),
+            klass.parse('2009-09-27T19:41:00.123-05:00')
+        )
+
+        # unix convention (uses regex)
+        
+        [
+            '2009-09-27 19:41:00 -05:00',
+            '2009-09-27 19:41:00.123 -05:00'
+        ].each do |string|
+            assert_equal(DateTime.parse(string), klass.parse(string))
+        end
+
+        # offset comparison check
+        assert_equal(
+            DateTime.parse('2009-09-27 19:41:00.123 -05:00'),
+            klass.parse('2009-09-28 00:41:00.123 +00:00')
+        )
+
+        assert_equal(
+            DateTime.parse('2009-09-28 00:41:00.123 +00:00'),
+            klass.parse('2009-09-27 19:41:00.123 -05:00')
+        )
+    end
+end
+
+class TC_DBI_TypeUtil < Test::Unit::TestCase
+    def cast(obj)
+        DBI::TypeUtil.convert(nil, obj)
+    end
+
+    def datecast(obj)
+        "'#{::DateTime.parse(obj.to_s).strftime("%Y-%m-%dT%H:%M:%S")}'"
+    end
+
+    def test_default_unknown_cast
+        assert_kind_of(String, cast(MyType.new("foo")))
+        assert_equal("'foo'", cast(MyType.new("foo")))
+    end
+
+    def test_default_numeric_cast
+        assert_kind_of(String, cast(1))
+        assert_equal("1", cast(1))
+    end
+
+    def test_default_string_cast
+        assert_kind_of(String, cast("foo"))
+        assert_equal("'foo'", cast("foo"))
+        assert_equal("'foo''bar'", cast("foo'bar"))
+    end
+
+    def test_default_time_casts
+        assert_kind_of(String, cast(Time.now))
+        assert_kind_of(String, cast(Date.today))
+        assert_kind_of(String, cast(DateTime.now))
+      
+        obj = Time.now
+        assert_equal(datecast(obj), cast(obj))
+        obj = Date.today
+        assert_equal(datecast(obj), cast(obj))
+        obj = DateTime.now
+        assert_equal(datecast(obj), cast(obj))
+    end
+
+    def test_default_boolean_casts
+        assert_kind_of(String, cast(false))
+        assert_kind_of(String, cast(true))
+        assert_kind_of(NilClass, cast(nil))
+
+        assert_equal("'1'", cast(true))
+        assert_equal("'0'", cast(false))
+        assert_equal(nil, cast(nil))
+    end
+
+    def test_default_binary_casts
+        assert_kind_of(DBI::Binary, cast(DBI::Binary.new("poop")))
+        obj = DBI::Binary.new("poop")
+        assert_equal(obj.object_id, cast(obj).object_id)
+    end
+end
+
+DBI::TypeUtil.register_conversion("test") do |obj|
+    case obj
+    when ::NilClass
+        ["Custom Nil", false]
+    when ::TrueClass
+        ["Custom True", false]
+    when ::FalseClass
+        ["Custom False", false]
+    else
+        [obj, true]
+    end
+end
+
+class TC_DBI_TypeUtil_Custom < Test::Unit::TestCase
+    def cast(obj)
+        DBI::TypeUtil.convert("test", obj)
+    end
+
+    def test_custom_casts
+        assert_equal("Custom Nil", cast(nil))
+        assert_equal("Custom True", cast(true))
+        assert_equal("Custom False", cast(false))
+    end
+
+    def test_custom_fallthrough
+        assert_equal("'foo'", cast(:foo))
+        assert_equal("'foo'", cast("foo"))
+        assert_equal("'foo''bar'", cast("foo'bar"))
+        assert_equal("1", cast(1))
+        assert_equal("'foo'", cast(MyType.new("foo")))
+    end
+end