ydbi 0.5.7 → 0.5.9

data/test/dbd/postgresql/testdbipg.rb

@@ -1,307 +0,0 @@
-require 'dbd/Pg'
-
-module DBI
-  class ForcedError < ::DBI::Error
-  end
-end
-
-######################################################################
-# Test the PostgreSql DBD driver.  This test exercises options
-# difficult to test through the standard DBI interface.
-#
-class TestDbdPostgres < DBDConfig.testbase(:postgresql)
-
-    # FIXME this is a feature that should be there, but currently isn't.
-#   def test_connect
-#     dbd = get_dbd
-#     assert_not_nil dbd.connection
-#     assert_equal 'localhost', dbd.connection.host
-#     assert_equal 'erikh', dbd.connection.user
-#     assert_equal 'rubytest', dbd.connection.db
-#     assert_equal 5432, dbd.connection.port
-#   ensure
-#      dbd.disconnect if dbd
-#   end
-
-    # this monkeypatch is used for the following test... NEVER integrate this into DBI proper.
-    class DBI::StatementHandle < DBI::Handle
-        def stmt_name
-            @handle.instance_variable_get(:@stmt_name)
-        end
-    end
-
-    def test_database_name
-        assert_nothing_raised do
-            assert_equal DBDConfig.get_config[dbtype]['dbname'], @dbh.database_name
-        end
-    end
-
-    def test_enum_type
-        assert_nothing_raised do
-            assert(@dbh.convert_types)
-            @sth = @dbh.prepare("insert into enum_type_test values (?)")
-            @sth.execute("one")
-            @sth.finish
-
-            @sth = @dbh.prepare("select foo from enum_type_test")
-            @sth.execute
-            assert_equal(@sth.fetch, ['one'])
-            @sth.finish
-        end
-    end
-
-    def test_statement_finish_deallocates_sth
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from names")
-            @sth.execute
-            sth_internal_name = @sth.stmt_name
-            assert(sth_internal_name)
-            assert(!sth_internal_name.empty?)
-            @sth.finish
-
-            # at this point, the statement name should no longer exist
-            #
-            # XXX this is a potentially horrible way of doing it since it'll
-            # create another prepared statement, but *at this time*, I don't
-            # see any drawbacks and the alternative is considerably uglier.
-
-            @sth = @dbh.prepare("select count(*) from pg_prepared_statements where name = ?")
-            @sth.execute(sth_internal_name)
-            assert_equal([0], @sth.fetch)
-            @sth.finish
-        end
-    end
-
-    def test_binding
-        assert(@dbh["pg_native_binding"])
-
-        assert_raises(DBI::ProgrammingError) do
-            @sth = @dbh.prepare("select * from names where age IS NOT ?")
-            @sth.execute("NULL")
-            @sth.finish
-        end
-
-        assert_nothing_raised do
-            @dbh["pg_native_binding"] = false
-            @sth = @dbh.prepare("select * from names where age IS NOT ? order by age")
-            @sth.execute("NULL")
-            assert_equal(
-                [
-                    ["Joe", 19],
-                    ["Bob", 21],
-                    ["Jim", 30],
-                ],
-                @sth.fetch_all
-            )
-
-            @sth.finish
-
-            @sth = @dbh.prepare("select * from names where age = ?")
-            @sth.execute(19)
-            assert_equal(
-                [
-                    ["Joe", 19]
-                ],
-                @sth.fetch_all
-            )
-
-            @sth.finish
-        end
-    end
-
-    def test_function_multiple_return_values
-        @sth = @dbh.prepare("SELECT age, select_subproperty(age, NULL), select_subproperty(age, 1) FROM names WHERE age = 19")
-        @sth.execute
-        assert_equal([[19, nil, 19]], @sth.fetch_all)
-        @sth.finish
-    end
-
-    def test_columns
-        assert_equal(
-            [
-                {
-                        :name =>"age",
-                        :default =>nil,
-                        :primary =>nil,
-                        :scale =>nil,
-                        :sql_type =>4,
-                        :nullable =>true,
-                        :indexed =>false,
-                        :precision =>4,
-                        :type_name =>"integer",
-                        :unique =>nil,
-                        :array_of_type =>nil
-                },
-                {
-                        :name =>"name",
-                        :default =>nil,
-                        :primary =>nil,
-                        :scale =>nil,
-                        :sql_type =>12,
-                        :nullable =>true,
-                        :indexed =>false,
-                        :precision =>255,
-                        :type_name =>"character varying",
-                        :unique =>nil,
-                        :array_of_type =>nil
-                }
-        ], @dbh.columns("names").sort_by { |x| x["name"] })
-
-        assert_equal(2, @dbh.columns("names").size) # make sure this works before the search path change
-
-        assert_equal(0, @dbh.columns("tbl").size) # tbl doesn't exist in public
-
-        @dbh.do('SET search_path TO schema1,schema2,"$user",public')
-
-        assert_equal(1, @dbh.columns('tbl').size);
-        assert_equal(
-            [
-                {
-                    :name =>"foo",
-                    :default =>nil,
-                    :primary =>nil,
-                    :scale =>nil,
-                    :sql_type =>4,
-                    :nullable =>true,
-                    :indexed =>false,
-                    :precision =>4,
-                    :type_name =>"integer",
-                    :unique =>nil,
-                    :array_of_type =>nil
-
-                }
-            ],
-            @dbh.columns('tbl')
-        )
-
-    end
-
-  def test_statement_name_uniqueness
-    5000.times do
-      begin
-        @dbh.prepare('SELECT 1').execute()
-        raise DBI::ForcedError
-        sth.finish # never reached
-      rescue DBI::ProgrammingError => e
-        # ERROR:  prepared statement "ruby-dbi:Pg:-604926268" already exists
-        # This should never happen
-        raise e
-      rescue DBI::ForcedError
-        # no-op
-      end
-    end
-  end
-
-  def test_connect_errors
-    dbd = nil
-    ex = assert_raises(DBI::OperationalError) {
-      dbd = DBI::DBD::Pg::Database.new('rubytest:1234', 'jim', nil, {})
-    }
-    ex = assert_raises(DBI::OperationalError) {
-      dbd = DBI::DBD::Pg::Database.new('bad_db_name', 'jim', nil, {})
-    }
-
-    # this corresponds to the test_parse_url_expected_errors test in tc_dbi.rb
-    assert_raises(DBI::InterfaceError) do
-        DBI.connect("dbi:Pg").disconnect
-    end
-
-  ensure
-    dbd.disconnect if dbd
-  end
-
-  def skip_test_type_map
-    dbd = get_dbd
-    def dbd.type_map
-      @type_map
-    end
-    assert dbd.type_map
-    assert_equal 21, dbd.convert("21", 23)
-    assert_equal "21", dbd.convert("21", 1043)
-    assert_equal 21.5, dbd.convert("21.5", 701)
-  end
-
-  def test_simple_command
-    dbd = get_dbd
-    res = dbd.do("INSERT INTO names (name, age) VALUES('Dan', 16)")
-    assert_equal 1, res
-
-    @sth = get_dbi.prepare("SELECT name FROM names WHERE age=16")
-    @sth.execute
-    assert @sth.fetchable?
-    # XXX FIXME This is a bug in the DBD. #rows should equal 1 for select statements.
-    assert_equal 0, @sth.rows
-  ensure
-    dbd.do("DELETE FROM names WHERE age < 20")
-    dbd.disconnect if dbd
-  end
-
-  def test_bad_command
-    dbd = get_dbd
-    assert_raises(DBI::ProgrammingError) {
-      dbd.do("INSERT INTO bad_table (name, age) VALUES('Dave', 12)")
-    }
-  ensure
-    dbd.disconnect if dbd
-  end
-
-  def test_query_single
-    dbd = get_dbi
-    res = dbd.prepare("SELECT name, age FROM names WHERE age=21;")
-    assert res
-    res.execute
-    fields = res.column_info
-    assert_equal 2, fields.length
-    assert_equal 'name', fields[0]['name']
-    assert_equal 'varchar', fields[0]['type_name']
-    assert_equal 'age', fields[1]['name']
-    assert_equal 'int4', fields[1]['type_name']
-
-    row = res.fetch
-
-    assert_equal 'Bob', row[0]
-    assert_equal 21, row[1]
-
-    row = res.fetch
-    assert_nil row
-
-    res.finish
-  ensure
-    dbd.disconnect if dbd
-  end
-
-  def test_query_multi
-    dbd = get_dbd
-    res = dbd.prepare("SELECT name, age FROM names WHERE age > 20;")
-
-    expected_list = ['Jim', 'Bob', 'Charlie']
-    res.execute
-    while row=res.fetch
-      expected = expected_list.shift
-      assert_equal expected, row[0]
-    end
-
-    res.finish
-  ensure
-    dbd.disconnect if dbd
-  end
-
-  def test_tables_call
-      # per bug #1082, views do not show up in tables listing.
-      assert get_dbi.tables.include?("view_names")
-  end
-
-  def get_dbi
-      config = DBDConfig.get_config
-      DBI.connect("dbi:Pg:#{config['postgresql']['dbname']}", config['postgresql']['username'], config['postgresql']['password'])
-  end
-
-  def get_dbd
-      config = DBDConfig.get_config['postgresql']
-      result = DBI::DBD::Pg::Database.new(config['dbname'], config['username'], config['password'], {})
-      result['AutoCommit'] = true
-      result
-  end
-end
-
-# --------------------------------------------------------------------

data/test/dbd/postgresql/up.sql

@@ -1,60 +0,0 @@
-create table names (
-    name varchar(255),
-    age integer
-);
----
-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 OID);
----
-create view view_names as select * from names;
----
-create or replace function test_insert (varchar(255), integer) 
-    returns integer 
-    language sql 
-    as 'insert into names (name, age) values ($1, $2); select age from names where name = $1';
----
-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 type enum_test as ENUM ('one', 'two', 'three');
----
-create table enum_type_test (foo enum_test);
----
-create table db_specific_types_test (foo integer);
----
-create table array_test (foo integer[], bar integer[3], baz integer[3][3], quux varchar[2]);
----
-create table bytea_test (foo bytea);
----
-create schema schema1;
----
-create schema schema2;
----
-create table schema1.tbl (foo integer);
----
-create table schema2.tbl (bar integer);
----
-create or replace function 
-    select_subproperty(value names.age%TYPE, sub names.age%TYPE, out retval names.age%TYPE) 
-    as $$ 
-        select 
-            case 
-            when $2 is not null 
-                then $1 
-            else null 
-        end 
-    $$ language sql;

data/test/dbd/sqlite/base.rb

@@ -1,32 +0,0 @@
-require 'fileutils'
-
-DBDConfig.set_testbase(:sqlite, Class.new(Test::Unit::TestCase) do
-
-        def dbtype
-            "sqlite"
-        end
-
-        def test_base
-            if @dbh # FIXME for some reason, @dbh isn't initialized in some cases. investigate.
-                assert_equal(@dbh.driver_name, "SQLite")
-                assert_kind_of(DBI::DBD::SQLite::Database, @dbh.instance_variable_get(:@handle))
-            end
-        end
-
-        def set_base_dbh
-            config = DBDConfig.get_config['sqlite']
-            @dbh = DBI.connect('dbi:SQLite:'+config['dbname'], nil, nil, { }) 
-        end
-
-        def setup
-            set_base_dbh
-            DBDConfig.inject_sql(@dbh, dbtype, "dbd/sqlite/up.sql")
-        end
-
-        def teardown
-            @dbh.disconnect if @dbh.connected?
-            config = DBDConfig.get_config['sqlite']
-            FileUtils.rm_f(config['dbname'])
-        end
-    end
-)

data/test/dbd/sqlite/test_database.rb

@@ -1,30 +0,0 @@
-class TestSQLiteDatabase < DBDConfig.testbase(:sqlite)
-    def test_database_name
-        assert_nothing_raised do
-            assert_equal DBDConfig.get_config[dbtype]['dbname'], @dbh.database_name
-        end
-    end
-
-    def test_disconnect
-        assert_nil @dbh.disconnect
-        assert_nil @dbh.instance_variable_get("@db")
-    end
-    
-    def test_columns
-        assert_equal [
-            {
-                :name       => "name",
-                :default    => nil,
-                :nullable   => true,
-                :precision  => 255,
-                :type_name  => "varchar"
-            },
-            {
-                :name       => "age",
-                :default    => nil,
-                :nullable   => true,
-                :type_name  => "integer"
-            }
-        ], @dbh.columns("names")  
-    end
-end

data/test/dbd/sqlite/test_driver.rb

@@ -1,68 +0,0 @@
-class TestSQLiteDriver < DBDConfig.testbase(:sqlite)
-    def test_require
-        require 'dbd/SQLite'
-        assert_kind_of Module, DBI
-        assert_kind_of Module, DBI::DBD
-        assert_kind_of Class, DBI::DBD::SQLite
-        assert_kind_of Class, DBI::DBD::SQLite::Driver
-        assert_kind_of Class, DBI::DBD::SQLite::Database
-        assert_kind_of Class, DBI::DBD::SQLite::Statement
-    end
-
-    def test_connect
-        config = DBDConfig.get_config['sqlite']
-
-        # this tests DBI more than SQLite, but makes sure our chain works with it.
-        dbh = DBI.connect("dbi:SQLite:" + config['dbname'], nil, nil, {})
-        assert dbh
-        assert_kind_of DBI::DatabaseHandle, dbh
-
-        # first argument should be a string
-        assert_raises(DBI::InterfaceError) do
-            DBI::DBD::SQLite::Driver.new.connect(nil, nil, nil, { })
-        end
-
-        # that string should have some frackin' length
-        assert_raises(DBI::InterfaceError) do
-            DBI::DBD::SQLite::Driver.new.connect("", nil, nil, { })
-        end
-
-        # last argument should be a hash
-        assert_raises(DBI::InterfaceError) do
-            DBI::DBD::SQLite::Driver.new.connect(config['dbname'], nil, nil, nil)
-        end
-
-        dbh = nil
-        driver = nil
-        assert_nothing_raised do
-            driver = DBI::DBD::SQLite::Driver.new
-            dbh = driver.connect(config['dbname'], nil, nil, { })
-        end
-
-        assert_kind_of DBI::DBD::SQLite::Driver, driver
-        assert_kind_of DBI::DBD::SQLite::Database, dbh
-
-        assert !dbh.instance_variable_get("@autocommit")
-
-        dbh = nil 
-        driver = nil
-        assert_nothing_raised do
-            dbh = DBI::DBD::SQLite::Driver.new.connect(config['dbname'], nil, nil, { "AutoCommit" => true, "sqlite_full_column_names" => true })
-        end
-       
-        assert dbh
-        assert dbh.instance_variable_get("@attr_hash")
-        assert_equal 0, dbh.instance_variable_get("@open_handles")
-        assert_kind_of SQLite::Database, dbh.instance_variable_get("@db")
-
-        assert File.exists?(config['dbname'])
-    end
-
-    def setup
-    end
-
-    def teardown
-        config = DBDConfig.get_config['sqlite']
-        FileUtils.rm_f(config['dbname'])
-    end
-end

data/test/dbd/sqlite/test_statement.rb

@@ -1,112 +0,0 @@
-class TestSQLiteStatement < DBDConfig.testbase(:sqlite)
-    def test_constructor
-        sth = DBI::DBD::SQLite::Statement.new("select * from foo", @dbh.instance_variable_get("@handle"))
-
-        assert_kind_of DBI::DBD::SQLite::Statement, sth
-        assert sth.instance_variable_get("@dbh")
-        assert_kind_of DBI::DBD::SQLite::Database, sth.instance_variable_get("@dbh")
-        assert_equal(@dbh.instance_variable_get("@handle"), sth.instance_variable_get("@dbh"))
-        assert_kind_of DBI::SQL::PreparedStatement, sth.instance_variable_get("@statement")
-        assert_equal({ }, sth.instance_variable_get("@attr"))
-        assert_equal([ ], sth.instance_variable_get("@params"))
-        assert_nil(sth.instance_variable_get("@result_set"))
-        assert_equal([ ], sth.instance_variable_get("@rows"))
-
-        sth = @dbh.prepare("select * from foo")
-
-        assert_kind_of DBI::StatementHandle, sth
-    end
-
-    def test_bind_param
-        sth = DBI::DBD::SQLite::Statement.new("select * from foo", @dbh.instance_variable_get("@handle"))
-
-        assert_raises(DBI::InterfaceError) do
-            sth.bind_param(:foo, "monkeys")
-        end
-
-        # XXX this is fairly ugly, but...
-        # what i've attempted to do here is normalize what is tested, even
-        # though the data differs subtly.  you'll notice that there are two
-        # arrays that get passed to the each block for evaluation.  the first
-        # argument is the statment handle (raw from SQLite DBD or the facade
-        # from DBI), the second is how we access the @params internally held
-        # variable, and the third is how these params are scrubbed before we
-        # assert against them.
-        #
-        # the @params variable is in different spots in both statement handles
-        # and the values of the params are quoted differently. However, the
-        # full pipe works and I'd like to ensure that both do their job as a
-        # team.
-        #
-        [ 
-          [ 
-              sth, 
-              proc { |x| x.instance_variable_get("@params") }, 
-              proc { |x| x } 
-          ],
-          [ 
-              @dbh.prepare("select * from foo"), 
-              proc { |x| x.instance_variable_get("@handle").instance_variable_get("@params") },
-              proc { |x| x.gsub(/(^')|('$)/, '') }
-          ]
-        ].each do |sthpack|
-            sthpack[0].bind_param(1, "monkeys", nil)
-
-            params = sthpack[1].call(sthpack[0])
-            
-            assert_equal "monkeys", sthpack[2].call(params[0])
-
-            # set a bunch of stuff.
-            %w(I like monkeys).each_with_index { |x, i| sthpack[0].bind_param(i+1, x) }
-
-            params = sthpack[1].call(sthpack[0])
-            
-            assert_equal %w(I like monkeys), params.collect { |x| sthpack[2].call(x) }
-
-            # FIXME what to do with attributes? are they important in SQLite?
-        end
-    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.finish
-        end
-
-        assert_nothing_raised do
-            @sth = @dbh.prepare("select * from db_specific_types_test")
-            @sth.execute
-            assert_equal([11111111.111111], @sth.fetch)
-            @sth.finish
-        end
-    end
-end

data/test/dbd/sqlite/up.sql

@@ -1,25 +0,0 @@
-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);

data/test/dbd/sqlite3/base.rb

@@ -1,32 +0,0 @@
-require 'fileutils'
-
-DBDConfig.set_testbase(:sqlite3, Class.new(Test::Unit::TestCase) do
-        def dbtype 
-            "sqlite3"
-        end
-
-        def test_base
-            if @dbh # FIXME for some reason, @dbh isn't initialized in some cases. investigate.
-                assert_equal(@dbh.driver_name, "SQLite3")
-                assert_kind_of(DBI::DBD::SQLite3::Database, @dbh.instance_variable_get(:@handle))
-            end
-        end
-
-        def set_base_dbh
-            config = DBDConfig.get_config['sqlite3']
-            @dbh = DBI.connect('dbi:SQLite3:'+config['dbname'], nil, nil, { }) 
-        end
-
-        def setup
-            set_base_dbh
-            DBDConfig.inject_sql(@dbh, dbtype, "dbd/sqlite3/up.sql")
-        end
-
-        def teardown
-            @sth.finish if(@sth && !@sth.finished?)
-            @dbh.disconnect if @dbh.connected?
-            config = DBDConfig.get_config['sqlite3']
-            FileUtils.rm_f(config['dbname'])
-        end
-    end
-)