mockley_crew 1.1.9 → 1.2.2

data/vendor/gems/sqlite3/gems/sqlite3-1.3.13/test/test_integration_resultset.rb

@@ -1,159 +0,0 @@
-require 'helper'
-
-class TC_ResultSet < SQLite3::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 )
-    hash = @result.next
-    assert_equal( { "a" => 1, "b" => "foo" },
-      hash )
-    assert_equal hash[0], 1
-    assert_equal hash[1], "foo"
-  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/vendor/gems/sqlite3/gems/sqlite3-1.3.13/test/test_integration_statement.rb

@@ -1,194 +0,0 @@
-require 'helper'
-
-class TC_Statement < SQLite3::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

data/vendor/gems/sqlite3/gems/sqlite3-1.3.13/test/test_result_set.rb

@@ -1,37 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestResultSet < SQLite3::TestCase
-    def test_each_hash
-      db = SQLite3::Database.new ':memory:'
-      db.execute "create table foo ( a integer primary key, b text )"
-      list = ('a'..'z').to_a
-      list.each do |t|
-        db.execute "insert into foo (b) values (\"#{t}\")"
-      end
-
-      rs = db.prepare('select * from foo').execute
-      rs.each_hash do |hash|
-        assert_equal list[hash['a'] - 1], hash['b']
-      end
-    end
-
-    def test_next_hash
-      db = SQLite3::Database.new ':memory:'
-      db.execute "create table foo ( a integer primary key, b text )"
-      list = ('a'..'z').to_a
-      list.each do |t|
-        db.execute "insert into foo (b) values (\"#{t}\")"
-      end
-
-      rs = db.prepare('select * from foo').execute
-      rows = []
-      while row = rs.next_hash
-        rows << row
-      end
-      rows.each do |hash|
-        assert_equal list[hash['a'] - 1], hash['b']
-      end
-    end
-  end
-end

data/vendor/gems/sqlite3/gems/sqlite3-1.3.13/test/test_sqlite3.rb

@@ -1,21 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestSQLite3 < SQLite3::TestCase
-    def test_libversion
-      assert_not_nil SQLite3.libversion
-    end
-
-    def test_threadsafe
-      assert_not_nil SQLite3.threadsafe
-    end
-
-    def test_threadsafe?
-      if SQLite3.threadsafe > 0
-        assert SQLite3.threadsafe?
-      else
-        refute SQLite3.threadsafe?
-      end
-    end
-  end
-end

data/vendor/gems/sqlite3/gems/sqlite3-1.3.13/test/test_statement.rb

@@ -1,260 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestStatement < SQLite3::TestCase
-    def setup
-      @db   = SQLite3::Database.new(':memory:')
-      @stmt = SQLite3::Statement.new(@db, "select 'foo'")
-    end
-
-    def test_double_close_does_not_segv
-      @db.execute 'CREATE TABLE "things" ("number" float NOT NULL)'
-
-      stmt = @db.prepare 'INSERT INTO things (number) VALUES (?)'
-      assert_raises(SQLite3::ConstraintException) { stmt.execute(nil) }
-
-      stmt.close
-
-      assert_raises(SQLite3::Exception) { stmt.close }
-    end
-
-    def test_raises_type_error
-      assert_raises(TypeError) do
-        SQLite3::Statement.new( @db, nil )
-      end
-    end
-
-    def test_insert_duplicate_records
-      @db.execute 'CREATE TABLE "things" ("name" varchar(20) CONSTRAINT "index_things_on_name" UNIQUE)'
-      stmt = @db.prepare("INSERT INTO things(name) VALUES(?)")
-      stmt.execute('ruby')
-
-      exception = assert_raises(SQLite3::ConstraintException) { stmt.execute('ruby') }
-      # SQLite 3.8.2 returns new error message:
-      #   UNIQUE constraint failed: *table_name*.*column_name*
-      # Older versions of SQLite return:
-      #   column *column_name* is not unique
-      assert_match(/(column(s)? .* (is|are) not unique|UNIQUE constraint failed: .*)/, exception.message)
-    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
-
-    def test_with_error
-      @db.execute('CREATE TABLE "employees" ("name" varchar(20) NOT NULL CONSTRAINT "index_employees_on_name" UNIQUE)')
-      stmt = @db.prepare("INSERT INTO Employees(name) VALUES(?)")
-      stmt.execute('employee-1')
-      stmt.execute('employee-1') rescue SQLite3::ConstraintException
-      stmt.reset!
-      assert stmt.execute('employee-2')
-    end
-
-    def test_clear_bindings
-      stmt = @db.prepare('select ?, ?')
-      stmt.bind_param 1, "foo"
-      stmt.bind_param 2, "bar"
-
-      # We can't fetch bound parameters back out of sqlite3, so just call
-      # the clear_bindings! method and assert that nil is returned
-      stmt.clear_bindings!
-
-      while x = stmt.step
-        assert_equal [nil, nil], x
-      end
-    end
-  end
-end

data/vendor/gems/sqlite3/gems/sqlite3-1.3.13/test/test_statement_execute.rb

@@ -1,35 +0,0 @@
-require 'helper'
-
-module SQLite3
-  class TestStatementExecute < SQLite3::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