dbd-sqlite 0.1

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/sqlite/base.rb

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

@@ -0,0 +1,24 @@
+class TestSQLiteDatabase < DBDConfig.testbase(:sqlite)
+    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

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

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