ibm_db 3.0.5-x86-mingw32 → 4.0.0-x86-mingw32

data/test/cases/adapters/postgresql/xml_test.rb

@@ -0,0 +1,54 @@
+require 'cases/helper'
+require 'support/schema_dumping_helper'
+
+class PostgresqlXMLTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+  class XmlDataType < ActiveRecord::Base
+    self.table_name = 'xml_data_type'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    begin
+      @connection.transaction do
+        @connection.create_table('xml_data_type') do |t|
+          t.xml 'payload'
+        end
+      end
+    rescue ActiveRecord::StatementInvalid
+      skip "do not test on PG without xml"
+    end
+    @column = XmlDataType.columns_hash['payload']
+  end
+
+  teardown do
+    @connection.drop_table 'xml_data_type', if_exists: true
+  end
+
+  def test_column
+    assert_equal :xml, @column.type
+  end
+
+  def test_null_xml
+    @connection.execute %q|insert into xml_data_type (payload) VALUES(null)|
+    assert_nil XmlDataType.first.payload
+  end
+
+  def test_round_trip
+    data = XmlDataType.new(payload: "<foo>bar</foo>")
+    assert_equal "<foo>bar</foo>", data.payload
+    data.save!
+    assert_equal "<foo>bar</foo>", data.reload.payload
+  end
+
+  def test_update_all
+    data = XmlDataType.create!
+    XmlDataType.update_all(payload: "<bar>baz</bar>")
+    assert_equal "<bar>baz</bar>", data.reload.payload
+  end
+
+  def test_schema_dump_with_shorthand
+    output = dump_table_schema("xml_data_type")
+    assert_match %r{t\.xml "payload"}, output
+  end
+end

data/test/cases/adapters/sqlite3/collation_test.rb

@@ -0,0 +1,53 @@
+require "cases/helper"
+require 'support/schema_dumping_helper'
+
+class SQLite3CollationTest < ActiveRecord::SQLite3TestCase
+  include SchemaDumpingHelper
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table :collation_table_sqlite3, force: true do |t|
+      t.string :string_nocase, collation: 'NOCASE'
+      t.text :text_rtrim, collation: 'RTRIM'
+    end
+  end
+
+  def teardown
+    @connection.drop_table :collation_table_sqlite3, if_exists: true
+  end
+
+  test "string column with collation" do
+    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == 'string_nocase' }
+    assert_equal :string, column.type
+    assert_equal 'NOCASE', column.collation
+  end
+
+  test "text column with collation" do
+    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == 'text_rtrim' }
+    assert_equal :text, column.type
+    assert_equal 'RTRIM', column.collation
+  end
+
+  test "add column with collation" do
+    @connection.add_column :collation_table_sqlite3, :title, :string, collation: 'RTRIM'
+
+    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == 'title' }
+    assert_equal :string, column.type
+    assert_equal 'RTRIM', column.collation
+  end
+
+  test "change column with collation" do
+    @connection.add_column :collation_table_sqlite3, :description, :string
+    @connection.change_column :collation_table_sqlite3, :description, :text, collation: 'RTRIM'
+
+    column = @connection.columns(:collation_table_sqlite3).find { |c| c.name == 'description' }
+    assert_equal :text, column.type
+    assert_equal 'RTRIM', column.collation
+  end
+
+  test "schema dump includes collation" do
+    output = dump_table_schema("collation_table_sqlite3")
+    assert_match %r{t.string\s+"string_nocase",\s+collation: "NOCASE"$}, output
+    assert_match %r{t.text\s+"text_rtrim",\s+collation: "RTRIM"$}, output
+  end
+end

data/test/cases/adapters/sqlite3/copy_table_test.rb

@@ -0,0 +1,98 @@
+require "cases/helper"
+
+class CopyTableTest < ActiveRecord::SQLite3TestCase
+  fixtures :customers
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    class << @connection
+      public :copy_table, :table_structure, :indexes
+    end
+  end
+
+  def test_copy_table(from = 'customers', to = 'customers2', options = {})
+    assert_nothing_raised {copy_table(from, to, options)}
+    assert_equal row_count(from), row_count(to)
+
+    if block_given?
+      yield from, to, options
+    else
+      assert_equal column_names(from), column_names(to)
+    end
+
+    @connection.drop_table(to) rescue nil
+  end
+
+  def test_copy_table_renaming_column
+    test_copy_table('customers', 'customers2',
+        :rename => {'name' => 'person_name'}) do |from, to, options|
+      expected = column_values(from, 'name')
+      assert_equal expected, column_values(to, 'person_name')
+      assert expected.any?, "No values in table: #{expected.inspect}"
+    end
+  end
+
+  def test_copy_table_allows_to_pass_options_to_create_table
+    @connection.create_table('blocker_table')
+    test_copy_table('customers', 'blocker_table', force: true)
+  end
+
+  def test_copy_table_with_index
+    test_copy_table('comments', 'comments_with_index') do
+      @connection.add_index('comments_with_index', ['post_id', 'type'])
+      test_copy_table('comments_with_index', 'comments_with_index2') do
+        assert_equal table_indexes_without_name('comments_with_index'),
+                     table_indexes_without_name('comments_with_index2')
+      end
+    end
+  end
+
+  def test_copy_table_without_primary_key
+    test_copy_table('developers_projects', 'programmers_projects') do
+      assert_nil @connection.primary_key('programmers_projects')
+    end
+  end
+
+  def test_copy_table_with_id_col_that_is_not_primary_key
+    test_copy_table('goofy_string_id', 'goofy_string_id2') do
+      original_id = @connection.columns('goofy_string_id').detect{|col| col.name == 'id' }
+      copied_id = @connection.columns('goofy_string_id2').detect{|col| col.name == 'id' }
+      assert_equal original_id.type, copied_id.type
+      assert_equal original_id.sql_type, copied_id.sql_type
+      assert_equal original_id.limit, copied_id.limit
+    end
+  end
+
+  def test_copy_table_with_unconventional_primary_key
+    test_copy_table('owners', 'owners_unconventional') do
+      original_pk = @connection.primary_key('owners')
+      copied_pk = @connection.primary_key('owners_unconventional')
+      assert_equal original_pk, copied_pk
+    end
+  end
+
+  def test_copy_table_with_binary_column
+    test_copy_table 'binaries', 'binaries2'
+  end
+
+protected
+  def copy_table(from, to, options = {})
+    @connection.copy_table(from, to, {:temporary => true}.merge(options))
+  end
+
+  def column_names(table)
+    @connection.table_structure(table).map {|column| column['name']}
+  end
+
+  def column_values(table, column)
+    @connection.select_all("SELECT #{column} FROM #{table} ORDER BY id").map {|row| row[column]}
+  end
+
+  def table_indexes_without_name(table)
+    @connection.indexes(table).delete(:name)
+  end
+
+  def row_count(table)
+    @connection.select_one("SELECT COUNT(*) AS count FROM #{table}")['count']
+  end
+end

data/test/cases/adapters/sqlite3/explain_test.rb

@@ -0,0 +1,21 @@
+require "cases/helper"
+require 'models/developer'
+require 'models/computer'
+
+class SQLite3ExplainTest < ActiveRecord::SQLite3TestCase
+  fixtures :developers
+
+  def test_explain_for_one_query
+    explain = Developer.where(id: 1).explain
+    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = (?:\? \[\["id", 1\]\]|1)), explain
+    assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+  end
+
+  def test_explain_with_eager_loading
+    explain = Developer.where(id: 1).includes(:audit_logs).explain
+    assert_match %r(EXPLAIN for: SELECT "developers".* FROM "developers" WHERE "developers"."id" = (?:\? \[\["id", 1\]\]|1)), explain
+    assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+    assert_match %(EXPLAIN for: SELECT "audit_logs".* FROM "audit_logs" WHERE "audit_logs"."developer_id" = 1), explain
+    assert_match(/(SCAN )?TABLE audit_logs/, explain)
+  end
+end

data/test/cases/adapters/sqlite3/quoting_test.rb

@@ -0,0 +1,101 @@
+require "cases/helper"
+require 'bigdecimal'
+require 'yaml'
+require 'securerandom'
+
+class SQLite3QuotingTest < ActiveRecord::SQLite3TestCase
+  def setup
+    @conn = ActiveRecord::Base.connection
+  end
+
+  def test_type_cast_binary_encoding_without_logger
+    @conn.extend(Module.new { def logger; end })
+    binary = SecureRandom.hex
+    expected = binary.dup.encode!(Encoding::UTF_8)
+    assert_equal expected, @conn.type_cast(binary)
+  end
+
+  def test_type_cast_symbol
+    assert_equal 'foo', @conn.type_cast(:foo)
+  end
+
+  def test_type_cast_date
+    date = Date.today
+    expected = @conn.quoted_date(date)
+    assert_equal expected, @conn.type_cast(date)
+  end
+
+  def test_type_cast_time
+    time = Time.now
+    expected = @conn.quoted_date(time)
+    assert_equal expected, @conn.type_cast(time)
+  end
+
+  def test_type_cast_numeric
+    assert_equal 10, @conn.type_cast(10)
+    assert_equal 2.2, @conn.type_cast(2.2)
+  end
+
+  def test_type_cast_nil
+    assert_equal nil, @conn.type_cast(nil)
+  end
+
+  def test_type_cast_true
+    assert_equal 't', @conn.type_cast(true)
+  end
+
+  def test_type_cast_false
+    assert_equal 'f', @conn.type_cast(false)
+  end
+
+  def test_type_cast_bigdecimal
+    bd = BigDecimal.new '10.0'
+    assert_equal bd.to_f, @conn.type_cast(bd)
+  end
+
+  def test_type_cast_unknown_should_raise_error
+    obj = Class.new.new
+    assert_raise(TypeError) { @conn.type_cast(obj) }
+  end
+
+  def test_type_cast_object_which_responds_to_quoted_id
+    quoted_id_obj = Class.new {
+      def quoted_id
+        "'zomg'"
+      end
+
+      def id
+        10
+      end
+    }.new
+    assert_equal 10, @conn.type_cast(quoted_id_obj)
+
+    quoted_id_obj = Class.new {
+      def quoted_id
+        "'zomg'"
+      end
+    }.new
+    assert_raise(TypeError) { @conn.type_cast(quoted_id_obj) }
+  end
+
+  def test_quoting_binary_strings
+    value = "hello".encode('ascii-8bit')
+    type = ActiveRecord::Type::String.new
+
+    assert_equal "'hello'", @conn.quote(type.serialize(value))
+  end
+
+  def test_quoted_time_returns_date_qualified_time
+    value = ::Time.utc(2000, 1, 1, 12, 30, 0, 999999)
+    type = ActiveRecord::Type::Time.new
+
+    assert_equal "'2000-01-01 12:30:00.999999'", @conn.quote(type.serialize(value))
+  end
+
+  def test_quoted_time_normalizes_date_qualified_time
+    value = ::Time.utc(2018, 3, 11, 12, 30, 0, 999999)
+    type = ActiveRecord::Type::Time.new
+
+    assert_equal "'2000-01-01 12:30:00.999999'", @conn.quote(type.serialize(value))
+  end
+end

data/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb

@@ -0,0 +1,441 @@
+require "cases/helper"
+require 'models/owner'
+require 'tempfile'
+require 'support/ddl_helper'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3AdapterTest < ActiveRecord::SQLite3TestCase
+      include DdlHelper
+
+      self.use_transactional_tests = false
+
+      class DualEncoding < ActiveRecord::Base
+      end
+
+      def setup
+        @conn = Base.sqlite3_connection database: ':memory:',
+                                        adapter: 'sqlite3',
+                                        timeout: 100
+      end
+
+      def test_bad_connection
+        assert_raise ActiveRecord::NoDatabaseError do
+          connection = ActiveRecord::Base.sqlite3_connection(adapter: "sqlite3", database: "/tmp/should/_not/_exist/-cinco-dog.db")
+          connection.drop_table 'ex', if_exists: true
+        end
+      end
+
+      unless in_memory_db?
+        def test_connect_with_url
+          original_connection = ActiveRecord::Base.remove_connection
+          tf = Tempfile.open 'whatever'
+          url = "sqlite3:#{tf.path}"
+          ActiveRecord::Base.establish_connection(url)
+          assert ActiveRecord::Base.connection
+        ensure
+          tf.close
+          tf.unlink
+          ActiveRecord::Base.establish_connection(original_connection)
+        end
+
+        def test_connect_memory_with_url
+          original_connection = ActiveRecord::Base.remove_connection
+          url = "sqlite3::memory:"
+          ActiveRecord::Base.establish_connection(url)
+          assert ActiveRecord::Base.connection
+        ensure
+          ActiveRecord::Base.establish_connection(original_connection)
+        end
+      end
+
+      def test_valid_column
+        with_example_table do
+          column = @conn.columns('ex').find { |col| col.name == 'id' }
+          assert @conn.valid_type?(column.type)
+        end
+      end
+
+      # sqlite3 databases should be able to support any type and not just the
+      # ones mentioned in the native_database_types.
+      #
+      # Therefore test_invalid column should always return true even if the
+      # type is not valid.
+      def test_invalid_column
+        assert @conn.valid_type?(:foobar)
+      end
+
+      def test_column_types
+        owner = Owner.create!(name: "hello".encode('ascii-8bit'))
+        owner.reload
+        select = Owner.columns.map { |c| "typeof(#{c.name})" }.join ', '
+        result = Owner.connection.exec_query <<-esql
+          SELECT #{select}
+          FROM   #{Owner.table_name}
+          WHERE  #{Owner.primary_key} = #{owner.id}
+        esql
+
+        assert(!result.rows.first.include?("blob"), "should not store blobs")
+      ensure
+        owner.delete
+      end
+
+      def test_exec_insert
+        with_example_table do
+          vals = [Relation::QueryAttribute.new("number", 10, Type::Value.new)]
+          @conn.exec_insert('insert into ex (number) VALUES (?)', 'SQL', vals)
+
+          result = @conn.exec_query(
+            'select number from ex where number = ?', 'SQL', vals)
+
+          assert_equal 1, result.rows.length
+          assert_equal 10, result.rows.first.first
+        end
+      end
+
+      def test_primary_key_returns_nil_for_no_pk
+        with_example_table 'id int, data string' do
+          assert_nil @conn.primary_key('ex')
+        end
+      end
+
+      def test_connection_no_db
+        assert_raises(ArgumentError) do
+          Base.sqlite3_connection {}
+        end
+      end
+
+      def test_bad_timeout
+        assert_raises(TypeError) do
+          Base.sqlite3_connection database: ':memory:',
+                                  adapter: 'sqlite3',
+                                  timeout: 'usa'
+        end
+      end
+
+      # connection is OK with a nil timeout
+      def test_nil_timeout
+        conn = Base.sqlite3_connection database: ':memory:',
+                                       adapter: 'sqlite3',
+                                       timeout: nil
+        assert conn, 'made a connection'
+      end
+
+      def test_connect
+        assert @conn, 'should have connection'
+      end
+
+      # sqlite3 defaults to UTF-8 encoding
+      def test_encoding
+        assert_equal 'UTF-8', @conn.encoding
+      end
+
+      def test_exec_no_binds
+        with_example_table 'id int, data string' do
+          result = @conn.exec_query('SELECT id, data FROM ex')
+          assert_equal 0, result.rows.length
+          assert_equal 2, result.columns.length
+          assert_equal %w{ id data }, result.columns
+
+          @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+          result = @conn.exec_query('SELECT id, data FROM ex')
+          assert_equal 1, result.rows.length
+          assert_equal 2, result.columns.length
+
+          assert_equal [[1, 'foo']], result.rows
+        end
+      end
+
+      def test_exec_query_with_binds
+        with_example_table 'id int, data string' do
+          @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+          result = @conn.exec_query(
+            'SELECT id, data FROM ex WHERE id = ?', nil, [Relation::QueryAttribute.new(nil, 1, Type::Value.new)])
+
+          assert_equal 1, result.rows.length
+          assert_equal 2, result.columns.length
+
+          assert_equal [[1, 'foo']], result.rows
+        end
+      end
+
+      def test_exec_query_typecasts_bind_vals
+        with_example_table 'id int, data string' do
+          @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+
+          result = @conn.exec_query(
+            'SELECT id, data FROM ex WHERE id = ?', nil, [Relation::QueryAttribute.new("id", "1-fuu", Type::Integer.new)])
+
+          assert_equal 1, result.rows.length
+          assert_equal 2, result.columns.length
+
+          assert_equal [[1, 'foo']], result.rows
+        end
+      end
+
+      def test_quote_binary_column_escapes_it
+        DualEncoding.connection.execute(<<-eosql)
+          CREATE TABLE IF NOT EXISTS dual_encodings (
+            id integer PRIMARY KEY AUTOINCREMENT,
+            name varchar(255),
+            data binary
+          )
+        eosql
+        str = "\x80".force_encoding("ASCII-8BIT")
+        binary = DualEncoding.new name: 'いただきます！', data: str
+        binary.save!
+        assert_equal str, binary.data
+      ensure
+        DualEncoding.connection.drop_table 'dual_encodings', if_exists: true
+      end
+
+      def test_type_cast_should_not_mutate_encoding
+        name  = 'hello'.force_encoding(Encoding::ASCII_8BIT)
+        Owner.create(name: name)
+        assert_equal Encoding::ASCII_8BIT, name.encoding
+      ensure
+        Owner.delete_all
+      end
+
+      def test_execute
+        with_example_table do
+          @conn.execute "INSERT INTO ex (number) VALUES (10)"
+          records = @conn.execute "SELECT * FROM ex"
+          assert_equal 1, records.length
+
+          record = records.first
+          assert_equal 10, record['number']
+          assert_equal 1, record['id']
+        end
+      end
+
+      def test_quote_string
+        assert_equal "''", @conn.quote_string("'")
+      end
+
+      def test_insert_logged
+        with_example_table do
+          sql = "INSERT INTO ex (number) VALUES (10)"
+          name = "foo"
+          assert_logged [[sql, name, []]] do
+            @conn.insert(sql, name)
+          end
+        end
+      end
+
+      def test_insert_id_value_returned
+        with_example_table do
+          sql = "INSERT INTO ex (number) VALUES (10)"
+          idval = 'vuvuzela'
+          id = @conn.insert(sql, nil, nil, idval)
+          assert_equal idval, id
+        end
+      end
+
+      def test_select_rows
+        with_example_table do
+          2.times do |i|
+            @conn.create "INSERT INTO ex (number) VALUES (#{i})"
+          end
+          rows = @conn.select_rows 'select number, id from ex'
+          assert_equal [[0, 1], [1, 2]], rows
+        end
+      end
+
+      def test_select_rows_logged
+        with_example_table do
+          sql = "select * from ex"
+          name = "foo"
+          assert_logged [[sql, name, []]] do
+            @conn.select_rows sql, name
+          end
+        end
+      end
+
+      def test_transaction
+        with_example_table do
+          count_sql = 'select count(*) from ex'
+
+          @conn.begin_db_transaction
+          @conn.create "INSERT INTO ex (number) VALUES (10)"
+
+          assert_equal 1, @conn.select_rows(count_sql).first.first
+          @conn.rollback_db_transaction
+          assert_equal 0, @conn.select_rows(count_sql).first.first
+        end
+      end
+
+      def test_tables
+        with_example_table do
+          ActiveSupport::Deprecation.silence { assert_equal %w{ ex }, @conn.tables }
+          with_example_table 'id integer PRIMARY KEY AUTOINCREMENT, number integer', 'people' do
+            ActiveSupport::Deprecation.silence { assert_equal %w{ ex people }.sort, @conn.tables.sort }
+          end
+        end
+      end
+
+      def test_tables_logs_name
+        sql = <<-SQL
+          SELECT name FROM sqlite_master
+          WHERE type IN ('table','view') AND name <> 'sqlite_sequence'
+        SQL
+        assert_logged [[sql.squish, 'SCHEMA', []]] do
+          ActiveSupport::Deprecation.silence do
+            @conn.tables('hello')
+          end
+        end
+      end
+
+      def test_indexes_logs_name
+        with_example_table do
+          assert_logged [["PRAGMA index_list(\"ex\")", 'SCHEMA', []]] do
+            @conn.indexes('ex', 'hello')
+          end
+        end
+      end
+
+      def test_table_exists_logs_name
+        with_example_table do
+          sql = <<-SQL
+            SELECT name FROM sqlite_master
+            WHERE type IN ('table','view') AND name <> 'sqlite_sequence' AND name = 'ex'
+          SQL
+          assert_logged [[sql.squish, 'SCHEMA', []]] do
+            ActiveSupport::Deprecation.silence do
+              assert @conn.table_exists?('ex')
+            end
+          end
+        end
+      end
+
+      def test_columns
+        with_example_table do
+          columns = @conn.columns('ex').sort_by(&:name)
+          assert_equal 2, columns.length
+          assert_equal %w{ id number }.sort, columns.map(&:name)
+          assert_equal [nil, nil], columns.map(&:default)
+          assert_equal [true, true], columns.map(&:null)
+        end
+      end
+
+      def test_columns_with_default
+        with_example_table 'id integer PRIMARY KEY AUTOINCREMENT, number integer default 10' do
+          column = @conn.columns('ex').find { |x|
+            x.name == 'number'
+          }
+          assert_equal '10', column.default
+        end
+      end
+
+      def test_columns_with_not_null
+        with_example_table 'id integer PRIMARY KEY AUTOINCREMENT, number integer not null' do
+          column = @conn.columns('ex').find { |x| x.name == 'number' }
+          assert_not column.null, "column should not be null"
+        end
+      end
+
+      def test_indexes_logs
+        with_example_table do
+          assert_logged [["PRAGMA index_list(\"ex\")", "SCHEMA", []]] do
+            @conn.indexes('ex')
+          end
+        end
+      end
+
+      def test_no_indexes
+        assert_equal [], @conn.indexes('items')
+      end
+
+      def test_index
+        with_example_table do
+          @conn.add_index 'ex', 'id', unique: true, name: 'fun'
+          index = @conn.indexes('ex').find { |idx| idx.name == 'fun' }
+
+          assert_equal 'ex', index.table
+          assert index.unique, 'index is unique'
+          assert_equal ['id'], index.columns
+        end
+      end
+
+      def test_non_unique_index
+        with_example_table do
+          @conn.add_index 'ex', 'id', name: 'fun'
+          index = @conn.indexes('ex').find { |idx| idx.name == 'fun' }
+          assert_not index.unique, 'index is not unique'
+        end
+      end
+
+      def test_compound_index
+        with_example_table do
+          @conn.add_index 'ex', %w{ id number }, name: 'fun'
+          index = @conn.indexes('ex').find { |idx| idx.name == 'fun' }
+          assert_equal %w{ id number }.sort, index.columns.sort
+        end
+      end
+
+      def test_primary_key
+        with_example_table do
+          assert_equal 'id', @conn.primary_key('ex')
+          with_example_table 'internet integer PRIMARY KEY AUTOINCREMENT, number integer not null', 'foos' do
+            assert_equal 'internet', @conn.primary_key('foos')
+          end
+        end
+      end
+
+      def test_no_primary_key
+        with_example_table 'number integer not null' do
+          assert_nil @conn.primary_key('ex')
+        end
+      end
+
+      def test_supports_extensions
+        assert_not @conn.supports_extensions?, 'does not support extensions'
+      end
+
+      def test_respond_to_enable_extension
+        assert @conn.respond_to?(:enable_extension)
+      end
+
+      def test_respond_to_disable_extension
+        assert @conn.respond_to?(:disable_extension)
+      end
+
+      def test_statement_closed
+        db = ::SQLite3::Database.new(ActiveRecord::Base.
+                                   configurations['arunit']['database'])
+        statement = ::SQLite3::Statement.new(db,
+                                           'CREATE TABLE statement_test (number integer not null)')
+        statement.stub(:step, ->{ raise ::SQLite3::BusyException.new('busy') }) do
+          assert_called(statement, :columns, returns: []) do
+            assert_called(statement, :close) do
+              ::SQLite3::Statement.stub(:new, statement) do
+                assert_raises ActiveRecord::StatementInvalid do
+                  @conn.exec_query 'select * from statement_test'
+                end
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def assert_logged logs
+        subscriber = SQLSubscriber.new
+        subscription = ActiveSupport::Notifications.subscribe('sql.active_record', subscriber)
+        yield
+        assert_equal logs, subscriber.logged
+      ensure
+        ActiveSupport::Notifications.unsubscribe(subscription)
+      end
+
+      def with_example_table(definition = nil, table_name = 'ex', &block)
+        definition ||= <<-SQL
+          id integer PRIMARY KEY AUTOINCREMENT,
+          number integer
+        SQL
+        super(@conn, table_name, definition, &block)
+      end
+    end
+  end
+end