luislavena-sqlite3-ruby 1.2.4.1

data/test/native-vs-dl.rb

@@ -0,0 +1,126 @@
+$:.unshift "../lib", "../ext/sqlite3_api"
+
+require 'sqlite3'
+
+require 'benchmark'
+
+N = 1000
+
+$VERBOSE=nil
+
+puts "database creation..."
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    N.times do
+      File.delete "test.db" rescue nil
+      SQLite3::Database.open( "test.db", :driver => "DL" ).close
+    end
+  end
+  x.report('native') do
+    N.times do
+      File.delete "test.db" rescue nil
+      SQLite3::Database.open( "test.db", :driver => "Native" ).close
+    end
+  end
+end
+File.delete "test.db" rescue nil
+
+SQLite3::Database.open( "test.db" ).close
+
+puts
+puts "database open..."
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    N.times do
+      SQLite3::Database.open( "test.db", :driver => "DL" ).close
+    end
+  end
+  x.report('native') do
+    N.times do
+      SQLite3::Database.open( "test.db", :driver => "Native" ).close
+    end
+  end
+end
+File.delete "test.db" rescue nil
+
+dl = SQLite3::Database.open( "test-dl.db", :driver => "DL" )
+native = SQLite3::Database.open( "test-native.db", :driver => "Native" )
+
+dl.execute "create table foo (a,b)"
+native.execute "create table foo (a,b)"
+
+puts
+puts "insertions"
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    dl.transaction do
+      N.times do |i|
+        dl.execute "insert into foo values (#{i}, #{i+1})"
+      end
+    end
+  end
+  x.report('native') do
+    native.transaction do
+      N.times do |i|
+        native.execute "insert into foo values (#{i}, #{i+1})"
+      end
+    end
+  end
+end
+
+puts
+puts "insertions using prepared statement"
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    dl.transaction do
+      dl.prepare "insert into foo values (?,?)" do |stmt|
+        N.times { |i| stmt.execute i, i+1 }
+      end
+    end
+  end
+  x.report('native') do
+    native.transaction do
+      native.prepare( "insert into foo values (?,?)" ) do |stmt|
+        N.times { |i| stmt.execute i, i+1 }
+      end
+    end
+  end
+end
+
+dl.close
+native.close
+File.delete "test-dl.db" rescue nil
+File.delete "test-native.db" rescue nil
+
+dl = SQLite3::Database.open( "test-dl.db", :driver => "DL" )
+native = SQLite3::Database.open( "test-native.db", :driver => "Native" )
+
+dl.execute "create table foo (a,b)"
+dl.execute "insert into foo values (1,2)"
+dl.execute "insert into foo values (3,4)"
+dl.execute "insert into foo values (5,6)"
+
+native.execute "create table foo (a,b)"
+native.execute "insert into foo values (1,2)"
+native.execute "insert into foo values (3,4)"
+native.execute "insert into foo values (5,6)"
+
+puts
+puts "queries"
+Benchmark.bm( 7 ) do |x|
+  x.report('dl') do
+    N.times do
+      dl.execute "select * from foo"
+    end
+  end
+  x.report('native') do
+    N.times do
+      native.execute "select * from foo"
+    end
+  end
+end
+
+dl.close
+native.close
+File.delete "test-dl.db" rescue nil
+File.delete "test-native.db" rescue nil

data/test/test_database.rb

@@ -0,0 +1,193 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TC_Database_Init < Test::Unit::TestCase
+  def test_new
+    # any_instance fails here...
+    driver = Driver.new
+    driver.expects(:open).once.with('foo.db', false).returns([0, 'cookie'])
+    Driver.stubs(:new).returns(driver)
+    db = SQLite3::Database.new( 'foo.db', :driver => Driver )
+    assert !db.closed?
+    assert !db.results_as_hash
+    assert !db.type_translation
+  end
+
+  def test_open
+    driver = Driver.new
+    driver.expects(:open).once.with('foo.db', false).returns([0, 'cookie'])
+    Driver.stubs(:new).returns(driver)
+    db = SQLite3::Database.open( "foo.db", :driver => Driver )
+    assert !db.closed?
+    assert !db.results_as_hash
+    assert !db.type_translation
+  end
+  
+  def test_with_type_translation
+    db = SQLite3::Database.open( "foo.db", :driver => Driver,
+      :type_translation => true )
+    assert db.type_translation
+  end
+  
+  def test_with_results_as_hash
+    db = SQLite3::Database.open( "foo.db", :driver => Driver,
+      :results_as_hash => true )
+    assert db.results_as_hash
+  end
+  
+  def test_with_type_translation_and_results_as_hash
+    db = SQLite3::Database.open( "foo.db", :driver => Driver,
+      :results_as_hash => true,
+      :type_translation => true )
+    assert db.results_as_hash
+    assert db.type_translation
+  end
+end
+
+class TC_Database < Test::Unit::TestCase
+  def setup
+    @db = SQLite3::Database.open( "foo.db",
+      :driver => Driver, :statement_factory => Statement )
+  end
+
+  def test_quote
+    assert_equal "''one''two''three''", SQLite3::Database.quote(
+      "'one'two'three'" )
+  end
+
+  def test_complete
+    Driver.any_instance.expects(:complete?)
+    @db.complete? "foo"
+  end
+
+  def test_errmsg
+    Driver.any_instance.expects(:errmsg)
+    @db.errmsg
+  end
+
+  def test_errcode
+    Driver.any_instance.expects(:errcode)
+    @db.errcode
+  end
+
+  def test_translator
+    translator = @db.translator
+    assert_instance_of SQLite3::Translator, translator
+  end
+
+  def test_close
+    Driver.any_instance.expects(:close).returns(0)
+    @db.close
+    assert @db.closed?
+    Driver.any_instance.expects(:close).never
+    @db.close
+  end
+
+  def test_trace
+    Driver.any_instance.expects(:trace).with('cookie', 15)
+    @db.trace( 15 ) { "foo" }
+    # assert_equal 1, driver.mock_blocks[:trace].length
+  end
+
+  def test_authorizer
+    Driver.any_instance.expects(:set_authorizer).with('cookie', 15).returns(0)
+    @db.authorizer( 15 ) { "foo" }
+    # assert_equal 1, driver.mock_blocks[:set_authorizer].length
+  end
+
+  def test_prepare_no_block
+    Statement.any_instance.expects(:close).never
+    assert_nothing_raised { @db.prepare( "foo" ) }
+  end
+
+  def test_prepare_with_block
+    called = false
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:close).once
+    Statement.stubs(:new).returns(statement)
+    @db.prepare( "foo" ) { |stmt| called = true }
+    assert called
+  end
+
+  def test_execute_no_block
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new)
+    Statement.stubs(:new).returns(statement)
+    MockResultSet.any_instance.stubs(:inject).returns([['foo']])
+    result = @db.execute( "foo", "bar", "baz" )
+    assert_equal [["foo"]], result
+  end
+
+  def test_execute_with_block
+    called = false
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new)
+    Statement.stubs(:new).returns(statement)
+    @db.execute( "foo", "bar", "baz" ) do |row|
+      called = true
+      assert_equal ["foo"], row
+    end
+
+    assert called
+  end
+
+  def test_execute2_no_block
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new)
+    Statement.stubs(:new).returns(statement)
+    MockResultSet.any_instance.stubs(:inject).returns([['name'], ['foo']])
+    result = @db.execute2( "foo", "bar", "baz" )
+    assert_equal [["name"],["foo"]], result
+  end
+
+  def test_execute2_with_block
+    called = false
+    parts = [ ["name"],["foo"] ]
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new)
+    Statement.stubs(:new).returns(statement)
+    @db.execute2( "foo", "bar", "baz" ) do |row|
+      called = true
+      assert_equal parts.shift, row
+    end
+
+    assert called
+  end
+
+  def test_execute_batch
+    # any_instance fails here...
+    statement = Statement.new('cookie', 'foo')
+    statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new)
+    Statement.stubs(:new).returns(statement)
+    @db.execute_batch( "foo", "bar", "baz" )
+  end
+
+  def test_get_first_row
+    result = @db.get_first_row( "foo", "bar", "baz" )
+    assert_equal ["foo"], result
+  end
+
+  def test_get_first_value
+    result = @db.get_first_value( "foo", "bar", "baz" )
+    assert_equal "foo", result
+  end
+
+  def test_changes
+    Driver.any_instance.expects(:changes).returns(14)
+    assert_equal 14, @db.changes
+  end
+
+  def test_total_changes
+    Driver.any_instance.expects(:total_changes).returns(28)
+    assert_equal 28, @db.total_changes
+  end
+
+  def test_interrupt
+    Driver.any_instance.expects(:interrupt)
+    @db.interrupt
+  end
+end

data/test/test_errors.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TC_Errors < Test::Unit::TestCase
+  (1..26).each do |code|
+    define_method( "test_error_code_%02d" % code ) do
+      db = stub('database', :errmsg => 'message')
+      begin
+        SQLite3::Error.check( code, db )
+      rescue SQLite3::Exception => e
+        assert_instance_of SQLite3::EXCEPTIONS[code], e
+        assert_equal code, e.code
+        assert_equal code, e.class.code
+        assert_equal "message", e.message
+      end
+    end
+  end
+end