ibm_db 5.2.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/log_subscriber_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "models/binary"
 require "models/developer"
@@ -21,6 +23,7 @@ class LogSubscriberTest < ActiveRecord::TestCase
       TRANSACTION: REGEXP_CYAN,
       OTHER: REGEXP_MAGENTA
   }
+  Event = Struct.new(:duration, :payload)
 
   class TestDebugLogSubscriber < ActiveRecord::LogSubscriber
     attr_reader :debugs
@@ -30,8 +33,9 @@ class LogSubscriberTest < ActiveRecord::TestCase
       super
     end
 
-    def debug message
-      @debugs << message
+    def debug(progname = nil, &block)
+      @debugs << progname
+      super
     end
   end
 
@@ -40,6 +44,7 @@ class LogSubscriberTest < ActiveRecord::TestCase
   def setup
     @old_logger = ActiveRecord::Base.logger
     Developer.primary_key
+    ActiveRecord::Base.connection.materialize_transactions
     super
     ActiveRecord::LogSubscriber.attach_to(:active_record)
   end
@@ -55,25 +60,22 @@ class LogSubscriberTest < ActiveRecord::TestCase
   end
 
   def test_schema_statements_are_ignored
-    event = Struct.new(:duration, :payload)
-
     logger = TestDebugLogSubscriber.new
     assert_equal 0, logger.debugs.length
 
-    logger.sql(event.new(0.9, sql: "hi mom!"))
+    logger.sql(Event.new(0.9, sql: "hi mom!"))
     assert_equal 1, logger.debugs.length
 
-    logger.sql(event.new(0.9, sql: "hi mom!", name: "foo"))
+    logger.sql(Event.new(0.9, sql: "hi mom!", name: "foo"))
     assert_equal 2, logger.debugs.length
 
-    logger.sql(event.new(0.9, sql: "hi mom!", name: "SCHEMA"))
+    logger.sql(Event.new(0.9, sql: "hi mom!", name: "SCHEMA"))
     assert_equal 2, logger.debugs.length
   end
 
   def test_sql_statements_are_not_squeezed
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
-    logger.sql(event.new(0.9, sql: "ruby   rails"))
+    logger.sql(Event.new(0.9, sql: "ruby   rails"))
     assert_match(/ruby   rails/, logger.debugs.first)
   end
 
@@ -86,56 +88,61 @@ class LogSubscriberTest < ActiveRecord::TestCase
   end
 
   def test_basic_query_logging_coloration
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
     logger.colorize_logging = true
     SQL_COLORINGS.each do |verb, color_regex|
-      logger.sql(event.new(0.9, sql: verb.to_s))
+      logger.sql(Event.new(0.9, sql: verb.to_s))
       assert_match(/#{REGEXP_BOLD}#{color_regex}#{verb}#{REGEXP_CLEAR}/i, logger.debugs.last)
     end
   end
 
+  def test_logging_sql_coloration_disabled
+    logger = TestDebugLogSubscriber.new
+    logger.colorize_logging = false
+
+    SQL_COLORINGS.each do |verb, color_regex|
+      logger.sql(Event.new(0.9, sql: verb.to_s))
+      assert_no_match(/#{REGEXP_BOLD}#{color_regex}#{verb}#{REGEXP_CLEAR}/i, logger.debugs.last)
+    end
+  end
+
   def test_basic_payload_name_logging_coloration_generic_sql
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
     logger.colorize_logging = true
     SQL_COLORINGS.each do |verb, _|
-      logger.sql(event.new(0.9, sql: verb.to_s))
+      logger.sql(Event.new(0.9, sql: verb.to_s))
       assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
 
-      logger.sql(event.new(0.9, sql: verb.to_s, name: "SQL"))
+      logger.sql(Event.new(0.9, sql: verb.to_s, name: "SQL"))
       assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA}SQL \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
     end
   end
 
   def test_basic_payload_name_logging_coloration_named_sql
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
     logger.colorize_logging = true
     SQL_COLORINGS.each do |verb, _|
-      logger.sql(event.new(0.9, sql: verb.to_s, name: "Model Load"))
+      logger.sql(Event.new(0.9, sql: verb.to_s, name: "Model Load"))
       assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}Model Load \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
 
-      logger.sql(event.new(0.9, sql: verb.to_s, name: "Model Exists"))
+      logger.sql(Event.new(0.9, sql: verb.to_s, name: "Model Exists"))
       assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}Model Exists \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
 
-      logger.sql(event.new(0.9, sql: verb.to_s, name: "ANY SPECIFIC NAME"))
+      logger.sql(Event.new(0.9, sql: verb.to_s, name: "ANY SPECIFIC NAME"))
       assert_match(/#{REGEXP_BOLD}#{REGEXP_CYAN}ANY SPECIFIC NAME \(0\.9ms\)#{REGEXP_CLEAR}/i, logger.debugs.last)
     end
   end
 
   def test_query_logging_coloration_with_nested_select
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
     logger.colorize_logging = true
     SQL_COLORINGS.slice(:SELECT, :INSERT, :UPDATE, :DELETE).each do |verb, color_regex|
-      logger.sql(event.new(0.9, sql: "#{verb} WHERE ID IN SELECT"))
+      logger.sql(Event.new(0.9, sql: "#{verb} WHERE ID IN SELECT"))
       assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{color_regex}#{verb} WHERE ID IN SELECT#{REGEXP_CLEAR}/i, logger.debugs.last)
     end
   end
 
   def test_query_logging_coloration_with_multi_line_nested_select
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
     logger.colorize_logging = true
     SQL_COLORINGS.slice(:SELECT, :INSERT, :UPDATE, :DELETE).each do |verb, color_regex|
@@ -145,13 +152,12 @@ class LogSubscriberTest < ActiveRecord::TestCase
           SELECT ID FROM THINGS
         )
       EOS
-      logger.sql(event.new(0.9, sql: sql))
+      logger.sql(Event.new(0.9, sql: sql))
       assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{color_regex}.*#{verb}.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
     end
   end
 
   def test_query_logging_coloration_with_lock
-    event = Struct.new(:duration, :payload)
     logger = TestDebugLogSubscriber.new
     logger.colorize_logging = true
     sql = <<-EOS
@@ -159,13 +165,13 @@ class LogSubscriberTest < ActiveRecord::TestCase
         (SELECT * FROM mytable FOR UPDATE) ss
       WHERE col1 = 5;
     EOS
-    logger.sql(event.new(0.9, sql: sql))
+    logger.sql(Event.new(0.9, sql: sql))
     assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{SQL_COLORINGS[:LOCK]}.*FOR UPDATE.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
 
     sql = <<-EOS
       LOCK TABLE films IN SHARE MODE;
     EOS
-    logger.sql(event.new(0.9, sql: sql))
+    logger.sql(Event.new(0.9, sql: sql))
     assert_match(/#{REGEXP_BOLD}#{REGEXP_MAGENTA} \(0\.9ms\)#{REGEXP_CLEAR}  #{REGEXP_BOLD}#{SQL_COLORINGS[:LOCK]}.*LOCK TABLE.*#{REGEXP_CLEAR}/mi, logger.debugs.last)
   end
 
@@ -177,6 +183,36 @@ class LogSubscriberTest < ActiveRecord::TestCase
     assert_match(/SELECT .*?FROM .?developers.?/i, @logger.logged(:debug).last)
   end
 
+  def test_vebose_query_logs
+    ActiveRecord::Base.verbose_query_logs = true
+
+    logger = TestDebugLogSubscriber.new
+    logger.sql(Event.new(0, sql: "hi mom!"))
+    assert_equal 2, @logger.logged(:debug).size
+    assert_match(/↳/, @logger.logged(:debug).last)
+  ensure
+    ActiveRecord::Base.verbose_query_logs = false
+  end
+
+  def test_verbose_query_with_ignored_callstack
+    ActiveRecord::Base.verbose_query_logs = true
+
+    logger = TestDebugLogSubscriber.new
+    def logger.extract_query_source_location(*); nil; end
+
+    logger.sql(Event.new(0, sql: "hi mom!"))
+    assert_equal 1, @logger.logged(:debug).size
+    assert_no_match(/↳/, @logger.logged(:debug).last)
+  ensure
+    ActiveRecord::Base.verbose_query_logs = false
+  end
+
+  def test_verbose_query_logs_disabled_by_default
+    logger = TestDebugLogSubscriber.new
+    logger.sql(Event.new(0, sql: "hi mom!"))
+    assert_no_match(/↳/, @logger.logged(:debug).last)
+  end
+
   def test_cached_queries
     ActiveRecord::Base.cache do
       Developer.all.load
@@ -210,8 +246,14 @@ class LogSubscriberTest < ActiveRecord::TestCase
   end
 
   if ActiveRecord::Base.connection.prepared_statements
+    def test_where_in_binds_logging_include_attribute_names
+      Developer.where(id: [1, 2, 3, 4, 5]).load
+      wait
+      assert_match(%{["id", 1], ["id", 2], ["id", 3], ["id", 4], ["id", 5]}, @logger.logged(:debug).last)
+    end
+
     def test_binary_data_is_not_logged
-      Binary.create(data: 'some binary data')
+      Binary.create(data: "some binary data")
       wait
       assert_match(/<16 bytes of binary data>/, @logger.logged(:debug).join)
     end

data/test/cases/marshal_serialization_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/reply"
+
+class MarshalSerializationTest < ActiveRecord::TestCase
+  fixtures :topics
+
+  def test_deserializing_rails_6_0_marshal_basic
+    topic = Marshal.load(marshal_fixture("rails_6_0_topic"))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+  end
+
+  def test_deserializing_rails_6_0_marshal_with_loaded_association_cache
+    topic = Marshal.load(marshal_fixture("rails_6_0_topic_associations"))
+
+    assert_not_predicate topic, :new_record?
+    assert_equal 1, topic.id
+    assert_equal "The First Topic", topic.title
+    assert_equal "Have a nice day", topic.content
+  end
+
+  private
+    def marshal_fixture(file_name)
+      File.binread(marshal_fixture_path(file_name))
+    end
+
+    def marshal_fixture_path(file_name)
+      File.expand_path(
+        "support/marshal_compatibility_fixtures/#{ActiveRecord::Base.connection.adapter_name}/#{file_name}.dump",
+        TEST_ROOT
+      )
+    end
+end

data/test/cases/migration/change_schema_test.rb

@@ -1,4 +1,6 @@
-require 'cases/helper'
+# frozen_string_literal: true
+
+require "cases/helper"
 
 module ActiveRecord
   class Migration
@@ -40,10 +42,10 @@ module ActiveRecord
 
       def test_create_table_with_not_null_column
         connection.create_table :testings do |t|
-          t.column :foo, :string, :null => false
+          t.column :foo, :string, null: false
         end
 
-        assert_raises(ActiveRecord::StatementInvalid) do
+        assert_raises(ActiveRecord::NotNullViolation) do
           connection.execute "insert into testings (foo) values (NULL)"
         end
       end
@@ -53,11 +55,11 @@ module ActiveRecord
         mysql = current_adapter?(:Mysql2Adapter)
 
         connection.create_table :testings do |t|
-          t.column :one, :string, :default => "hello"
-          t.column :two, :boolean, :default => true
-          t.column :three, :boolean, :default => false
-          t.column :four, :integer, :default => 1
-          t.column :five, :text, :default => "hello" unless mysql
+          t.column :one, :string, default: "hello"
+          t.column :two, :boolean, default: true
+          t.column :three, :boolean, default: false
+          t.column :four, :integer, default: 1
+          t.column :five, :text, default: "hello" unless mysql
         end
 
         columns = connection.columns(:testings)
@@ -70,30 +72,30 @@ module ActiveRecord
         assert_equal "hello", one.default
         assert_equal true, connection.lookup_cast_type_from_column(two).deserialize(two.default)
         assert_equal false, connection.lookup_cast_type_from_column(three).deserialize(three.default)
-        assert_equal '1', four.default
+        assert_equal "1", four.default
         assert_equal "hello", five.default unless mysql
       end
 
       if current_adapter?(:PostgreSQLAdapter)
         def test_add_column_with_array
           connection.create_table :testings
-          connection.add_column :testings, :foo, :string, :array => true
+          connection.add_column :testings, :foo, :string, array: true
 
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
 
-          assert array_column.array?
+          assert_predicate array_column, :array?
         end
 
         def test_create_table_with_array_column
           connection.create_table :testings do |t|
-            t.string :foo, :array => true
+            t.string :foo, array: true
           end
 
           columns = connection.columns(:testings)
           array_column = columns.detect { |c| c.name == "foo" }
 
-          assert array_column.array?
+          assert_predicate array_column, :array?
         end
       end
 
@@ -105,9 +107,9 @@ module ActiveRecord
         eight   = columns.detect { |c| c.name == "eight_int"   }
 
         if current_adapter?(:OracleAdapter)
-          assert_equal 'NUMBER(19)', eight.sql_type
+          assert_equal "NUMBER(19)", eight.sql_type
         elsif current_adapter?(:SQLite3Adapter)
-          assert_equal 'bigint', eight.sql_type
+          assert_equal "bigint", eight.sql_type
         else
           assert_equal :integer, eight.type
           assert_equal 8, eight.limit
@@ -118,13 +120,13 @@ module ActiveRecord
 
       def test_create_table_with_limits
         connection.create_table :testings do |t|
-          t.column :foo, :string, :limit => 255
+          t.column :foo, :string, limit: 255
 
           t.column :default_int, :integer
 
-          t.column :one_int,    :integer, :limit => 1
-          t.column :four_int,   :integer, :limit => 4
-          t.column :eight_int,  :integer, :limit => 8
+          t.column :one_int,    :integer, limit: 1
+          t.column :four_int,   :integer, limit: 4
+          t.column :eight_int,  :integer, limit: 8
         end
 
         columns = connection.columns(:testings)
@@ -137,20 +139,20 @@ module ActiveRecord
         eight   = columns.detect { |c| c.name == "eight_int"   }
 
         if current_adapter?(:PostgreSQLAdapter)
-          assert_equal 'integer', default.sql_type
-          assert_equal 'smallint', one.sql_type
-          assert_equal 'integer', four.sql_type
-          assert_equal 'bigint', eight.sql_type
+          assert_equal "integer", default.sql_type
+          assert_equal "smallint", one.sql_type
+          assert_equal "integer", four.sql_type
+          assert_equal "bigint", eight.sql_type
         elsif current_adapter?(:Mysql2Adapter)
-          assert_match 'int(11)', default.sql_type
-          assert_match 'tinyint', one.sql_type
-          assert_match 'int', four.sql_type
-          assert_match 'bigint', eight.sql_type
+          assert_match %r/\Aint/, default.sql_type
+          assert_match %r/\Atinyint/, one.sql_type
+          assert_match %r/\Aint/, four.sql_type
+          assert_match %r/\Abigint/, eight.sql_type
         elsif current_adapter?(:OracleAdapter)
-          assert_equal 'NUMBER(38)', default.sql_type
-          assert_equal 'NUMBER(1)', one.sql_type
-          assert_equal 'NUMBER(4)', four.sql_type
-          assert_equal 'NUMBER(8)', eight.sql_type
+          assert_equal "NUMBER(38)", default.sql_type
+          assert_equal "NUMBER(1)", one.sql_type
+          assert_equal "NUMBER(4)", four.sql_type
+          assert_equal "NUMBER(8)", eight.sql_type
         end
       end
 
@@ -194,17 +196,28 @@ module ActiveRecord
         assert_equal "you can't redefine the primary key column 'testing_id'. To define a custom primary key, pass { id: false } to create_table.", error.message
       end
 
+      def test_create_table_raises_when_defining_existing_column
+        error = assert_raise(ArgumentError) do
+          connection.create_table :testings do |t|
+            t.column :testing_column, :string
+            t.column :testing_column, :integer
+          end
+        end
+
+        assert_equal "you can't define an already defined column 'testing_column'.", error.message
+      end
+
       def test_create_table_with_timestamps_should_create_datetime_columns
         connection.create_table table_name do |t|
           t.timestamps
         end
         created_columns = connection.columns(table_name)
 
-        created_at_column = created_columns.detect {|c| c.name == 'created_at' }
-        updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }
+        created_at_column = created_columns.detect { |c| c.name == "created_at" }
+        updated_at_column = created_columns.detect { |c| c.name == "updated_at" }
 
-        assert !created_at_column.null
-        assert !updated_at_column.null
+        assert_not created_at_column.null
+        assert_not updated_at_column.null
       end
 
       def test_create_table_with_timestamps_should_create_datetime_columns_with_options
@@ -213,8 +226,8 @@ module ActiveRecord
         end
         created_columns = connection.columns(table_name)
 
-        created_at_column = created_columns.detect {|c| c.name == 'created_at' }
-        updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }
+        created_at_column = created_columns.detect { |c| c.name == "created_at" }
+        updated_at_column = created_columns.detect { |c| c.name == "updated_at" }
 
         assert created_at_column.null
         assert updated_at_column.null
@@ -231,9 +244,9 @@ module ActiveRecord
           connection.create_table :testings do |t|
             t.column :foo, :string
           end
-          connection.add_column :testings, :bar, :string, :null => false
+          connection.add_column :testings, :bar, :string, null: false
 
-          assert_raise(ActiveRecord::StatementInvalid) do
+          assert_raise(ActiveRecord::NotNullViolation) do
             connection.execute "insert into testings (foo, bar) values ('hello', NULL)"
           end
         end
@@ -244,12 +257,16 @@ module ActiveRecord
           t.column :foo, :string
         end
 
-        con = connection
-        connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}) values (1, 'hello')"
-        assert_nothing_raised {connection.add_column :testings, :bar, :string, :null => false, :default => "default" }
+        quoted_id  = connection.quote_column_name("id")
+        quoted_foo = connection.quote_column_name("foo")
+        quoted_bar = connection.quote_column_name("bar")
+        connection.execute("insert into testings (#{quoted_id}, #{quoted_foo}) values (1, 'hello')")
+        assert_nothing_raised do
+          connection.add_column :testings, :bar, :string, null: false, default: "default"
+        end
 
-        assert_raises(ActiveRecord::StatementInvalid) do
-          connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) values (2, 'hello', NULL)"
+        assert_raises(ActiveRecord::NotNullViolation) do
+          connection.execute("insert into testings (#{quoted_id}, #{quoted_foo}, #{quoted_bar}) values (2, 'hello', NULL)")
         end
       end
 
@@ -258,15 +275,40 @@ module ActiveRecord
           t.column :foo, :timestamp
         end
 
-        klass = Class.new(ActiveRecord::Base)
-        klass.table_name = 'testings'
+        column = connection.columns(:testings).find { |c| c.name == "foo" }
+
+        assert_equal :datetime, column.type
+
+        if current_adapter?(:PostgreSQLAdapter)
+          assert_equal "timestamp without time zone", column.sql_type
+        elsif current_adapter?(:Mysql2Adapter)
+          assert_equal "timestamp", column.sql_type
+        elsif current_adapter?(:OracleAdapter, :IBM_DBAdapter)
+          assert_equal "timestamp(6)", column.sql_type
+        else
+          assert_equal connection.type_to_sql("datetime"), column.sql_type
+        end
+      end
+
+      def test_change_column_with_timestamp_type
+        connection.create_table :testings do |t|
+          t.column :foo, :datetime, null: false
+        end
+
+        connection.change_column :testings, :foo, :timestamp
+
+        column = connection.columns(:testings).find { |c| c.name == "foo" }
 
-        assert_equal :datetime, klass.columns_hash['foo'].type
+        assert_equal :datetime, column.type
 
         if current_adapter?(:PostgreSQLAdapter)
-          assert_equal 'timestamp without time zone', klass.columns_hash['foo'].sql_type
+          assert_equal "timestamp without time zone", column.sql_type
+        elsif current_adapter?(:Mysql2Adapter)
+          assert_equal "timestamp", column.sql_type
+        elsif current_adapter?(:OracleAdapter, :IBM_DBAdapter)
+          assert_equal "timestamp(6)", column.sql_type
         else
-          assert_equal klass.connection.type_to_sql('datetime'), klass.columns_hash['foo'].sql_type
+          assert_equal connection.type_to_sql("datetime"), column.sql_type
         end
       end
 
@@ -275,7 +317,7 @@ module ActiveRecord
           t.column :select, :string
         end
 
-        connection.change_column :testings, :select, :string, :limit => 10
+        connection.change_column :testings, :select, :string, limit: 10
 
         # Oracle needs primary key value from sequence
         if current_adapter?(:OracleAdapter)
@@ -290,17 +332,17 @@ module ActiveRecord
           t.column :title, :string
         end
         person_klass = Class.new(ActiveRecord::Base)
-        person_klass.table_name = 'testings'
+        person_klass.table_name = "testings"
 
-        person_klass.connection.add_column "testings", "wealth", :integer, :null => false, :default => 99
+        person_klass.connection.add_column "testings", "wealth", :integer, null: false, default: 99
         person_klass.reset_column_information
         assert_equal 99, person_klass.column_defaults["wealth"]
         assert_equal false, person_klass.columns_hash["wealth"].null
         # Oracle needs primary key value from sequence
         if current_adapter?(:OracleAdapter)
-          assert_nothing_raised {person_klass.connection.execute("insert into testings (id, title) values (testings_seq.nextval, 'tester')")}
+          assert_nothing_raised { person_klass.connection.execute("insert into testings (id, title) values (testings_seq.nextval, 'tester')") }
         else
-          assert_nothing_raised {person_klass.connection.execute("insert into testings (title) values ('tester')")}
+          assert_nothing_raised { person_klass.connection.execute("insert into testings (title) values ('tester')") }
         end
 
         # change column default to see that column doesn't lose its not null definition
@@ -317,19 +359,19 @@ module ActiveRecord
         assert_equal false, person_klass.columns_hash["money"].null
 
         # change column
-        person_klass.connection.change_column "testings", "money", :integer, :null => false, :default => 1000
+        person_klass.connection.change_column "testings", "money", :integer, null: false, default: 1000
         person_klass.reset_column_information
         assert_equal 1000, person_klass.column_defaults["money"]
         assert_equal false, person_klass.columns_hash["money"].null
 
         # change column, make it nullable and clear default
-        person_klass.connection.change_column "testings", "money", :integer, :null => true, :default => nil
+        person_klass.connection.change_column "testings", "money", :integer, null: true, default: nil
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["money"].default
         assert_equal true, person_klass.columns_hash["money"].null
 
         # change_column_null, make it not nullable and set null values to a default value
-        person_klass.connection.execute('UPDATE testings SET money = NULL')
+        person_klass.connection.execute("UPDATE testings SET money = NULL")
         person_klass.connection.change_column_null "testings", "money", false, 2000
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["money"].default
@@ -346,9 +388,9 @@ module ActiveRecord
           end
           notnull_migration.new.suppress_messages do
             notnull_migration.migrate(:up)
-            assert_equal false, connection.columns(:testings).find{ |c| c.name == "foo"}.null
+            assert_equal false, connection.columns(:testings).find { |c| c.name == "foo" }.null
             notnull_migration.migrate(:down)
-            assert connection.columns(:testings).find{ |c| c.name == "foo"}.null
+            assert connection.columns(:testings).find { |c| c.name == "foo" }.null
           end
         end
       end
@@ -365,7 +407,7 @@ module ActiveRecord
       def test_column_exists_with_type
         connection.create_table :testings do |t|
           t.column :foo, :string
-          t.column :bar, :decimal, :precision => 8, :scale => 2
+          t.column :bar, :decimal, precision: 8, scale: 2
         end
 
         assert connection.column_exists?(:testings, :foo, :string)
@@ -380,7 +422,7 @@ module ActiveRecord
           t.column :foo, :string, limit: 100
           t.column :bar, :decimal, precision: 8, scale: 2
           t.column :taggable_id, :integer, null: false
-          t.column :taggable_type, :string, default: 'Photo'
+          t.column :taggable_type, :string, default: "Photo"
         end
 
         assert connection.column_exists?(:testings, :foo, :string, limit: 100)
@@ -389,7 +431,7 @@ module ActiveRecord
         assert_not connection.column_exists?(:testings, :bar, :decimal, precision: nil, scale: nil)
         assert connection.column_exists?(:testings, :taggable_id, :integer, null: false)
         assert_not connection.column_exists?(:testings, :taggable_id, :integer, null: true)
-        assert connection.column_exists?(:testings, :taggable_type, :string, default: 'Photo')
+        assert connection.column_exists?(:testings, :taggable_type, :string, default: "Photo")
         assert_not connection.column_exists?(:testings, :taggable_type, :string, default: nil)
       end
 
@@ -399,15 +441,15 @@ module ActiveRecord
         end
         connection.change_table :testings do |t|
           assert t.column_exists?(:foo)
-          assert !(t.column_exists?(:bar))
+          assert_not (t.column_exists?(:bar))
         end
       end
 
       def test_drop_table_if_exists
         connection.create_table(:testings)
-        ActiveSupport::Deprecation.silence { assert connection.table_exists?(:testings) }
+        assert connection.table_exists?(:testings)
         connection.drop_table(:testings, if_exists: true)
-        ActiveSupport::Deprecation.silence { assert_not connection.table_exists?(:testings) }
+        assert_not connection.table_exists?(:testings)
       end
 
       def test_drop_table_if_exists_nothing_raised
@@ -415,13 +457,13 @@ module ActiveRecord
       end
 
       private
-      def testing_table_with_only_foo_attribute
-        connection.create_table :testings, :id => false do |t|
-          t.column :foo, :string
-        end
+        def testing_table_with_only_foo_attribute
+          connection.create_table :testings, id: false do |t|
+            t.column :foo, :string
+          end
 
-        yield
-      end
+          yield
+        end
     end
 
     if ActiveRecord::Base.connection.supports_foreign_keys?
@@ -442,7 +484,11 @@ module ActiveRecord
         end
 
         def test_create_table_with_force_cascade_drops_dependent_objects
-          skip "MySQL > 5.5 does not drop dependent objects with DROP TABLE CASCADE" if current_adapter?(:Mysql2Adapter)
+          if current_adapter?(:Mysql2Adapter)
+            skip "MySQL > 5.5 does not drop dependent objects with DROP TABLE CASCADE"
+          elsif current_adapter?(:SQLite3Adapter)
+            skip "SQLite3 does not support DROP TABLE CASCADE syntax"
+          end
           # can't re-create table referenced by foreign key
           assert_raises(ActiveRecord::StatementInvalid) do
             @connection.create_table :trains, force: true