dawanda-sqlite3 1.3.3

data/test/test_integration_open_close.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+class TC_OpenClose < Test::Unit::TestCase
+  def test_create_close
+    begin
+      db = SQLite3::Database.new( "test-create.db" )
+      assert File.exist?( "test-create.db" )
+      assert_nothing_raised { db.close }
+    ensure
+      File.delete( "test-create.db" ) rescue nil
+    end
+  end
+
+  def test_open_close
+    begin
+      File.open( "test-open.db", "w" ) { |f| }
+      assert File.exist?( "test-open.db" )
+      db = SQLite3::Database.new( "test-open.db" )
+      assert_nothing_raised { db.close }
+    ensure
+      File.delete( "test-open.db" ) rescue nil
+    end
+  end
+
+  def test_bad_open
+    assert_raise( SQLite3::CantOpenException ) do
+      SQLite3::Database.new( "." )
+    end
+  end
+end

data/test/test_integration_pending.rb

@@ -0,0 +1,115 @@
+require 'helper'
+
+require 'thread'
+require 'benchmark'
+
+class TC_Integration_Pending < Test::Unit::TestCase
+  def setup
+    @db = SQLite3::Database.new("test.db")
+    @db.transaction do
+      @db.execute "create table foo ( a integer primary key, b text )"
+      @db.execute "insert into foo ( b ) values ( 'foo' )"
+      @db.execute "insert into foo ( b ) values ( 'bar' )"
+      @db.execute "insert into foo ( b ) values ( 'baz' )"
+    end
+  end
+
+  def teardown
+    @db.close
+    File.delete( "test.db" )
+  end
+
+  def test_busy_handler_outwait
+    skip("not working in 1.9") if RUBY_VERSION >= '1.9'
+
+    busy = Mutex.new
+    busy.lock
+    handler_call_count = 0
+
+    t = Thread.new(busy) do |locker|
+      begin
+        db2 = SQLite3::Database.open( "test.db" )
+        db2.transaction( :exclusive ) do
+          locker.lock
+        end
+      ensure
+        db2.close if db2
+      end
+    end
+
+    @db.busy_handler do |data,count|
+      handler_call_count += 1
+      busy.unlock
+      true
+    end
+
+    assert_nothing_raised do
+      @db.execute "insert into foo (b) values ( 'from 2' )"
+    end
+
+    t.join
+
+    assert_equal 1, handler_call_count
+  end
+
+  def test_busy_handler_impatient
+    busy = Mutex.new
+    busy.lock
+    handler_call_count = 0
+
+    t = Thread.new do
+      begin
+        db2 = SQLite3::Database.open( "test.db" )
+        db2.transaction( :exclusive ) do
+          busy.lock
+        end
+      ensure
+        db2.close if db2
+      end
+    end
+    sleep 1
+
+    @db.busy_handler do |count|
+      handler_call_count += 1
+      false
+    end
+
+    assert_raise( SQLite3::BusyException ) do
+      @db.execute "insert into foo (b) values ( 'from 2' )"
+    end
+
+    busy.unlock
+    t.join
+
+    assert_equal 1, handler_call_count
+  end
+
+  def test_busy_timeout
+    @db.busy_timeout 1000
+    busy = Mutex.new
+    busy.lock
+
+    t = Thread.new do
+      begin
+        db2 = SQLite3::Database.open( "test.db" )
+        db2.transaction( :exclusive ) do
+          busy.lock
+        end
+      ensure
+        db2.close if db2
+      end
+    end
+
+    sleep 1
+    time = Benchmark.measure do
+      assert_raise( SQLite3::BusyException ) do
+        @db.execute "insert into foo (b) values ( 'from 2' )"
+      end
+    end
+
+    busy.unlock
+    t.join
+
+    assert time.real*1000 >= 1000
+  end
+end

data/test/test_integration_resultset.rb

@@ -0,0 +1,156 @@
+require 'helper'
+
+class TC_ResultSet < Test::Unit::TestCase
+  def setup
+    @db = SQLite3::Database.new(":memory:")
+    @db.transaction do
+      @db.execute "create table foo ( a integer primary key, b text )"
+      @db.execute "insert into foo ( b ) values ( 'foo' )"
+      @db.execute "insert into foo ( b ) values ( 'bar' )"
+      @db.execute "insert into foo ( b ) values ( 'baz' )"
+    end
+    @stmt = @db.prepare( "select * from foo where a in ( ?, ? )" )
+    @result = @stmt.execute
+  end
+
+  def teardown
+    @stmt.close
+    @db.close
+  end
+
+  def test_reset_unused
+    assert_nothing_raised { @result.reset }
+    assert @result.to_a.empty?
+  end
+
+  def test_reset_used
+    @result.to_a
+    assert_nothing_raised { @result.reset }
+    assert @result.to_a.empty?
+  end
+
+  def test_reset_with_bind
+    @result.to_a
+    assert_nothing_raised { @result.reset( 1, 2 ) }
+    assert_equal 2, @result.to_a.length
+  end
+
+  def test_eof_inner
+    @result.reset( 1 )
+    assert !@result.eof?
+  end
+
+  def test_eof_edge
+    @result.reset( 1 )
+    @result.next # to first row
+    @result.next # to end of result set
+    assert @result.eof?
+  end
+
+  def test_next_eof
+    @result.reset( 1 )
+    assert_not_nil @result.next
+    assert_nil @result.next
+  end
+
+  def test_next_no_type_translation_no_hash
+    @result.reset( 1 )
+    assert_equal [ 1, "foo" ], @result.next
+  end
+
+  def test_next_type_translation
+    @result.reset( 1 )
+    assert_equal [ 1, "foo" ], @result.next
+  end
+
+  def test_next_type_translation_with_untyped_column
+    @db.query( "select count(*) from foo" ) do |result|
+      assert_equal [3], result.next
+    end
+  end
+
+  def test_type_translation_with_null_column
+    time = '1974-07-25 14:39:00'
+
+    @db.execute "create table bar ( a integer, b time, c string )"
+    @db.execute "insert into bar (a, b, c) values (NULL, '#{time}', 'hello')"
+    @db.execute "insert into bar (a, b, c) values (1, NULL, 'hello')"
+    @db.execute "insert into bar (a, b, c) values (2, '#{time}', NULL)"
+    @db.query( "select * from bar" ) do |result|
+      assert_equal [nil, time, 'hello'], result.next
+      assert_equal [1, nil, 'hello'], result.next
+      assert_equal [2, time, nil], result.next
+    end
+  end
+
+  def test_real_translation
+    @db.execute('create table foo_real(a real)')
+    @db.execute('insert into foo_real values (42)' )
+    @db.query('select a, sum(a), typeof(a), typeof(sum(a)) from foo_real') do |result|
+      result = result.next
+      assert result[0].is_a?(Float)
+      assert result[1].is_a?(Float)
+      assert result[2].is_a?(String)
+      assert result[3].is_a?(String)
+    end
+  end
+
+  def test_next_results_as_hash
+    @db.results_as_hash = true
+    @result.reset( 1 )
+    assert_equal( { "a" => 1, "b" => "foo", 0 => 1, 1 => "foo" },
+      @result.next )
+  end
+
+  def test_tainted_results_as_hash
+    @db.results_as_hash = true
+    @result.reset( 1 )
+    row = @result.next
+    row.each do |_, v|
+      assert(v.tainted?) if String === v
+    end
+  end
+
+  def test_tainted_row_values
+    @result.reset( 1 )
+    row = @result.next
+    row.each do |v|
+      assert(v.tainted?) if String === v
+    end
+  end
+
+  def test_each
+    called = 0
+    @result.reset( 1, 2 )
+    @result.each { |row| called += 1 }
+    assert_equal 2, called
+  end
+
+  def test_enumerable
+    @result.reset( 1, 2 )
+    assert_equal 2, @result.to_a.length
+  end
+
+  def test_types
+    assert_equal [ "integer", "text" ], @result.types
+  end
+
+  def test_columns
+    assert_equal [ "a", "b" ], @result.columns
+  end
+
+  def test_close
+    stmt = @db.prepare( "select * from foo" )
+    result = stmt.execute
+    assert !result.closed?
+    result.close
+    assert result.closed?
+    assert stmt.closed?
+    assert_raise( SQLite3::Exception ) { result.reset }
+    assert_raise( SQLite3::Exception ) { result.next }
+    assert_raise( SQLite3::Exception ) { result.each }
+    assert_raise( SQLite3::Exception ) { result.close }
+    assert_raise( SQLite3::Exception ) { result.types }
+    assert_raise( SQLite3::Exception ) { result.columns }
+  end
+end

data/test/test_integration_statement.rb

@@ -0,0 +1,194 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TC_Statement < Test::Unit::TestCase
+  def setup
+    @db = SQLite3::Database.new(":memory:")
+    @db.transaction do
+      @db.execute "create table foo ( a integer primary key, b text )"
+      @db.execute "insert into foo ( b ) values ( 'foo' )"
+      @db.execute "insert into foo ( b ) values ( 'bar' )"
+      @db.execute "insert into foo ( b ) values ( 'baz' )"
+    end
+    @stmt = @db.prepare( "select * from foo where a in ( ?, :named )" )
+  end
+
+  def teardown
+    @stmt.close
+    @db.close
+  end
+
+  def test_remainder_empty
+    assert_equal "", @stmt.remainder
+  end
+
+  def test_remainder_nonempty
+    called = false
+    @db.prepare( "select * from foo;\n blah" ) do |stmt|
+      called = true
+      assert_equal "\n blah", stmt.remainder
+    end
+    assert called
+  end
+
+  def test_bind_params_empty
+    assert_nothing_raised { @stmt.bind_params }
+    assert @stmt.execute!.empty?
+  end
+
+  def test_bind_params_array
+    @stmt.bind_params 1, 2
+    assert_equal 2, @stmt.execute!.length
+  end
+
+  def test_bind_params_hash
+    @stmt.bind_params ":named" => 2
+    assert_equal 1, @stmt.execute!.length
+  end
+
+  def test_bind_params_hash_without_colon
+    @stmt.bind_params "named" => 2
+    assert_equal 1, @stmt.execute!.length
+  end
+
+  def test_bind_params_hash_as_symbol
+    @stmt.bind_params :named => 2
+    assert_equal 1, @stmt.execute!.length
+  end
+
+  def test_bind_params_mixed
+    @stmt.bind_params( 1, ":named" => 2 )
+    assert_equal 2, @stmt.execute!.length
+  end
+
+  def test_bind_param_by_index
+    @stmt.bind_params( 1, 2 )
+    assert_equal 2, @stmt.execute!.length
+  end
+
+  def test_bind_param_by_name_bad
+    assert_raise( SQLite3::Exception ) { @stmt.bind_param( "@named", 2 ) }
+  end
+
+  def test_bind_param_by_name_good
+    @stmt.bind_param( ":named", 2 )
+    assert_equal 1, @stmt.execute!.length
+  end
+
+  def test_bind_param_with_various_types
+    @db.transaction do
+      @db.execute "create table all_types ( a integer primary key, b float, c string, d integer )"
+      @db.execute "insert into all_types ( b, c, d ) values ( 1.4, 'hello', 68719476735 )"
+    end
+
+    assert_equal 1, @db.execute( "select * from all_types where b = ?", 1.4 ).length
+    assert_equal 1, @db.execute( "select * from all_types where c = ?", 'hello').length
+    assert_equal 1, @db.execute( "select * from all_types where d = ?", 68719476735).length
+  end
+
+  def test_execute_no_bind_no_block
+    assert_instance_of SQLite3::ResultSet, @stmt.execute
+  end
+
+  def test_execute_with_bind_no_block
+    assert_instance_of SQLite3::ResultSet, @stmt.execute( 1, 2 )
+  end
+
+  def test_execute_no_bind_with_block
+    called = false
+    @stmt.execute { |row| called = true }
+    assert called
+  end
+
+  def test_execute_with_bind_with_block
+    called = 0
+    @stmt.execute( 1, 2 ) { |row| called += 1 }
+    assert_equal 1, called
+  end
+
+  def test_reexecute
+    r = @stmt.execute( 1, 2 )
+    assert_equal 2, r.to_a.length
+    assert_nothing_raised { r = @stmt.execute( 1, 2 ) }
+    assert_equal 2, r.to_a.length
+  end
+
+  def test_execute_bang_no_bind_no_block
+    assert @stmt.execute!.empty?
+  end
+
+  def test_execute_bang_with_bind_no_block
+    assert_equal 2, @stmt.execute!( 1, 2 ).length
+  end
+
+  def test_execute_bang_no_bind_with_block
+    called = 0
+    @stmt.execute! { |row| called += 1 }
+    assert_equal 0, called
+  end
+
+  def test_execute_bang_with_bind_with_block
+    called = 0
+    @stmt.execute!( 1, 2 ) { |row| called += 1 }
+    assert_equal 2, called
+  end
+
+  def test_columns
+    c1 = @stmt.columns
+    c2 = @stmt.columns
+    assert_same c1, c2
+    assert_equal 2, c1.length
+  end
+
+  def test_columns_computed
+    called = false
+    @db.prepare( "select count(*) from foo" ) do |stmt|
+      called = true
+      assert_equal [ "count(*)" ], stmt.columns
+    end
+    assert called
+  end
+
+  def test_types
+    t1 = @stmt.types
+    t2 = @stmt.types
+    assert_same t1, t2
+    assert_equal 2, t1.length
+  end
+
+  def test_types_computed
+    called = false
+    @db.prepare( "select count(*) from foo" ) do |stmt|
+      called = true
+      assert_equal [ nil ], stmt.types
+    end
+    assert called
+  end
+
+  def test_close
+    stmt = @db.prepare( "select * from foo" )
+    assert !stmt.closed?
+    stmt.close
+    assert stmt.closed?
+    assert_raise( SQLite3::Exception ) { stmt.execute }
+    assert_raise( SQLite3::Exception ) { stmt.execute! }
+    assert_raise( SQLite3::Exception ) { stmt.close }
+    assert_raise( SQLite3::Exception ) { stmt.bind_params 5 }
+    assert_raise( SQLite3::Exception ) { stmt.bind_param 1, 5 }
+    assert_raise( SQLite3::Exception ) { stmt.columns }
+    assert_raise( SQLite3::Exception ) { stmt.types }
+  end
+
+  def test_committing_tx_with_statement_active
+    called = false
+    @db.prepare( "select count(*) from foo" ) do |stmt|
+      called = true
+      count = stmt.execute!.first.first.to_i
+      @db.transaction do
+        @db.execute "insert into foo ( b ) values ( 'hello' )"
+      end
+      new_count = stmt.execute!.first.first.to_i
+      assert_equal new_count, count+1
+    end
+    assert called
+  end
+end