dawanda-sqlite3 1.3.3

data/test/test_sqlite3.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+module SQLite3
+  class TestSQLite3 < Test::Unit::TestCase
+    def test_libversion
+      assert_not_nil SQLite3.libversion
+    end
+  end
+end

data/test/test_statement.rb

@@ -0,0 +1,213 @@
+require 'helper'
+
+module SQLite3
+  class TestStatement < Test::Unit::TestCase
+    def setup
+      @db   = SQLite3::Database.new(':memory:')
+      @stmt = SQLite3::Statement.new(@db, "select 'foo'")
+    end
+
+    def test_raises_type_error
+      assert_raises(TypeError) do
+        SQLite3::Statement.new( @db, nil )
+      end
+    end
+
+    ###
+    # This method may not exist depending on how sqlite3 was compiled
+    def test_database_name
+      @db.execute('create table foo(text BLOB)')
+      @db.execute('insert into foo(text) values (?)',SQLite3::Blob.new('hello'))
+      stmt = @db.prepare('select text from foo')
+      if stmt.respond_to?(:database_name)
+        assert_equal 'main', stmt.database_name(0)
+      end
+    end
+
+    def test_prepare_blob
+      @db.execute('create table foo(text BLOB)')
+      stmt = @db.prepare('insert into foo(text) values (?)')
+      stmt.bind_param(1, SQLite3::Blob.new('hello'))
+      stmt.step
+      stmt.close
+    end
+
+    def test_select_blob
+      @db.execute('create table foo(text BLOB)')
+      @db.execute('insert into foo(text) values (?)',SQLite3::Blob.new('hello'))
+      assert_equal 'hello', @db.execute('select * from foo').first.first
+    end
+
+    def test_new
+      assert @stmt
+    end
+
+    def test_new_closed_handle
+      @db = SQLite3::Database.new(':memory:')
+      @db.close
+      assert_raises(ArgumentError) do
+        SQLite3::Statement.new(@db, 'select "foo"')
+      end
+    end
+
+    def test_new_with_remainder
+      stmt = SQLite3::Statement.new(@db, "select 'foo';bar")
+      assert_equal 'bar', stmt.remainder
+    end
+
+    def test_empty_remainder
+      assert_equal '', @stmt.remainder
+    end
+
+    def test_close
+      @stmt.close
+      assert @stmt.closed?
+    end
+
+    def test_double_close
+      @stmt.close
+      assert_raises(SQLite3::Exception) do
+        @stmt.close
+      end
+    end
+
+    def test_bind_param_string
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, "hello")
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_bind_param_int
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 10)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [10], result
+    end
+
+    def test_bind_nil
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, nil)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [nil], result
+    end
+
+    def test_bind_blobs
+    end
+
+    def test_bind_64
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 2 ** 31)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [2 ** 31], result
+    end
+
+    def test_bind_double
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 2.2)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [2.2], result
+    end
+
+    def test_named_bind
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param(':foo', 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_no_colon
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param('foo', 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_symbol
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param(:foo, 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_not_found
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      assert_raises(SQLite3::Exception) do
+        stmt.bind_param('bar', 'hello')
+      end
+    end
+
+    def test_each
+      r = nil
+      @stmt.each do |row|
+        r = row
+      end
+      assert_equal(['foo'], r)
+    end
+
+    def test_reset!
+      r = []
+      @stmt.each { |row| r << row }
+      @stmt.reset!
+      @stmt.each { |row| r << row }
+      assert_equal [['foo'], ['foo']], r
+    end
+
+    def test_step
+      r = @stmt.step
+      assert_equal ['foo'], r
+    end
+
+    def test_tainted
+      r = @stmt.step
+      assert r.first.tainted?
+    end
+
+    def test_step_twice
+      assert_not_nil @stmt.step
+      assert !@stmt.done?
+      assert_nil @stmt.step
+      assert @stmt.done?
+
+      @stmt.reset!
+      assert !@stmt.done?
+    end
+
+    def test_step_never_moves_past_done
+      10.times { @stmt.step }
+      @stmt.done?
+    end
+
+    def test_column_count
+      assert_equal 1, @stmt.column_count
+    end
+
+    def test_column_name
+      assert_equal "'foo'", @stmt.column_name(0)
+      assert_equal nil, @stmt.column_name(10)
+    end
+
+    def test_bind_parameter_count
+      stmt = SQLite3::Statement.new(@db, "select ?, ?, ?")
+      assert_equal 3, stmt.bind_parameter_count
+    end
+
+    def test_execute_with_varargs
+      stmt = @db.prepare('select ?, ?')
+      assert_equal [[nil, nil]], stmt.execute(nil, nil).to_a
+    end
+
+    def test_execute_with_hash
+      stmt = @db.prepare('select :n, :h')
+      assert_equal [[10, nil]], stmt.execute('n' => 10, 'h' => nil).to_a
+    end
+  end
+end

data/test/test_statement_execute.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+module SQLite3
+  class TestStatementExecute < Test::Unit::TestCase
+    def setup
+      @db   = SQLite3::Database.new(':memory:')
+      @db.execute_batch(
+        "CREATE TABLE items (id integer PRIMARY KEY, number integer)")
+    end
+
+    def test_execute_insert
+      ps = @db.prepare("INSERT INTO items (number) VALUES (:n)")
+      ps.execute('n'=>10)
+      assert_equal 1, @db.get_first_value("SELECT count(*) FROM items")
+      ps.close
+    end
+
+    def test_execute_update
+      @db.execute("INSERT INTO items (number) VALUES (?)", [10])
+
+      ps = @db.prepare("UPDATE items SET number = :new WHERE number = :old")
+      ps.execute('old'=>10, 'new'=>20)
+      assert_equal 20, @db.get_first_value("SELECT number FROM items")
+      ps.close
+    end
+
+    def test_execute_delete
+      @db.execute("INSERT INTO items (number) VALUES (?)", [20])
+      ps = @db.prepare("DELETE FROM items WHERE number = :n")
+      ps.execute('n' => 20)
+      assert_equal 0, @db.get_first_value("SELECT count(*) FROM items")
+      ps.close
+    end
+  end
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification 
+name: dawanda-sqlite3
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 1
+  - 3
+  - 3
+  version: 1.3.3
+platform: ruby
+authors: 
+- Jamis Buck
+- Luis Lavena
+- Aaron Patterson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-14 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 7
+        - 0
+        version: 0.7.0
+  type: :development
+  requirement: *id001
+  name: rake-compiler
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 2
+        - 9
+        - 4
+        version: 2.9.4
+  type: :development
+  requirement: *id002
+  name: hoe
+  prerelease: false
+description: |-
+  This module allows Ruby programs to interface with the SQLite3
+  database engine (http://www.sqlite.org).  You must have the
+  SQLite engine installed in order to build this module.
+  
+  Note that this module is NOT compatible with SQLite 2.x.
+email: 
+- jamis@37signals.com
+- luislavena@gmail.com
+- aaron@tenderlovemaking.com
+executables: []
+
+extensions: 
+- ext/sqlite3/extconf.rb
+extra_rdoc_files: 
+- Manifest.txt
+- README.rdoc
+- API_CHANGES.rdoc
+- CHANGELOG.rdoc
+- ext/sqlite3/database.c
+- ext/sqlite3/exception.c
+- ext/sqlite3/statement.c
+- ext/sqlite3/backup.c
+- ext/sqlite3/sqlite3.c
+files: 
+- API_CHANGES.rdoc
+- CHANGELOG.rdoc
+- ChangeLog.cvs
+- LICENSE
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- ext/sqlite3/backup.c
+- ext/sqlite3/backup.h
+- ext/sqlite3/database.c
+- ext/sqlite3/database.h
+- ext/sqlite3/exception.c
+- ext/sqlite3/exception.h
+- ext/sqlite3/extconf.rb
+- ext/sqlite3/sqlite3.c
+- ext/sqlite3/sqlite3_ruby.h
+- ext/sqlite3/statement.c
+- ext/sqlite3/statement.h
+- faq/faq.rb
+- faq/faq.yml
+- lib/sqlite3.rb
+- lib/sqlite3/constants.rb
+- lib/sqlite3/database.rb
+- lib/sqlite3/errors.rb
+- lib/sqlite3/pragmas.rb
+- lib/sqlite3/resultset.rb
+- lib/sqlite3/statement.rb
+- lib/sqlite3/translator.rb
+- lib/sqlite3/value.rb
+- lib/sqlite3/version.rb
+- setup.rb
+- tasks/faq.rake
+- tasks/gem.rake
+- tasks/native.rake
+- tasks/vendor_sqlite3.rake
+- test/helper.rb
+- test/test_backup.rb
+- test/test_collation.rb
+- test/test_database.rb
+- test/test_database_readonly.rb
+- test/test_deprecated.rb
+- test/test_encoding.rb
+- test/test_integration.rb
+- test/test_integration_open_close.rb
+- test/test_integration_pending.rb
+- test/test_integration_resultset.rb
+- test/test_integration_statement.rb
+- test/test_sqlite3.rb
+- test/test_statement.rb
+- test/test_statement_execute.rb
+- .gemtest
+has_rdoc: true
+homepage: http://github.com/luislavena/sqlite3-ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 17
+      segments: 
+      - 1
+      - 3
+      - 5
+      version: 1.3.5
+requirements: []
+
+rubyforge_project: dawanda-sqlite3
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: This module allows Ruby programs to interface with the SQLite3 database engine (http://www.sqlite.org)
+test_files: 
+- test/test_statement_execute.rb
+- test/test_integration_resultset.rb
+- test/test_database_readonly.rb
+- test/test_database.rb
+- test/test_encoding.rb
+- test/test_integration_open_close.rb
+- test/test_integration.rb
+- test/test_sqlite3.rb
+- test/test_collation.rb
+- test/test_integration_pending.rb
+- test/test_integration_statement.rb
+- test/test_deprecated.rb
+- test/test_backup.rb
+- test/test_statement.rb