Merge branch 'master' into adequaterecord

* master: (108 commits)
  make tests pass on Ruby 2.2
  Use Sqlite3 adapter in examples
  use the body proxy to freeze headers
  just ask the response for the commit status, we do not need to ask the jar
  only write the jar if the response isn't committed
  Fix a grammatical error in the i18n guide [ci skip]
  use method_defined? to check whether or not a method is defined
  Enhance docs for update_attribute [ci-skip]
  Change usec to 0 on tests that compare seconds
  Unit test for mysql quote time usec
  Changelog entry for mysql56 microseconds
  Test microsecond on mysql 5.6
  MySQL 5.6 and later supports microsecond precision in datetime.
  [ci skip] Add documentation for original_fullpath.
  Remove mocking on save, when not necessary
  comment why we are modifying global state. [ci skip]
  `change_table` supports `citext`. Follow up to #12523.
  Removed unnecessary command "application"
  register OID for PostgreSQL citex datatype [Troy Kruthoff & Lachlan Sylvester]
  Fixes STI when 2+ levels deep.
  ...

20 files changed, 309 insertions, 32 deletions

diff --git a/activerecord/test/cases/adapters/mysql/case_sensitivity_test.rb b/activerecord/test/cases/adapters/mysql/case_sensitivity_test.rb
index 97adb6b297..340fc95503 100644
--- a/activerecord/test/cases/adapters/mysql/case_sensitivity_test.rb
+++ b/activerecord/test/cases/adapters/mysql/case_sensitivity_test.rb
@@ -3,10 +3,10 @@ require 'models/person'
 
 class MysqlCaseSensitivityTest < ActiveRecord::TestCase
   class CollationTest < ActiveRecord::Base
-    validates_uniqueness_of :string_cs_column, :case_sensitive => false
-    validates_uniqueness_of :string_ci_column, :case_sensitive => false
   end
 
+  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
@@ -18,6 +18,7 @@ class MysqlCaseSensitivityTest < ActiveRecord::TestCase
   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 }
@@ -26,10 +27,29 @@ class MysqlCaseSensitivityTest < ActiveRecord::TestCase
   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/) }
     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 }
+    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 }
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
+    assert_no_match(/binary/i, cs_uniqueness_query)
+  end
 end
diff --git a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
index 6bcc113482..09bebf3071 100644
--- a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
@@ -3,10 +3,10 @@ require 'models/person'
 
 class Mysql2CaseSensitivityTest < ActiveRecord::TestCase
   class CollationTest < ActiveRecord::Base
-    validates_uniqueness_of :string_cs_column, :case_sensitive => false
-    validates_uniqueness_of :string_ci_column, :case_sensitive => false
   end
 
+  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
@@ -18,6 +18,7 @@ class Mysql2CaseSensitivityTest < ActiveRecord::TestCase
   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 }
@@ -26,10 +27,29 @@ class Mysql2CaseSensitivityTest < ActiveRecord::TestCase
   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/)}
     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 }
+    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 }
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
+    assert_no_match(/binary/i, cs_uniqueness_query)
+  end
 end
diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
index 9b7202c915..98febd2d75 100644
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/connection_test.rb
@@ -97,6 +97,13 @@ class MysqlConnectionTest < ActiveRecord::TestCase
     @connection.execute "DROP TABLE `bar_baz`"
   end
 
+  if mysql_56?
+    def test_quote_time_usec
+      assert_equal "'1970-01-01 00:00:00.000000'", @connection.quote(Time.at(0))
+      assert_equal "'1970-01-01 00:00:00.000000'", @connection.quote(Time.at(0).to_datetime)
+    end
+  end
+
   private
 
   def run_without_connection
diff --git a/activerecord/test/cases/adapters/postgresql/citext_test.rb b/activerecord/test/cases/adapters/postgresql/citext_test.rb
new file mode 100644
index 0000000000..ebb9ff98b1
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/citext_test.rb
@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+require 'cases/helper'
+require 'active_record/base'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+class PostgresqlCitextTest < ActiveRecord::TestCase
+  class Citext < ActiveRecord::Base
+    self.table_name = 'citexts'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+
+    unless @connection.extension_enabled?('citext')
+      @connection.enable_extension 'citext'
+      @connection.commit_db_transaction
+    end
+
+    @connection.reconnect!
+
+    @connection.create_table('citexts') do |t|
+      t.citext 'cival'
+    end
+    @column = Citext.columns_hash['cival']
+  end
+
+  def teardown
+    @connection.execute 'DROP TABLE IF EXISTS citexts;'
+    @connection.execute 'DROP EXTENSION IF EXISTS citext CASCADE;'
+  end
+
+  def test_citext_enabled
+    assert @connection.extension_enabled?('citext')
+  end
+
+  def test_column_type
+    assert_equal :citext, @column.type
+  end
+
+  def test_column_sql_type
+    assert_equal 'citext', @column.sql_type
+  end
+
+  def test_change_table_supports_json
+    @connection.transaction do
+      @connection.change_table('citexts') do |t|
+        t.citext 'username'
+      end
+      Citext.reset_column_information
+      column = Citext.columns.find { |c| c.name == 'username' }
+      assert_equal :citext, column.type
+
+      raise ActiveRecord::Rollback # reset the schema change
+    end
+  ensure
+    Citext.reset_column_information
+  end
+
+  def test_write
+    x = Citext.new(cival: 'Some CI Text')
+    x.save!
+    citext = Citext.first
+    assert_equal "Some CI Text", citext.cival
+
+    citext.cival = "Some NEW CI Text"
+    citext.save!
+
+    assert_equal "Some NEW CI Text", citext.reload.cival
+  end
+
+  def test_select_case_insensitive
+    @connection.execute "insert into citexts (cival) values('Cased Text')"
+    x = Citext.where(cival: 'cased text').first
+    assert_equal 'Cased Text', x.cival
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/enum_test.rb b/activerecord/test/cases/adapters/postgresql/enum_test.rb
index bf8dbd6c3f..62f84caf91 100644
--- a/activerecord/test/cases/adapters/postgresql/enum_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/enum_test.rb
@@ -23,6 +23,8 @@ class PostgresqlEnumTest < ActiveRecord::TestCase
         t.column :current_mood, :mood
       end
     end
+    # reload type map after creating the enum type
+    @connection.send(:reload_type_map)
   end
 
   def test_enum_mapping
@@ -35,4 +37,28 @@ class PostgresqlEnumTest < ActiveRecord::TestCase
 
     assert_equal "happy", enum.reload.current_mood
   end
+
+  def test_invalid_enum_update
+    @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
+    enum = PostgresqlEnum.first
+    enum.current_mood = "angry"
+
+    assert_raise ActiveRecord::StatementInvalid do
+      enum.save
+    end
+  end
+
+  def test_no_oid_warning
+    @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
+    stderr_output = capture(:stderr) { PostgresqlEnum.first }
+
+    assert stderr_output.blank?
+  end
+
+  def test_enum_type_cast
+    enum = PostgresqlEnum.new
+    enum.current_mood = :happy
+
+    assert_equal "happy", enum.current_mood
+  end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/range_test.rb b/activerecord/test/cases/adapters/postgresql/range_test.rb
index 306bb09a0d..4e84335e9b 100644
--- a/activerecord/test/cases/adapters/postgresql/range_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/range_test.rb
@@ -156,7 +156,7 @@ _SQL
       assert_equal 0.5..0.7, @first_range.float_range
       assert_equal 0.5...0.7, @second_range.float_range
       assert_equal 0.5...Float::INFINITY, @third_range.float_range
-      assert_equal -Float::INFINITY...Float::INFINITY, @fourth_range.float_range
+      assert_equal (-Float::INFINITY...Float::INFINITY), @fourth_range.float_range
       assert_nil @empty_range.float_range
     end
 
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index e555c52281..cf71bc1597 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -159,7 +159,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
       activerecord.reload
       assert activerecord.developers_with_callbacks.size == 2
     end
-    log_array = activerecord.developers_with_callbacks.collect {|d| ["before_removing#{d.id}","after_removing#{d.id}"]}.flatten.sort
+    log_array = activerecord.developers_with_callbacks.flat_map {|d| ["before_removing#{d.id}","after_removing#{d.id}"]}.sort
     assert activerecord.developers_with_callbacks.clear
     assert_equal log_array, activerecord.developers_log.sort
   end
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 498a4e8144..5522a33b79 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -1194,4 +1194,13 @@ class EagerAssociationTest < ActiveRecord::TestCase
       authors(:david).essays.includes(:writer).any?
     end
   end
+
+  test "preloading associations with string joins and order references" do
+    author = assert_queries(2) {
+      Author.includes(:posts).joins("LEFT JOIN posts ON posts.author_id = authors.id").order("posts.title DESC").first
+    }
+    assert_no_queries {
+      assert_equal 5, author.posts.size
+    }
+  end
 end
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index a86fb15719..49d3301044 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -1242,6 +1242,16 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal orig_accounts, firm.accounts
   end
 
+  def test_replace_with_same_content
+    firm = Firm.first
+    firm.clients = []
+    firm.save
+
+    assert_queries(0, ignore_none: true) do
+      firm.clients = []
+    end
+  end
+
   def test_transactions_when_replacing_on_persisted
     good = Client.new(:name => "Good")
     bad  = Client.new(:name => "Bad", :raise_on_save => true)
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 1a1e442df0..173081cb28 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -746,6 +746,19 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert "unknown attribute: hello", error.message
   end
 
+  def test_methods_override_in_multi_level_subclass
+    klass = Class.new(Developer) do
+      def name
+        "dev:#{read_attribute(:name)}"
+      end
+    end
+
+    2.times { klass = Class.new klass }
+    dev = klass.new(name: 'arthurnn')
+    dev.save!
+    assert_equal 'dev:arthurnn', dev.reload.name
+  end
+
   def test_global_methods_are_overwritten
     klass = Class.new(ActiveRecord::Base) do
       self.table_name = 'computers'
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index d2f97df0fc..09892d50ba 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -64,10 +64,6 @@ class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
 
   private
 
-  def base
-    ActiveRecord::Base
-  end
-
   def assert_no_difference_when_adding_callbacks_twice_for(model, association_name)
     reflection = model.reflect_on_association(association_name)
     assert_no_difference "callbacks_for_model(#{model.name}).length" do
@@ -76,9 +72,9 @@ class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
   end
 
   def callbacks_for_model(model)
-    model.instance_variables.grep(/_callbacks$/).map do |ivar|
+    model.instance_variables.grep(/_callbacks$/).flat_map do |ivar|
       model.instance_variable_get(ivar)
-    end.flatten
+    end
   end
 end
 
@@ -622,15 +618,15 @@ end
 class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
   self.use_transactional_fixtures = false
 
-  def setup
-    super
+  setup do
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
     @ship = @pirate.create_ship(:name => 'Nights Dirty Lightning')
   end
 
-  def teardown
+  teardown do
     # We are running without transactional fixtures and need to cleanup.
     Bird.delete_all
+    Parrot.delete_all
     @ship.delete
     @pirate.delete
   end
@@ -687,10 +683,23 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
       end
     end
 
+    @ship.pirate.catchphrase = "Changed Catchphrase"
+
     assert_raise(RuntimeError) { assert !@pirate.save }
     assert_not_nil @pirate.reload.ship
   end
 
+  def test_should_save_changed_has_one_changed_object_if_child_is_saved
+    @pirate.ship.name = "NewName"
+    assert @pirate.save
+    assert_equal "NewName", @pirate.ship.reload.name
+  end
+
+  def test_should_not_save_changed_has_one_unchanged_object_if_child_is_saved
+    @pirate.ship.expects(:save).never
+    assert @pirate.save
+  end
+
   # belongs_to
   def test_should_destroy_a_parent_association_as_part_of_the_save_transaction_if_it_was_marked_for_destroyal
     assert !@ship.pirate.marked_for_destruction?
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 8a0b0b9589..6acb342d0b 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -212,7 +212,7 @@ class BasicsTest < ActiveRecord::TestCase
     )
 
     # For adapters which support microsecond resolution.
-    if current_adapter?(:PostgreSQLAdapter, :SQLite3Adapter)
+    if current_adapter?(:PostgreSQLAdapter, :SQLite3Adapter) || mysql_56?
       assert_equal 11, Topic.find(1).written_on.sec
       assert_equal 223300, Topic.find(1).written_on.usec
       assert_equal 9900, Topic.find(2).written_on.usec
diff --git a/activerecord/test/cases/enum_test.rb b/activerecord/test/cases/enum_test.rb
index 1b95708cb3..f8ebd7caee 100644
--- a/activerecord/test/cases/enum_test.rb
+++ b/activerecord/test/cases/enum_test.rb
@@ -222,4 +222,31 @@ class EnumTest < ActiveRecord::TestCase
       end
     end
   end
+
+  test "validate uniqueness" do
+    klass = Class.new(ActiveRecord::Base) do
+      def self.name; 'Book'; end
+      enum status: [:proposed, :written]
+      validates_uniqueness_of :status
+    end
+    klass.delete_all
+    klass.create!(status: "proposed")
+    book = klass.new(status: "written")
+    assert book.valid?
+    book.status = "proposed"
+    assert_not book.valid?
+  end
+
+  test "validate inclusion of value in array" do
+    klass = Class.new(ActiveRecord::Base) do
+      def self.name; 'Book'; end
+      enum status: [:proposed, :written]
+      validates_inclusion_of :status, in: ["written"]
+    end
+    klass.delete_all
+    invalid_book = klass.new(status: "proposed")
+    assert_not invalid_book.valid?
+    valid_book = klass.new(status: "written")
+    assert valid_book.valid?
+  end
 end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index b1eded6494..98b1dafdf0 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -58,15 +58,25 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal false, Topic.exists?(45)
     assert_equal false, Topic.exists?(Topic.new)
 
-    begin
-      assert_equal false, Topic.exists?("foo")
-    rescue ActiveRecord::StatementInvalid
-      # PostgreSQL complains about string comparison with integer field
-    rescue Exception
-      flunk
+    assert_raise(NoMethodError) { Topic.exists?([1,2]) }
+  end
+
+  def test_exists_fails_when_parameter_has_invalid_type
+    if current_adapter?(:PostgreSQLAdapter, :MysqlAdapter)
+      assert_raises ActiveRecord::StatementInvalid do
+        Topic.exists?(("9"*53).to_i) # number that's bigger than int
+      end
+    else
+      assert_equal false, Topic.exists?(("9"*53).to_i) # number that's bigger than int
     end
 
-    assert_raise(NoMethodError) { Topic.exists?([1,2]) }
+    if current_adapter?(:PostgreSQLAdapter)
+      assert_raises ActiveRecord::StatementInvalid do
+        Topic.exists?("foo")
+      end
+    else
+      assert_equal false, Topic.exists?("foo")
+    end
   end
 
   def test_exists_does_not_select_columns_without_alias
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index 3758224b0c..8a49dfbb44 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -41,6 +41,11 @@ def in_memory_db?
   ActiveRecord::Base.connection_pool.spec.config[:database] == ":memory:"
 end
 
+def mysql_56?
+  current_adapter?(:Mysql2Adapter) &&
+    ActiveRecord::Base.connection.send(:version).join(".") >= "5.6.0"
+end
+
 def supports_savepoints?
   ActiveRecord::Base.connection.supports_savepoints?
 end
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index b9f0624f76..046fe83e54 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -452,7 +452,7 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_update_attribute_for_updated_at_on
     developer = Developer.find(1)
-    prev_month = Time.now.prev_month
+    prev_month = Time.now.prev_month.change(usec: 0)
 
     developer.update_attribute(:updated_at, prev_month)
     assert_equal prev_month, developer.updated_at
@@ -523,7 +523,7 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_update_column_should_not_modify_updated_at
     developer = Developer.find(1)
-    prev_month = Time.now.prev_month
+    prev_month = Time.now.prev_month.change(usec: 0)
 
     developer.update_column(:updated_at, prev_month)
     assert_equal prev_month, developer.updated_at
@@ -620,7 +620,7 @@ class PersistenceTest < ActiveRecord::TestCase
 
   def test_update_columns_should_not_modify_updated_at
     developer = Developer.find(1)
-    prev_month = Time.now.prev_month
+    prev_month = Time.now.prev_month.change(usec: 0)
 
     developer.update_columns(updated_at: prev_month)
     assert_equal prev_month, developer.updated_at
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 21d05e4ac0..b74139d6f5 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -171,7 +171,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal topics(:first).title, topics.first.title
   end
 
-
   def test_finding_with_arel_order
     topics = Topic.order(Topic.arel_table[:id].asc)
     assert_equal 5, topics.to_a.size
@@ -194,8 +193,33 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal Topic.order(:id).to_sql, Topic.order(:id => :asc).to_sql
   end
 
+  def test_finding_with_desc_order_with_string
+    topics = Topic.order(id: "desc")
+    assert_equal 5, topics.to_a.size
+    assert_equal [topics(:fifth), topics(:fourth), topics(:third), topics(:second), topics(:first)], topics.to_a
+  end
+
+  def test_finding_with_asc_order_with_string
+    topics = Topic.order(id: 'asc')
+    assert_equal 5, topics.to_a.size
+    assert_equal [topics(:first), topics(:second), topics(:third), topics(:fourth), topics(:fifth)], topics.to_a
+  end
+
+  def test_support_upper_and_lower_case_directions
+    assert_includes Topic.order(id: "ASC").to_sql, "ASC"
+    assert_includes Topic.order(id: "asc").to_sql, "ASC"
+    assert_includes Topic.order(id: :ASC).to_sql, "ASC"
+    assert_includes Topic.order(id: :asc).to_sql, "ASC"
+
+    assert_includes Topic.order(id: "DESC").to_sql, "DESC"
+    assert_includes Topic.order(id: "desc").to_sql, "DESC"
+    assert_includes Topic.order(id: :DESC).to_sql, "DESC"
+    assert_includes Topic.order(id: :desc).to_sql,"DESC"
+  end
+
   def test_raising_exception_on_invalid_hash_params
-    assert_raise(ArgumentError) { Topic.order(:name, "id DESC", :id => :DeSc) }
+    e = assert_raise(ArgumentError) { Topic.order(:name, "id DESC", id: :asfsdf) }
+    assert_equal 'Direction "asfsdf" is invalid. Valid directions are: [:asc, :desc, :ASC, :DESC, "asc", "desc", "ASC", "DESC"]', e.message
   end
 
   def test_finding_last_with_arel_order
diff --git a/activerecord/test/cases/schema_dumper_test.rb b/activerecord/test/cases/schema_dumper_test.rb
index c085663efb..575eb34a9c 100644
--- a/activerecord/test/cases/schema_dumper_test.rb
+++ b/activerecord/test/cases/schema_dumper_test.rb
@@ -177,7 +177,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
   def test_schema_dumps_index_columns_in_right_order
     index_definition = standard_dump.split(/\n/).grep(/add_index.*companies/).first.strip
-    if current_adapter?(:MysqlAdapter) || current_adapter?(:Mysql2Adapter) || current_adapter?(:PostgreSQLAdapter)
+    if current_adapter?(:MysqlAdapter, :Mysql2Adapter, :PostgreSQLAdapter)
       assert_equal 'add_index "companies", ["firm_id", "type", "rating"], name: "company_index", using: :btree', index_definition
     else
       assert_equal 'add_index "companies", ["firm_id", "type", "rating"], name: "company_index"', index_definition
@@ -188,7 +188,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
     index_definition = standard_dump.split(/\n/).grep(/add_index.*company_partial_index/).first.strip
     if current_adapter?(:PostgreSQLAdapter)
       assert_equal 'add_index "companies", ["firm_id", "type"], name: "company_partial_index", where: "(rating > 10)", using: :btree', index_definition
-    elsif current_adapter?(:MysqlAdapter) || current_adapter?(:Mysql2Adapter)
+    elsif current_adapter?(:MysqlAdapter, :Mysql2Adapter)
       assert_equal 'add_index "companies", ["firm_id", "type"], name: "company_partial_index", using: :btree', index_definition
     elsif current_adapter?(:SQLite3Adapter) && ActiveRecord::Base.connection.supports_partial_index?
       assert_equal 'add_index "companies", ["firm_id", "type"], name: "company_partial_index", where: "rating > 10"', index_definition
@@ -319,6 +319,13 @@ class SchemaDumperTest < ActiveRecord::TestCase
       end
     end
 
+    def test_schema_dump_includes_citext_shorthand_definition
+      output = standard_dump
+      if %r{create_table "postgresql_citext"} =~ output
+        assert_match %r[t.citext "text_citext"], output
+      end
+    end
+
     def test_schema_dump_includes_ltrees_shorthand_definition
       output = standard_dump
       if %r{create_table "postgresql_ltrees"} =~ output
diff --git a/activerecord/test/schema/postgresql_specific_schema.rb b/activerecord/test/schema/postgresql_specific_schema.rb
index a86a188bcf..4fcbf4dbd2 100644
--- a/activerecord/test/schema/postgresql_specific_schema.rb
+++ b/activerecord/test/schema/postgresql_specific_schema.rb
@@ -1,7 +1,7 @@
 ActiveRecord::Schema.define do
 
   %w(postgresql_tsvectors postgresql_hstores postgresql_arrays postgresql_moneys postgresql_numbers postgresql_times postgresql_network_addresses postgresql_bit_strings postgresql_uuids postgresql_ltrees
-      postgresql_oids postgresql_xml_data_type defaults geometrics postgresql_timestamp_with_zones postgresql_partitioned_table postgresql_partitioned_table_parent postgresql_json_data_type).each do |table_name|
+      postgresql_oids postgresql_xml_data_type defaults geometrics postgresql_timestamp_with_zones postgresql_partitioned_table postgresql_partitioned_table_parent postgresql_json_data_type postgresql_citext).each do |table_name|
     execute "DROP TABLE IF EXISTS #{quote_table_name table_name}"
   end
 
@@ -99,6 +99,15 @@ _SQL
 _SQL
   end
 
+  if 't' == select_value("select 'citext'=ANY(select typname from pg_type)")
+  execute <<_SQL
+  CREATE TABLE postgresql_citext (
+    id SERIAL PRIMARY KEY,
+    text_citext citext default ''::citext
+  );
+_SQL
+  end
+
   if 't' == select_value("select 'json'=ANY(select typname from pg_type)")
   execute <<_SQL
   CREATE TABLE postgresql_json_data_type (
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 5f2d6acbcb..b44e72a67c 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -674,7 +674,11 @@ ActiveRecord::Schema.define do
     t.string   :title
     t.string   :author_name
     t.string   :author_email_address
-    t.datetime :written_on
+    if mysql_56?
+      t.datetime :written_on, limit: 6
+    else
+      t.datetime :written_on
+    end
     t.time     :bonus_time
     t.date     :last_read
     # use VARCHAR2(4000) instead of CLOB datatype as CLOB data type has many limitations in