dbd-sqlanywhere 0.1.2 → 1.0.0

data/test/dbd/general/test_statement.rb

@@ -1,249 +0,0 @@
-@class = Class.new(DBDConfig.testbase(DBDConfig.current_dbtype)) do
-
-    def test_execute
-        assert_nothing_raised do
-            @dbh.execute("select * from names order by age") do |sth|
-                assert_equal([["Joe", 19], ["Bob", 21], ["Jim", 30]], sth.fetch_all)
-            end
-        end
-    end
-
-    def test_quoting # FIXME breaks sqlite-ruby to a segfault - research
-        @sth = nil
-
-        assert_nothing_raised do
-            if dbtype == "postgresql"
-                @sth = @dbh.prepare('select E\'\\\\\'')
-            else
-                @sth = @dbh.prepare('select \'\\\\\'')
-            end
-            @sth.execute
-            row = @sth.fetch
-            assert_equal ['\\'], row
-            @sth.finish
-        end
-    end
-
-    def test_duplicate_columns
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select name, name from names where name = ?")
-            @sth.execute("Bob")
-            assert_equal [["Bob", "Bob"]], @sth.fetch_all
-            @sth.finish
-        end
-    end
-
-    def test_columninfo
-        @sth = nil
-        
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from precision_test")
-            @sth.execute
-
-            cols = @sth.column_info
-
-            assert(cols)
-            assert_kind_of(Array, cols)
-            assert_equal(2, cols.length)
-            
-            # the first column should always be "text_field" and have the following
-            # properties:
-            assert_equal("text_field", cols[0]["name"])
-            assert_equal(20, cols[0]["precision"])
-            # scale can be either nil or 0 for character types.
-            case cols[0]["scale"]
-            when nil
-                assert_equal(nil, cols[0]["scale"])
-            when 0
-                assert_equal(0, cols[0]["scale"])
-            else
-                flunk "scale can be either 0 or nil for character types"
-            end
-                
-            assert_equal(
-                DBI::Type::Varchar, 
-                DBI::TypeUtil.type_name_to_module(cols[0]["type_name"])
-            )
-
-            # the second column should always be "integer_field" and have the following
-            # properties:
-            assert_equal("integer_field", cols[1]["name"])
-            assert_equal(1, cols[1]["scale"])
-            assert_equal(2, cols[1]["precision"])
-            assert_equal(
-                DBI::Type::Decimal, 
-                DBI::TypeUtil.type_name_to_module(cols[1]["type_name"])
-            )
-
-            cols.each { |col| assert_kind_of(DBI::ColumnInfo, col) }
-            @sth.finish
-        end
-    end
-
-    def test_duplicate_columns
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select name, name from names where name = ?")
-            @sth.execute("Bob")
-            assert_equal [["Bob", "Bob"]], @sth.fetch_all
-            @sth.finish
-        end
-    end
-
-    def test_rows
-        @sth = nil
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
-            @sth.execute("Bill", 22);
-        end
-
-        assert 1, @sth.rows
-
-        @sth.finish
-        @sth = nil
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("delete from names where name = ?")
-            @sth.execute("Bill");
-        end
-
-        assert 1, @sth.rows
-
-        @sth.finish
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from names")
-            @sth.execute
-        end
-
-        assert_equal 0, @sth.rows
-        assert @sth.fetchable?
-        assert @sth.any?
-        assert @sth.rows.zero?
-        @sth.finish
-    end
-
-    def test_prepare_execute
-        assert_nothing_raised do 
-            @sth = @dbh.prepare("select * from names")
-            @sth.execute
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from names where name = ?")
-            @sth.execute("Bob")
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
-            @sth.execute("Bill", 22);
-            @sth.finish
-        end
-    end
-
-    def test_prepare_execute_with_transactions
-        @dbh["AutoCommit"] = false 
-        config = DBDConfig.get_config['sqlite3']
-
-        # rollback 1 (the right way)
-        @sth = nil
-        @sth2 = nil
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
-            @sth.execute("Billy", 23)
-            @sth2 = @dbh.prepare("select * from names where name = ?")
-            @sth2.execute("Billy")
-        end
-        assert_equal ["Billy", 23 ], @sth2.fetch
-        @sth2.finish
-        @sth.finish
-        assert_nothing_raised { @dbh.rollback }
-
-        @sth = @dbh.prepare("select * from names where name = ?")
-        @sth.execute("Billy")
-        assert_nil @sth.fetch
-        @sth.finish
-       
-        # rollback 2 (without closing statements first)
-
-        @sth = nil
-        @sth2 = nil
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
-            @sth.execute("Billy", 23)
-            @sth2 = @dbh.prepare("select * from names where name = ?")
-            @sth2.execute("Billy")
-        end
-
-        assert_equal ["Billy", 23], @sth2.fetch
-
-        # FIXME some throw here, some don't. we should probably normalize this
-        @dbh.rollback rescue true
-        
-        @sth2.finish
-        @sth.finish
-        assert_nothing_raised { @dbh.rollback }
-        
-        @sth = @dbh.prepare("select * from names where name = ?")
-        @sth.execute("Billy")
-        assert_nil @sth.fetch
-        @sth.finish
-
-        # commit
-
-        @sth = nil
-        @sth2 = nil
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
-            @sth.execute("Billy", 23)
-            @sth2 = @dbh.prepare("select * from names where name = ?")
-            @sth2.execute("Billy")
-        end
-        assert_equal ["Billy", 23 ], @sth2.fetch
-        @sth2.finish
-        @sth.finish
-        assert_nothing_raised { @dbh.commit }
-
-        @sth = @dbh.prepare("select * from names where name = ?")
-        @sth.execute("Billy")
-        assert_equal ["Billy", 23 ], @sth.fetch
-        @sth.finish
-    end
-
-    def test_fetch
-        @sth = nil
-        assert_nothing_raised do 
-            @sth = @dbh.prepare("select * from names order by age")
-            @sth.execute
-        end
-
-        # this tests that we're getting the rows in the right order,
-        # and that the types are being converted. 
-        assert_equal ["Joe", 19], @sth.fetch
-        assert_equal ["Bob", 21], @sth.fetch
-        assert_equal ["Jim", 30], @sth.fetch
-        assert_nil @sth.fetch
-
-        @sth.finish
-    end
-
-    def test_transaction_block
-        @dbh["AutoCommit"] = false
-        # this transaction should not fail because it called return early
-        @dbh.transaction do |dbh|
-            dbh.do('INSERT INTO names (name, age) VALUES (?, ?)', "Cooter", 69)
-            return 42
-        end 
-        @sth = @dbh.prepare("select * from names where name = ?")
-        @sth.execute("Cooter")
-        row = @sth.fetch
-        assert row
-        assert_equal ["Cooter", 69], row
-        @sth.finish
-    end
-end

data/test/dbd/general/test_types.rb

@@ -1,253 +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
-
-    # 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
-
-        # 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_raise(DBI::InterfaceError) { @sth.bind_coltype(1, DBI::Type::Float) }
-        # can't index < 1
-        assert_raise(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