ydbi 0.5.0 → 0.5.1

data/test/dbd/general/test_types.rb

@@ -1,296 +0,0 @@
-@class = Class.new(DBDConfig.testbase(DBDConfig.current_dbtype)) do
-    def skip_bit
-        # FIXME this test fails because DBI's type system blows goats.
-       @sth = nil
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into bit_test (mybit) values (?)")
-            @sth.bind_param(1, 0, DBI::SQL_TINYINT)
-            @sth.execute
-#             if dbtype == "postgresql"
-#                 @sth.execute("0")
-#             else
-#                 @sth.execute(0)
-#             end
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from bit_test")
-            @sth.execute
-            row = @sth.fetch
-            @sth.finish
-
-            assert_equal [0], row
-        end
-    end
-
-    def test_numeric_types
-        assert(@dbh.convert_types)
-
-        @sth = @dbh.prepare("insert into precision_test (text_field, integer_field, decimal_field, numeric_field) values (?, ?, ?, ?)")
-        assert(@sth.convert_types)
-        1.step(5) do |x|
-            @sth.execute("poop#{x}", x, x + 0.123, x + 0.234)
-        end
-
-        @sth.finish
-
-        @sth = @dbh.prepare("select integer_field, decimal_field, numeric_field from precision_test")
-        @sth.execute
-        col_info = @sth.column_info
-        1.step(5) do |x|
-            row = @sth.fetch
-
-            assert_kind_of(Integer, row[0])
-            assert_kind_of(BigDecimal, row[1])
-            assert_kind_of(BigDecimal, row[2])
-
-            # FIXME BigDecimal requires a string and some databases will pad
-            # decimal/numeric with constrained precision. We should account for
-            # this, but I'm not quite sure how yet.
-        end
-        @sth.finish
-    end
-
-    # FIXME
-    # Ideally, this test should be split across the DBI tests and DBD, but for
-    # now testing against the DBDs really doesn't cost us anything other than
-    # debugging time if something breaks.
-    def test_bind_coltype
-        # ensure type conv didn't get turned off somewhere.
-        assert(DBI.convert_types)
-        assert(@dbh.convert_types)
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select name, age from names order by age")
-            assert(@sth.convert_types) # again
-            @sth.execute
-            @sth.bind_coltype(2, DBI::Type::Varchar)
-            assert_equal(
-                [
-                    ["Joe", "19"], 
-                    ["Bob", "21"],
-                    ["Jim", "30"], 
-                ], @sth.fetch_all
-            )
-            @sth.finish
-        end
-        
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select age, name from names order by age")
-            assert(@sth.convert_types) # again
-            @sth.execute
-            @sth.bind_coltype(1, DBI::Type::Varchar)
-            assert_equal(
-                [
-                    ["19", "Joe"], 
-                    ["21", "Bob"],
-                    ["30", "Jim"], 
-                ], @sth.fetch_all
-            )
-            @sth.finish
-        end
-
-        # just to be sure..
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select name, age from names order by age")
-            @sth.execute
-            @sth.bind_coltype(2, DBI::Type::Float)
-            @sth.fetch_all.collect { |x| assert_kind_of(Float, x[1]) }
-            @sth.finish
-        end
-
-        # now, let's check some failure cases
-        @sth = @dbh.prepare("select name, age from names order by age")
-
-        # can't bind_coltype before execute
-        assert_raises(DBI::InterfaceError) { @sth.bind_coltype(1, DBI::Type::Float) }
-        # can't index < 1
-        assert_raises(DBI::InterfaceError) { @sth.bind_coltype(0, DBI::Type::Float) }
-    end
-
-    def test_noconv
-        # XXX this test will fail the whole test suite miserably if it fails at any point.
-        assert(DBI.convert_types)
-
-        DBI.convert_types = false
-        @sth.finish rescue nil
-        @dbh.disconnect
-        set_base_dbh
-
-        assert(!@dbh.convert_types)
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from names order by age")
-            assert(!@sth.convert_types)
-            @sth.execute
-            assert_equal(
-                [
-                    ["Joe", "19"], 
-                    ["Bob", "21"],
-                    ["Jim", "30"], 
-                ], @sth.fetch_all
-            )
-            @sth.finish
-        end
-
-        DBI.convert_types = true
-        @sth.finish rescue nil
-        @dbh.disconnect
-        set_base_dbh
-
-        assert(DBI.convert_types)
-        assert(@dbh.convert_types)
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from names order by age")
-            assert(@sth.convert_types)
-            @sth.execute
-            assert_equal(
-                [
-                    ["Joe", 19], 
-                    ["Bob", 21],
-                    ["Jim", 30], 
-                ], @sth.fetch_all
-            )
-            @sth.finish
-        end
-
-        @dbh.convert_types = false
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from names order by age")
-            assert(!@sth.convert_types)
-            @sth.execute
-            assert_equal(
-                [
-                    ["Joe", "19"], 
-                    ["Bob", "21"],
-                    ["Jim", "30"], 
-                ], @sth.fetch_all
-            )
-            @sth.finish
-        end
-
-        @dbh.convert_types = true
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from names order by age")
-            assert(@sth.convert_types)
-            @sth.convert_types = false
-            @sth.execute
-            assert_equal(
-                [
-                    ["Joe", "19"], 
-                    ["Bob", "21"],
-                    ["Jim", "30"], 
-                ], @sth.fetch_all
-            )
-            @sth.finish
-        end
-    rescue Exception => e
-        DBI.convert_types = true
-        @sth.finish
-        @dbh.disconnect
-        set_base_dbh
-        raise e
-    end
-
-    def test_null
-        assert_nothing_raised do
-            @sth = @dbh.prepare('insert into names (name, age) values (?, ?)')
-            @sth.execute("'NULL'", 201)
-            @sth.execute(nil, 202)
-            @sth.execute("NULL", 203)
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare('select * from names where age > 200 order by age')
-            @sth.execute
-            assert_equal(["'NULL'", 201], @sth.fetch)
-            assert_equal([nil, 202], @sth.fetch)
-            assert_equal(["NULL", 203], @sth.fetch)
-            @sth.finish
-        end
-    end
-
-    def test_time
-        @sth = nil
-        t = nil
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into time_test (mytime) values (?)")
-            t = Time.now
-            @sth.execute(t)
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from time_test")
-            @sth.execute
-            row = @sth.fetch
-            assert_kind_of DateTime, row[0]
-            assert_equal t.hour, row[0].hour
-            assert_equal t.min, row[0].min
-            assert_equal t.sec, row[0].sec
-            @sth.finish
-        end
-    end
-
-    def test_timestamp
-        @sth = nil
-         # We omit fractional second testing here -- timestamp precision
-         # is a very slippery, dependent on driver and driver version.
-        t = DBI::Timestamp.new(2008, 3, 8, 10, 39, 1)
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into timestamp_test (mytimestamp) values (?)")
-            @sth.execute(t)
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from timestamp_test")
-            @sth.execute
-            row = @sth.fetch
-            assert_kind_of DateTime, row[0]
-            assert_equal t.year, row[0].year
-            assert_equal t.month, row[0].month
-            assert_equal t.day, row[0].day
-            assert_equal t.hour, row[0].hour
-            assert_equal t.min, row[0].min
-            assert_equal t.sec, row[0].sec
-             # omit fractional tests
-            @sth.finish
-        end
-    end
-
-    def test_boolean_return
-        @sth = nil
-
-        unless dbtype == "odbc" # ODBC has no boolean type
-            assert_nothing_raised do
-                @sth = @dbh.prepare("insert into boolean_test (num, mybool) values (?, ?)")
-                @sth.execute(1, true)
-                @sth.execute(2, false)
-                @sth.finish
-            end
-
-            assert_nothing_raised do
-                @sth = @dbh.prepare("select * from boolean_test order by num")
-                @sth.execute
-
-                pairs = @sth.fetch_all
-
-                assert_equal(
-                    [
-                                 [1, true],
-                                 [2, false],
-                    ], pairs
-                )
-
-                @sth.finish
-            end
-        end
-    end
-end

data/test/dbd/mysql/base.rb

@@ -1,26 +0,0 @@
-DBDConfig.set_testbase(:mysql, Class.new(Test::Unit::TestCase) do
-        def dbtype 
-            "mysql"
-        end
-
-        def test_base
-            assert_equal(@dbh.driver_name, "Mysql")
-            assert_kind_of(DBI::DBD::Mysql::Database, @dbh.instance_variable_get(:@handle))
-        end
-
-        def set_base_dbh
-            config = DBDConfig.get_config["mysql"]
-            @dbh = DBI.connect("dbi:Mysql:"+config["dbname"], config["username"], config["password"], { })
-        end
-
-        def setup
-            set_base_dbh
-            DBDConfig.inject_sql(@dbh, dbtype, "dbd/mysql/up.sql")
-        end
-
-        def teardown
-            DBDConfig.inject_sql(@dbh, dbtype, "dbd/mysql/down.sql")
-            @dbh.disconnect
-        end
-    end
-)

data/test/dbd/mysql/down.sql

@@ -1,19 +0,0 @@
-drop view view_names;
----
-drop table names;
----
-drop table blob_test;
----
-drop table boolean_test;
----
-drop table time_test;
----
-drop table timestamp_test;
----
-drop table bit_test;
----
-drop table field_types_test;
----
-drop table db_specific_types_test;
----
-drop table precision_test;

data/test/dbd/mysql/test_blob.rb

@@ -1,18 +0,0 @@
-class TestMySQLBlob < DBDConfig.testbase(:mysql)
-    def test_blob_round_trip
-        data =(0..255).collect{|n| n.chr}.join("")
-        sql = "INSERT INTO blob_test (name, data) VALUES (?, ?)"
-
-        @dbh.do(sql, 'test1', DBI::Binary.new(data)) 
-        @dbh.do(sql, 'test2', data) 
-
-        @dbh.prepare(sql) do |sth|
-            sth.execute('test3', DBI::Binary.new(data))
-            sth.execute('test4', data)
-        end
-
-        @dbh.select_all("SELECT name, data FROM blob_test") do |name, fetch_data|
-            assert_equal fetch_data, data
-        end
-    end
-end

data/test/dbd/mysql/test_new_methods.rb

@@ -1,7 +0,0 @@
-class TestNewMethods < DBDConfig.testbase(:mysql)
-    def test_database_name
-        assert_nothing_raised do
-            assert_equal DBDConfig.get_config[dbtype]['dbname'], @dbh.database_name
-        end
-    end
-end

data/test/dbd/mysql/test_patches.rb

@@ -1,111 +0,0 @@
-class TestMysqlPatches < DBDConfig.testbase(:mysql)
-    def test_exception_on_aggregate
-        assert_nothing_raised do
-            sth = @dbh.prepare("select sum(age) from names")
-            sth.execute
-            row = sth.fetch 
-            assert_equal(70.0, row[0])
-            sth.finish
-
-            sth = @dbh.prepare("select count(*) from names")
-            sth.execute
-            assert_equal([3], sth.fetch)
-            sth.finish
-        end
-    end
-
-    def test_timestamps
-        timestamp = "04-06-1978 06:00:00"
-        datestamp = "04-06-1978"
-        date  = Date.strptime(datestamp, "%m-%d-%Y")
-        stamp = DateTime.strptime(timestamp, "%m-%d-%Y %H:%M:%S")
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into db_specific_types_test (ts) values (?)")
-            @sth.execute(stamp)
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select ts from db_specific_types_test where ts is not null")
-            @sth.execute
-
-            newstamp = @sth.fetch[0]
-
-            assert_equal(newstamp, stamp)
-            assert_equal(newstamp.strftime("%m-%d-%Y %H:%M:%S"), timestamp)
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into db_specific_types_test (dt) values (?)")
-            @sth.execute(date)
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select dt from db_specific_types_test where dt is not null")
-            @sth.execute
-            
-            newdate = @sth.fetch[0]
-
-            assert_equal(newdate, date)
-            assert_equal(newdate.strftime("%m-%d-%Y"), datestamp)
-            @sth.finish
-        end
-    end
-
-    # FIXME when the spec is more solid, this should be in the general tests
-    def test_columns
-        assert_nothing_raised do
-            assert_equal [
-                {
-                    :name =>"foo",
-                    :default =>"1",
-                    :primary =>true,
-                    :scale =>nil,
-                    :sql_type =>4,
-                    :nullable =>false,
-                    :indexed =>true,
-                    :precision =>11,
-                    :type_name =>"int",
-                    :unique =>true
-                }
-            ], @dbh.columns("field_types_test")
-        end
-
-        assert_nothing_raised do
-            sth = @dbh.prepare("insert into field_types_test (foo) values (?)")
-            sth.execute(2)
-            sth.finish
-        end
-
-        assert_nothing_raised do
-            sth = @dbh.prepare("select * from field_types_test")
-            sth.execute
-            row = sth.fetch
-            columns = sth.column_info
-            sth.finish
-
-            assert_equal [2], row
-            assert_equal [
-                {
-                    :dbi_type => DBI::Type::Integer,
-                    :name =>"foo",
-                    :mysql_type_name =>"INT",
-                    :mysql_max_length =>1,
-                    :primary =>true,
-                    :scale =>0,
-                    :mysql_flags =>49155,
-                    :sql_type =>4,
-                    :nullable =>false,
-                    :mysql_type =>3,
-                    :indexed =>true,
-                    :mysql_length =>11,
-                    :precision =>11,
-                    :type_name =>"INTEGER",
-                    :unique =>true
-                }
-            ], columns
-        end
-    end
-end

data/test/dbd/mysql/up.sql

@@ -1,28 +0,0 @@
-create table names (
-    name varchar(255),
-    age integer
-) Engine=InnoDB;
----
-insert into names (name, age) values ('Joe', 19);
----
-insert into names (name, age) values ('Jim', 30);
----
-insert into names (name, age) values ('Bob', 21);
----
-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 TABLE blob_test (name VARCHAR(30), data BLOB) Engine=InnoDB;
----
-create view view_names as select * from names;
----
-create table boolean_test (num integer, mybool boolean) Engine=InnoDB;
----
-create table time_test (mytime time) Engine=InnoDB;
----
-create table timestamp_test (mytimestamp timestamp) Engine=InnoDB;
----
-create table bit_test (mybit bit) Engine=InnoDB;
----
-create table field_types_test (foo integer not null primary key default 1);
----
-create table db_specific_types_test (ts timestamp, dt date);

data/test/dbd/odbc/base.rb

@@ -1,30 +0,0 @@
-require 'fileutils'
-
-DBDConfig.set_testbase(:odbc, Class.new(Test::Unit::TestCase) do
-        
-        def dbtype
-            "odbc"
-        end
-
-        def test_base
-            assert_equal(@dbh.driver_name, "odbc")
-            assert_kind_of(DBI::DBD::ODBC::Database, @dbh.instance_variable_get(:@handle))
-        end
-        
-        def set_base_dbh
-            config = DBDConfig.get_config['odbc']
-            @dbh = DBI.connect("dbi:ODBC:#{config['dbname']}", config['username'], config['password'])
-        end
-
-        def setup
-            set_base_dbh
-            DBDConfig.inject_sql(@dbh, dbtype, "dbd/odbc/up.sql")
-        end
-
-        def teardown
-            @sth.finish if @sth && !@sth.finished?
-            DBDConfig.inject_sql(@dbh, dbtype, "dbd/odbc/down.sql")
-            @dbh.disconnect
-        end
-    end
-)

data/test/dbd/odbc/down.sql

@@ -1,19 +0,0 @@
-drop view view_names;
----
-drop table names;
----
-drop table blob_test;
----
-drop table boolean_test;
----
-drop table time_test;
----
-drop table timestamp_test;
----
-drop table bit_test;
----
-drop table field_types_test;
----
-drop table db_specific_types_test;
----
-drop table precision_test;

data/test/dbd/odbc/test_new_methods.rb

@@ -1,12 +0,0 @@
-class TestODBCPing < DBDConfig.testbase(:odbc)
-    def test_database_name
-        #
-        # NOTE this test will fail if the database is not named "rubytest". I
-        # don't think there's a good way to get around this, so I've set it to
-        # what I typically use in my odbc.ini. - erikh
-        #
-        assert_nothing_raised do
-            assert_equal "rubytest", @dbh.database_name
-        end
-    end
-end

data/test/dbd/odbc/test_ping.rb

@@ -1,10 +0,0 @@
-class TestODBCPing < DBDConfig.testbase(:odbc)
-    def test_ping
-        config = DBDConfig.get_config['odbc']
-        dbh = DBI.connect("dbi:ODBC:#{config['dbname']}", config['username'], config['password'])
-        assert dbh
-        assert dbh.ping
-        dbh.disconnect
-        assert_raises(DBI::InterfaceError) { dbh.ping }
-    end
-end

data/test/dbd/odbc/test_statement.rb

@@ -1,44 +0,0 @@
-class TestODBCStatement < DBDConfig.testbase(:odbc)
-    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]
-        # XXX odbc seems to have a problem with this every other edition of unixodbc or so.
-        #     yes, I know this test is important.
-#         assert_equal [
-#             {
-#                 :table=>"names", 
-#                 :precision=>255, 
-#                 :searchable=>true, 
-#                 :name=>"name", 
-#                 :unsigned=>true, 
-#                 :length=>255, 
-#                 :sql_type=>12, 
-#                 :scale=>0, 
-#                 :nullable=>true, 
-#                 :type_name=>"VARCHAR"
-#             },
-#             {
-#                 :table=>"names", 
-#                 :precision=>10, 
-#                 :searchable=>true, 
-#                 :name=>"age", 
-#                 :unsigned=>false, 
-#                 :length=>4, 
-#                 :sql_type=>4, 
-#                 :scale=>0, 
-#                 :nullable=>true, 
-#                 :type_name=>"INTEGER"
-#             }
-#         ], sth.column_info
-
-        sth.finish
-    end
-end

data/test/dbd/odbc/test_transactions.rb

@@ -1,58 +0,0 @@
-class TestODBCTransaction < DBDConfig.testbase(:odbc)
-    def test_rollback
-        dbh = get_dbh
-        dbh["AutoCommit"] = false
-        @sth = dbh.prepare('insert into names (name, age) values (?, ?)')
-        @sth.execute("Foo", 51)
-        dbh.rollback
-        assert_equal 1, @sth.rows
-        @sth.finish
-
-
-        @sth = dbh.prepare('select name, age from names where name=?')
-        @sth.execute("Foo")
-        assert !@sth.fetch
-        @sth.finish
-        dbh.disconnect 
-    end
-
-    def test_commit
-        dbh = get_dbh
-        dbh["AutoCommit"] = false
-        @sth = dbh.prepare('insert into names (name, age) values (?, ?)')
-        @sth.execute("Foo", 51)
-        dbh.commit
-        assert_equal 1, @sth.rows
-        @sth.finish
-        
-        @sth = dbh.prepare('select name, age from names where name=?')
-        @sth.execute("Foo")
-        row = @sth.fetch
-        assert row
-        assert_equal "Foo", row[0]
-        assert_equal 51, row[1]
-        @sth.finish
-        dbh.disconnect 
-    end
-
-    def test_select_transaction
-        # per bug #10466
-        dbh = get_dbh
-        dbh["AutoCommit"] = false
-        @sth = dbh.prepare('select * from test_insert(?, ?)');
-        @sth.execute("Foo", 51)
-        dbh.rollback
-        @sth.finish
-
-        @sth = dbh.prepare('select name, age from names where name=?')
-        @sth.execute("Foo")
-        assert !@sth.fetch
-        @sth.finish
-        dbh.disconnect 
-    end
-
-    def get_dbh
-        config = DBDConfig.get_config['odbc']
-        DBI.connect("dbi:ODBC:#{config['dbname']}", config['username'], config['password'])
-    end
-end