ibm_db 5.6.1 → 5.7.0

data/test/cases/database_configurations/resolver_test.rb

@@ -12,19 +12,11 @@ module ActiveRecord
         end
 
         def test_url_invalid_adapter
-          error = assert_raises(LoadError) do
-            Base.connection_handler.establish_connection "ridiculous://foo?encoding=utf8"
-          end
-
-          assert_match "Could not load the 'ridiculous' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", error.message
-        end
-
-        def test_error_if_no_adapter_method
           error = assert_raises(AdapterNotFound) do
-            Base.connection_handler.establish_connection "abstract://foo?encoding=utf8"
+            Base.connection_handler.establish_connection "ridiculous://foo?encoding=utf8"
           end
 
-          assert_match "database configuration specifies nonexistent abstract adapter", error.message
+          assert_match "Database configuration specifies nonexistent 'ridiculous' adapter. Available adapters are: abstract, fake, ibm_db, mysql2, postgresql, sqlite3, trilogy. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile if it's not in the list of available adapters.", error.message
         end
 
         # The abstract adapter is used simply to bypass the bit of code that
@@ -62,6 +54,18 @@ module ActiveRecord
           }, pool_config.configuration_hash)
         end
 
+        def test_url_sub_key_merges_correctly_when_query_param
+          hash = { "url" => "abstract:///?user=user&password=passwd&dbname=app" }
+          pool_config = resolve_db_config :production, "production" => hash
+
+          assert_equal({
+            adapter:  "abstract",
+            user:     "user",
+            password: "passwd",
+            dbname:   "app"
+          }, pool_config.configuration_hash)
+        end
+
         def test_url_host_no_db
           pool_config = resolve_db_config "abstract://foo?encoding=utf8"
           assert_equal({

data/test/cases/database_configurations/url_config_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class DatabaseConfigurations
+    class UrlConfigTest < ActiveRecord::TestCase
+      def test_schema_dump_parsing
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?schema_dump=false", {})
+        assert_nil config.schema_dump
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?schema_dump=db/foo_schema.rb", {})
+        assert_equal "db/foo_schema.rb", config.schema_dump
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo", {})
+        assert_equal "schema.rb", config.schema_dump
+      end
+
+      def test_query_cache_parsing
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?query_cache=false", {})
+        assert_equal false, config.query_cache
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?query_cache=42", {})
+        assert_equal "42", config.query_cache
+      end
+
+      def test_replica_parsing
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo", {})
+        assert_nil config.replica?
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?replica=true", {})
+        assert_equal true, config.replica?
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?replica=false", {})
+        assert_equal false, config.replica?
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?replica=random", {})
+        assert_equal true, config.replica?
+      end
+
+      def test_database_tasks_parsing
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo", {})
+        assert_equal true, config.database_tasks?
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?database_tasks=random", {})
+        assert_equal true, config.database_tasks?
+
+        config = UrlConfig.new("default_env", "primary", "postgres://localhost/foo?database_tasks=false", {})
+        assert_equal false, config.database_tasks?
+      end
+    end
+  end
+end

data/test/cases/database_configurations_test.rb

@@ -14,7 +14,6 @@ class DatabaseConfigurationsTest < ActiveRecord::TestCase
       assert_predicate ActiveRecord::Base.configurations, :blank?
     ensure
       ActiveRecord::Base.configurations = old_config
-      ActiveRecord::Base.establish_connection :arunit
     end
   end
 
@@ -36,34 +35,37 @@ class DatabaseConfigurationsTest < ActiveRecord::TestCase
     ENV["RAILS_ENV"] = previous_env
   end
 
-  def test_configs_for_getter_with_env_and_name
-    config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+  def test_configs_for_with_name_symbol
+    previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit2"
 
-    assert_equal "arunit", config.env_name
+    config = ActiveRecord::Base.configurations.configs_for(name: :primary)
+
+    assert_equal "arunit2", config.env_name
     assert_equal "primary", config.name
+  ensure
+    ENV["RAILS_ENV"] = previous_env
   end
 
-  def test_default_hash_returns_config_hash_from_default_env
-    original_rails_env = ENV["RAILS_ENV"]
-    ENV["RAILS_ENV"] = "arunit"
+  def test_configs_for_getter_with_env_and_name
+    config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
 
-    assert_deprecated do
-      assert_equal ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash, ActiveRecord::Base.configurations.default_hash
-    end
-  ensure
-    ENV["RAILS_ENV"] = original_rails_env
+    assert_equal "arunit", config.env_name
+    assert_equal "primary", config.name
   end
 
   def test_find_db_config_returns_first_config_for_env
     config = ActiveRecord::DatabaseConfigurations.new({
         "test" => {
           "config_1" => {
+            "adapter" => "abstract",
             "database" => "db"
           },
           "config_2" => {
+            "adapter" => "abstract",
             "database" => "db"
           },
           "config_3" => {
+            "adapter" => "abstract",
             "database" => "db"
           },
         }
@@ -82,7 +84,7 @@ class DatabaseConfigurationsTest < ActiveRecord::TestCase
   def test_find_db_config_prioritize_db_config_object_for_the_current_env
     config = ActiveRecord::DatabaseConfigurations.new({
       "primary" => {
-        "adapter" => "randomadapter"
+        "adapter" => "abstract",
       },
       ActiveRecord::ConnectionHandling::DEFAULT_ENV.call => {
         "primary" => {
@@ -97,49 +99,90 @@ class DatabaseConfigurationsTest < ActiveRecord::TestCase
     assert_equal ":memory:", config.database
   end
 
-  def test_to_h_turns_db_config_object_back_into_a_hash_and_is_deprecated
-    configs = ActiveRecord::Base.configurations
-    assert_equal "ActiveRecord::DatabaseConfigurations", configs.class.name
-    assert_deprecated do
-      assert_equal "Hash", configs.to_h.class.name
-      assert_equal ["arunit", "arunit2", "arunit_without_prepared_statements"], ActiveRecord::Base.configurations.to_h.keys.sort
+  class CustomHashConfig < ActiveRecord::DatabaseConfigurations::HashConfig
+    def sharded?
+      custom_config.fetch("sharded", false)
     end
+
+    private
+      def custom_config
+        configuration_hash.fetch(:custom_config)
+      end
   end
-end
 
-class LegacyDatabaseConfigurationsTest < ActiveRecord::TestCase
-  def test_can_turn_configurations_into_a_hash_and_is_deprecated
-    assert_deprecated do
-      assert ActiveRecord::Base.configurations.to_h.is_a?(Hash), "expected to be a hash but was not."
-      assert_equal ["arunit", "arunit2", "arunit_without_prepared_statements"].sort, ActiveRecord::Base.configurations.to_h.keys.sort
+  def test_registering_a_custom_config_object
+    previous_handlers = ActiveRecord::DatabaseConfigurations.db_config_handlers
+
+    ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, _, config|
+      next unless config.key?(:custom_config)
+      CustomHashConfig.new(env_name, name, config)
     end
-  end
 
-  def test_deprecated_config_method
-    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    configs = ActiveRecord::DatabaseConfigurations.new({
+      "test" => {
+        "config_1" => {
+          "adapter" => "abstract",
+          "database" => "db",
+          "custom_config" => {
+            "sharded" => 1
+          }
+        },
+        "config_2" => {
+          "adapter" => "abstract",
+          "database" => "db"
+        }
+      }
+    }).configurations
+
+    custom_config = configs.first
+    hash_config = configs.last
 
-    assert_equal db_config.configuration_hash.stringify_keys, assert_deprecated { db_config.config }
-  end
+    assert custom_config.is_a?(CustomHashConfig)
+    assert hash_config.is_a?(ActiveRecord::DatabaseConfigurations::HashConfig)
 
-  def test_unsupported_method_raises
-    assert_raises NoMethodError do
-      ActiveRecord::Base.configurations.fetch(:foo)
-    end
+    assert_predicate custom_config, :sharded?
+  ensure
+    ActiveRecord::DatabaseConfigurations.db_config_handlers = previous_handlers
   end
 
-  def test_spec_name_in_configs_for_is_deprecated
-    assert_deprecated do
-      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", spec_name: "primary")
+  def test_configs_for_with_custom_key
+    previous_handlers = ActiveRecord::DatabaseConfigurations.db_config_handlers
 
-      assert_equal "primary", db_config.name
+    ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, _, config|
+      next unless config.key?(:custom_config)
+      CustomHashConfig.new(env_name, name, config)
     end
+
+    config = {
+      "default_env" => {
+        "primary" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3", "custom_config" => { "sharded" => 1 } },
+        "replica" => { "adapter" => "sqlite3", "database" => "test/db/hidden.sqlite3", "replica" => true, "custom_config" => { "sharded" => 1 } },
+        "secondary" => { "adapter" => "sqlite3", "database" => "test/db/secondary.sqlite3" }
+      }
+    }
+    prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
+
+    assert_equal 1, ActiveRecord::Base.configurations.configs_for(env_name: "default_env", config_key: :custom_config).count
+    assert_equal 2, ActiveRecord::Base.configurations.configs_for(env_name: "default_env", config_key: :custom_config, include_hidden: true).count
+    assert_equal 2, ActiveRecord::Base.configurations.configs_for(env_name: "default_env").count
+  ensure
+    ActiveRecord::DatabaseConfigurations.db_config_handlers = previous_handlers
+    ActiveRecord::Base.configurations = prev_configs
   end
 
-  def test_spec_name_getter_is_deprecated
-    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+  def test_configs_for_with_include_hidden
+    config = {
+      "default_env" => {
+        "readonly" => { "adapter" => "sqlite3", "database" => "test/db/readonly.sqlite3", "replica" => true },
+        "hidden" => { "adapter" => "sqlite3", "database" => "test/db/hidden.sqlite3", "database_tasks" => false },
+        "default" => { "adapter" => "sqlite3", "database" => "test/db/primary.sqlite3" }
+      }
+    }
+    prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, config
 
-    assert_deprecated do
-      assert_equal "primary", db_config.spec_name
-    end
+    assert_equal 1, ActiveRecord::Base.configurations.configs_for(env_name: "default_env").count
+    assert_equal 3, ActiveRecord::Base.configurations.configs_for(env_name: "default_env", include_hidden: true).count
+  ensure
+    ActiveRecord::Base.configurations = prev_configs
   end
 end

data/test/cases/database_selector_test.rb

@@ -62,15 +62,15 @@ module ActiveRecord
           called = true
 
           assert ActiveRecord::Base.connected_to?(role: :reading)
-          assert_predicate ActiveRecord::Base.connection, :preventing_writes?
+          assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
 
           ActiveRecord::Base.connected_to(role: :writing, prevent_writes: false) do
             assert ActiveRecord::Base.connected_to?(role: :writing)
-            assert_not_predicate ActiveRecord::Base.connection, :preventing_writes?
+            assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
           end
 
           assert ActiveRecord::Base.connected_to?(role: :reading)
-          assert_predicate ActiveRecord::Base.connection, :preventing_writes?
+          assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
         end
         assert called
       end
@@ -202,12 +202,12 @@ module ActiveRecord
       write = false
       resolver.read do
         assert ActiveRecord::Base.connected_to?(role: :writing)
-        assert_predicate ActiveRecord::Base.connection, :preventing_writes?
+        assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
         read = true
 
         resolver.write do
           assert ActiveRecord::Base.connected_to?(role: :writing)
-          assert_not_predicate ActiveRecord::Base.connection, :preventing_writes?
+          assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
           write = true
         end
       end
@@ -227,7 +227,7 @@ module ActiveRecord
         resolver.read do
           inside_preventing.wait
           assert ActiveRecord::Base.connected_to?(role: :writing)
-          assert_predicate ActiveRecord::Base.connection, :preventing_writes?
+          assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
           finished_checking.set
         end
       end
@@ -235,7 +235,7 @@ module ActiveRecord
       t2 = Thread.new do
         resolver.write do
           assert ActiveRecord::Base.connected_to?(role: :writing)
-          assert_not_predicate ActiveRecord::Base.connection, :preventing_writes?
+          assert_not_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
           inside_preventing.set
           finished_checking.wait
         end
@@ -244,7 +244,7 @@ module ActiveRecord
       t3 = Thread.new do
         resolver.read do
           assert ActiveRecord::Base.connected_to?(role: :writing)
-          assert_predicate ActiveRecord::Base.connection, :preventing_writes?
+          assert_predicate ActiveRecord::Base.lease_connection, :preventing_writes?
         end
       end
 
@@ -282,6 +282,8 @@ module ActiveRecord
         assert ActiveRecord::Base.connected_to?(role: :writing)
         [200, {}, ["body"]]
       })
+      cache = ActiveSupport::Cache::MemoryStore.new
+      middleware = ActionDispatch::Session::CacheStore.new(middleware, cache: cache, key: "_session_id")
       assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "POST")
     end
 
@@ -290,7 +292,27 @@ module ActiveRecord
         assert ActiveRecord::Base.connected_to?(role: :reading)
         [200, {}, ["body"]]
       })
+      cache = ActiveSupport::Cache::MemoryStore.new
+      middleware = ActionDispatch::Session::CacheStore.new(middleware, cache: cache, key: "_session_id")
+
       assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "GET")
     end
+
+    class ReadonlyResolver < ActiveRecord::Middleware::DatabaseSelector::Resolver
+      def reading_request?(request)
+        true
+      end
+    end
+
+    def test_the_middleware_chooses_reading_role_with_POST_request_if_resolver_tells_it_to
+      middleware = ActiveRecord::Middleware::DatabaseSelector.new(lambda { |env|
+        assert ActiveRecord::Base.connected_to?(role: :reading)
+        [200, {}, ["body"]]
+      }, ReadonlyResolver)
+
+      cache = ActiveSupport::Cache::MemoryStore.new
+      middleware = ActionDispatch::Session::CacheStore.new(middleware, cache: cache, key: "_session_id")
+      assert_equal [200, {}, ["body"]], middleware.call("REQUEST_METHOD" => "POST")
+    end
   end
 end

data/test/cases/database_statements_test.rb

@@ -4,14 +4,12 @@ require "cases/helper"
 
 class DatabaseStatementsTest < ActiveRecord::TestCase
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
-  unless current_adapter?(:OracleAdapter)
-    def test_exec_insert
-      result = @connection.exec_insert("INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)", nil, [])
-      assert_not_nil @connection.send(:last_inserted_id, result)
-    end
+  def test_exec_insert
+    result = @connection.exec_insert("INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)", nil, [])
+    assert_not_nil @connection.send(:last_inserted_id, result)
   end
 
   def test_insert_should_return_the_inserted_id
@@ -22,15 +20,13 @@ class DatabaseStatementsTest < ActiveRecord::TestCase
     assert_not_nil return_the_inserted_id(method: :create)
   end
 
+  def test_extract_table_ref_from_insert_sql_with_hyphen_in_table_name
+    sql = "INSERT INTO \"table-with-hyphen\" (column1, column2) VALUES (value1, value2)"
+    assert_equal "table-with-hyphen", @connection.send(:extract_table_ref_from_insert_sql, sql)
+  end
+
   private
     def return_the_inserted_id(method:)
-      # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
-      if current_adapter?(:OracleAdapter)
-        sequence_name = "accounts_seq"
-        id_value = @connection.next_sequence_value(sequence_name)
-        @connection.send(method, "INSERT INTO accounts (id, firm_id,credit_limit) VALUES (accounts_seq.nextval,42,5000)", nil, :id, id_value, sequence_name)
-      else
-        @connection.send(method, "INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)")
-      end
+      @connection.send(method, "INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)")
     end
 end

data/test/cases/date_time_precision_test.rb

@@ -3,15 +3,16 @@
 require "cases/helper"
 require "support/schema_dumping_helper"
 
-if supports_datetime_with_precision?
-  class DateTimePrecisionTest < ActiveRecord::TestCase
+class DateTimePrecisionTest < ActiveRecord::TestCase
+  if supports_datetime_with_precision?
+    include InTimeZone
     include SchemaDumpingHelper
     self.use_transactional_tests = false
 
     class Foo < ActiveRecord::Base; end
 
     setup do
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
       Foo.reset_column_information
     end
 
@@ -45,11 +46,11 @@ if supports_datetime_with_precision?
       assert_equal 123456000, foo.updated_at.nsec
     end
 
-    unless current_adapter?(:Mysql2Adapter, :IBM_DBAdapter)
+    unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :IBM_DBAdapter)
       def test_no_datetime_precision_isnt_truncated_on_assignment
         @connection.create_table(:foos, force: true)
-        @connection.add_column :foos, :created_at, :datetime
-        @connection.add_column :foos, :updated_at, :datetime, precision: 6
+        @connection.add_column :foos, :created_at, :datetime, precision: nil
+        @connection.add_column :foos, :updated_at, :datetime
 
         time = ::Time.now.change(nsec: 123)
         foo = Foo.new(created_at: time, updated_at: time)
@@ -84,7 +85,7 @@ if supports_datetime_with_precision?
     def test_invalid_datetime_precision_raises_error
       assert_raises ArgumentError do
         @connection.create_table(:foos, force: true) do |t|
-          t.timestamps precision: 13
+          t.timestamps precision: 7
         end
       end
     end
@@ -100,22 +101,151 @@ if supports_datetime_with_precision?
 
       assert foo = Foo.find_by(created_at: date)
       assert_equal 1, Foo.where(updated_at: date).count
+      assert_equal date.to_i, foo.created_at.to_i
       assert_equal date.to_s, foo.created_at.to_s
       assert_equal date.to_s, foo.updated_at.to_s
       assert_equal 000000, foo.created_at.usec
       assert_equal 999900, foo.updated_at.usec
     end
 
-    def test_schema_dump_includes_datetime_precision
+    def test_formatting_datetime_according_to_precision_when_time_zone_aware
+      with_timezone_config aware_attributes: true, zone: "Pacific Time (US & Canada)" do
+        @connection.create_table(:foos, force: true) do |t|
+          t.datetime :created_at, precision: 0
+          t.datetime :updated_at, precision: 4
+        end
+
+        date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
+        Foo.create!(created_at: date, updated_at: date)
+
+        assert foo = Foo.find_by(created_at: date)
+        assert_equal 1, Foo.where(updated_at: date).count
+        assert_equal date.to_i, foo.created_at.to_i
+        assert_equal date.in_time_zone.to_s, foo.created_at.to_s
+        assert_equal date.in_time_zone.to_s, foo.updated_at.to_s
+        assert_equal 000000, foo.created_at.usec
+        assert_equal 999900, foo.updated_at.usec
+      end
+    end
+
+    if current_adapter?(:PostgreSQLAdapter)
+      def test_formatting_datetime_according_to_precision_using_timestamptz
+        with_postgresql_datetime_type(:timestamptz) do
+          @connection.create_table(:foos, force: true) do |t|
+            t.datetime :created_at, precision: 0
+            t.datetime :updated_at, precision: 4
+          end
+
+          date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
+          Foo.create!(created_at: date, updated_at: date)
+
+          assert foo = Foo.find_by(created_at: date)
+          assert_equal 1, Foo.where(updated_at: date).count
+          assert_equal date.to_i, foo.created_at.to_i
+          assert_equal date.to_s, foo.created_at.to_s
+          assert_equal date.to_s, foo.updated_at.to_s
+          assert_equal 000000, foo.created_at.usec
+          assert_equal 999900, foo.updated_at.usec
+        end
+      end
+
+      def test_formatting_datetime_according_to_precision_when_time_zone_aware_using_timestamptz
+        with_postgresql_datetime_type(:timestamptz) do
+          with_timezone_config aware_attributes: true, zone: "Pacific Time (US & Canada)" do
+            @connection.create_table(:foos, force: true) do |t|
+              t.datetime :created_at, precision: 0
+              t.datetime :updated_at, precision: 4
+            end
+
+            date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
+            Foo.create!(created_at: date, updated_at: date)
+
+            assert foo = Foo.find_by(created_at: date)
+            assert_equal 1, Foo.where(updated_at: date).count
+            assert_equal date.to_i, foo.created_at.to_i
+            assert_equal date.in_time_zone.to_s, foo.created_at.to_s
+            assert_equal date.in_time_zone.to_s, foo.updated_at.to_s
+            assert_equal 000000, foo.created_at.usec
+            assert_equal 999900, foo.updated_at.usec
+          end
+        end
+      end
+    end
+
+    def test_writing_a_blank_attribute
+      @connection.create_table(:foos, force: true) do |t|
+        t.datetime :happened_at
+      end
+
+      assert_nil Foo.create!(happened_at: nil).happened_at
+      assert_nil Foo.create!(happened_at: "").happened_at
+    end
+
+    def test_writing_a_date_attribute
+      @connection.create_table(:foos, force: true) do |t|
+        t.datetime :happened_at
+      end
+
+      date = ::Date.new(2001, 2, 3)
+      assert_equal date, Foo.create!(happened_at: date).happened_at
+    end
+
+    if current_adapter?(:PostgreSQLAdapter)
+      def test_writing_a_blank_attribute_timestamptz
+        with_postgresql_datetime_type(:timestamptz) do
+          @connection.create_table(:foos, force: true) do |t|
+            t.datetime :happened_at
+          end
+
+          assert_nil Foo.create!(happened_at: nil).happened_at
+          assert_nil Foo.create!(happened_at: "").happened_at
+        end
+      end
+
+      def test_writing_a_date_attribute_timestamptz
+        with_postgresql_datetime_type(:timestamptz) do
+          @connection.create_table(:foos, force: true) do |t|
+            t.datetime :happened_at
+          end
+
+          date = ::Date.new(2001, 2, 3)
+          assert_equal date, Foo.create!(happened_at: date).happened_at
+        end
+      end
+
+      def test_writing_a_time_with_zone_attribute_timestamptz
+        with_postgresql_datetime_type(:timestamptz) do
+          @connection.create_table(:foos, force: true) do |t|
+            t.datetime :happened_at
+          end
+
+          in_time_zone("Pacific Time (US & Canada)") do
+            time = Time.zone.now
+            assert_equal time.zone, Foo.new(happened_at: time).happened_at.zone
+          end
+        end
+      end
+    end
+
+    def test_schema_dump_with_default_precision_is_not_dumped
       @connection.create_table(:foos, force: true) do |t|
         t.timestamps precision: 6
       end
       output = dump_table_schema("foos")
-      assert_match %r{t\.datetime\s+"created_at",\s+precision: 6,\s+null: false$}, output
-      assert_match %r{t\.datetime\s+"updated_at",\s+precision: 6,\s+null: false$}, output
+      assert_match %r{t\.datetime\s+"created_at",\s+null: false$}, output
+      assert_match %r{t\.datetime\s+"updated_at",\s+null: false$}, output
+    end
+
+    def test_schema_dump_with_without_precision_has_precision_as_nil
+      @connection.create_table(:foos, force: true) do |t|
+        t.timestamps precision: nil
+      end
+      output = dump_table_schema("foos")
+      assert_match %r{t\.datetime\s+"created_at",\s+precision: nil,\s+null: false$}, output
+      assert_match %r{t\.datetime\s+"updated_at",\s+precision: nil,\s+null: false$}, output
     end
 
-    if current_adapter?(:PostgreSQLAdapter, :SQLServerAdapter)
+    if current_adapter?(:PostgreSQLAdapter)
       def test_datetime_precision_with_zero_should_be_dumped
         @connection.create_table(:foos, force: true) do |t|
           t.timestamps precision: 0

data/test/cases/date_time_test.rb

@@ -7,6 +7,25 @@ require "models/task"
 class DateTimeTest < ActiveRecord::TestCase
   include InTimeZone
 
+  def test_default_timezone_validation
+    assert_raises ArgumentError do
+      ActiveRecord.default_timezone = "UTC"
+    end
+
+    # These values should not raise errors
+    ActiveRecord.default_timezone = :local
+    ActiveRecord.default_timezone = :utc
+  end
+
+  def test_high_precision_current_timestamp
+    current_timestamp = Task.with_connection { |conn| conn.high_precision_current_timestamp }
+
+    task = Task.create!
+    task = Task.select(current_timestamp => :starting).find(task.id)
+
+    assert_in_delta Time.now, task.starting, 1
+  end
+
   def test_saves_both_date_and_time
     with_env_tz "America/New_York" do
       with_timezone_config default: :utc do
@@ -62,7 +81,6 @@ class DateTimeTest < ActiveRecord::TestCase
   end
 
   def test_date_time_with_string_value_with_subsecond_precision
-    skip unless supports_datetime_with_precision?
     string_value = "2017-07-04 14:19:00.5"
     topic = Topic.create(written_on: string_value)
     assert_equal topic, Topic.find_by(written_on: string_value)