Merge branch 'master' into rm-uuid-fixtures

Conflicts:
	activerecord/CHANGELOG.md
	activesupport/CHANGELOG.md

10 files changed, 160 insertions, 32 deletions

diff --git a/activerecord/test/cases/adapters/postgresql/array_test.rb b/activerecord/test/cases/adapters/postgresql/array_test.rb
index 36ded66998..18dd4a6de8 100644
--- a/activerecord/test/cases/adapters/postgresql/array_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/array_test.rb
@@ -25,7 +25,7 @@ class PostgresqlArrayTest < ActiveRecord::TestCase
 
   def test_column
     assert_equal :string, @column.type
-    assert_equal "character varying(255)", @column.sql_type
+    assert_equal "character varying", @column.sql_type
     assert @column.array
     assert_not @column.text?
     assert_not @column.number?
diff --git a/activerecord/test/cases/adapters/postgresql/bytea_test.rb b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
index c3394d7712..84fa199f17 100644
--- a/activerecord/test/cases/adapters/postgresql/bytea_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/bytea_test.rb
@@ -70,6 +70,23 @@ class PostgresqlByteaTest < ActiveRecord::TestCase
     assert_equal(data, record.payload)
   end
 
+  def test_via_to_sql
+    data = "'\u001F\\"
+    record = ByteaDataType.create(payload: data)
+    sql = ByteaDataType.where(payload: data).select(:payload).to_sql
+    result = @connection.query(sql)
+    assert_equal([[data]], result)
+  end
+
+  def test_via_to_sql_with_complicating_connection
+    Thread.new do
+      other_conn = ActiveRecord::Base.connection
+      other_conn.execute('SET standard_conforming_strings = off')
+    end.join
+
+    test_via_to_sql
+  end
+
   def test_write_binary
     data = File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'assets', 'example.log'))
     assert(data.size > 1)
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index a65f2da7a0..27f6fa575d 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -16,6 +16,8 @@ require 'models/essay'
 require 'models/toy'
 require 'models/invoice'
 require 'models/line_item'
+require 'models/column'
+require 'models/record'
 
 class BelongsToAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
@@ -885,4 +887,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
       end
     end
   end
+
+  test 'belongs_to works with model called Record' do
+    record = Record.create!
+    Column.create! record: record
+    assert_equal 1, Column.count
+  end
 end
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index db999f90ab..b8de78934e 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -387,6 +387,20 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_raise(ArgumentError) { Account.count(1, 2, 3) }
   end
 
+  def test_count_with_order
+    assert_equal 6, Account.order(:credit_limit).count
+  end
+
+  def test_count_with_reverse_order
+    assert_equal 6, Account.order(:credit_limit).reverse_order.count
+  end
+
+  def test_count_with_where_and_order
+    assert_equal 1, Account.where(firm_name: '37signals').count
+    assert_equal 1, Account.where(firm_name: '37signals').order(:firm_name).count
+    assert_equal 1, Account.where(firm_name: '37signals').order(:firm_name).reverse_order.count
+  end
+
   def test_should_sum_expression
     # Oracle adapter returns floating point value 636.0 after SUM
     if current_adapter?(:OracleAdapter)
diff --git a/activerecord/test/cases/connection_adapters/connection_handler_test.rb b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
index e097449029..f2d18e812d 100644
--- a/activerecord/test/cases/connection_adapters/connection_handler_test.rb
+++ b/activerecord/test/cases/connection_adapters/connection_handler_test.rb
@@ -25,35 +25,45 @@ module ActiveRecord
         ConnectionSpecification::Resolver.new(klass.new(config).resolve).spec(spec)
       end
 
-      def test_resolver_with_database_uri_and_known_key
+      def test_resolver_with_database_uri_and_current_env_symbol_key
         ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        config   = { "production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = resolve(:production, config)
+        config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        actual   = resolve(:default_env, config)
         expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
         assert_equal expected, actual
       end
 
-      def test_resolver_with_database_uri_and_known_string_key
+      def test_resolver_with_database_uri_and_and_current_env_string_key
         ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        config   = { "production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
-        actual   = assert_deprecated { resolve("production", config) }
+        config   = { "default_env" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        actual   = assert_deprecated { resolve("default_env", config) }
         expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
         assert_equal expected, actual
       end
 
-      def test_resolver_with_database_uri_and_unknown_symbol_key
+      def test_resolver_with_database_uri_and_known_key
         ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        config   = { "production" => { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost" } }
         actual   = resolve(:production, config)
-        expected = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
+        expected = { "adapter"=>"not_postgres", "database"=>"not_foo", "host"=>"localhost" }
         assert_equal expected, actual
       end
 
-      def test_resolver_with_database_uri_and_unknown_string_key
+      def test_resolver_with_database_uri_and_unknown_symbol_key
         ENV['DATABASE_URL'] = "postgres://localhost/foo"
         config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
         assert_raises AdapterNotSpecified do
-          spec("production", config)
+          resolve(:production, config)
+        end
+      end
+
+      def test_resolver_with_database_uri_and_unknown_string_key
+        ENV['DATABASE_URL'] = "postgres://localhost/foo"
+        config   = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        assert_deprecated do
+          assert_raises AdapterNotSpecified do
+            spec("production", config)
+          end
         end
       end
 
@@ -73,16 +83,24 @@ module ActiveRecord
 
       def test_environment_does_not_exist_in_config_url_does_exist
         ENV['DATABASE_URL'] = "postgres://localhost/foo"
-        config      = { "not_production" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
+        config      = { "not_default_env" => {  "adapter" => "not_postgres", "database" => "not_foo" } }
         actual      = klass.new(config).resolve
         expect_prod = { "adapter"=>"postgresql", "database"=>"foo", "host"=>"localhost" }
-        assert_equal expect_prod, actual["production"]
+        assert_equal expect_prod, actual["default_env"]
+      end
+
+      def test_url_with_hyphenated_scheme
+        ENV['DATABASE_URL'] = "ibm-db://localhost/foo"
+        config   = { "default_env" => { "adapter" => "not_postgres", "database" => "not_foo", "host" => "localhost" } }
+        actual   = resolve(:default_env, config)
+        expected = { "adapter"=>"ibm_db", "database"=>"foo", "host"=>"localhost" }
+        assert_equal expected, actual
       end
 
       def test_string_connection
-        config   = { "production" => "postgres://localhost/foo" }
+        config   = { "default_env" => "postgres://localhost/foo" }
         actual   = klass.new(config).resolve
-        expected = { "production" =>
+        expected = { "default_env" =>
                      { "adapter"  => "postgresql",
                        "database" => "foo",
                        "host"     => "localhost"
@@ -92,9 +110,9 @@ module ActiveRecord
       end
 
       def test_url_sub_key
-        config   = { "production" => { "url" => "postgres://localhost/foo" } }
+        config   = { "default_env" => { "url" => "postgres://localhost/foo" } }
         actual   = klass.new(config).resolve
-        expected = { "production" =>
+        expected = { "default_env" =>
                      { "adapter"  => "postgresql",
                        "database" => "foo",
                        "host"     => "localhost"
@@ -123,9 +141,10 @@ module ActiveRecord
         expected = { "adapter"  => "postgresql",
                      "database" => "foo",
                      "host"     => "localhost" }
-        assert_equal expected, actual["production"]
-        assert_equal expected, actual["development"]
-        assert_equal expected, actual["test"]
+        assert_equal expected, actual["default_env"]
+        assert_equal nil,      actual["production"]
+        assert_equal nil,      actual["development"]
+        assert_equal nil,      actual["test"]
         assert_equal nil,      actual[:production]
         assert_equal nil,      actual[:development]
         assert_equal nil,      actual[:test]
@@ -134,9 +153,9 @@ module ActiveRecord
       def test_url_sub_key_with_database_url
         ENV['DATABASE_URL'] = "NOT-POSTGRES://localhost/NOT_FOO"
 
-        config   = { "production" => { "url" => "postgres://localhost/foo" } }
+        config   = { "default_env" => { "url" => "postgres://localhost/foo" } }
         actual   = klass.new(config).resolve
-        expected = { "production" =>
+        expected = { "default_env" =>
                     { "adapter"  => "postgresql",
                        "database" => "foo",
                        "host"     => "localhost"
@@ -148,9 +167,9 @@ module ActiveRecord
       def test_merge_no_conflicts_with_database_url
         ENV['DATABASE_URL'] = "postgres://localhost/foo"
 
-        config   = {"production" => { "pool" => "5" } }
+        config   = {"default_env" => { "pool" => "5" } }
         actual   = klass.new(config).resolve
-        expected = { "production" =>
+        expected = { "default_env" =>
                      { "adapter"  => "postgresql",
                        "database" => "foo",
                        "host"     => "localhost",
@@ -163,9 +182,9 @@ module ActiveRecord
       def test_merge_conflicts_with_database_url
         ENV['DATABASE_URL'] = "postgres://localhost/foo"
 
-        config   = {"production" => { "adapter" => "NOT-POSTGRES", "database" => "NOT-FOO", "pool" => "5" } }
+        config   = {"default_env" => { "adapter" => "NOT-POSTGRES", "database" => "NOT-FOO", "pool" => "5" } }
         actual   = klass.new(config).resolve
-        expected = { "production" =>
+        expected = { "default_env" =>
                      { "adapter"  => "postgresql",
                        "database" => "foo",
                        "host"     => "localhost",
diff --git a/activerecord/test/cases/enum_test.rb b/activerecord/test/cases/enum_test.rb
index 47de3dec98..3b2f0dfe07 100644
--- a/activerecord/test/cases/enum_test.rb
+++ b/activerecord/test/cases/enum_test.rb
@@ -250,4 +250,40 @@ class EnumTest < ActiveRecord::TestCase
     valid_book = klass.new(status: "written")
     assert valid_book.valid?
   end
+
+  test "enums are distinct per class" do
+    klass1 = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum status: [:proposed, :written]
+    end
+
+    klass2 = Class.new(ActiveRecord::Base) do
+      self.table_name = "books"
+      enum status: [:drafted, :uploaded]
+    end
+
+    book1 = klass1.proposed.create!
+    book1.status = :written
+    assert_equal ['proposed', 'written'], book1.status_change
+
+    book2 = klass2.drafted.create!
+    book2.status = :uploaded
+    assert_equal ['drafted', 'uploaded'], book2.status_change
+  end
+
+  test "enums are inheritable" do
+    subklass1 = Class.new(Book)
+
+    subklass2 = Class.new(Book) do
+      enum status: [:drafted, :uploaded]
+    end
+
+    book1 = subklass1.proposed.create!
+    book1.status = :written
+    assert_equal ['proposed', 'written'], book1.status_change
+
+    book2 = subklass2.drafted.create!
+    book2.status = :uploaded
+    assert_equal ['drafted', 'uploaded'], book2.status_change
+  end
 end
diff --git a/activerecord/test/cases/migration/column_attributes_test.rb b/activerecord/test/cases/migration/column_attributes_test.rb
index ccf19fb4d0..6a02873cba 100644
--- a/activerecord/test/cases/migration/column_attributes_test.rb
+++ b/activerecord/test/cases/migration/column_attributes_test.rb
@@ -35,6 +35,14 @@ module ActiveRecord
         assert_no_column TestModel, :last_name
       end
 
+      def test_add_column_without_limit
+        # TODO: limit: nil should work with all adapters.
+        skip "MySQL wrongly enforces a limit of 255" if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+        add_column :test_models, :description, :string, limit: nil
+        TestModel.reset_column_information
+        assert_nil TestModel.columns_hash["description"].limit
+      end
+
       if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
         def test_unabstracted_database_dependent_types
           add_column :test_models, :intelligence_quotient, :tinyint
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index d7ad5ed29f..fed199f6e9 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -63,7 +63,7 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_column_string_type_and_limit
     assert_equal :string, @first.column_for_attribute("title").type
-    assert_equal 255, @first.column_for_attribute("title").limit
+    assert_equal 250, @first.column_for_attribute("title").limit
   end
 
   def test_column_null_not_null
@@ -192,7 +192,7 @@ class ReflectionTest < ActiveRecord::TestCase
   end
 
   def test_reflection_should_not_raise_error_when_compared_to_other_object
-    assert_nothing_raised { Firm.reflections[:clients] == Object.new }
+    assert_nothing_raised { Firm.reflections['clients'] == Object.new }
   end
 
   def test_has_many_through_reflection
diff --git a/activerecord/test/cases/relation/mutation_test.rb b/activerecord/test/cases/relation/mutation_test.rb
index 4fafa668fb..c81a3002d6 100644
--- a/activerecord/test/cases/relation/mutation_test.rb
+++ b/activerecord/test/cases/relation/mutation_test.rb
@@ -107,10 +107,18 @@ module ActiveRecord
     end
 
     test 'reverse_order!' do
-      assert relation.reverse_order!.equal?(relation)
-      assert relation.reverse_order_value
+      relation = Post.order('title ASC, comments_count DESC')
+
+      relation.reverse_order!
+
+      assert_equal 'title DESC', relation.order_values.first
+      assert_equal 'comments_count ASC', relation.order_values.last
+
+
       relation.reverse_order!
-      assert !relation.reverse_order_value
+
+      assert_equal 'title ASC', relation.order_values.first
+      assert_equal 'comments_count DESC', relation.order_values.last
     end
 
     test 'create_with!' do
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index fddb7c204a..2aa6d643a5 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -573,6 +573,12 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal expected, actual
   end
 
+  def test_to_sql_on_scoped_proxy
+    auth = Author.first
+    Post.where("1=1").written_by(auth)
+    assert_not auth.posts.to_sql.include?("1=1")
+  end
+
   def test_loading_with_one_association_with_non_preload
     posts = Post.eager_load(:last_comment).order('comments.id DESC')
     post = posts.find { |p| p.id == 1 }
@@ -1418,6 +1424,18 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal [], scope.references_values
   end
 
+  def test_order_with_reorder_nil_removes_the_order
+    relation = Post.order(:title).reorder(nil)
+
+    assert_nil relation.order_values.first
+  end
+
+  def test_reverse_order_with_reorder_nil_removes_the_order
+    relation = Post.order(:title).reverse_order.reorder(nil)
+
+    assert_nil relation.order_values.first
+  end
+
   def test_presence
     topics = Topic.all