11 files changed, 348 insertions, 126 deletions
diff --git a/activerecord/test/cases/adapters/mysql2/boolean_test.rb b/activerecord/test/cases/adapters/mysql2/boolean_test.rb
new file mode 100644
index 0000000000..267aa232d9
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql2/boolean_test.rb
@@ -0,0 +1,91 @@
+require "cases/helper"
+
+class Mysql2BooleanTest < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  class BooleanType < ActiveRecord::Base
+    self.table_name = "mysql_booleans"
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table("mysql_booleans") do |t|
+      t.boolean "archived"
+      t.string "published", limit: 1
+    end
+    BooleanType.reset_column_information
+
+    @emulate_booleans = ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans
+  end
+
+  teardown do
+    emulate_booleans @emulate_booleans
+    @connection.drop_table "mysql_booleans"
+  end
+
+  test "column type with emulated booleans" do
+    emulate_booleans true
+
+    assert_equal :boolean, boolean_column.type
+    assert_equal :string, string_column.type
+  end
+
+  test "column type without emulated booleans" do
+    emulate_booleans false
+
+    assert_equal :integer, boolean_column.type
+    assert_equal :string, string_column.type
+  end
+
+  test "test type casting with emulated booleans" do
+    emulate_booleans true
+
+    boolean = BooleanType.create!(archived: true, published: true)
+    attributes = boolean.reload.attributes_before_type_cast
+
+    assert_equal 1, attributes["archived"]
+    assert_equal "1", attributes["published"]
+
+    assert_equal 1, @connection.type_cast(true, boolean_column)
+    assert_equal 1, @connection.type_cast(true, string_column)
+  end
+
+  test "test type casting without emulated booleans" do
+    emulate_booleans false
+
+    boolean = BooleanType.create!(archived: true, published: true)
+    attributes = boolean.reload.attributes_before_type_cast
+
+    assert_equal 1, attributes["archived"]
+    assert_equal "1", attributes["published"]
+
+    assert_equal 1, @connection.type_cast(true, boolean_column)
+    assert_equal 1, @connection.type_cast(true, string_column)
+  end
+
+  test "with booleans stored as 1 and 0" do
+    @connection.execute "INSERT INTO mysql_booleans(archived, published) VALUES(1, '1')"
+    boolean = BooleanType.first
+    assert_equal true, boolean.archived
+    assert_equal "1", boolean.published
+  end
+
+  test "with booleans stored as t" do
+    @connection.execute "INSERT INTO mysql_booleans(published) VALUES('t')"
+    boolean = BooleanType.first
+    assert_equal "t", boolean.published
+  end
+
+  def boolean_column
+    BooleanType.columns.find { |c| c.name == 'archived' }
+  end
+
+  def string_column
+    BooleanType.columns.find { |c| c.name == 'published' }
+  end
+
+  def emulate_booleans(value)
+    ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans = value
+    BooleanType.reset_column_information
+  end
+end
diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index c450b1beb5..47592f312e 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -514,6 +514,15 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal(post.taggings.count, post.taggings_count)
   end
 
+  def test_update_counter_caches_on_destroy
+    post = posts(:welcome)
+    tag  = post.tags.create!(name: 'doomed')
+
+    assert_difference 'post.reload.taggings_count', -1 do
+      tag.tagged_posts.destroy(post)
+    end
+  end
+
   def test_replace_association
     assert_queries(4){posts(:welcome);people(:david);people(:michael); posts(:welcome).people(true)}
 
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index cdd386187b..a7a8e0c5c6 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -509,16 +509,30 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_no_queries { Firm.new.account = account }
   end
 
-  def test_has_one_assignment_triggers_save_on_change
+  def test_has_one_assignment_dont_triggers_save_on_change_of_same_object
     pirate = Pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
     ship = pirate.build_ship(name: 'old name')
     ship.save!
 
     ship.name = 'new name'
     assert ship.changed?
+    assert_queries(1) do
+      # One query for updating name, not triggering query for updating pirate_id
+      pirate.ship = ship
+    end
+
+    assert_equal 'new name', pirate.ship.reload.name
+  end
+
+  def test_has_one_assignment_triggers_save_on_change_on_replacing_object
+    pirate = Pirate.create!(catchphrase: "Don' botharrr talkin' like one, savvy?")
+    ship = pirate.build_ship(name: 'old name')
+    ship.save!
+
+    new_ship = Ship.create(name: 'new name')
     assert_queries(2) do
       # One query for updating name and second query for updating pirate_id
-      pirate.ship = ship
+      pirate.ship = new_ship
     end
 
     assert_equal 'new name', pirate.ship.reload.name
diff --git a/activerecord/test/cases/integration_test.rb b/activerecord/test/cases/integration_test.rb
index 840865c4cf..1f62433ea2 100644
--- a/activerecord/test/cases/integration_test.rb
+++ b/activerecord/test/cases/integration_test.rb
@@ -23,6 +23,24 @@ class IntegrationTest < ActiveRecord::TestCase
     assert_equal '1', client.to_param
   end
 
+  def test_to_param_class_method
+    firm = Firm.find(4)
+    assert_equal '4-flamboyant-software', firm.to_param
+  end
+
+  def to_param_class_method_uses_default_if_blank
+    firm = Firm.find(4)
+    firm.name = nil
+    assert_equal '4', firm.to_param
+    firm.name = ' '
+    assert_equal '4', firm.to_param
+  end
+
+  def to_param_class_method_uses_default_if_not_persisted
+    firm = Firm.new(name: 'Fancy Shirts')
+    assert_equal nil, firm.to_param
+  end
+
   def test_cache_key_for_existing_record_is_not_timezone_dependent
     utc_key = Developer.first.cache_key
 
diff --git a/activerecord/test/cases/relation/delegation_test.rb b/activerecord/test/cases/relation/delegation_test.rb
index c171c5e14e..7f99b6841f 100644
--- a/activerecord/test/cases/relation/delegation_test.rb
+++ b/activerecord/test/cases/relation/delegation_test.rb
@@ -61,8 +61,10 @@ module ActiveRecord
   end
 
   class DelegationRelationTest < DelegationTest
+    fixtures :comments
+
     def target
-      Comment.where.not(body: nil)
+      Comment.where(body: 'Normal type')
     end
 
     [:map, :collect].each do |method|
@@ -88,7 +90,7 @@ module ActiveRecord
     end
 
     [:select!, :uniq!].each do |method|
-      test "##{method} is triggers an immutable error" do
+      test "##{method} triggers an immutable error" do
         assert_raises ActiveRecord::ImmutableRelation do
           assert_responds(target, method)
         end
diff --git a/activerecord/test/cases/relation/merging_test.rb b/activerecord/test/cases/relation/merging_test.rb
new file mode 100644
index 0000000000..782c8bc1fd
--- /dev/null
+++ b/activerecord/test/cases/relation/merging_test.rb
@@ -0,0 +1,150 @@
+require 'cases/helper'
+require 'models/author'
+require 'models/comment'
+require 'models/developer'
+require 'models/post'
+require 'models/project'
+
+class RelationMergingTest < ActiveRecord::TestCase
+  fixtures :developers, :comments, :authors, :posts
+
+  def test_relation_merging
+    devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order('id ASC').where("id < 3"))
+    assert_equal [developers(:david), developers(:jamis)], devs.to_a
+
+    dev_with_count = Developer.limit(1).merge(Developer.order('id DESC')).merge(Developer.select('developers.*'))
+    assert_equal [developers(:poor_jamis)], dev_with_count.to_a
+  end
+
+  def test_relation_to_sql
+    sql = Post.connection.unprepared_statement do
+      Post.first.comments.to_sql
+    end
+    assert_no_match(/\?/, sql)
+  end
+
+  def test_relation_merging_with_arel_equalities_keeps_last_equality
+    devs = Developer.where(Developer.arel_table[:salary].eq(80000)).merge(
+      Developer.where(Developer.arel_table[:salary].eq(9000))
+    )
+    assert_equal [developers(:poor_jamis)], devs.to_a
+  end
+
+  def test_relation_merging_with_arel_equalities_keeps_last_equality_with_non_attribute_left_hand
+    salary_attr = Developer.arel_table[:salary]
+    devs = Developer.where(
+      Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(80000)
+    ).merge(
+      Developer.where(
+        Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(9000)
+      )
+    )
+    assert_equal [developers(:poor_jamis)], devs.to_a
+  end
+
+  def test_relation_merging_with_eager_load
+    relations = []
+    relations << Post.order('comments.id DESC').merge(Post.eager_load(:last_comment)).merge(Post.all)
+    relations << Post.eager_load(:last_comment).merge(Post.order('comments.id DESC')).merge(Post.all)
+
+    relations.each do |posts|
+      post = posts.find { |p| p.id == 1 }
+      assert_equal Post.find(1).last_comment, post.last_comment
+    end
+  end
+
+  def test_relation_merging_with_locks
+    devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
+    assert devs.locked.present?
+  end
+
+  def test_relation_merging_with_preload
+    [Post.all.merge(Post.preload(:author)), Post.preload(:author).merge(Post.all)].each do |posts|
+      assert_queries(2) { assert posts.first.author }
+    end
+  end
+
+  def test_relation_merging_with_joins
+    comments = Comment.joins(:post).where(:body => 'Thank you for the welcome').merge(Post.where(:body => 'Such a lovely day'))
+    assert_equal 1, comments.count
+  end
+
+  def test_relation_merging_with_association
+    assert_queries(2) do  # one for loading post, and another one merged query
+      post = Post.where(:body => 'Such a lovely day').first
+      comments = Comment.where(:body => 'Thank you for the welcome').merge(post.comments)
+      assert_equal 1, comments.count
+    end
+  end
+
+  test "merge collapses wheres from the LHS only" do
+    left  = Post.where(title: "omg").where(comments_count: 1)
+    right = Post.where(title: "wtf").where(title: "bbq")
+
+    expected = [left.where_values[1]] + right.where_values
+    merged   = left.merge(right)
+
+    assert_equal expected, merged.where_values
+    assert !merged.to_sql.include?("omg")
+    assert merged.to_sql.include?("wtf")
+    assert merged.to_sql.include?("bbq")
+  end
+
+  def test_merging_removes_rhs_bind_parameters
+    left  = Post.where(id: Arel::Nodes::BindParam.new('?'))
+    column = Post.columns_hash['id']
+    left.bind_values += [[column, 20]]
+    right   = Post.where(id: 10)
+
+    merged = left.merge(right)
+    assert_equal [], merged.bind_values
+  end
+
+  def test_merging_keeps_lhs_bind_parameters
+    column = Post.columns_hash['id']
+    binds = [[column, 20]]
+
+    right  = Post.where(id: Arel::Nodes::BindParam.new('?'))
+    right.bind_values += binds
+    left   = Post.where(id: 10)
+
+    merged = left.merge(right)
+    assert_equal binds, merged.bind_values
+  end
+
+  def test_merging_reorders_bind_params
+    post         = Post.first
+    id_column    = Post.columns_hash['id']
+    title_column = Post.columns_hash['title']
+
+    bv = Post.connection.substitute_at id_column, 0
+
+    right  = Post.where(id: bv)
+    right.bind_values += [[id_column, post.id]]
+
+    left   = Post.where(title: bv)
+    left.bind_values += [[title_column, post.title]]
+
+    merged = left.merge(right)
+    assert_equal post, merged.first
+  end
+end
+
+class MergingDifferentRelationsTest < ActiveRecord::TestCase
+  fixtures :posts, :authors
+
+  test "merging where relations" do
+    hello_by_bob = Post.where(body: "hello").joins(:author).
+      merge(Author.where(name: "Bob")).pluck("posts.id")
+
+    assert_equal [posts(:misc_by_bob).id,
+                  posts(:other_by_bob).id], hello_by_bob
+  end
+
+  test "merging order relations" do
+    posts_by_author_name = Post.limit(3).joins(:author).
+      merge(Author.order(:name)).pluck("authors.name")
+
+    assert_equal ["Bob", "Bob", "David"], posts_by_author_name
+  end
+end
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index c9c7ac04b3..baa3acf3fb 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -774,75 +774,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_raises(ArgumentError) { Developer.select }
   end
 
-  def test_relation_merging
-    devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order('id ASC').where("id < 3"))
-    assert_equal [developers(:david), developers(:jamis)], devs.to_a
-
-    dev_with_count = Developer.limit(1).merge(Developer.order('id DESC')).merge(Developer.select('developers.*'))
-    assert_equal [developers(:poor_jamis)], dev_with_count.to_a
-  end
-
-  def test_relation_to_sql
-    sql = Post.connection.unprepared_statement do
-      Post.first.comments.to_sql
-    end
-    assert_no_match(/\?/, sql)
-  end
-
-  def test_relation_merging_with_arel_equalities_keeps_last_equality
-    devs = Developer.where(Developer.arel_table[:salary].eq(80000)).merge(
-      Developer.where(Developer.arel_table[:salary].eq(9000))
-    )
-    assert_equal [developers(:poor_jamis)], devs.to_a
-  end
-
-  def test_relation_merging_with_arel_equalities_keeps_last_equality_with_non_attribute_left_hand
-    salary_attr = Developer.arel_table[:salary]
-    devs = Developer.where(
-      Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(80000)
-    ).merge(
-      Developer.where(
-        Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(9000)
-      )
-    )
-    assert_equal [developers(:poor_jamis)], devs.to_a
-  end
-
-  def test_relation_merging_with_eager_load
-    relations = []
-    relations << Post.order('comments.id DESC').merge(Post.eager_load(:last_comment)).merge(Post.all)
-    relations << Post.eager_load(:last_comment).merge(Post.order('comments.id DESC')).merge(Post.all)
-
-    relations.each do |posts|
-      post = posts.find { |p| p.id == 1 }
-      assert_equal Post.find(1).last_comment, post.last_comment
-    end
-  end
-
-  def test_relation_merging_with_locks
-    devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
-    assert devs.locked.present?
-  end
-
-  def test_relation_merging_with_preload
-    [Post.all.merge(Post.preload(:author)), Post.preload(:author).merge(Post.all)].each do |posts|
-      assert_queries(2) { assert posts.first.author }
-    end
-  end
-
-  def test_relation_merging_with_joins
-    comments = Comment.joins(:post).where(:body => 'Thank you for the welcome').merge(Post.where(:body => 'Such a lovely day'))
-    assert_equal 1, comments.count
-  end
-
-  def test_relation_merging_with_association
-    assert_queries(2) do  # one for loading post, and another one merged query
-      post = Post.where(:body => 'Such a lovely day').first
-      comments = Comment.where(:body => 'Thank you for the welcome').merge(post.comments)
-      assert_equal 1, comments.count
-    end
-  end
-
   def test_count
     posts = Post.all
 
@@ -1597,56 +1528,4 @@ class RelationTest < ActiveRecord::TestCase
       Array.send(:remove_method, :__omg__)
     end
   end
-
-  test "merge collapses wheres from the LHS only" do
-    left  = Post.where(title: "omg").where(comments_count: 1)
-    right = Post.where(title: "wtf").where(title: "bbq")
-
-    expected = [left.where_values[1]] + right.where_values
-    merged   = left.merge(right)
-
-    assert_equal expected, merged.where_values
-    assert !merged.to_sql.include?("omg")
-    assert merged.to_sql.include?("wtf")
-    assert merged.to_sql.include?("bbq")
-  end
-
-  def test_merging_removes_rhs_bind_parameters
-    left  = Post.where(id: Arel::Nodes::BindParam.new('?'))
-    column = Post.columns_hash['id']
-    left.bind_values += [[column, 20]]
-    right   = Post.where(id: 10)
-
-    merged = left.merge(right)
-    assert_equal [], merged.bind_values
-  end
-
-  def test_merging_keeps_lhs_bind_parameters
-    column = Post.columns_hash['id']
-    binds = [[column, 20]]
-
-    right  = Post.where(id: Arel::Nodes::BindParam.new('?'))
-    right.bind_values += binds
-    left   = Post.where(id: 10)
-
-    merged = left.merge(right)
-    assert_equal binds, merged.bind_values
-  end
-
-  def test_merging_reorders_bind_params
-    post         = Post.first
-    id_column    = Post.columns_hash['id']
-    title_column = Post.columns_hash['title']
-
-    bv = Post.connection.substitute_at id_column, 0
-
-    right  = Post.where(id: bv)
-    right.bind_values += [[id_column, post.id]]
-
-    left   = Post.where(title: bv)
-    left.bind_values += [[title_column, post.title]]
-
-    merged = left.merge(right)
-    assert_equal post, merged.first
-  end
 end
diff --git a/activerecord/test/cases/test_case.rb b/activerecord/test/cases/test_case.rb
index 8c6d189b0c..910f46d693 100644
--- a/activerecord/test/cases/test_case.rb
+++ b/activerecord/test/cases/test_case.rb
@@ -78,7 +78,7 @@ module ActiveRecord
     # ignored SQL, or better yet, use a different notification for the queries
     # instead examining the SQL content.
     oracle_ignored     = [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
-    mysql_ignored      = [/^SHOW TABLES/i, /^SHOW FULL FIELDS/]
+    mysql_ignored      = [/^SHOW TABLES/i, /^SHOW FULL FIELDS/, /^SHOW CREATE TABLE /i]
     postgresql_ignored = [/^\s*select\b.*\bfrom\b.*pg_namespace\b/im, /^\s*select\b.*\battname\b.*\bfrom\b.*\bpg_attribute\b/im, /^SHOW search_path/i]
     sqlite3_ignored =    [/^\s*SELECT name\b.*\bFROM sqlite_master/im]
 
diff --git a/activerecord/test/cases/timestamp_test.rb b/activerecord/test/cases/timestamp_test.rb
index ff1b01556d..8c45f2a3f8 100644
--- a/activerecord/test/cases/timestamp_test.rb
+++ b/activerecord/test/cases/timestamp_test.rb
@@ -11,6 +11,7 @@ class TimestampTest < ActiveRecord::TestCase
 
   def setup
     @developer = Developer.first
+    @owner = Owner.first
     @developer.update_columns(updated_at: Time.now.prev_month)
     @previously_updated_at = @developer.updated_at
   end
@@ -92,6 +93,53 @@ class TimestampTest < ActiveRecord::TestCase
     assert_nothing_raised { Car.first.touch }
   end
 
+  def test_touching_a_no_touching_object
+    Developer.no_touching do
+      assert @developer.no_touching?
+      assert !@owner.no_touching?
+      @developer.touch
+    end
+
+    assert !@developer.no_touching?
+    assert !@owner.no_touching?
+    assert_equal @previously_updated_at, @developer.updated_at
+  end
+
+  def test_touching_related_objects
+    @owner = Owner.first
+    @previously_updated_at = @owner.updated_at
+
+    Owner.no_touching do
+      @owner.pets.first.touch
+    end
+
+    assert_equal @previously_updated_at, @owner.updated_at
+  end
+
+  def test_global_no_touching
+    ActiveRecord::Base.no_touching do
+      assert @developer.no_touching?
+      assert @owner.no_touching?
+      @developer.touch
+    end
+
+    assert !@developer.no_touching?
+    assert !@owner.no_touching?
+    assert_equal @previously_updated_at, @developer.updated_at
+  end
+
+  def test_no_touching_threadsafe
+    Thread.new do
+      Developer.no_touching do
+        assert @developer.no_touching?
+
+        sleep(1)
+      end
+    end
+
+    assert !@developer.no_touching?
+  end
+
   def test_saving_a_record_with_a_belongs_to_that_specifies_touching_the_parent_should_update_the_parent_updated_at
     pet   = Pet.first
     owner = pet.owner
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index cda4e7453b..89dab16975 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -485,6 +485,13 @@ class TransactionTest < ActiveRecord::TestCase
         raise ActiveRecord::Rollback
       end
     end
+  ensure
+    begin
+      Topic.connection.remove_column('topics', 'stuff')
+    rescue
+    ensure
+      Topic.reset_column_information
+    end
   end
 
   def test_transactions_state_from_rollback
diff --git a/activerecord/test/cases/yaml_serialization_test.rb b/activerecord/test/cases/yaml_serialization_test.rb
index 83a710b1b7..15815d56e4 100644
--- a/activerecord/test/cases/yaml_serialization_test.rb
+++ b/activerecord/test/cases/yaml_serialization_test.rb
@@ -43,4 +43,8 @@ class YamlSerializationTest < ActiveRecord::TestCase
     t = Psych.load Psych.dump topic
     assert_equal topic.attributes, t.attributes
   end
+
+  def test_active_record_relation_serialization
+    [Topic.all].to_yaml
+  end
 end