dbd-sqlite3 1.2.2

data/test/dbd/general/test_types.rb

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

data/test/dbd/sqlite3/base.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+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
+)

data/test/dbd/sqlite3/test_database.rb

@@ -0,0 +1,26 @@
+class TestDatabase < DBDConfig.testbase(:sqlite3)
+    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")  
+    end
+end

data/test/dbd/sqlite3/test_driver.rb

@@ -0,0 +1,67 @@
+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_raise(DBI::InterfaceError) do
+            DBI::DBD::SQLite3::Driver.new.connect(nil, nil, nil, { })
+        end
+
+        # that string should have some frackin' length
+        assert_raise(DBI::InterfaceError) do
+            DBI::DBD::SQLite3::Driver.new.connect("", nil, nil, { })
+        end
+
+        # last argument should be a hash
+        assert_raise(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

@@ -0,0 +1,57 @@
+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_raise(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
+end

data/test/dbd/sqlite3/up.sql

@@ -0,0 +1,23 @@
+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 decimal(2,1));
+---
+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);