rdbi 0.9.1 → 1.1.0

data/lib/rdbi/types.rb

@@ -94,6 +94,8 @@ module RDBI::Type
           true
         when /^(f(alse)?|0)$/i
           false
+        else
+          nil
       end
     }
   end

data/rdbi.gemspec

@@ -14,14 +14,12 @@ Gem::Specification.new do |s|
   s.email = %q{erik@hollensbe.org}
   s.extra_rdoc_files = [
     "LICENSE",
-    "README.rdoc"
+    "README.txt"
   ]
   s.files = [
-    ".document",
     "LICENSE",
-    "README.rdoc",
+    "README.txt",
     "Rakefile",
-    "VERSION",
     "docs/external-api.pdf",
     "docs/external-api.texi",
     "lib/rdbi.rb",

data/test/helper.rb

@@ -1,6 +1,5 @@
 require 'rubygems'
 gem 'rdbi-driver-mock'
-gem 'test-unit'
 require 'test/unit'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
@@ -8,6 +7,35 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'rdbi'
 require 'rdbi/driver/mock'
 
+# -- Fake an exceptional statement handle
+module FaultyDB
+  class Error < Exception; end
+end
+
+module RDBI
+  class Driver
+    class MockFaulty < RDBI::Driver
+      def initialize(*args)
+        super(MockFaulty::Database, *args)
+      end
+    end
+
+    class MockFaulty::Database < Mock::DBH
+      def new_statement(query)
+        MockFaulty::Statement.new(query, self)
+      end
+    end
+
+    class MockFaulty::Statement < Mock::STH
+      def execute(*binds)
+        raise ::FaultyDB::Error.new('Deadlocked, de-synchronized, corrupted, invalid, etc.')
+      end
+      alias :execute_modification :execute
+    end
+  end
+end
+
+
 class Test::Unit::TestCase
   def mock_connect
     RDBI.connect(:Mock, :username => 'foo', :password => 'bar')

data/test/test_database.rb

@@ -5,6 +5,10 @@ class TestDatabase < Test::Unit::TestCase
     @dbh = mock_connect
   end
 
+  def teardown
+    @dbh.disconnect
+  end
+
   def assert_transaction(count)
     in_transaction = @dbh.instance_variable_get("@in_transaction") ||
       @dbh.instance_variable_get(:@in_transaction)
@@ -38,7 +42,7 @@ class TestDatabase < Test::Unit::TestCase
       raise StandardError, "should call rollback"
     end
 
-    assert_raises(StandardError.new("should call rollback")) do
+    assert_raises(StandardError) do
       @dbh.transaction do |dbh|
         assert_transaction(1)
         true
@@ -52,7 +56,7 @@ class TestDatabase < Test::Unit::TestCase
 
     @dbh.next_action = proc { |*args| true }
 
-    assert_raises(StandardError.new("should call rollback")) do
+    assert_raises(StandardError) do
       @dbh.transaction do |dbh|
         assert_transaction(1)
 
@@ -206,20 +210,52 @@ class TestDatabase < Test::Unit::TestCase
     my_sth = nil
     my_res = nil
 
+    # ordinary execution
     @dbh.prepare("some statement") do |sth|
       assert(sth)
       assert_respond_to(sth, :execute)
       res = sth.execute
       assert(res)
       my_sth = sth
+      assert(! my_sth.finished?)
     end
 
     assert(my_sth.finished?)
 
-    @dbh.execute("some statement") do |res|
-      assert(res)
-      assert_kind_of(RDBI::Result, res)
+    # and exceptional
+    begin
+      @dbh.prepare("some statement") do |sth|
+        assert(sth)
+        assert_respond_to(sth, :execute)
+        res = sth.execute
+        assert(res)
+        my_sth = sth
+        assert(! my_sth.finished?)
+        raise "Blam!"
+      end
+    rescue
     end
+
+    assert(my_sth.finished?)
+
+    # Database#execute &block
+
+    my_res = nil
+    block_ret = @dbh.execute("some statement") do |res|
+                  my_res = res
+                  assert(res)
+                  assert_kind_of(RDBI::Result, res)
+                  "BLOCK RETURN"
+                end
+
+    assert_kind_of(RDBI::Result, my_res)
+    # Result#finish implies Statement#finish, nil'ing
+    assert(my_res.sth.nil?,
+           'Database#execute &p did not finish its Result')
+    assert(!block_ret.kind_of?(RDBI::Result),
+           'Database#execute &block wrongly returned its Result')
+    assert_equal("BLOCK RETURN", block_ret,
+                 "Database#execute &block didn't return the return value of &block")
   end
 
   def test_09_statement_allocation
@@ -239,9 +275,62 @@ class TestDatabase < Test::Unit::TestCase
     @dbh.disconnect
   end
 
-  def teardown
+  def test_10_execute_finish
+    @dbh.execute("SELECT 1") do |res|
+      # noop
+    end
+    assert(@dbh.last_statement.finished?,
+           "#execute() block did not finish implicit sth")
+
+    res = @dbh.execute("SELECT 2")
+    assert(!@dbh.last_statement.finished?,
+           "#execute() unexpectedly finished implicit sth")
+    assert_nothing_raised do
+      res.finish
+      @dbh.disconnect
+    end
+
+    @dbh = RDBI.connect(:MockFaulty, :user => 'u', :pass => 'p')
+    assert_raises(FaultyDB::Error) do
+      @dbh.execute("ignored") do |not_reached|
+        assert(false, "A block not supposed to be reached was executed")
+      end
+    end
+    assert(@dbh.last_statement.finished?,
+           "Failed execute() &block did not finish statement")
+
+    assert_raises(FaultyDB::Error) do
+      res = @dbh.execute("ignored")
+      res.finish # Not reached
+    end
+    assert(@dbh.last_statement.finished?,
+           "Failed execute() did not finish statement")
+  end
+
+  def test_11_execute_mod_finish
+    @dbh.execute_modification("DROP SCHEMA INFORMATION_SCHEMA")
+    assert(@dbh.last_statement.finished?,
+           "#execute_modification() did not finish implicit sth")
+
+    a = nil
+    @dbh.execute_modification("IGNORED!") do |*blah|
+      a = "Not nil - but this block is not executed"
+    end
+
+    assert(a.nil?, "#execute_modification() invoked a block unexpectedly")
+    assert(@dbh.last_statement.finished?,
+           "#execute_modification() &ignored_block did not finish implicit sth")
+
     @dbh.disconnect
+
+    @dbh = RDBI.connect(:MockFaulty, :user => 'u', :pass => 'p')
+    assert_raises(FaultyDB::Error) do
+      count = @dbh.execute_modification("ignored")
+    end
+    assert(@dbh.last_statement.finished?,
+           "Failed execute_modification() did not finish statement")
   end
+
 end
 
 # vim: syntax=ruby ts=2 et sw=2 sts=2

data/test/test_pool.rb

@@ -20,7 +20,7 @@ class TestPool < Test::Unit::TestCase
 
   def test_03_pooling!
     pool = create_pool(:test_03)
-    assert_raise(ArgumentError.new("too many handles in this pool (max: 5)")) do
+    assert_raise(ArgumentError) do
       6.times do
         RDBI::Pool[:test_03].add_connection
       end
@@ -160,7 +160,7 @@ class TestPool < Test::Unit::TestCase
       assert_kind_of(RDBI::Pool, pool)
     end
 
-    assert(10, count)
+    assert_equal(10, count)
     assert_respond_to(RDBI::Pool, :map)
 
     pool = create_pool(:test_08)
@@ -182,6 +182,15 @@ class TestPool < Test::Unit::TestCase
 
     assert_respond_to(pool, :map)
   end
+
+  def test_09_alternative_connect_syntax
+    pool = RDBI::Pool.new("connections!", { :driver => :Mock, :database => ":memory:", :username => "foo" })
+    dbh = pool.get_dbh
+    assert(dbh)
+    assert_kind_of(RDBI::Database, dbh)
+
+    assert_equal([:Mock, { :database => ":memory:", :username =>  "foo" }], pool.instance_variable_get(:@connect_args))
+  end
 end
 
 # vim: syntax=ruby ts=2 et sw=2 sts=2

data/test/test_rdbi.rb

@@ -16,7 +16,7 @@ class TestRDBI < Test::Unit::TestCase
 
     assert_raise(ArgumentError) { RDBI.connect(1, :user => :blah) }
 
-    assert_nothing_raised { dbh = RDBI.connect(:Mock) }
+    assert_raise(ArgumentError) { dbh = RDBI.connect(:Mock) }
   end
 
   def test_02_last_dbh
@@ -63,6 +63,59 @@ class TestRDBI < Test::Unit::TestCase
     dbh = RDBI.connect_cached(:Mock, :username => :foo, :pool_name => :test_05)
     assert_equal(RDBI.pool(:test_05).handles[0], dbh)
   end
+
+  def test_06_connect_block
+    my_dbh = nil
+
+    # Ordinary operation
+    RDBI.connect(:Mock, :username => :foo, :password => :bar) do |dbh|
+      assert(dbh)
+      assert_kind_of(RDBI::Database, dbh)
+      my_dbh = dbh
+      assert(my_dbh.connected?)
+    end
+    assert(! my_dbh.connected?)
+
+    # and exceptional operation
+    begin
+      RDBI.connect(:Mock, :username => :foo, :password => :bar) do |dbh|
+        assert(dbh)
+        assert_kind_of(RDBI::Database, dbh)
+        my_dbh = dbh
+        assert(my_dbh.connected?)
+        raise "Blam!"
+      end
+    rescue
+    end
+    assert(! my_dbh.connected?)
+  end
+
+  def test_07_connect_cached_block
+    conn_args = [:Mock, {:username => :foo, :password => :bar}]
+    my_dbh = nil
+
+    # Ordinary operation
+    RDBI.connect_cached(*conn_args) do |dbh|
+      assert(dbh)
+      assert_kind_of(RDBI::Database, dbh)
+      my_dbh = dbh
+      assert(my_dbh.connected?)
+    end
+    assert(my_dbh.connected?)
+
+    # and exceptional operation
+    begin
+      RDBI.connect_cached(*conn_args) do |dbh|
+        assert(dbh)
+        assert_kind_of(RDBI::Database, dbh)
+        my_dbh = dbh
+        assert(my_dbh.connected?)
+        raise "Blam!"
+      end
+    rescue
+    end
+    assert(my_dbh.connected?)
+  end
 end
 
 # vim: syntax=ruby ts=2 et sw=2 sts=2

data/test/test_result.rb

@@ -15,21 +15,34 @@ class TestResult < Test::Unit::TestCase
   
   def mock_result
     names = [:zero, :one, :two]
-    res = RDBI::Result.new(@dbh.prepare("foo"), [1], generate_data, RDBI::Schema.new((0..2).to_a.map { |x| RDBI::Column.new(names[x], :integer, :default) }), { :default => RDBI::Type.filterlist() })
+    res = RDBI::Result.new(
+      @dbh.prepare("foo"), 
+      [1], 
+      generate_data, 
+      RDBI::Schema.new((0..2).to_a.map { |x| RDBI::Column.new(names[x], :integer, :default) }), 
+      { :default => RDBI::Type.filterlist() }
+    )
   end
 
   def mock_empty_result
     names = [:zero, :one, :two]
-    res = RDBI::Result.new(@dbh.prepare("foo"), [1], RDBI::Driver::Mock::Cursor.new([]), RDBI::Schema.new((0..2).to_a.map { |x| RDBI::Column.new(names[x], :integer, :default) }), { :default => RDBI::Type.filterlist() })
+    res = RDBI::Result.new(
+      @dbh.prepare("foo"), 
+      [1], 
+      RDBI::Driver::Mock::Cursor.new([]), 
+      RDBI::Schema.new((0..2).to_a.map { |x| RDBI::Column.new(names[x], :integer, :default) }), 
+      { :default => RDBI::Type.filterlist() }
+    )
   end
 
   def get_index(res)
-    get_guts(get_guts(res)[:data])[:index]
+    cursor = get_guts(res)[:data]
+    cursor.instance_variable_get("@index") || res.instance_variable_get(:@index)
   end
 
   def get_guts(res)
     h = { }
-    %W[index schema binds sth data].collect(&:to_sym).each do |sym|
+    %W[schema binds sth data].collect(&:to_sym).each do |sym|
       h[sym] = res.instance_variable_get("@#{sym}") || res.instance_variable_get("@#{sym}".to_sym)
     end
 
@@ -76,10 +89,9 @@ class TestResult < Test::Unit::TestCase
       as
       fetch
       read
-      raw_fetch
-      finish 
+      finish
     ].collect(&:to_sym).each do |sym|
-      assert_respond_to(res, sym)
+      assert_respond_to(res, sym, "#{res.class} did not respond to :#{sym}")
     end
 
     res.sth.finish
@@ -299,6 +311,116 @@ class TestResult < Test::Unit::TestCase
     assert_equal({:zero=>-1, :one=>0, :two=>1}, YAML.load(res.as(:YAML).first))
     assert_equal({:zero=>8, :one=>9, :two=>10}, YAML.load(res.as(:YAML).last))
   end
+
+  def test_13_enumerable_as
+    # 'master' dab6270 branch (0.9.1+) returned a Result::Driver for as()
+
+    res = mock_result
+
+    i = -1
+    # Mock result set is:
+    #
+    #   ZERO  ONE  TWO
+    #   ====  ===  ===
+    #    -1    0    1
+    #     0    1    2
+    #     1    2    3
+    #         ...
+    #     8    9   10
+    #
+    res.as(:Struct).each do |row|
+      assert_kind_of(::Struct, row)
+      assert_equal([i, i+1, i+2], [row.zero, row.one, row.two])
+      i += 1
+    end
+    res.sth.finish
+  end
+
+  def test_14_results_driven_struct
+    # 'master' dab6270 branch (0.9.1+) returned 'raw' rows for #each,
+    # #first and #last
+
+    res = mock_result
+
+    res.as(:Struct)
+    row = res.first # does not advance underlying index
+    assert_kind_of(::Struct, row)
+    assert_equal([-1, 0, 1], [row.zero, row.one, row.two])
+
+    res.each do |r|
+      assert_kind_of(::Struct, r)
+      assert_equal([-1, 0, 1], [r.zero, r.one, r.two])
+      break # Just one row, thank you
+    end
+
+    row = res.last
+    assert_kind_of(::Struct, row)
+    assert_equal([8, 9, 10], [row.zero, row.one, row.two])
+
+    res.sth.finish
+  end
+
+  def test_15_results_driven_csv
+    # 'master' 20917a3 branch (pilcrow/result-as) didn't handle
+    # eof properly for result drivers that didn't return sets of
+    # rows as an array of rows
+
+    res = mock_result
+
+    res.as(:CSV)
+    row = res.first # does not advance underlying index
+    assert_equal("-1,0,1\n", row)
+
+    res.each do |r|
+      assert_equal("-1,0,1\n", r)
+      break # Just one row, thank you
+    end
+
+    row = res.last
+    assert_equal("8,9,10\n", row)
+
+    res.sth.finish
+  end
+
+  def test_16_results_driven_yaml
+    # As for test_15, but with YAML
+    # 'master' 20917a3 branch (pilcrow/result-as) didn't handle
+    # eof properly for result drivers that didn't return sets of
+    # rows as an array of rows
+
+    res = mock_result
+
+    res.as(:YAML)
+    row = res.first # does not advance underlying index
+    assert_equal({:zero=>-1, :one=>0, :two=>1}, YAML.load(row))
+
+    res.each do |r|
+      assert_equal({:zero=>-1, :one=>0, :two=>1}, YAML.load(r))
+      break # Just one row, thank you
+    end
+
+    row = res.last
+    assert_equal({:zero=>8, :one=>9, :two=>10}, YAML.load(row))
+
+    res.sth.finish
+  end
+
+  def test_17_results_as_empty
+    [:Array, :Struct, :YAML, :CSV].each do |rd|
+      res = mock_empty_result
+      res.as(rd).each do |not_reached|
+        assert(false, "each block unexpectedly reached during :#{rd} test")
+      end
+      res.sth.finish
+
+      res = mock_empty_result
+      res.as(rd)
+      assert_nil(res.first, "#first was not nil on empty result set")
+      assert_nil(res.last, "#last was not nil on empty result set")
+      res.sth.finish
+    end
+  end
+
 end
 
 # vim: syntax=ruby ts=2 et sw=2 sts=2