ydbi 0.5.0 → 0.5.1

data/test/DBD_TESTS

@@ -1,50 +0,0 @@
-================================================================================
-Using DBD tests
-================================================================================
-
-Before you do anything, read the TESTING file.
-
-Create a YAML file named .ruby-dbi.test-config.yaml in your home directory.
-
-This file is a hash of keys that determine what you want to test and how you
-access the databases related to those tests.
-
-The key 'dbtypes' is an array which determines what tests you want to run. They
-*do not* correspond to the driver names, they correspond to the test
-directories that were made for them.
-
-Each 'dbtype' has a key that contains a hash of values:
-    - username: the username of your account
-    - password: the password for your account
-    - dbname: the name of the database to connect to
-
-NOTE that tests expect to connect to a database on localhost currently. This
-may be fixed in the future, especially when we start writing Oracle and
-SQLServer tests.
-
-Each DBD test relies on database semantics which may not match up entirely with
-this configuration. For instance, the postgresql tests expect you to be able to
-work with the database directly via the `psql' client. This is something which
-will eventually be remedied as time and ability allows.
-
-Here is a sample configuration to get you started with the postgresql tests:
-
-################################################################################
-
----
-dbtypes:
-    - postgresql
-postgresql:
-    username: erikh
-    password: monkeys
-    dbname: rubytest 
-
-################################################################################
-
-NOTE the --- is part of the file and is not a separator.
-
-================================================================================
-Writing DBD tests
-================================================================================
-
-Coming soon.

data/test/TESTING

@@ -1,16 +0,0 @@
-================================================================================
-Running Tests
-================================================================================
-
-You must have the source distribution (from git) to run the tests properly. This
-is something I plan to remedy in 0.6.0.
-
-You need the 'test-unit' gem to get started...
-
-    gem install test-unit
-
-There are three rake targets, run from the root of the source.
-
-    test_dbi: these are interface tests and do not require database connectivity.
-    test_dbd: these are database-specific tests. Read DBD_TESTS.
-    test: runs the both test_dbi and test_dbd

data/test/dbd/general/test_database.rb

@@ -1,206 +0,0 @@
-@class = Class.new(DBDConfig.testbase(DBDConfig.current_dbtype)) do
-
-    def test_last_statement
-        @sth = @dbh.prepare("select * from names")
-        @sth.finish
-        assert_equal "select * from names", @dbh.last_statement
-
-        @sth = @dbh.execute("select * from names")
-        @sth.finish
-        assert_equal "select * from names", @dbh.last_statement
-         
-        @dbh.do("select * from names")
-        assert_equal "select * from names", @dbh.last_statement
-    end
-
-    def test_empty_query
-        ["", " ", "\t"].each do |str|
-            [:do, :prepare, :execute, :select_one, :select_all].each do |call|
-                assert_raises(DBI::InterfaceError) do
-                    @dbh.send(call, str)
-                end
-            end
-        end
-    end
-
-    def test_ping
-        assert @dbh.ping
-        # XXX if it isn't obvious, this should be tested better. Not sure what
-        # good behavior is yet.
-    end
-
-    def test_columns
-        assert_nothing_raised do
-            cols = @dbh.columns("precision_test")
-
-            assert(cols)
-            assert_kind_of(Array, cols)
-            assert_equal(4, cols.length)
-
-            # the first column should always be "text_field" and have the following
-            # properties:
-            assert_equal("text_field", cols[0]["name"])
-            assert(!cols[0]["nullable"])
-
-            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.object_id,
-                DBI::TypeUtil.type_name_to_module(cols[0]["type_name"]).object_id
-            )
-
-            # the second column should always be "integer_field" and have the following
-            # properties:
-            assert_equal("integer_field", cols[1]["name"])
-            assert(cols[1]["nullable"])
-            assert_equal(1, cols[2]["scale"])
-            assert_equal(2, cols[2]["precision"])
-
-            assert_equal(
-                DBI::Type::Integer.object_id,
-                DBI::TypeUtil.type_name_to_module(cols[1]["type_name"]).object_id
-            )
-
-            # the second column should always be "integer_field" and have the following
-            # properties:
-            assert_equal("decimal_field", cols[2]["name"])
-            assert(cols[2]["nullable"])
-            assert_equal(1, cols[2]["scale"])
-            assert_equal(2, cols[2]["precision"])
-            assert_equal(
-                DBI::Type::Decimal.object_id,
-                DBI::TypeUtil.type_name_to_module(cols[2]["type_name"]).object_id
-            )
-
-            # the second column should always be "numeric_field" and have the following
-            # properties:
-            assert_equal("numeric_field", cols[3]["name"])
-            assert(cols[3]["nullable"])
-            assert_equal(6, cols[3]["scale"])
-            assert_equal(30, cols[3]["precision"])
-            assert_equal(
-                DBI::Type::Decimal.object_id,
-                DBI::TypeUtil.type_name_to_module(cols[3]["type_name"]).object_id
-            )
-
-            # finally, we ensure that every column in the array is a ColumnInfo
-            # object
-            cols.each { |col| assert_kind_of(DBI::ColumnInfo, col) }
-        end
-    end
-
-    def test_prepare
-        @sth = @dbh.prepare('select * from names')
-
-        assert @sth
-        assert_kind_of DBI::StatementHandle, @sth
-
-        @sth.finish
-    end
-
-    def test_do
-        assert_equal 1, @dbh.do("insert into names (name, age) values (?, ?)", "Billy", 21)
-        @sth = @dbh.prepare("select * from names where name = ?")
-        @sth.execute("Billy")
-        assert_equal ["Billy", 21], @sth.fetch
-        @sth.finish
-    end
-
-    def test_tables
-        tables = @dbh.tables.sort
-
-        # since this is a general test, let's prune the system tables
-        # FIXME not so sure if this should be a general test anymore.
-        if dbtype == "odbc"
-            tables -= [
-                "administrable_role_authorizations",
-                "applicable_roles",
-                "attributes",
-                "check_constraint_routine_usage",
-                "check_constraints",
-                "column_domain_usage",
-                "column_privileges",
-                "column_udt_usage",
-                "columns",
-                "constraint_column_usage",
-                "constraint_table_usage",
-                "data_type_privileges",
-                "domain_constraints",
-                "domain_udt_usage",
-                "domains",
-                "element_types",
-                "enabled_roles",
-                "information_schema_catalog_name",
-                "key_column_usage",
-                "parameters",
-                "referential_constraints",
-                "role_column_grants",
-                "role_routine_grants",
-                "role_table_grants",
-                "role_usage_grants",
-                "routine_privileges",
-                "routines",
-                "schemata",
-                "sequences",
-                "sql_features",
-                "sql_implementation_info",
-                "sql_languages",
-                "sql_packages",
-                "sql_parts",
-                "sql_sizing",
-                "sql_sizing_profiles",
-                "table_constraints",
-                "table_privileges",
-                "tables",
-                "triggered_update_columns",
-                "triggers",
-                "usage_privileges",
-                "view_column_usage",
-                "view_routine_usage",
-                "view_table_usage",
-                "views"
-            ]
-        end
-
-        case dbtype
-        when "postgresql"
-            tables.reject! { |x| x =~ /^pg_/ }
-            assert_equal %w(array_test bit_test blob_test boolean_test bytea_test db_specific_types_test enum_type_test field_types_test names precision_test time_test timestamp_test view_names), tables
-        when 'sqlite3'
-            assert_equal %w(bit_test blob_test boolean_test db_specific_types_test field_types_test names names_defined_with_spaces precision_test time_test timestamp_test view_names), tables
-        else
-            assert_equal %w(bit_test blob_test boolean_test db_specific_types_test field_types_test names precision_test time_test timestamp_test view_names), tables
-        end
-    end
-
-    def test_attrs
-        # test defaults
-        assert @dbh["AutoCommit"] # should be true
-
-        # test setting
-        assert !(@dbh["AutoCommit"] = false)
-        assert !@dbh["AutoCommit"]
-
-        # test committing an outstanding transaction
-
-        @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
-        @sth.execute("Billy", 22)
-        @sth.finish
-
-        assert @dbh["AutoCommit"] = true # should commit at this point
-
-        @sth = @dbh.prepare("select * from names where name = ?")
-        @sth.execute("Billy")
-        assert_equal [ "Billy", 22 ], @sth.fetch
-        @sth.finish
-    end
-end

data/test/dbd/general/test_statement.rb

@@ -1,326 +0,0 @@
-@class = Class.new(DBDConfig.testbase(DBDConfig.current_dbtype)) do
-   
-    def prep_status_statement
-        @sth.finish if (@sth and !@sth.finished?)
-        @sth = @dbh.prepare("select * from names order by age")
-        @sth.raise_error = true
-    end
-
-    def test_status
-        names_rc = 3
-
-        [:fetch, :fetch_hash, :each, :fetch_all].each do |call|
-            assert_raise(DBI::InterfaceError, DBI::NotSupportedError) do
-                prep_status_statement
-                @sth.send(call)
-            end
-        end
-        
-        # for these next three, it doesn't really matter what the args are, it should fail
-        assert_raises(DBI::InterfaceError, DBI::NotSupportedError) do
-            prep_status_statement
-            @sth.fetch_many(1) 
-        end
-
-        assert_raises(DBI::InterfaceError, DBI::NotSupportedError) do
-            prep_status_statement
-            @sth.fetch_scroll(0, 0)
-        end
-
-        assert_raises(DBI::InterfaceError, DBI::NotSupportedError) do
-            prep_status_statement
-            @sth.each { |x| }
-        end
-
-        assert_raises(DBI::InterfaceError) do
-            prep_status_statement
-            @sth.execute
-            2.times { @sth.fetch_all }
-        end
-
-        assert_raises(DBI::InterfaceError) do
-            prep_status_statement
-            @sth.execute
-            # XXX fetch_many won't know it can't fetch anything until the third time around.
-            3.times { @sth.fetch_many(names_rc) }
-        end
-    end
-
-    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(4, 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.object_id, 
-                DBI::TypeUtil.type_name_to_module(cols[0]["type_name"]).object_id
-            )
-
-            # the second column should always be "integer_field" and have the following
-            # properties:
-            assert_equal("integer_field", cols[1]["name"])
-            # if these aren't set on the field, they should not exist
-            # FIXME mysql does not follow this rule, neither does ODBC
-            if dbtype == "mysql" 
-                assert_equal(0, cols[1]["scale"])
-                assert_equal(11, cols[1]["precision"])
-            elsif dbtype == "odbc"
-                assert_equal(0, cols[1]["scale"])
-                assert_equal(10, cols[1]["precision"])
-            else
-                assert(!cols[1]["scale"])
-                assert(!cols[1]["precision"])
-            end
-
-            assert_equal(
-                DBI::Type::Integer.object_id, 
-                DBI::TypeUtil.type_name_to_module(cols[1]["type_name"]).object_id
-            )
-
-            # the second column should always be "integer_field" and have the following
-            # properties:
-            assert_equal("decimal_field", cols[2]["name"])
-            assert_equal(1, cols[2]["scale"])
-            assert_equal(2, cols[2]["precision"])
-            assert_equal(
-                DBI::Type::Decimal.object_id, 
-                DBI::TypeUtil.type_name_to_module(cols[2]["type_name"]).object_id
-            )
-
-            # the second column should always be "numeric_field" and have the following
-            # properties:
-            assert_equal("numeric_field", cols[3]["name"])
-            assert_equal(6, cols[3]["scale"])
-            assert_equal(30, cols[3]["precision"])
-            assert_equal(
-                DBI::Type::Decimal.object_id, 
-                DBI::TypeUtil.type_name_to_module(cols[3]["type_name"]).object_id
-            )
-
-            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