ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

data/test/cases/adapters/mysql2/active_schema_test.rb

@@ -1,13 +1,24 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/connection_helper'
+require "support/connection_helper"
 
 class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
   include ConnectionHelper
 
   def setup
+    ActiveRecord::Base.connection.send(:default_row_format)
     ActiveRecord::Base.connection.singleton_class.class_eval do
       alias_method :execute_without_stub, :execute
-      def execute(sql, name = nil) return sql end
+      def execute(sql, name = nil)
+        ActiveSupport::Notifications.instrumenter.instrument(
+          "sql.active_record",
+          sql: sql,
+          name: name,
+          connection: self) do
+          sql
+        end
+      end
     end
   end
 
@@ -16,87 +27,91 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
   end
 
   def test_add_index
-    # add_index calls data_source_exists? and index_name_exists? which can't work since execute is stubbed
-    def (ActiveRecord::Base.connection).data_source_exists?(*); true; end
-    def (ActiveRecord::Base.connection).index_name_exists?(*); false; end
+    expected = "CREATE INDEX `index_people_on_last_name` ON `people` (`last_name`)"
+    assert_equal expected, add_index(:people, :last_name, length: nil)
 
-    expected = "CREATE  INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
-    assert_equal expected, add_index(:people, :last_name, :length => nil)
+    expected = "CREATE INDEX `index_people_on_last_name` ON `people` (`last_name`(10))"
+    assert_equal expected, add_index(:people, :last_name, length: 10)
 
-    expected = "CREATE  INDEX `index_people_on_last_name`  ON `people` (`last_name`(10)) "
-    assert_equal expected, add_index(:people, :last_name, :length => 10)
-
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(15)) "
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`(15))"
     assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15)
     assert_equal expected, add_index(:people, ["last_name", "first_name"], length: 15)
 
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`) "
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`)"
     assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15 })
     assert_equal expected, add_index(:people, ["last_name", "first_name"], length: { last_name: 15 })
 
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name`  ON `people` (`last_name`(15), `first_name`(10)) "
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`(10))"
     assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15, first_name: 10 })
     assert_equal expected, add_index(:people, ["last_name", :first_name], length: { last_name: 15, "first_name" => 10 })
 
     %w(SPATIAL FULLTEXT UNIQUE).each do |type|
-      expected = "CREATE #{type} INDEX `index_people_on_last_name`  ON `people` (`last_name`) "
-      assert_equal expected, add_index(:people, :last_name, :type => type)
+      expected = "CREATE #{type} INDEX `index_people_on_last_name` ON `people` (`last_name`)"
+      assert_equal expected, add_index(:people, :last_name, type: type)
     end
 
     %w(btree hash).each do |using|
-      expected = "CREATE  INDEX `index_people_on_last_name` USING #{using} ON `people` (`last_name`) "
-      assert_equal expected, add_index(:people, :last_name, :using => using)
+      expected = "CREATE INDEX `index_people_on_last_name` USING #{using} ON `people` (`last_name`)"
+      assert_equal expected, add_index(:people, :last_name, using: using)
+    end
+
+    expected = "CREATE INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10))"
+    assert_equal expected, add_index(:people, :last_name, length: 10, using: :btree)
+
+    %i(default copy inplace instant).each do |algorithm|
+      expected = "CREATE INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) ALGORITHM = #{algorithm.upcase}"
+      assert_equal expected, add_index(:people, :last_name, length: 10, using: :btree, algorithm: algorithm)
     end
 
-    expected = "CREATE  INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) "
-    assert_equal expected, add_index(:people, :last_name, :length => 10, :using => :btree)
+    with_real_execute do
+      add_index(:people, :first_name)
+      assert index_exists?(:people, :first_name)
 
-    expected = "CREATE  INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) ALGORITHM = COPY"
-    assert_equal expected, add_index(:people, :last_name, :length => 10, using: :btree, algorithm: :copy)
+      assert_nothing_raised do
+        add_index(:people, :first_name, if_not_exists: true)
+      end
+    end
 
     assert_raise ArgumentError do
       add_index(:people, :last_name, algorithm: :coyp)
     end
 
-    expected = "CREATE  INDEX `index_people_on_last_name_and_first_name` USING btree ON `people` (`last_name`(15), `first_name`(15)) "
-    assert_equal expected, add_index(:people, [:last_name, :first_name], :length => 15, :using => :btree)
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` USING btree ON `people` (`last_name`(15), `first_name`(15))"
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15, using: :btree)
   end
 
   def test_index_in_create
-    def (ActiveRecord::Base.connection).data_source_exists?(*); false; end
-
     %w(SPATIAL FULLTEXT UNIQUE).each do |type|
-      expected = "CREATE TABLE `people` (#{type} INDEX `index_people_on_last_name`  (`last_name`)) ENGINE=InnoDB"
+      expected = /\ACREATE TABLE `people` \(#{type} INDEX `index_people_on_last_name` \(`last_name`\)\)/
       actual = ActiveRecord::Base.connection.create_table(:people, id: false) do |t|
         t.index :last_name, type: type
       end
-      assert_equal expected, actual
+      assert_match expected, actual
     end
 
-    expected = "CREATE TABLE `people` ( INDEX `index_people_on_last_name` USING btree (`last_name`(10))) ENGINE=InnoDB"
+    expected = /\ACREATE TABLE `people` \(INDEX `index_people_on_last_name` USING btree \(`last_name`\(10\)\)\)/
     actual = ActiveRecord::Base.connection.create_table(:people, id: false) do |t|
       t.index :last_name, length: 10, using: :btree
     end
-    assert_equal expected, actual
+    assert_match expected, actual
   end
 
   def test_index_in_bulk_change
-    def (ActiveRecord::Base.connection).data_source_exists?(*); true; end
-    def (ActiveRecord::Base.connection).index_name_exists?(*); false; end
-
     %w(SPATIAL FULLTEXT UNIQUE).each do |type|
-      expected = "ALTER TABLE `people` ADD #{type} INDEX `index_people_on_last_name`  (`last_name`)"
-      actual = ActiveRecord::Base.connection.change_table(:people, bulk: true) do |t|
-        t.index :last_name, type: type
+      expected = "ALTER TABLE `people` ADD #{type} INDEX `index_people_on_last_name` (`last_name`)"
+      assert_sql(expected) do
+        ActiveRecord::Base.connection.change_table(:people, bulk: true) do |t|
+          t.index :last_name, type: type
+        end
       end
-      assert_equal expected, actual
     end
 
-    expected = "ALTER TABLE `peaple` ADD  INDEX `index_peaple_on_last_name` USING btree (`last_name`(10)), ALGORITHM = COPY"
-    actual = ActiveRecord::Base.connection.change_table(:peaple, bulk: true) do |t|
-      t.index :last_name, length: 10, using: :btree, algorithm: :copy
+    expected = "ALTER TABLE `people` ADD INDEX `index_people_on_last_name` USING btree (`last_name`(10)), ALGORITHM = COPY"
+    assert_sql(expected) do
+      ActiveRecord::Base.connection.change_table(:people, bulk: true) do |t|
+        t.index :last_name, length: 10, using: :btree, algorithm: :copy
+      end
     end
-    assert_equal expected, actual
   end
 
   def test_drop_table
@@ -104,14 +119,20 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
   end
 
   def test_create_mysql_database_with_encoding
-    assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8`", create_database(:matt)
-    assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, {:charset => 'latin1'})
-    assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT CHARACTER SET `big5` COLLATE `big5_chinese_ci`", create_database(:matt_aimonetti, {:charset => :big5, :collation => :big5_chinese_ci})
+    if ActiveRecord::Base.connection.send(:row_format_dynamic_by_default?)
+      assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8mb4`", create_database(:matt)
+    else
+      error = assert_raises(RuntimeError) { create_database(:matt) }
+      expected = "Configure a supported :charset and ensure innodb_large_prefix is enabled to support indexes on varchar(255) string columns."
+      assert_equal expected, error.message
+    end
+    assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, charset: "latin1")
+    assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT COLLATE `utf8mb4_bin`", create_database(:matt_aimonetti, collation: "utf8mb4_bin")
   end
 
   def test_recreate_mysql_database_with_encoding
-    create_database(:luca, {:charset => 'latin1'})
-    assert_equal "CREATE DATABASE `luca` DEFAULT CHARACTER SET `latin1`", recreate_database(:luca, {:charset => 'latin1'})
+    create_database(:luca, charset: "latin1")
+    assert_equal "CREATE DATABASE `luca` DEFAULT CHARACTER SET `latin1`", recreate_database(:luca, charset: "latin1")
   end
 
   def test_add_column
@@ -119,51 +140,44 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
   end
 
   def test_add_column_with_limit
-    assert_equal "ALTER TABLE `people` ADD `key` varchar(32)", add_column(:people, :key, :string, :limit => 32)
+    assert_equal "ALTER TABLE `people` ADD `key` varchar(32)", add_column(:people, :key, :string, limit: 32)
   end
 
   def test_drop_table_with_specific_database
-    assert_equal "DROP TABLE `otherdb`.`people`", drop_table('otherdb.people')
+    assert_equal "DROP TABLE `otherdb`.`people`", drop_table("otherdb.people")
   end
 
   def test_add_timestamps
     with_real_execute do
-      begin
-        ActiveRecord::Base.connection.create_table :delete_me
-        ActiveRecord::Base.connection.add_timestamps :delete_me, null: true
-        assert column_present?('delete_me', 'updated_at', 'datetime')
-        assert column_present?('delete_me', 'created_at', 'datetime')
-      ensure
-        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
-      end
+      ActiveRecord::Base.connection.create_table :delete_me
+      ActiveRecord::Base.connection.add_timestamps :delete_me, null: true
+      assert column_exists?("delete_me", "updated_at", "datetime")
+      assert column_exists?("delete_me", "created_at", "datetime")
+    ensure
+      ActiveRecord::Base.connection.drop_table :delete_me rescue nil
     end
   end
 
   def test_remove_timestamps
     with_real_execute do
-      begin
-        ActiveRecord::Base.connection.create_table :delete_me do |t|
-          t.timestamps null: true
-        end
-        ActiveRecord::Base.connection.remove_timestamps :delete_me, { null: true }
-        assert !column_present?('delete_me', 'updated_at', 'datetime')
-        assert !column_present?('delete_me', 'created_at', 'datetime')
-      ensure
-        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
+      ActiveRecord::Base.connection.create_table :delete_me do |t|
+        t.timestamps null: true
       end
+      ActiveRecord::Base.connection.remove_timestamps :delete_me, null: true
+      assert_not column_exists?("delete_me", "updated_at", "datetime")
+      assert_not column_exists?("delete_me", "created_at", "datetime")
+    ensure
+      ActiveRecord::Base.connection.drop_table :delete_me rescue nil
     end
   end
 
   def test_indexes_in_create
-    ActiveRecord::Base.connection.stubs(:data_source_exists?).with(:temp).returns(false)
-    ActiveRecord::Base.connection.stubs(:index_name_exists?).with(:index_temp_on_zip).returns(false)
-
-    expected = "CREATE TEMPORARY TABLE `temp` ( INDEX `index_temp_on_zip`  (`zip`)) ENGINE=InnoDB AS SELECT id, name, zip FROM a_really_complicated_query"
+    expected = /\ACREATE TEMPORARY TABLE `temp` \(INDEX `index_temp_on_zip` \(`zip`\)\)(?: ROW_FORMAT=DYNAMIC)? AS SELECT id, name, zip FROM a_really_complicated_query/
     actual = ActiveRecord::Base.connection.create_table(:temp, temporary: true, as: "SELECT id, name, zip FROM a_really_complicated_query") do |t|
       t.index :zip
     end
 
-    assert_equal expected, actual
+    assert_match expected, actual
   end
 
   private
@@ -183,11 +197,7 @@ class Mysql2ActiveSchemaTest < ActiveRecord::Mysql2TestCase
     end
 
     def method_missing(method_symbol, *arguments)
-      ActiveRecord::Base.connection.send(method_symbol, *arguments)
-    end
-
-    def column_present?(table_name, column_name, type)
-      results = ActiveRecord::Base.connection.select_all("SHOW FIELDS FROM #{table_name} LIKE '#{column_name}'")
-      results.first && results.first['Type'] == type
+      ActiveRecord::Base.connection.public_send(method_symbol, *arguments)
     end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 end

data/test/cases/adapters/mysql2/auto_increment_test.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class Mysql2AutoIncrementTest < ActiveRecord::Mysql2TestCase
+  include SchemaDumpingHelper
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    @connection.drop_table :auto_increments, if_exists: true
+  end
+
+  def test_auto_increment_without_primary_key
+    @connection.create_table :auto_increments, id: false, force: true do |t|
+      t.integer :id, null: false, auto_increment: true
+      t.index :id
+    end
+    output = dump_table_schema("auto_increments")
+    assert_match(/t\.integer\s+"id",\s+null: false,\s+auto_increment: true$/, output)
+  end
+
+  def test_auto_increment_with_composite_primary_key
+    @connection.create_table :auto_increments, primary_key: [:id, :created_at], force: true do |t|
+      t.integer :id, null: false, auto_increment: true
+      t.datetime :created_at, null: false
+    end
+    output = dump_table_schema("auto_increments")
+    assert_match(/t\.integer\s+"id",\s+null: false,\s+auto_increment: true$/, output)
+  end
+end

data/test/cases/adapters/mysql2/bind_parameter_test.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/topic'
+require "models/topic"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -20,7 +22,7 @@ module ActiveRecord
 
         def test_create_question_marks
           str = "foo?bar"
-          x   = Topic.create!(:title => str, :content => str)
+          x   = Topic.create!(title: str, content: str)
           x.reload
           assert_equal str, x.title
           assert_equal str, x.content
@@ -39,7 +41,7 @@ module ActiveRecord
 
         def test_create_null_bytes
           str = "foo\0bar"
-          x   = Topic.create!(:title => str, :content => str)
+          x   = Topic.create!(title: str, content: str)
           x.reload
           assert_equal str, x.title
           assert_equal str, x.content

data/test/cases/adapters/mysql2/boolean_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class Mysql2BooleanTest < ActiveRecord::Mysql2TestCase
@@ -38,7 +40,7 @@ class Mysql2BooleanTest < ActiveRecord::Mysql2TestCase
     assert_equal :string, string_column.type
   end
 
-  test "test type casting with emulated booleans" do
+  test "type casting with emulated booleans" do
     emulate_booleans true
 
     boolean = BooleanType.create!(archived: true, published: true)
@@ -55,7 +57,7 @@ class Mysql2BooleanTest < ActiveRecord::Mysql2TestCase
     assert_equal 0, @connection.type_cast(false)
   end
 
-  test "test type casting without emulated booleans" do
+  test "type casting without emulated booleans" do
     emulate_booleans false
 
     boolean = BooleanType.create!(archived: true, published: true)
@@ -86,11 +88,11 @@ class Mysql2BooleanTest < ActiveRecord::Mysql2TestCase
   end
 
   def boolean_column
-    BooleanType.columns.find { |c| c.name == 'archived' }
+    BooleanType.columns.find { |c| c.name == "archived" }
   end
 
   def string_column
-    BooleanType.columns.find { |c| c.name == 'published' }
+    BooleanType.columns.find { |c| c.name == "published" }
   end
 
   def emulate_booleans(value)

data/test/cases/adapters/mysql2/case_sensitivity_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
@@ -7,56 +9,56 @@ class Mysql2CaseSensitivityTest < ActiveRecord::Mysql2TestCase
   repair_validations(CollationTest)
 
   def test_columns_include_collation_different_from_table
-    assert_equal 'utf8_bin', CollationTest.columns_hash['string_cs_column'].collation
-    assert_equal 'utf8_general_ci', CollationTest.columns_hash['string_ci_column'].collation
+    assert_equal "utf8mb4_bin", CollationTest.columns_hash["string_cs_column"].collation
+    assert_equal "utf8mb4_general_ci", CollationTest.columns_hash["string_ci_column"].collation
   end
 
   def test_case_sensitive
-    assert !CollationTest.columns_hash['string_ci_column'].case_sensitive?
-    assert CollationTest.columns_hash['string_cs_column'].case_sensitive?
+    assert_not_predicate CollationTest.columns_hash["string_ci_column"], :case_sensitive?
+    assert_predicate CollationTest.columns_hash["string_cs_column"], :case_sensitive?
   end
 
   def test_case_insensitive_comparison_for_ci_column
-    CollationTest.validates_uniqueness_of(:string_ci_column, :case_sensitive => false)
-    CollationTest.create!(:string_ci_column => 'A')
-    invalid = CollationTest.new(:string_ci_column => 'a')
-    queries = assert_sql { invalid.save }
+    CollationTest.validates_uniqueness_of(:string_ci_column, case_sensitive: false)
+    CollationTest.create!(string_ci_column: "A")
+    invalid = CollationTest.new(string_ci_column: "a")
+    queries = capture_sql { invalid.save }
     ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
     assert_no_match(/lower/i, ci_uniqueness_query)
   end
 
   def test_case_insensitive_comparison_for_cs_column
-    CollationTest.validates_uniqueness_of(:string_cs_column, :case_sensitive => false)
-    CollationTest.create!(:string_cs_column => 'A')
-    invalid = CollationTest.new(:string_cs_column => 'a')
-    queries = assert_sql { invalid.save }
-    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/)}
+    CollationTest.validates_uniqueness_of(:string_cs_column, case_sensitive: false)
+    CollationTest.create!(string_cs_column: "A")
+    invalid = CollationTest.new(string_cs_column: "a")
+    queries = capture_sql { invalid.save }
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
     assert_match(/lower/i, cs_uniqueness_query)
   end
 
   def test_case_sensitive_comparison_for_ci_column
-    CollationTest.validates_uniqueness_of(:string_ci_column, :case_sensitive => true)
-    CollationTest.create!(:string_ci_column => 'A')
-    invalid = CollationTest.new(:string_ci_column => 'A')
-    queries = assert_sql { invalid.save }
+    CollationTest.validates_uniqueness_of(:string_ci_column, case_sensitive: true)
+    CollationTest.create!(string_ci_column: "A")
+    invalid = CollationTest.new(string_ci_column: "A")
+    queries = capture_sql { invalid.save }
     ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
     assert_match(/binary/i, ci_uniqueness_query)
   end
 
   def test_case_sensitive_comparison_for_cs_column
-    CollationTest.validates_uniqueness_of(:string_cs_column, :case_sensitive => true)
-    CollationTest.create!(:string_cs_column => 'A')
-    invalid = CollationTest.new(:string_cs_column => 'A')
-    queries = assert_sql { invalid.save }
+    CollationTest.validates_uniqueness_of(:string_cs_column, case_sensitive: true)
+    CollationTest.create!(string_cs_column: "A")
+    invalid = CollationTest.new(string_cs_column: "A")
+    queries = capture_sql { invalid.save }
     cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
     assert_no_match(/binary/i, cs_uniqueness_query)
   end
 
   def test_case_sensitive_comparison_for_binary_column
     CollationTest.validates_uniqueness_of(:binary_column, case_sensitive: true)
-    CollationTest.create!(binary_column: 'A')
-    invalid = CollationTest.new(binary_column: 'A')
-    queries = assert_sql { invalid.save }
+    CollationTest.create!(binary_column: "A")
+    invalid = CollationTest.new(binary_column: "A")
+    queries = capture_sql { invalid.save }
     bin_uniqueness_query = queries.detect { |q| q.match(/binary_column/) }
     assert_no_match(/\bBINARY\b/, bin_uniqueness_query)
   end

data/test/cases/adapters/mysql2/charset_collation_test.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class Mysql2CharsetCollationTest < ActiveRecord::Mysql2TestCase
   include SchemaDumpingHelper
@@ -7,9 +9,9 @@ class Mysql2CharsetCollationTest < ActiveRecord::Mysql2TestCase
 
   setup do
     @connection = ActiveRecord::Base.connection
-    @connection.create_table :charset_collations, force: true do |t|
-      t.string :string_ascii_bin, charset: 'ascii', collation: 'ascii_bin'
-      t.text :text_ucs2_unicode_ci, charset: 'ucs2', collation: 'ucs2_unicode_ci'
+    @connection.create_table :charset_collations, id: { type: :string, collation: "utf8mb4_bin" }, force: true do |t|
+      t.string :string_ascii_bin, charset: "ascii", collation: "ascii_bin"
+      t.text :text_ucs2_unicode_ci, charset: "ucs2", collation: "ucs2_unicode_ci"
     end
   end
 
@@ -18,37 +20,38 @@ class Mysql2CharsetCollationTest < ActiveRecord::Mysql2TestCase
   end
 
   test "string column with charset and collation" do
-    column = @connection.columns(:charset_collations).find { |c| c.name == 'string_ascii_bin' }
+    column = @connection.columns(:charset_collations).find { |c| c.name == "string_ascii_bin" }
     assert_equal :string, column.type
-    assert_equal 'ascii_bin', column.collation
+    assert_equal "ascii_bin", column.collation
   end
 
   test "text column with charset and collation" do
-    column = @connection.columns(:charset_collations).find { |c| c.name == 'text_ucs2_unicode_ci' }
+    column = @connection.columns(:charset_collations).find { |c| c.name == "text_ucs2_unicode_ci" }
     assert_equal :text, column.type
-    assert_equal 'ucs2_unicode_ci', column.collation
+    assert_equal "ucs2_unicode_ci", column.collation
   end
 
   test "add column with charset and collation" do
-    @connection.add_column :charset_collations, :title, :string, charset: 'utf8', collation: 'utf8_bin'
+    @connection.add_column :charset_collations, :title, :string, charset: "utf8mb4", collation: "utf8mb4_bin"
 
-    column = @connection.columns(:charset_collations).find { |c| c.name == 'title' }
+    column = @connection.columns(:charset_collations).find { |c| c.name == "title" }
     assert_equal :string, column.type
-    assert_equal 'utf8_bin', column.collation
+    assert_equal "utf8mb4_bin", column.collation
   end
 
   test "change column with charset and collation" do
-    @connection.add_column :charset_collations, :description, :string, charset: 'utf8', collation: 'utf8_unicode_ci'
-    @connection.change_column :charset_collations, :description, :text, charset: 'utf8', collation: 'utf8_general_ci'
+    @connection.add_column :charset_collations, :description, :string, charset: "utf8mb4", collation: "utf8mb4_unicode_ci"
+    @connection.change_column :charset_collations, :description, :text, charset: "utf8mb4", collation: "utf8mb4_general_ci"
 
-    column = @connection.columns(:charset_collations).find { |c| c.name == 'description' }
+    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
     assert_equal :text, column.type
-    assert_equal 'utf8_general_ci', column.collation
+    assert_equal "utf8mb4_general_ci", column.collation
   end
 
   test "schema dump includes collation" do
     output = dump_table_schema("charset_collations")
-    assert_match %r{t.string\s+"string_ascii_bin",\s+collation: "ascii_bin"$}, output
-    assert_match %r{t.text\s+"text_ucs2_unicode_ci",\s+limit: 65535,\s+collation: "ucs2_unicode_ci"$}, output
+    assert_match %r/create_table "charset_collations", id: { type: :string, collation: "utf8mb4_bin" }/, output
+    assert_match %r{t\.string\s+"string_ascii_bin",\s+collation: "ascii_bin"$}, output
+    assert_match %r{t\.text\s+"text_ucs2_unicode_ci",\s+collation: "ucs2_unicode_ci"$}, output
   end
 end