ibm_db 5.6.1 → 5.7.0

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

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/tasks/database_tasks"
+
+module ActiveRecord
+  class MysqlDBCreateTest < ActiveRecord::TestCase
+    def setup
+      @connection = Class.new do
+        def create_database(*); end
+        def error_number(_); end
+      end.new
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_establishes_connection_without_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      mock = Minitest::Mock.new
+      mock.expect(:call, nil, [adapter: "mysql2", database: nil])
+      mock.expect(:call, nil, [db_config])
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        ActiveRecord::Base.stub(:establish_connection, mock) do
+          ActiveRecord::Tasks::DatabaseTasks.create(db_config)
+        end
+      end
+
+      assert_mock(mock)
+    end
+
+    def test_creates_database_with_no_default_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :create_database, ["my-app-db", {}]) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        end
+      end
+    end
+
+    def test_creates_database_with_given_encoding
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :create_database, ["my-app-db", charset: "latin1"]) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("encoding" => "latin1")
+        end
+      end
+    end
+
+    def test_creates_database_with_given_collation
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :create_database,
+          ["my-app-db", collation: "latin1_swedish_ci"]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("collation" => "latin1_swedish_ci")
+        end
+      end
+    end
+
+    def test_when_database_created_successfully_outputs_info_to_stdout
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+        assert_equal "Created database 'my-app-db'\n", $stdout.string
+      end
+    end
+
+    def test_create_when_database_exists_outputs_info_to_stderr
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Base.lease_connection.stub(
+          :create_database,
+          proc { raise ActiveRecord::DatabaseAlreadyExists }
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+          assert_equal "Database 'my-app-db' already exists\n", $stderr.string
+        end
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MysqlDBCreateWithInvalidPermissionsTest < ActiveRecord::TestCase
+    def setup
+      @error         = Mysql2::Error.new("Invalid permissions")
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "my-app-db",
+        "username" => "pat",
+        "password" => "wossname"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_raises_error
+      ActiveRecord::Base.stub(:establish_connection, -> * { raise @error }) do
+        assert_raises(Mysql2::Error, "Invalid permissions") do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        end
+      end
+    end
+  end
+
+  class MySQLDBDropTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def drop_database(name); end }.new
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_establishes_connection_to_mysql_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called_with(
+          ActiveRecord::Base,
+          :establish_connection,
+          [db_config]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop(db_config)
+        end
+      end
+    end
+
+    def test_drops_database
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :drop_database, ["my-app-db"]) do
+          ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+        end
+      end
+    end
+
+    def test_when_database_dropped_successfully_outputs_info_to_stdout
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+
+        assert_equal "Dropped database 'my-app-db'\n", $stdout.string
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MySQLPurgeTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def recreate_database(*); end }.new
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "test-db"
+      }
+    end
+
+    def test_establishes_connection_without_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(ActiveRecord::Base, :establish_connection, times: 2) do
+          ActiveRecord::Tasks::DatabaseTasks.purge(db_config)
+        end
+      end
+    end
+
+    def test_recreates_database_with_no_default_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :recreate_database, ["test-db", {}]) do
+          ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+        end
+      end
+    end
+
+    def test_recreates_database_with_the_given_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :recreate_database,
+          ["test-db", charset: "latin", collation: "latin1_swedish_ci"]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.purge @configuration.merge(
+            "encoding" => "latin", "collation" => "latin1_swedish_ci")
+        end
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MysqlDBCharsetTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def charset; end }.new
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_db_retrieves_charset
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :charset) do
+          ActiveRecord::Tasks::DatabaseTasks.charset @configuration
+        end
+      end
+    end
+  end
+
+  class MysqlDBCollationTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def collation; end }.new
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_db_retrieves_collation
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :collation) do
+          ActiveRecord::Tasks::DatabaseTasks.collation @configuration
+        end
+      end
+    end
+  end
+
+  class MySQLStructureDumpTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "test-db"
+      }
+    end
+
+    def test_structure_dump
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+      end
+    end
+
+    def test_structure_dump_with_extra_flags
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--noop", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_hash_extra_flags_for_a_different_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags({ postgresql: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_hash_extra_flags_for_the_correct_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--noop", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags({ mysql2: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_ignore_tables
+      filename = "awesome-file.sql"
+      ActiveRecord::Base.lease_connection.stub(:data_sources, ["foo", "bar", "prefix_foo", "ignored_foo"]) do
+        ActiveRecord::SchemaDumper.stub(:ignore_tables, [/^prefix_/, "ignored_foo"]) do
+          assert_called_with(
+            Kernel,
+            :system,
+            ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "--ignore-table=test-db.prefix_foo", "--ignore-table=test-db.ignored_foo", "test-db"],
+            returns: true
+          ) do
+            ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+          end
+        end
+      end
+    end
+
+    def test_warn_when_external_structure_dump_command_execution_fails
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"],
+        returns: false
+      ) do
+        e = assert_raise(RuntimeError) {
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        }
+        assert_match(/^failed to execute: `mysqldump`$/, e.message)
+      end
+    end
+
+    def test_structure_dump_with_port_number
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--port=10000", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+          @configuration.merge("port" => 10000),
+          filename)
+      end
+    end
+
+    def test_structure_dump_with_ssl
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--ssl-ca=ca.crt", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"],
+        returns: true
+      ) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+            @configuration.merge("sslca" => "ca.crt"),
+            filename)
+        end
+    end
+
+    private
+      def with_structure_dump_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = old
+      end
+  end
+
+  class MySQLStructureLoadTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "mysql2",
+        "database" => "test-db"
+      }
+    end
+
+    def test_structure_load
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--noop", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_with_hash_extra_flags_for_a_different_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags({ postgresql: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_with_hash_extra_flags_for_the_correct_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--noop", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags({ mysql2: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    private
+      def with_structure_load_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_load_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = old
+      end
+  end
+end

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

@@ -4,7 +4,7 @@ require "cases/helper"
 
 class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
   def setup
-    ActiveRecord::Base.connection.materialize_transactions
+    ActiveRecord::Base.lease_connection.materialize_transactions
 
     ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
       def execute(sql, name = nil) sql end
@@ -73,6 +73,11 @@ class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
     expected = %(CREATE INDEX IF NOT EXISTS "index_people_on_last_name" ON "people" ("last_name"))
     assert_equal expected, add_index(:people, :last_name, if_not_exists: true)
 
+    if supports_nulls_not_distinct?
+      expected = %(CREATE INDEX "index_people_on_last_name" ON "people" ("last_name") NULLS NOT DISTINCT)
+      assert_equal expected, add_index(:people, :last_name, nulls_not_distinct: true)
+    end
+
     assert_raise ArgumentError do
       add_index(:people, :last_name, algorithm: :copy)
     end
@@ -106,8 +111,7 @@ class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
   end
 
   private
-    def method_missing(method_symbol, *arguments)
-      ActiveRecord::Base.connection.public_send(method_symbol, *arguments)
+    def method_missing(...)
+      ActiveRecord::Base.lease_connection.public_send(...)
     end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 end

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

@@ -12,7 +12,7 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
 
     enable_extension!("hstore", @connection)
 
@@ -49,7 +49,7 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
 
   def test_not_compatible_with_serialize_array
     new_klass = Class.new(PgArray) do
-      serialize :tags, Array
+      serialize :tags, type: Array
     end
     assert_raises(ActiveRecord::AttributeMethods::Serialization::ColumnNotSerializableError) do
       new_klass.new
@@ -65,7 +65,7 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
 
   def test_array_with_serialized_attributes
     new_klass = Class.new(PgArray) do
-      serialize :tags, MyTags
+      serialize :tags, coder: MyTags
     end
 
     new_klass.create!(tags: MyTags.new(["one", "two"]))
@@ -269,7 +269,7 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
     oid = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
     comma_delim = oid::Array.new(ActiveRecord::Type::String.new, ",")
     semicolon_delim = oid::Array.new(ActiveRecord::Type::String.new, ";")
-    conn = PgArray.connection
+    conn = PgArray.lease_connection
 
     assert_equal %({"hello,",world;}), conn.type_cast(comma_delim.serialize(strings))
     assert_equal %({hello,;"world;"}), conn.type_cast(semicolon_delim.serialize(strings))
@@ -354,11 +354,11 @@ class PostgresqlArrayTest < ActiveRecord::PostgreSQLTestCase
       def self.model_name; ActiveModel::Name.new(PgArray) end
     end
     e1 = klass.create("tags" => ["black", "blue"])
-    assert e1.persisted?, "Saving e1"
+    assert_predicate e1, :persisted?, "Saving e1"
 
     e2 = klass.create("tags" => ["black", "blue"])
     assert_not e2.persisted?, "e2 shouldn't be valid"
-    assert e2.errors[:tags].any?, "Should have errors for tags"
+    assert_predicate e2.errors[:tags], :any?, "Should have errors for tags"
     assert_equal ["has already been taken"], e2.errors[:tags], "Should have uniqueness message for tags"
   end
 

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      class BindParameterTest < ActiveRecord::PostgreSQLTestCase
+        fixtures :posts
+
+        def test_where_with_string_for_string_column_using_bind_parameters
+          assert_quoted_as "'Welcome to the weblog'", "Welcome to the weblog", match: 1
+        end
+
+        def test_where_with_integer_for_string_column_using_bind_parameters
+          assert_quoted_as "0", 0
+        end
+
+        def test_where_with_float_for_string_column_using_bind_parameters
+          assert_quoted_as "0.0", 0.0
+        end
+
+        def test_where_with_boolean_for_string_column_using_bind_parameters
+          assert_quoted_as "FALSE", false
+        end
+
+        def test_where_with_decimal_for_string_column_using_bind_parameters
+          assert_quoted_as "0.0", BigDecimal(0)
+        end
+
+        def test_where_with_rational_for_string_column_using_bind_parameters
+          assert_quoted_as "0/1", Rational(0)
+        end
+
+        private
+          def assert_quoted_as(expected, value, match: 0)
+            relation = Post.where("title = ?", value)
+            assert_equal(
+              %{SELECT "posts".* FROM "posts" WHERE (title = #{expected})},
+              relation.to_sql,
+            )
+            if match == 0
+              assert_empty relation.to_a
+            else
+              assert_equal match, relation.count
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlBitString < ActiveRecord::Base; end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_bit_strings", force: true) do |t|
       t.bit :a_bit, default: "00000011", limit: 8
       t.bit_varying :a_bit_varying, default: "0011", limit: 4
@@ -59,7 +59,7 @@ class PostgresqlBitStringTest < ActiveRecord::PostgreSQLTestCase
     assert_match %r{t\.bit_varying\s+"a_bit_varying",\s+limit: 4,\s+default: "0011"$}, output
   end
 
-  if ActiveRecord::Base.connection.prepared_statements
+  if ActiveRecord::Base.lease_connection.prepared_statements
     def test_assigning_invalid_hex_string_raises_exception
       assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit: "FF" }
       assert_raises(ActiveRecord::StatementInvalid) { PostgresqlBitString.create! a_bit_varying: "F" }

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

@@ -11,7 +11,7 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.transaction do
       @connection.create_table("bytea_data_type") do |t|
         t.binary "payload"
@@ -87,7 +87,7 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
 
   def test_via_to_sql_with_complicating_connection
     Thread.new do
-      other_conn = ActiveRecord::Base.connection
+      other_conn = ActiveRecord::Base.lease_connection
       other_conn.execute("SET standard_conforming_strings = off")
       other_conn.execute("SET escape_string_warning = off")
     end.join
@@ -118,7 +118,7 @@ class PostgresqlByteaTest < ActiveRecord::PostgreSQLTestCase
 
   def test_serialize
     klass = Class.new(ByteaDataType) {
-      serialize :serialized, Serializer.new
+      serialize :serialized, coder: Serializer.new
     }
     obj = klass.new
     obj.serialized = "hello world"

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

@@ -6,7 +6,7 @@ class PostgresqlCaseInsensitiveTest < ActiveRecord::PostgreSQLTestCase
   class Default < ActiveRecord::Base; end
 
   def test_case_insensitiveness
-    connection = ActiveRecord::Base.connection
+    connection = ActiveRecord::Base.lease_connection
 
     attr = Default.arel_table[:char1]
     comparison = connection.case_insensitive_comparison(attr, nil)

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

@@ -9,7 +9,7 @@ module ActiveRecord
 
       def setup
         super
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
         connection.create_table(:strings) do |t|
           t.string :somedate
         end
@@ -29,6 +29,37 @@ module ActiveRecord
         assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
       end
 
+      def test_change_type_with_symbol_with_timestamptz
+        connection.change_column :strings, :somedate, :timestamptz, cast_as: :timestamptz
+        assert_equal :timestamptz, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+      end
+
+      def test_change_type_with_symbol_using_datetime
+        connection.change_column :strings, :somedate, :datetime, cast_as: :datetime
+        assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+      end
+
+      def test_change_type_with_symbol_using_timestamp_with_timestamptz_as_default
+        with_postgresql_datetime_type(:timestamptz) do
+          connection.change_column :strings, :somedate, :timestamp, cast_as: :timestamp
+          assert_equal :timestamp, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+      end
+
+      def test_change_type_with_symbol_with_timestamptz_as_default
+        with_postgresql_datetime_type(:timestamptz) do
+          connection.change_column :strings, :somedate, :timestamptz, cast_as: :timestamptz
+          assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+      end
+
+      def test_change_type_with_symbol_using_datetime_with_timestamptz_as_default
+        with_postgresql_datetime_type(:timestamptz) do
+          connection.change_column :strings, :somedate, :datetime, cast_as: :datetime
+          assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+      end
+
       def test_change_type_with_array
         connection.change_column :strings, :somedate, :timestamp, array: true, cast_as: :timestamp
         column = connection.columns(:strings).find { |c| c.name == "somedate" }