ydbi 0.5.0

data/test/dbd/sqlite3/test_statement.rb

@@ -0,0 +1,88 @@
+class TestStatement < DBDConfig.testbase(:sqlite3)
+    def test_constructor
+        sth = DBI::DBD::SQLite3::Statement.new("select * from names", @dbh.instance_variable_get("@handle").instance_variable_get("@db"))
+
+        assert_kind_of DBI::DBD::SQLite3::Statement, sth
+        assert sth.instance_variable_get("@db")
+        assert_kind_of ::SQLite3::Database, sth.instance_variable_get("@db")
+        assert_equal(@dbh.instance_variable_get("@handle").instance_variable_get("@db"), sth.instance_variable_get("@db"))
+        assert_kind_of ::SQLite3::Statement, sth.instance_variable_get("@stmt")
+        assert_nil(@sth.instance_variable_get("@result"))
+
+        sth.finish
+
+        sth = @dbh.prepare("select * from names")
+
+        assert_kind_of DBI::StatementHandle, sth
+        sth.finish
+    end
+
+    def test_bind_param
+        sth = DBI::DBD::SQLite3::Statement.new("select * from names", @dbh.instance_variable_get("@handle").instance_variable_get("@db"))
+
+        assert_raises(DBI::InterfaceError) do
+            sth.bind_param(:foo, "monkeys")
+        end
+
+        sth.finish
+    end
+    
+    def test_column_info
+        @sth = nil
+        
+        assert_nothing_raised do 
+            @sth = @dbh.prepare("select * from names")
+            @sth.execute
+        end
+
+        assert_kind_of Array, @sth.column_info 
+        assert_kind_of DBI::ColumnInfo, @sth.column_info[0]
+        assert_kind_of DBI::ColumnInfo, @sth.column_info[1]
+        assert_equal [ 
+            { 
+                :name  => "name",
+                :sql_type  => 12,
+                :precision  => 255,
+                :type_name  => "varchar"
+            }, 
+            { 
+                :name  => "age",
+                :sql_type  => 4,
+                :type_name  => "integer"
+            } 
+        ], @sth.column_info
+
+        @sth.finish
+    end
+    
+    def test_specific_types
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into db_specific_types_test (dbl) values (?)")
+            @sth.execute(11111111.111111)
+            @sth.execute(22)
+            @sth.finish
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from db_specific_types_test")
+            @sth.execute
+            assert_equal([11111111.111111], @sth.fetch)
+            assert_equal([22], @sth.fetch)
+            @sth.finish
+
+            assert_equal([[11111111.111111], [22]], @dbh.select_all("select * from db_specific_types_test"))
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
+            @sth.execute(:joseph, 20)
+            @sth.finish
+
+            @sth = @dbh.prepare("select name, age from names where name=?")
+            @sth.execute("joseph")
+            rows = @sth.fetch_all
+            @sth.finish
+            assert_equal(rows, [["joseph", 20]])
+        end
+    end
+end

data/test/dbd/sqlite3/up.sql

@@ -0,0 +1,33 @@
+create table names (name varchar(255), age integer);
+---
+insert into names (name, age) values ("Bob", 21);
+---
+insert into names (name, age) values ("Joe", 19);
+---
+insert into names (name, age) values ("Jim", 30);
+---
+create table precision_test (text_field varchar(20) primary key not null, integer_field integer, decimal_field decimal(2,1), numeric_field numeric(30,6));
+---
+create view view_names as select * from names;
+---
+create table blob_test (name varchar(255));
+---
+create table boolean_test (num integer, mybool boolean);
+---
+create table time_test (mytime time);
+---
+create table timestamp_test (mytimestamp timestamp);
+---
+create table bit_test (mybit bit);
+---
+create table field_types_test (foo integer not null primary key default 1);
+---
+create table db_specific_types_test (dbl double);
+---
+create table names_defined_with_spaces ( name varchar( 255 ), age integer );
+---
+insert into names_defined_with_spaces (name, age) values ("Bob", 21);
+---
+insert into names_defined_with_spaces (name, age) values ("Joe", 19);
+---
+insert into names_defined_with_spaces (name, age) values ("Jim", 30);

data/test/dbi/tc_columninfo.rb

@@ -0,0 +1,94 @@
+############################################################
+# tc_columninfo.rb
+#
+# Test case for the DBI::ColumnInfo class.
+############################################################
+$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/columninfo"
+require "test/unit"
+
+class TC_DBI_ColumnInfo < Test::Unit::TestCase
+   def setup
+      @colinfo = DBI::ColumnInfo.new(
+         "name"      => "test",
+         "sql_type"  => "numeric",
+         "type_name" => "test_type_name",
+         "precision" => 2,
+         "scale"     => 2,
+         "default"   => 100.00,
+         "nullable"  => false,
+         "indexed"   => true,
+         "primary"   => true,
+         "unique"    => false
+      )
+      @keys = %w/name sql_type type_name precision scale default nullable
+         indexed primary unique
+      /
+   end
+   
+   def test_constructor
+      assert_nothing_raised{ DBI::ColumnInfo.new }
+
+      assert_nothing_raised do
+          DBI::ColumnInfo.new({"foo" => "bar", "baz" => "quux"})
+          DBI::ColumnInfo.new({:foo => "bar", :baz => "quux"})
+      end
+
+      assert_raises(ArgumentError) do
+          DBI::ColumnInfo.new({"foo" => "bar", :foo => "quux"})
+      end
+   end
+
+   def test_accessors
+       assert_nothing_raised do
+           @keys.each do |x|
+               assert_equal(@colinfo[x], @colinfo[x.to_sym])
+               assert_equal(@colinfo.send(x.to_sym), @colinfo[x.to_sym])
+               @colinfo[x] = "poop"
+               assert_equal("poop", @colinfo[x])
+               assert_equal("poop", @colinfo[x.to_sym])
+           end
+       end
+   end
+
+   def test_precision_basic
+      assert_respond_to(@colinfo, :size)
+      assert_respond_to(@colinfo, :size=)
+      assert_respond_to(@colinfo, :length)
+      assert_respond_to(@colinfo, :length=)
+   end
+
+   def test_scale_basic
+      assert_respond_to(@colinfo, :decimal_digits)
+      assert_respond_to(@colinfo, :decimal_digits=)
+   end
+
+   def test_default_value_basic
+      assert_respond_to(@colinfo, :default_value)
+      assert_respond_to(@colinfo, :default_value=)
+   end
+
+   def test_unique_basic
+      assert_respond_to(@colinfo, :is_unique)
+   end
+
+   def test_keys
+      assert_respond_to(@colinfo, :keys)
+      assert_equal(@keys.sort, @colinfo.keys.collect { |x| x.to_s }.sort)
+   end
+   
+   def test_respond_to_hash_methods
+      assert_respond_to(@colinfo, :each)
+      assert_respond_to(@colinfo, :empty?)
+      assert_respond_to(@colinfo, :has_key?)
+   end
+
+   def teardown
+      @colinfo = nil
+   end
+end

data/test/dbi/tc_date.rb

@@ -0,0 +1,88 @@
+##############################################################################
+# tc_date.rb
+#
+# Test case for the DBI::Date 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_date = DBI::Date.new
+   end
+
+   def test_constructor
+      assert_nothing_raised{ DBI::Date.new(2006) }
+      assert_nothing_raised{ DBI::Date.new(2006, 1) }
+      assert_nothing_raised{ DBI::Date.new(2006, 1, 20) }
+      assert_nothing_raised{ DBI::Date.new(Date.new) }
+      assert_nothing_raised{ DBI::Date.new(Time.now) }
+   end
+
+   def test_year
+      assert_respond_to(@dbi_date, :year)
+      assert_respond_to(@dbi_date, :year=)
+      assert_equal(0, @dbi_date.year)
+   end
+
+   def test_month
+      assert_respond_to(@dbi_date, :month)
+      assert_respond_to(@dbi_date, :month=)
+   end
+
+   # An alias for :month, :month=
+   def test_mon
+      assert_respond_to(@dbi_date, :mon)
+      assert_respond_to(@dbi_date, :mon=)
+      assert_equal(0, @dbi_date.mon)
+   end
+
+   def test_day
+      assert_respond_to(@dbi_date, :day)
+      assert_respond_to(@dbi_date, :day=)
+      assert_equal(0, @dbi_date.day)
+   end
+
+   # An alias for :day, :day=
+   def test_mday
+      assert_respond_to(@dbi_date, :mday)
+      assert_respond_to(@dbi_date, :mday=)
+   end
+
+   def test_to_time
+      assert_respond_to(@dbi_date, :to_time)
+      assert_equal(@time, DBI::Date.new(@time).to_time)
+      assert_equal(@time.object_id, DBI::Date.new(@time).to_time.object_id)
+   end
+
+   def test_to_date
+      assert_respond_to(@dbi_date, :to_date)
+      assert_equal(@date, DBI::Date.new(@date).to_date)
+      assert_equal(@date.object_id, DBI::Date.new(@date).to_date.object_id)
+   end
+
+   # We test .to_s because it has an explicit implementation
+   def test_to_s
+      assert_respond_to(@dbi_date, :to_s)
+      assert_nothing_raised{ @dbi_date.to_s }
+      assert_kind_of(String, @dbi_date.to_s)
+      assert_equal("0000-00-00", @dbi_date.to_s)
+   end
+
+   def teardown
+      @date = nil
+      @time = nil
+      @dbi_date = nil
+   end
+end

data/test/dbi/tc_dbi.rb

@@ -0,0 +1,184 @@
+######################################################################
+# tc_dbi.rb
+#
+# Test case for the DBI module (dbi.rb).
+######################################################################
+$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 TC_DBI < Test::Unit::TestCase
+    def setup
+        @db_error  = DBI::DatabaseError.new("test", 1, "montana")
+        @db_binary = DBI::Binary.new("test")
+        @url_basic = 'dbi:foo:bar'
+        @url_inter = 'dbi:foo:bar:host'
+        @url_advan = 'dbi:foo:database=db;host=xx;port=99'
+    end
+
+    def test_dbi_version
+        assert_equal("0.5.0", DBI::VERSION)
+    end
+
+    def test_dbd_module
+        assert_equal("0.3", DBI::DBD::API_VERSION)
+    end
+
+    def test_fetch_scroll_constants
+        assert_equal(1, DBI::SQL_FETCH_NEXT)
+        assert_equal(2, DBI::SQL_FETCH_PRIOR)
+        assert_equal(3, DBI::SQL_FETCH_FIRST)
+        assert_equal(4, DBI::SQL_FETCH_LAST)
+        assert_equal(5, DBI::SQL_FETCH_ABSOLUTE)
+        assert_equal(6, DBI::SQL_FETCH_RELATIVE)
+    end
+
+    def test_sql_type_constants
+        assert_equal(1, DBI::SQL_CHAR)
+        assert_equal(2, DBI::SQL_NUMERIC)
+        assert_equal(3, DBI::SQL_DECIMAL)
+        assert_equal(4, DBI::SQL_INTEGER)
+        assert_equal(5, DBI::SQL_SMALLINT)
+        assert_equal(6, DBI::SQL_FLOAT)
+        assert_equal(7, DBI::SQL_REAL)
+        assert_equal(8, DBI::SQL_DOUBLE)
+        assert_equal(9, DBI::SQL_DATE)
+        assert_equal(10, DBI::SQL_TIME)
+        assert_equal(11, DBI::SQL_TIMESTAMP)
+        assert_equal(12, DBI::SQL_VARCHAR)
+        assert_equal(100, DBI::SQL_OTHER)
+        assert_equal(-1, DBI::SQL_LONGVARCHAR)
+        assert_equal(-2, DBI::SQL_BINARY)
+        assert_equal(-3, DBI::SQL_VARBINARY)
+        assert_equal(-4, DBI::SQL_LONGVARBINARY)
+        assert_equal(-5, DBI::SQL_BIGINT)
+        assert_equal(-6, DBI::SQL_TINYINT)
+        assert_equal(-7, DBI::SQL_BIT)
+        assert_equal(-10, DBI::SQL_BLOB)
+        assert_equal(-11, DBI::SQL_CLOB)
+    end
+
+    def test_sql_type_names
+        assert_equal('BIT', DBI::SQL_TYPE_NAMES[DBI::SQL_BIT])
+        assert_equal('TINYINT', DBI::SQL_TYPE_NAMES[DBI::SQL_TINYINT])
+        assert_equal('SMALLINT', DBI::SQL_TYPE_NAMES[DBI::SQL_SMALLINT])
+        assert_equal('INTEGER', DBI::SQL_TYPE_NAMES[DBI::SQL_INTEGER])
+        assert_equal('BIGINT', DBI::SQL_TYPE_NAMES[DBI::SQL_BIGINT])
+        assert_equal('FLOAT', DBI::SQL_TYPE_NAMES[DBI::SQL_FLOAT])
+        assert_equal('REAL', DBI::SQL_TYPE_NAMES[DBI::SQL_REAL])
+        assert_equal('DOUBLE', DBI::SQL_TYPE_NAMES[DBI::SQL_DOUBLE])
+        assert_equal('NUMERIC', DBI::SQL_TYPE_NAMES[DBI::SQL_NUMERIC])
+        assert_equal('DECIMAL', DBI::SQL_TYPE_NAMES[DBI::SQL_DECIMAL])
+        assert_equal('CHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_CHAR])
+        assert_equal('VARCHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_VARCHAR])
+        assert_equal('LONG VARCHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_LONGVARCHAR])
+        assert_equal('DATE', DBI::SQL_TYPE_NAMES[DBI::SQL_DATE])
+        assert_equal('TIME', DBI::SQL_TYPE_NAMES[DBI::SQL_TIME])
+        assert_equal('TIMESTAMP', DBI::SQL_TYPE_NAMES[DBI::SQL_TIMESTAMP])
+        assert_equal('BINARY', DBI::SQL_TYPE_NAMES[DBI::SQL_BINARY])
+        assert_equal('VARBINARY', DBI::SQL_TYPE_NAMES[DBI::SQL_VARBINARY])
+        assert_equal('LONG VARBINARY',
+                     DBI::SQL_TYPE_NAMES[DBI::SQL_LONGVARBINARY])
+        assert_equal('BLOB', DBI::SQL_TYPE_NAMES[DBI::SQL_BLOB])
+        assert_equal('CLOB', DBI::SQL_TYPE_NAMES[DBI::SQL_CLOB])
+        assert_equal(nil, DBI::SQL_TYPE_NAMES[DBI::SQL_OTHER])
+    end
+
+    def test_dbi_exception_classes
+        assert(DBI::Error)
+        assert(DBI::Warning)
+        assert(DBI::InterfaceError)
+        assert(DBI::NotImplementedError)
+        assert(DBI::DatabaseError)
+        assert(DBI::DataError)
+        assert(DBI::OperationalError)
+        assert(DBI::IntegrityError)
+        assert(DBI::InternalError)
+        assert(DBI::ProgrammingError)
+        assert(DBI::NotSupportedError)
+    end
+
+   # This error class gets extra testing since it defines some custom
+   # accessors.
+   def test_dbi_database_error
+       assert_respond_to(@db_error, :errstr)
+       assert_respond_to(@db_error, :err)
+       assert_respond_to(@db_error, :state)
+       assert_equal("test", @db_error.errstr)
+       assert_equal(1, @db_error.err)
+       assert_equal("montana", @db_error.state)
+   end
+
+   def test_binary_datatype
+       assert_respond_to(@db_binary, :data)
+       assert_respond_to(@db_binary, :to_s)
+       assert_equal("test", @db_binary.data)
+       assert_equal("test", @db_binary.to_s)
+   end
+
+   def test_misc_constants
+       assert_equal(2, DBI::DEFAULT_TRACE_MODE)
+       assert_equal(STDERR, DBI::DEFAULT_TRACE_OUTPUT)
+   end
+
+   def test_last_connection
+       assert_respond_to(DBI, :last_connection)
+   end
+
+   def test_convert_types
+       assert_respond_to(DBI, :convert_types)
+       assert_respond_to(DBI, :convert_types=)
+   end
+
+   def test_connect
+       assert_respond_to(DBI, :connect)
+   end
+
+   def test_available_drivers
+       assert_respond_to(DBI, :available_drivers)
+       assert_equal(
+       [
+            "dbi:Mysql:",
+            "dbi:ODBC:",
+            "dbi:Pg:",
+            "dbi:SQLite3:",
+            "dbi:SQLite:"
+       ], DBI.available_drivers.sort)
+   end
+
+   # PRIVATE METHODS
+   def test_parse_url
+      assert_nothing_raised{ DBI.send(:parse_url, "dbi:foo:bar") }
+      assert_equal(["foo","bar"], DBI.send(:parse_url, @url_basic))
+      assert_equal(["foo","bar:host"], DBI.send(:parse_url, @url_inter))
+      assert_equal(["foo","database=db;host=xx;port=99"],
+         DBI.send(:parse_url, @url_advan)
+      )
+   end
+
+   def test_parse_url_expected_errors
+      assert_raises(DBI::InterfaceError){ DBI.send(:parse_url, 'dbi') }
+      assert_raises(DBI::InterfaceError){ DBI.send(:parse_url, 'dbi::foo') }
+
+      # XXX we're looking for a specific exception message here
+      assert_nothing_raised do
+          begin
+              DBI.send(:parse_url, 'dbi:blah')
+          rescue DBI::InterfaceError => e
+              assert true
+              assert_kind_of DBI::InterfaceError, e
+              assert_equal "Invalid Data Source Name", e.message
+          end
+      end
+   end
+
+   def teardown
+      @db_error  = nil
+      @db_binary = nil
+   end
+end