ydbi 0.5.0 → 0.5.1

data/test/dbd/sqlite3/test_database.rb

@@ -1,77 +0,0 @@
-class TestDatabase < DBDConfig.testbase(:sqlite3)
-    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,
-                :sql_type  => 100,
-                :precision => 255,
-                :type_name => "varchar"
-            },
-            {
-                :name      => "age",
-                :default   => nil,
-                :nullable  => true,
-                :sql_type  => 4,
-                :type_name => "integer"
-            }
-        ], @dbh.columns("names")
-
-        assert_equal [
-            {
-                :name      => "name",
-                :default   => nil,
-                :nullable  => true,
-                :sql_type  => 100,
-                :precision => 255,
-                :type_name => "varchar"
-            },
-            {
-                :name      => "age",
-                :default   => nil,
-                :nullable  => true,
-                :sql_type  => 4,
-                :type_name => "integer"
-            }
-        ], @dbh.columns("names_defined_with_spaces")
-    end
-    
-    def test_parse_type
-      # Some tests to ensure various whitespace and case styles don't confuse parse_type.
-      
-      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR' )
-      assert_equal 'VARCHAR', match[ 1 ]
-      
-      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR(4096)' )
-      assert_equal 'VARCHAR', match[ 1 ]
-      assert_equal '4096', match[ 3 ]
-      
-      match = DBI::DBD::SQLite3.parse_type( 'varchar(4096)' )
-      assert_equal 'varchar', match[ 1 ]
-      assert_equal '4096', match[ 3 ]
-      
-      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR( 4096 )' )
-      assert_equal 'VARCHAR', match[ 1 ]
-      assert_equal '4096', match[ 3 ]
-      
-      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR ( 4096 )' )
-      assert_equal 'VARCHAR', match[ 1 ]
-      assert_equal '4096', match[ 3 ]
-      
-      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR (4096)' )
-      assert_equal 'VARCHAR', match[ 1 ]
-      assert_equal '4096', match[ 3 ]
-    end
-end

data/test/dbd/sqlite3/test_driver.rb

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

data/test/dbd/sqlite3/test_statement.rb

@@ -1,88 +0,0 @@
-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

@@ -1,33 +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);
----
-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/ts_dbd.rb

@@ -1,131 +0,0 @@
-require 'rubygems'
-gem 'test-unit'
-# figure out what tests to run
-require 'yaml'
-require 'test/unit/testsuite'
-require 'test/unit/ui/console/testrunner'
-
-if File.basename(Dir.pwd) == "test"
-    $:.unshift('../lib')
-else
-    $:.unshift('lib')
-end
-
-module Test::Unit::Assertions
-    def build_message(head, template=nil, *arguments)
-        template += "\n" + "DATABASE: " + dbtype
-        template &&= template.chomp
-        return AssertionMessage.new(head, template, arguments)
-    end
-end
-
-class Class
-    def name=(klass_name)
-        @name = klass_name
-    end
-
-    def name
-        return @name || super
-    end
-end
-
-module DBDConfig
-    @testbase = { }
-    @current_dbtype = nil
-
-    def self.get_config
-        config = nil
-
-        begin
-            config = YAML.load_file(File.join(ENV["HOME"], ".ruby-dbi.test-config.yaml"))
-        rescue Exception => e
-            config = { }
-            config["dbtypes"] = [ ]
-        end
-
-        return config
-    end
-
-    def self.inject_sql(dbh, dbtype, file)
-        # splits by --- in the file, strips newlines and the semicolons.
-        # this way we can still manually import the file, but use it with our
-        # drivers for client-independent injection.
-        File.open(file).read.split(/\n*---\n*/, -1).collect { |x| x.gsub!(/\n/, ''); x.sub(/;\z/, '') }.each do |stmt|
-            tmp = STDERR.dup
-            STDERR.reopen('sql.log', 'a')
-            begin
-                dbh.commit rescue nil
-                dbh["AutoCommit"] = true rescue nil
-                dbh.do(stmt)
-                dbh.commit unless dbtype == 'sqlite3'
-            rescue Exception => e
-                tmp.puts "Error injecting '#{stmt}' for db #{dbtype}"
-                tmp.puts "Error: #{e.message}"
-            end
-            STDERR.reopen(tmp)
-        end
-    end
-
-    def self.current_dbtype
-        @current_dbtype
-    end
-
-    def self.current_dbtype=(setting)
-        @current_dbtype = setting
-    end
-
-    def self.testbase(klass_name)
-        return @testbase[klass_name]
-    end
-
-    def self.set_testbase(klass_name, klass)
-        @testbase[klass_name] = klass
-        klass.name = klass_name.to_s
-    end
-
-    def self.suite
-        @suite ||= []
-    end
-end
-
-if __FILE__ == $0
-    Dir.chdir("..") if File.basename(Dir.pwd) == "test"
-    $LOAD_PATH.unshift(File.join(Dir.pwd, "lib"))
-    Dir.chdir("test") rescue nil
-
-    begin
-        require 'dbi'
-    rescue LoadError => e
-        begin
-            require 'rubygems'
-            gem 'dbi'
-            require 'dbi'
-        rescue LoadError => e
-            abort "DBI must already be installed or must come with this package for tests to work."
-        end
-    end
-
-    Deprecate.set_action(proc { })
-
-    config = DBDConfig.get_config
-
-    config["dbtypes"] = ENV["DBTYPES"].split(/\s+/) if ENV["DBTYPES"]
-
-    if config and config["dbtypes"]
-        config["dbtypes"].each do |dbtype|
-            unless config[dbtype]
-                warn "#{dbtype} is selected for testing but not configured; see test/DBD_TESTS"
-                next
-            end
-
-            # base.rb is special, see DBD_TESTS
-            require "dbd/#{dbtype}/base.rb"
-            Dir["dbd/#{dbtype}/test*.rb"].each { |file| require file }
-            # run the general tests
-            DBDConfig.current_dbtype = dbtype.to_sym
-            Dir["dbd/general/test*.rb"].each { |file| load file; @class.name = file; DBDConfig.suite << @class }
-        end
-    elsif !config["dbtypes"]
-        warn "Please see test/DBD_TESTS for information on configuring DBD tests."
-    end
-end

data/ydbi.gemspec

@@ -1,24 +0,0 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'dbi/version'
-Gem::Specification.new do |gem|
-  gem.name          = 'ydbi'
-  gem.version       = DBI::VERSION
-  gem.authors       = ['Erik Hollensbe', 'Christopher Maujean']
-  gem.email         = 'ruby-dbi-users@rubyforge.org'
-  gem.homepage      = 'http://www.rubyforge.org/projects/ruby-dbi'
-  gem.summary       = 'A vendor independent interface for accessing databases, similar to Perl\'s DBI'
-  gem.description   = 'Branch by ywesee com, as our patches were never accepted by upstream'
-  gem.has_rdoc      = true
-
-  gem.files         = `git ls-files`.split($/)
-  gem.test_file     = 'test/ts_dbi.rb'
-  gem.executables   = ['dbi', 'test_broken_dbi']
-  gem.require_paths = ['lib']
- 
-  gem.add_development_dependency "rake"
-  gem.add_development_dependency "minitest"
-  gem.add_development_dependency "test-unit"
-  gem.add_runtime_dependency 'deprecated', '= 2.0.1'
-end