ydbi 0.5.0

data/test/dbi/tc_row.rb

@@ -0,0 +1,256 @@
+######################################################################
+# tc_row.rb
+#
+# Test case for the DBI::Row class. 
+######################################################################
+$LOAD_PATH.unshift(Dir.pwd)
+$LOAD_PATH.unshift(File.dirname(Dir.pwd))
+$LOAD_PATH.unshift("../../lib")
+$LOAD_PATH.unshift("../../lib/dbi")
+$LOAD_PATH.unshift("lib")
+
+require 'test/unit'
+require 'dbi'
+
+class TC_DBI_Row < Test::Unit::TestCase
+   def setup
+      @data = %w/Daniel Berger 36/
+      @cols = %w/first last age/
+      @coltypes = [DBI::Type::Varchar, DBI::Type::Varchar, DBI::Type::Integer]
+      @row  = DBI::Row.new(@cols, @coltypes, @data.clone)
+      @row_noconv = DBI::Row.new(@cols, @coltypes, @data.clone, false) 
+   end
+
+   def teardown
+      @data = nil
+      @cols = nil
+      @row  = nil
+   end
+
+   def test_row_multiassign # this should only be an issue in 1.8.7 and up, if at all.
+       first, last, age = @row
+       assert_equal("Daniel", first)
+       assert_equal("Berger", last)
+       assert_equal(36, age)
+   end
+
+   def test_row_noconv
+       assert_nothing_raised do
+           assert_equal(
+               [
+                   'Daniel',
+                   'Berger',
+                   36
+               ], @row
+           )
+           assert_equal(@data, @row_noconv)
+       end
+   end
+   
+   # Ensure that constructor only allows Integers or Arrays (or nil)
+   def test_row_constructor
+      assert_nothing_raised{ DBI::Row.new(@cols, @coltypes) }
+      assert_nothing_raised{ DBI::Row.new(@cols, @coltypes, 1) }
+      assert_nothing_raised{ DBI::Row.new(@cols, @coltypes, nil) }
+      assert_nothing_raised{ DBI::Row.new(@cols, @coltypes, [1,2,3])}
+      assert_raises(ArgumentError){ DBI::Row.new }
+      assert_raises(ArgumentError){ DBI::Row.new(@cols) }
+      assert_raises(TypeError){ DBI::Row.new(@cols, @coltypes, {}) }
+   end
+
+   # Test added to ensure that Row#at is equivalent to Row#by_index.  When the
+   # latter method is (hopefully) removed, this test can be removed as well.
+   def test_at
+      assert_respond_to(@row, :at)
+      assert_equal(@data[0].to_s, @row.at(0).to_s)
+      assert_equal(@data[1].to_s, @row.at(1).to_s)
+      assert_equal(@data[2].to_s, @row.at(2).to_s)
+      assert_equal(@data[99].to_s, @row.at(99).to_s)
+   end
+   
+   # Should respond to Array and Enumerable methods
+   def test_row_delegate
+      assert_respond_to(@row, :length)
+      assert_respond_to(@row, :each)
+      assert_respond_to(@row, :grep)
+   end
+   
+   def test_row_length
+      assert_equal(3, @row.length)
+      assert_equal(3, DBI::Row.new(@cols, @coltypes).length)
+   end
+
+   def test_row_data_by_index
+      assert_equal(@data[0], @row.by_index(0))
+      assert_equal(@data[1], @row.by_index(1))
+      assert_equal(@data[2], @row.by_index(2).to_s)
+      assert_nil(@row.by_index(3))
+   end
+   
+   def test_row_data_by_field
+      assert_equal @data[0], @row.by_field('first')
+      assert_equal @data[1], @row.by_field('last')
+      assert_equal @data[2], @row.by_field('age').to_s
+      assert_equal nil, @row.by_field('unknown')
+   end
+   
+   def test_row_set_values
+      assert_respond_to(@row, :set_values)
+      assert_nothing_raised{ @row.set_values(["John", "Doe", 23]) }
+      assert_equal("John", @row.by_index(0))
+      assert_equal("Doe", @row.by_index(1))
+      assert_equal(23, @row.by_index(2))
+   end
+   
+   def test_row_to_h
+      assert_respond_to(@row, :to_h)
+      assert_nothing_raised{ @row.to_h }
+      assert_kind_of(Hash, @row.to_h)
+      assert_equal({"first"=>"Daniel", "last"=>"Berger", "age"=>36}, @row.to_h)
+   end
+   
+   def test_row_column_names
+      assert_respond_to(@row, :column_names)
+      assert_nothing_raised{ @row.column_names }
+      assert_kind_of(Array, @row.column_names)
+      assert_equal(["first", "last", "age"], @row.column_names)
+   end
+
+   # An alias for column_names
+   def test_row_field_names
+      assert_respond_to(@row, :column_names)
+      assert_nothing_raised{ @row.column_names }
+      assert_kind_of(Array, @row.column_names)
+      assert_equal(["first", "last", "age"], @row.column_names)
+   end
+   
+   def test_indexing_numeric
+      assert_equal(@data[0], @row[0])   
+      assert_equal(@data[1], @row[1])  
+      assert_equal(@data[2], @row[2].to_s)      
+   end
+   
+   def test_indexing_string_or_symbol
+      assert_equal(@data[0], @row['first'])
+      assert_equal(@data[0], @row[:first])
+      assert_equal(@data[1], @row['last'])
+      assert_equal(@data[2], @row['age'].to_s)
+      assert_equal(nil, @row['unknown'])
+   end
+   
+   def test_indexing_regexp
+      assert_equal(["Daniel"], @row[/first/])
+      assert_equal(["Berger"], @row[/last/])
+      assert_equal([36], @row[/age/])
+      assert_equal(["Daniel", "Berger"], @row[/first|last/])
+      assert_equal([], @row[/bogus/])
+   end
+
+   def test_indexing_array
+      assert_equal(["Daniel"], @row[[0]])
+      assert_equal(["Daniel"], @row[["first"]])
+      assert_equal(["Berger"], @row[[1]])
+      assert_equal([36], @row[[2]])
+      assert_equal([nil], @row[[3]])
+      assert_equal(["Daniel", 36], @row[[0,2]])
+      assert_equal(["Daniel", 36], @row[[0,:age]])
+   end
+
+   def test_indexing_range
+      assert_equal(["Daniel","Berger"], @row[0..1])
+      assert_equal(["Berger",36], @row[1..2])
+      assert_equal(["Berger",36], @row[1..99])
+      assert_equal(nil, @row[90..100])
+   end
+
+   # The two argument reference should behave like the second form of Array#[]
+   def test_indexing_two_args
+      assert_equal([], @row[0,0])
+      assert_equal(["Daniel"], @row[0,1])
+      assert_equal(["Daniel", "Berger"], @row[0,2])
+      assert_equal(["Daniel", "Berger", 36], @row[0,3])
+      assert_equal(["Daniel", "Berger", 36], @row[0,99])
+   end
+
+   def test_indexing_multiple_args
+      assert_equal(["Berger", 36, "Daniel"], @row[:last, :age, :first])
+      assert_equal(["Berger", 36, "Daniel"], @row[1, :age, :first])
+      assert_equal(["Berger", 36, "Daniel"], @row[1, 2, :first])
+      assert_equal(["Berger", 36, "Daniel"], @row[1, 2, 0])
+      assert_equal(["Berger", 36, "Daniel", nil], @row[1, 2, 0, 9])
+      assert_equal(["Berger", 36, "Daniel", nil], @row[1, 2, 0, :bogus])
+   end
+
+   def test_indexing_assignment
+      assert_nothing_raised{ @row[0] = "kirk" }
+      assert_equal("kirk", @row[0])
+
+      assert_nothing_raised{ @row[:age] = 29 }
+      assert_equal(29, @row[:age])
+
+      assert_nothing_raised{ @row[1,2] = "francis" }
+      assert_equal("francis", @row[:last])
+      assert_nil(@row[:age])
+   end
+
+   def test_clone_with
+      another_row = @row.clone_with(["Jane", "Smith", 33])
+      assert_kind_of(DBI::Row, another_row)
+      assert_equal "Jane", another_row.by_index(0)
+      assert_equal "Smith", another_row.by_index(1)
+      assert_equal 33, another_row.by_index(2)
+      assert(@row != another_row)
+   end
+
+   def test_iteration
+      expect = @data.clone
+      @row.each { |value|
+         assert_equal(expect.shift, value.to_s)
+      }
+      assert_equal([], expect)
+      @row.collect { |value| "Field=#{value}" }
+   end
+
+   def test_row_each_with_name
+      assert_respond_to(@row, :each_with_name)
+      assert_nothing_raised{ @row.each_with_name{ } }
+
+      @row.each_with_name{ |value, column|
+         assert(@cols.include?(column))
+         assert(@data.include?(value.to_s))
+      }
+   end
+
+   def test_to_a
+      assert_respond_to(@row, :to_a)
+      assert_equal(@data, DBI::Row.new(@cols, @coltypes, @data).to_a.collect { |x| x.to_s })
+   end
+
+   def test_dup_clone
+      dupped = nil
+      cloned = nil
+
+      assert_nothing_raised{ dupped = @row.dup }
+      assert_nothing_raised{ cloned = @row.clone }
+      assert_nothing_raised{ @row.set_values(["Bill", "Jones", 16])}
+
+      assert_equal(@data, dupped.to_a.collect { |x| x.to_s })
+      assert_equal(@data, cloned.to_a.collect { |x| x.to_s })
+
+      assert(dupped.object_id != @row.object_id)
+      assert(cloned.object_id != @row.object_id)
+   end
+
+   def test_dup_ruby18
+      res = []
+      r = DBI::Row.new(["col1","col2"],[nil,nil])
+
+      [["one",1],["two",2],["three",3]].each do |x,y|
+         r["col1"] = x
+         r["col2"] = y
+         res << r.dup
+      end
+
+      assert_equal res, [["one", 1], ["two", 2], ["three", 3]]
+   end
+end

data/test/dbi/tc_sqlbind.rb

@@ -0,0 +1,168 @@
+$: << 'lib'
+require 'test/unit'
+require "dbi/sql"
+
+# ====================================================================
+class TestSqlBind < Test::Unit::TestCase
+
+  def bind(quoter, sql, args)
+      ps = DBI::SQL::PreparedStatement.new(quoter, sql)
+      ps.bind(DBI::Utils::ConvParam.conv_param('default', *args))
+  end
+
+  def test_one
+    assert_equal "10", bind(self, "?", [10])
+    assert_equal "'hi'", bind(self, "?", ["hi"])
+    assert_equal "I 'don''t' know", bind(self, "I ? know", ["don't"])
+  end
+
+  def test_many
+    assert_equal "WHERE age=12 AND name='Jim'",
+      bind(self, "WHERE age=? AND name=?", [12, 'Jim'])
+  end
+
+  def test_too_many
+    assert_raises (RuntimeError) {
+      bind(self, "age=?", [10, 11])
+    }
+  end
+
+  def test_too_few
+    assert_raises (RuntimeError) {
+      bind(self, "age in (?, ?, ?)", [10, 11])
+    }
+  end
+
+  def test_embedded_questions
+    assert_equal "10 ? 11", bind(self, "? ?? ?", [10, 11])
+    assert_equal "????", bind(self, "????????", [])
+  end
+
+  def test_questions_in_param
+    assert_equal "WHERE c='connected?'",
+      bind(self, "WHERE c=?", ["connected?"])
+
+    assert_equal "WHERE c='connected?' AND d='???'",
+      bind(self, "WHERE c=? AND d=?", ["connected?", "???"])
+  end
+
+  def test_questions_in_quotes
+    assert_equal "WHERE c='connected?' AND d=10",
+      bind(self, "WHERE c='connected?' AND d=?", [10])
+  end
+
+  def test_comment_dan
+    sql = %{--Dan's query\n--random comment\nselect column1, column2\nfrom table1\nwhere somevalue = ?}
+    res = %{--Dan's query\n--random comment\nselect column1, column2\nfrom table1\nwhere somevalue = 10}
+    assert_equal res, bind(self, sql, [10])
+  end
+
+  def test_minus_bug
+    sql = "SELECT 1 - 3"
+    res = "SELECT 1 - 3"
+    assert_equal res, bind(self, sql, []) 
+  end
+
+  def test_minus2
+    sql = "SELECT * from test --Dan's query" 
+    assert_equal sql, bind(self, sql, []) 
+  end
+
+  def test_slash
+    sql = "SELECT 5 / 4"
+    res = "SELECT 5 / 4"
+    assert_equal res, bind(self, sql, []) 
+  end
+
+  def test_much
+    sql = <<ENDSQL
+SELECT s.id, cwajga_magic_number((cwajga_product(r.rating) ^ (1 / 1)), MAX(lastplay.lastheard), 5) as magic
+INTO TEMP magic_order
+FROM song AS s LEFT OUTER JOIN rating AS r ON s.id = r.song LEFT OUTER JOIN last play ON lastplay.song = s.id
+WHERE r.name ILIKE 'omega697'
+GROUP BY s.id;
+
+SELECT SUM(magic) as total INTO TEMP magic_tot FROM magic_order;
+
+SELECT id, 100.0*magic/total as percent
+FROM magic_order, magic_tot
+order by percent;
+ENDSQL
+    res = sql
+    assert_equal res, bind(self, sql, [])
+  end
+
+  def test_nested_insert
+    sql = "insert into logins (user_id, hostmask) values ((select id from users where username = ?), ?)"
+    res = sql.sub(/\?/, "1")
+    res.sub!(/\?/, "'foo@bar'")
+    assert_equal res, bind(self, sql, [1, "foo@bar"])
+  end
+
+end
+
+######################################################################
+class TestLex < Test::Unit::TestCase
+
+    def tokens(sql)
+        DBI::SQL::PreparedStatement.tokens(sql)
+    end
+
+  def test_non_strings
+    assert_equal ['This is _a t35t'],
+      tokens("This is _a t35t")
+  end
+
+  def test_simple_strings
+    assert_equal ["hi ", "'hello world'"],
+      tokens("hi 'hello world'")
+    assert_equal ["c = ", "''"],
+      tokens("c = ''")
+  end
+
+  def test_strings_with_quotes
+    assert_equal ["hi ", "'''lo world'"],
+      tokens("hi '''lo world'")
+    assert_equal ['a', "''''", 'b'],
+      tokens("a''''b")
+  end
+
+  def test_strings_with_escaped_quotes
+    assert_equal ["hi ", "'don\\'t do that'"],
+      tokens("hi 'don\\'t do that'")
+    assert_equal ['a', "'\\''", 'b'],
+      tokens("a'\\''b")
+  end
+
+  def test_simple_dq_strings
+    assert_equal ["hi ", '"hello world"'],
+      tokens('hi "hello world"')
+    assert_equal ["c = ", '""'],
+      tokens('c = ""')
+  end
+
+  def test_dq_strings_with_quotes
+    assert_equal ["hi ", '"""lo world"'],
+      tokens('hi """lo world"')
+    assert_equal ['a', '""""', 'b'],
+      tokens('a""""b')
+  end
+
+  def test_dq_strings_with_escaped_quotes
+    assert_equal ["hi ", '"don\"t do that"'],
+      tokens('hi "don\"t do that"')
+    assert_equal ['a', '"\""', 'b'],
+      tokens('a"\""b')
+  end
+
+  def test_qmarks
+    assert_equal ["a = ", "?"],
+      tokens("a = ?")
+    assert_equal ["'?'", " = ", "?"],
+      tokens("'?' = ?")
+    assert_equal ["'?'", " = ", "??"],
+      tokens("'?' = ??")
+  end
+
+end
+

data/test/dbi/tc_statementhandle.rb

@@ -0,0 +1,29 @@
+$: << 'lib'
+require 'test/unit'
+require 'dbi'
+
+class TC_DBI_StatementHandle < Test::Unit::TestCase
+    def test_fetch
+        mock_handle = 'any_object'
+        def mock_handle.cancel; end
+        def mock_handle.column_info; {}; end
+        def mock_handle.fetch; nil; end
+        sth = DBI::StatementHandle.new( mock_handle, true, true, false, true)
+        
+        10.times do
+            assert_nil sth.fetch
+        end
+
+        sth.raise_error = true
+
+        assert_raises(DBI::InterfaceError) do
+            sth.fetch
+        end
+
+        sth.raise_error = false
+
+        10.times do
+            assert_nil sth.fetch
+        end
+    end
+end