From a9aed2ac94d2e0d1a233a3c193985ae78d7e79e9 Mon Sep 17 00:00:00 2001
From: Michael Grosser <michael@grosser.it>
Date: Fri, 16 Sep 2016 09:44:05 -0700
Subject: improve error message when include assertions fail

assert [1, 3].includes?(2) fails with unhelpful "Asserting failed" message

assert_includes [1, 3], 2 fails with "Expected [1, 3] to include 2" which makes it easier to debug and more obvious what went wrong
---
 activesupport/test/autoload_test.rb                | 12 ++--
 activesupport/test/concern_test.rb                 |  4 +-
 activesupport/test/configurable_test.rb            |  4 +-
 .../test/core_ext/array/conversions_test.rb        | 46 +++++++--------
 activesupport/test/core_ext/hash_ext_test.rb       | 68 +++++++++++-----------
 .../test/core_ext/module/concerning_test.rb        |  6 +-
 activesupport/test/core_ext/range_ext_test.rb      |  6 +-
 activesupport/test/dependencies_test.rb            | 18 +++---
 activesupport/test/logger_test.rb                  | 34 +++++------
 activesupport/test/multibyte_chars_test.rb         | 10 ++--
 activesupport/test/ordered_hash_test.rb            | 12 ++--
 activesupport/test/time_zone_test.rb               |  8 +--
 12 files changed, 114 insertions(+), 114 deletions(-)

(limited to 'activesupport/test')

diff --git a/activesupport/test/autoload_test.rb b/activesupport/test/autoload_test.rb
index c4d6a69212..6c8aa3e055 100644
--- a/activesupport/test/autoload_test.rb
+++ b/activesupport/test/autoload_test.rb
@@ -31,7 +31,7 @@ class TestAutoloadModule < ActiveSupport::TestCase
       end
     end
 
-    assert !$LOADED_FEATURES.include?(@some_class_path)
+    assert_not_includes $LOADED_FEATURES, @some_class_path
     assert_nothing_raised { ::Fixtures::Autoload::SomeClass }
   end
 
@@ -40,7 +40,7 @@ class TestAutoloadModule < ActiveSupport::TestCase
       autoload :SomeClass
     end
 
-    assert !$LOADED_FEATURES.include?(@some_class_path)
+    assert_not_includes $LOADED_FEATURES, @some_class_path
     assert_nothing_raised { ::Fixtures::Autoload::SomeClass }
   end
 
@@ -51,9 +51,9 @@ class TestAutoloadModule < ActiveSupport::TestCase
       end
     end
 
-    assert !$LOADED_FEATURES.include?(@some_class_path)
+    assert_not_includes $LOADED_FEATURES, @some_class_path
     ::Fixtures::Autoload.eager_load!
-    assert $LOADED_FEATURES.include?(@some_class_path)
+    assert_includes $LOADED_FEATURES, @some_class_path
     assert_nothing_raised { ::Fixtures::Autoload::SomeClass }
   end
 
@@ -64,7 +64,7 @@ class TestAutoloadModule < ActiveSupport::TestCase
       end
     end
 
-    assert !$LOADED_FEATURES.include?(@another_class_path)
+    assert_not_includes $LOADED_FEATURES, @another_class_path
     assert_nothing_raised { ::Fixtures::AnotherClass }
   end
 
@@ -75,7 +75,7 @@ class TestAutoloadModule < ActiveSupport::TestCase
       end
     end
 
-    assert !$LOADED_FEATURES.include?(@another_class_path)
+    assert_not_includes $LOADED_FEATURES, @another_class_path
     assert_nothing_raised { ::Fixtures::AnotherClass }
   end
 end
diff --git a/activesupport/test/concern_test.rb b/activesupport/test/concern_test.rb
index 4af9ce8163..95507c815d 100644
--- a/activesupport/test/concern_test.rb
+++ b/activesupport/test/concern_test.rb
@@ -66,7 +66,7 @@ class ConcernTest < ActiveSupport::TestCase
   def test_module_is_included_normally
     @klass.include(Baz)
     assert_equal "baz", @klass.new.baz
-    assert @klass.included_modules.include?(ConcernTest::Baz)
+    assert_includes @klass.included_modules, ConcernTest::Baz
   end
 
   def test_class_methods_are_extended
@@ -105,7 +105,7 @@ class ConcernTest < ActiveSupport::TestCase
     assert_equal "bar", @klass.new.bar
     assert_equal "bar+baz", @klass.new.baz
     assert_equal "bar's baz + baz", @klass.baz
-    assert @klass.included_modules.include?(ConcernTest::Bar)
+    assert_includes @klass.included_modules, ConcernTest::Bar
   end
 
   def test_dependencies_with_multiple_modules
diff --git a/activesupport/test/configurable_test.rb b/activesupport/test/configurable_test.rb
index c67ea8b222..3cd6d2d4d0 100644
--- a/activesupport/test/configurable_test.rb
+++ b/activesupport/test/configurable_test.rb
@@ -121,11 +121,11 @@ class ConfigurableActiveSupport < ActiveSupport::TestCase
 
   def assert_method_defined(object, method)
     methods = object.public_methods.map(&:to_s)
-    assert methods.include?(method.to_s), "Expected #{methods.inspect} to include #{method.to_s.inspect}"
+    assert_includes methods, method.to_s, "Expected #{methods.inspect} to include #{method.to_s.inspect}"
   end
 
   def assert_method_not_defined(object, method)
     methods = object.public_methods.map(&:to_s)
-    assert !methods.include?(method.to_s), "Expected #{methods.inspect} to not include #{method.to_s.inspect}"
+    assert_not_includes methods, method.to_s, "Expected #{methods.inspect} to not include #{method.to_s.inspect}"
   end
 end
diff --git a/activesupport/test/core_ext/array/conversions_test.rb b/activesupport/test/core_ext/array/conversions_test.rb
index ccbdab19f0..469efcd934 100644
--- a/activesupport/test/core_ext/array/conversions_test.rb
+++ b/activesupport/test/core_ext/array/conversions_test.rb
@@ -97,28 +97,28 @@ class ToXmlTest < ActiveSupport::TestCase
     ].to_xml(skip_instruct: true, indent: 0)
 
     assert_equal '<objects type="array"><object>', xml.first(30)
-    assert xml.include?(%(<age type="integer">26</age>)), xml
-    assert xml.include?(%(<age-in-millis type="integer">820497600000</age-in-millis>)), xml
-    assert xml.include?(%(<name>David</name>)), xml
-    assert xml.include?(%(<age type="integer">31</age>)), xml
-    assert xml.include?(%(<age-in-millis type="decimal">1.0</age-in-millis>)), xml
-    assert xml.include?(%(<name>Jason</name>)), xml
+    assert_includes xml, %(<age type="integer">26</age>), xml
+    assert_includes xml, %(<age-in-millis type="integer">820497600000</age-in-millis>), xml
+    assert_includes xml, %(<name>David</name>), xml
+    assert_includes xml, %(<age type="integer">31</age>), xml
+    assert_includes xml, %(<age-in-millis type="decimal">1.0</age-in-millis>), xml
+    assert_includes xml, %(<name>Jason</name>), xml
   end
 
   def test_to_xml_with_non_hash_elements
     xml = %w[1 2 3].to_xml(skip_instruct: true, indent: 0)
 
     assert_equal '<strings type="array"><string', xml.first(29)
-    assert xml.include?(%(<string>2</string>)), xml
+    assert_includes xml, %(<string>2</string>), xml
   end
 
   def test_to_xml_with_non_hash_different_type_elements
     xml = [1, 2.0, "3"].to_xml(skip_instruct: true, indent: 0)
 
     assert_equal '<objects type="array"><object', xml.first(29)
-    assert xml.include?(%(<object type="integer">1</object>)), xml
-    assert xml.include?(%(<object type="float">2.0</object>)), xml
-    assert xml.include?(%(object>3</object>)), xml
+    assert_includes xml, %(<object type="integer">1</object>), xml
+    assert_includes xml, %(<object type="float">2.0</object>), xml
+    assert_includes xml, %(object>3</object>), xml
   end
 
   def test_to_xml_with_dedicated_name
@@ -135,10 +135,10 @@ class ToXmlTest < ActiveSupport::TestCase
     ].to_xml(skip_instruct: true, skip_types: true, indent: 0)
 
     assert_equal "<objects><object>", xml.first(17)
-    assert xml.include?(%(<street-address>Paulina</street-address>))
-    assert xml.include?(%(<name>David</name>))
-    assert xml.include?(%(<street-address>Evergreen</street-address>))
-    assert xml.include?(%(<name>Jason</name>))
+    assert_includes xml, %(<street-address>Paulina</street-address>)
+    assert_includes xml, %(<name>David</name>)
+    assert_includes xml, %(<street-address>Evergreen</street-address>)
+    assert_includes xml, %(<name>Jason</name>)
   end
 
   def test_to_xml_with_indent_set
@@ -147,10 +147,10 @@ class ToXmlTest < ActiveSupport::TestCase
     ].to_xml(skip_instruct: true, skip_types: true, indent: 4)
 
     assert_equal "<objects>\n    <object>", xml.first(22)
-    assert xml.include?(%(\n        <street-address>Paulina</street-address>))
-    assert xml.include?(%(\n        <name>David</name>))
-    assert xml.include?(%(\n        <street-address>Evergreen</street-address>))
-    assert xml.include?(%(\n        <name>Jason</name>))
+    assert_includes xml, %(\n        <street-address>Paulina</street-address>)
+    assert_includes xml, %(\n        <name>David</name>)
+    assert_includes xml, %(\n        <street-address>Evergreen</street-address>)
+    assert_includes xml, %(\n        <name>Jason</name>)
   end
 
   def test_to_xml_with_dasherize_false
@@ -159,8 +159,8 @@ class ToXmlTest < ActiveSupport::TestCase
     ].to_xml(skip_instruct: true, skip_types: true, indent: 0, dasherize: false)
 
     assert_equal "<objects><object>", xml.first(17)
-    assert xml.include?(%(<street_address>Paulina</street_address>))
-    assert xml.include?(%(<street_address>Evergreen</street_address>))
+    assert_includes xml, %(<street_address>Paulina</street_address>)
+    assert_includes xml, %(<street_address>Evergreen</street_address>)
   end
 
   def test_to_xml_with_dasherize_true
@@ -169,8 +169,8 @@ class ToXmlTest < ActiveSupport::TestCase
     ].to_xml(skip_instruct: true, skip_types: true, indent: 0, dasherize: true)
 
     assert_equal "<objects><object>", xml.first(17)
-    assert xml.include?(%(<street-address>Paulina</street-address>))
-    assert xml.include?(%(<street-address>Evergreen</street-address>))
+    assert_includes xml, %(<street-address>Paulina</street-address>)
+    assert_includes xml, %(<street-address>Evergreen</street-address>)
   end
 
   def test_to_xml_with_instruct
@@ -191,7 +191,7 @@ class ToXmlTest < ActiveSupport::TestCase
       builder.count 2
     end
 
-    assert xml.include?(%(<count>2</count>)), xml
+    assert_includes xml, %(<count>2</count>), xml
   end
 
   def test_to_xml_with_empty
diff --git a/activesupport/test/core_ext/hash_ext_test.rb b/activesupport/test/core_ext/hash_ext_test.rb
index e457cb866d..ae35adb19b 100644
--- a/activesupport/test/core_ext/hash_ext_test.rb
+++ b/activesupport/test/core_ext/hash_ext_test.rb
@@ -1127,63 +1127,63 @@ class HashToXmlTest < ActiveSupport::TestCase
   def test_one_level
     xml = { name: "David", street: "Paulina" }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<street>Paulina</street>))
-    assert xml.include?(%(<name>David</name>))
+    assert_includes xml, %(<street>Paulina</street>)
+    assert_includes xml, %(<name>David</name>)
   end
 
   def test_one_level_dasherize_false
     xml = { name: "David", street_name: "Paulina" }.to_xml(@xml_options.merge(dasherize: false))
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<street_name>Paulina</street_name>))
-    assert xml.include?(%(<name>David</name>))
+    assert_includes xml, %(<street_name>Paulina</street_name>)
+    assert_includes xml, %(<name>David</name>)
   end
 
   def test_one_level_dasherize_true
     xml = { name: "David", street_name: "Paulina" }.to_xml(@xml_options.merge(dasherize: true))
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<street-name>Paulina</street-name>))
-    assert xml.include?(%(<name>David</name>))
+    assert_includes xml, %(<street-name>Paulina</street-name>)
+    assert_includes xml, %(<name>David</name>)
   end
 
   def test_one_level_camelize_true
     xml = { name: "David", street_name: "Paulina" }.to_xml(@xml_options.merge(camelize: true))
     assert_equal "<Person>", xml.first(8)
-    assert xml.include?(%(<StreetName>Paulina</StreetName>))
-    assert xml.include?(%(<Name>David</Name>))
+    assert_includes xml, %(<StreetName>Paulina</StreetName>)
+    assert_includes xml, %(<Name>David</Name>)
   end
 
   def test_one_level_camelize_lower
     xml = { name: "David", street_name: "Paulina" }.to_xml(@xml_options.merge(camelize: :lower))
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<streetName>Paulina</streetName>))
-    assert xml.include?(%(<name>David</name>))
+    assert_includes xml, %(<streetName>Paulina</streetName>)
+    assert_includes xml, %(<name>David</name>)
   end
 
   def test_one_level_with_types
     xml = { name: "David", street: "Paulina", age: 26, age_in_millis: 820497600000, moved_on: Date.new(2005, 11, 15), resident: :yes }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<street>Paulina</street>))
-    assert xml.include?(%(<name>David</name>))
-    assert xml.include?(%(<age type="integer">26</age>))
-    assert xml.include?(%(<age-in-millis type="integer">820497600000</age-in-millis>))
-    assert xml.include?(%(<moved-on type="date">2005-11-15</moved-on>))
-    assert xml.include?(%(<resident type="symbol">yes</resident>))
+    assert_includes xml, %(<street>Paulina</street>)
+    assert_includes xml, %(<name>David</name>)
+    assert_includes xml, %(<age type="integer">26</age>)
+    assert_includes xml, %(<age-in-millis type="integer">820497600000</age-in-millis>)
+    assert_includes xml, %(<moved-on type="date">2005-11-15</moved-on>)
+    assert_includes xml, %(<resident type="symbol">yes</resident>)
   end
 
   def test_one_level_with_nils
     xml = { name: "David", street: "Paulina", age: nil }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<street>Paulina</street>))
-    assert xml.include?(%(<name>David</name>))
-    assert xml.include?(%(<age nil="true"/>))
+    assert_includes xml, %(<street>Paulina</street>)
+    assert_includes xml, %(<name>David</name>)
+    assert_includes xml, %(<age nil="true"/>)
   end
 
   def test_one_level_with_skipping_types
     xml = { name: "David", street: "Paulina", age: nil }.to_xml(@xml_options.merge(skip_types: true))
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<street>Paulina</street>))
-    assert xml.include?(%(<name>David</name>))
-    assert xml.include?(%(<age nil="true"/>))
+    assert_includes xml, %(<street>Paulina</street>)
+    assert_includes xml, %(<name>David</name>)
+    assert_includes xml, %(<age nil="true"/>)
   end
 
   def test_one_level_with_yielding
@@ -1192,37 +1192,37 @@ class HashToXmlTest < ActiveSupport::TestCase
     end
 
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<street>Paulina</street>))
-    assert xml.include?(%(<name>David</name>))
-    assert xml.include?(%(<creator>Rails</creator>))
+    assert_includes xml, %(<street>Paulina</street>)
+    assert_includes xml, %(<name>David</name>)
+    assert_includes xml, %(<creator>Rails</creator>)
   end
 
   def test_two_levels
     xml = { name: "David", address: { street: "Paulina" } }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<address><street>Paulina</street></address>))
-    assert xml.include?(%(<name>David</name>))
+    assert_includes xml, %(<address><street>Paulina</street></address>)
+    assert_includes xml, %(<name>David</name>)
   end
 
   def test_two_levels_with_second_level_overriding_to_xml
     xml = { name: "David", address: { street: "Paulina" }, child: IWriteMyOwnXML.new }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<address><street>Paulina</street></address>))
-    assert xml.include?(%(<level_one><second_level>content</second_level></level_one>))
+    assert_includes xml, %(<address><street>Paulina</street></address>)
+    assert_includes xml, %(<level_one><second_level>content</second_level></level_one>)
   end
 
   def test_two_levels_with_array
     xml = { name: "David", addresses: [{ street: "Paulina" }, { street: "Evergreen" }] }.to_xml(@xml_options)
     assert_equal "<person>", xml.first(8)
-    assert xml.include?(%(<addresses type="array"><address>))
-    assert xml.include?(%(<address><street>Paulina</street></address>))
-    assert xml.include?(%(<address><street>Evergreen</street></address>))
-    assert xml.include?(%(<name>David</name>))
+    assert_includes xml, %(<addresses type="array"><address>)
+    assert_includes xml, %(<address><street>Paulina</street></address>)
+    assert_includes xml, %(<address><street>Evergreen</street></address>)
+    assert_includes xml, %(<name>David</name>)
   end
 
   def test_three_levels_with_array
     xml = { name: "David", addresses: [{ streets: [ { name: "Paulina" }, { name: "Paulina" } ] } ] }.to_xml(@xml_options)
-    assert xml.include?(%(<addresses type="array"><address><streets type="array"><street><name>))
+    assert_includes xml, %(<addresses type="array"><address><streets type="array"><street><name>)
   end
 
   def test_timezoned_attributes
diff --git a/activesupport/test/core_ext/module/concerning_test.rb b/activesupport/test/core_ext/module/concerning_test.rb
index 038cbf1f2f..098036828a 100644
--- a/activesupport/test/core_ext/module/concerning_test.rb
+++ b/activesupport/test/core_ext/module/concerning_test.rb
@@ -4,7 +4,7 @@ require "active_support/core_ext/module/concerning"
 class ModuleConcerningTest < ActiveSupport::TestCase
   def test_concerning_declares_a_concern_and_includes_it_immediately
     klass = Class.new { concerning(:Foo) {} }
-    assert klass.ancestors.include?(klass::Foo), klass.ancestors.inspect
+    assert_includes klass.ancestors, klass::Foo, klass.ancestors.inspect
   end
 end
 
@@ -21,10 +21,10 @@ class ModuleConcernTest < ActiveSupport::TestCase
     assert klass.const_defined?(:Baz, false)
     assert !ModuleConcernTest.const_defined?(:Baz)
     assert_kind_of ActiveSupport::Concern, klass::Baz
-    assert !klass.ancestors.include?(klass::Baz), klass.ancestors.inspect
+    assert_not_includes klass.ancestors, klass::Baz, klass.ancestors.inspect
 
     # Public method visibility by default
-    assert klass::Baz.public_instance_methods.map(&:to_s).include?("should_be_public")
+    assert_includes klass::Baz.public_instance_methods.map(&:to_s), "should_be_public"
 
     # Calls included hook
     assert_equal 1, Class.new { include klass::Baz }.instance_variable_get("@foo")
diff --git a/activesupport/test/core_ext/range_ext_test.rb b/activesupport/test/core_ext/range_ext_test.rb
index 25e6693e4d..fc0e72e09a 100644
--- a/activesupport/test/core_ext/range_ext_test.rb
+++ b/activesupport/test/core_ext/range_ext_test.rb
@@ -66,15 +66,15 @@ class RangeTest < ActiveSupport::TestCase
   end
 
   def test_exclusive_end_should_not_include_identical_with_inclusive_end
-    assert !(1...10).include?(1..10)
+    assert_not_includes (1...10), 1..10
   end
 
   def test_should_not_include_overlapping_first
-    assert !(2..8).include?(1..3)
+    assert_not_includes (2..8), 1..3
   end
 
   def test_should_not_include_overlapping_last
-    assert !(2..8).include?(5..9)
+    assert_not_includes (2..8), 5..9
   end
 
   def test_should_include_identical_exclusive_with_floats
diff --git a/activesupport/test/dependencies_test.rb b/activesupport/test/dependencies_test.rb
index e0edb4a086..54068f5a08 100644
--- a/activesupport/test/dependencies_test.rb
+++ b/activesupport/test/dependencies_test.rb
@@ -114,25 +114,25 @@ class DependenciesTest < ActiveSupport::TestCase
       assert_equal 1, $check_warnings_load_count
       assert_equal true, $checked_verbose, "On first load warnings should be enabled."
 
-      assert ActiveSupport::Dependencies.loaded.include?(expanded)
+      assert_includes ActiveSupport::Dependencies.loaded, expanded
       ActiveSupport::Dependencies.clear
       assert_not ActiveSupport::Dependencies.loaded.include?(expanded)
-      assert ActiveSupport::Dependencies.history.include?(expanded)
+      assert_includes ActiveSupport::Dependencies.history, expanded
 
       silence_warnings { require_dependency filename }
       assert_equal 2, $check_warnings_load_count
       assert_equal nil, $checked_verbose, "After first load warnings should be left alone."
 
-      assert ActiveSupport::Dependencies.loaded.include?(expanded)
+      assert_includes ActiveSupport::Dependencies.loaded, expanded
       ActiveSupport::Dependencies.clear
       assert_not ActiveSupport::Dependencies.loaded.include?(expanded)
-      assert ActiveSupport::Dependencies.history.include?(expanded)
+      assert_includes ActiveSupport::Dependencies.history, expanded
 
       enable_warnings { require_dependency filename }
       assert_equal 3, $check_warnings_load_count
       assert_equal true, $checked_verbose, "After first load warnings should be left alone."
 
-      assert ActiveSupport::Dependencies.loaded.include?(expanded)
+      assert_includes ActiveSupport::Dependencies.loaded, expanded
       ActiveSupport::Dependencies.warnings_on_first_load = old_warnings
     end
   end
@@ -1059,13 +1059,13 @@ class DependenciesTest < ActiveSupport::TestCase
   end
 
   def test_load_and_require_stay_private
-    assert Object.private_methods.include?(:load)
-    assert Object.private_methods.include?(:require)
+    assert_includes Object.private_methods, :load
+    assert_includes Object.private_methods, :require
 
     ActiveSupport::Dependencies.unhook!
 
-    assert Object.private_methods.include?(:load)
-    assert Object.private_methods.include?(:require)
+    assert_includes Object.private_methods, :load
+    assert_includes Object.private_methods, :require
   ensure
     ActiveSupport::Dependencies.hook!
   end
diff --git a/activesupport/test/logger_test.rb b/activesupport/test/logger_test.rb
index ece4167de9..3f04783401 100644
--- a/activesupport/test/logger_test.rb
+++ b/activesupport/test/logger_test.rb
@@ -67,7 +67,7 @@ class LoggerTest < ActiveSupport::TestCase
   def test_should_log_debugging_message_when_debugging
     @logger.level = Logger::DEBUG
     @logger.add(Logger::DEBUG, @message)
-    assert @output.string.include?(@message)
+    assert_includes @output.string, @message
   end
 
   def test_should_not_log_debug_messages_when_log_level_is_info
@@ -79,25 +79,25 @@ class LoggerTest < ActiveSupport::TestCase
   def test_should_add_message_passed_as_block_when_using_add
     @logger.level = Logger::INFO
     @logger.add(Logger::INFO) { @message }
-    assert @output.string.include?(@message)
+    assert_includes @output.string, @message
   end
 
   def test_should_add_message_passed_as_block_when_using_shortcut
     @logger.level = Logger::INFO
     @logger.info { @message }
-    assert @output.string.include?(@message)
+    assert_includes @output.string, @message
   end
 
   def test_should_convert_message_to_string
     @logger.level = Logger::INFO
     @logger.info @integer_message
-    assert @output.string.include?(@integer_message.to_s)
+    assert_includes @output.string, @integer_message.to_s
   end
 
   def test_should_convert_message_to_string_when_passed_in_block
     @logger.level = Logger::INFO
     @logger.info { @integer_message }
-    assert @output.string.include?(@integer_message.to_s)
+    assert_includes @output.string, @integer_message.to_s
   end
 
   def test_should_not_evaluate_block_if_message_wont_be_logged
@@ -125,10 +125,10 @@ class LoggerTest < ActiveSupport::TestCase
     @logger.level = Logger::INFO
     @logger.info(UNICODE_STRING)
     @logger.info(BYTE_STRING)
-    assert @output.string.include?(UNICODE_STRING)
+    assert_includes @output.string, UNICODE_STRING
     byte_string = @output.string.dup
     byte_string.force_encoding("ASCII-8BIT")
-    assert byte_string.include?(BYTE_STRING)
+    assert_includes byte_string, BYTE_STRING
   end
 
   def test_silencing_everything_but_errors
@@ -138,7 +138,7 @@ class LoggerTest < ActiveSupport::TestCase
     end
 
     assert_not @output.string.include?("NOT THERE")
-    assert @output.string.include?("THIS IS HERE")
+    assert_includes @output.string, "THIS IS HERE"
   end
 
   def test_logger_silencing_works_for_broadcast
@@ -154,12 +154,12 @@ class LoggerTest < ActiveSupport::TestCase
       @logger.error "CORRECT ERROR"
     end
 
-    assert @output.string.include?("CORRECT DEBUG")
-    assert @output.string.include?("CORRECT ERROR")
+    assert_includes @output.string, "CORRECT DEBUG"
+    assert_includes @output.string, "CORRECT ERROR"
     assert_not @output.string.include?("FAILURE")
 
-    assert another_output.string.include?("CORRECT DEBUG")
-    assert another_output.string.include?("CORRECT ERROR")
+    assert_includes another_output.string, "CORRECT DEBUG"
+    assert_includes another_output.string, "CORRECT ERROR"
     assert_not another_output.string.include?("FAILURE")
   end
 
@@ -176,13 +176,13 @@ class LoggerTest < ActiveSupport::TestCase
       @logger.error "CORRECT ERROR"
     end
 
-    assert @output.string.include?("CORRECT DEBUG")
-    assert @output.string.include?("CORRECT ERROR")
+    assert_includes @output.string, "CORRECT DEBUG"
+    assert_includes @output.string, "CORRECT ERROR"
     assert_not @output.string.include?("FAILURE")
 
-    assert another_output.string.include?("CORRECT DEBUG")
-    assert another_output.string.include?("CORRECT ERROR")
-    assert another_output.string.include?("FAILURE")
+    assert_includes another_output.string, "CORRECT DEBUG"
+    assert_includes another_output.string, "CORRECT ERROR"
+    assert_includes another_output.string, "FAILURE"
     # We can't silence plain ruby Logger cause with thread safety
     # but at least we don't break it
   end
diff --git a/activesupport/test/multibyte_chars_test.rb b/activesupport/test/multibyte_chars_test.rb
index 54429f4aab..5ff1543328 100644
--- a/activesupport/test/multibyte_chars_test.rb
+++ b/activesupport/test/multibyte_chars_test.rb
@@ -213,11 +213,11 @@ class MultibyteCharsUTF8BehaviourTest < ActiveSupport::TestCase
   end
 
   def test_should_know_if_one_includes_the_other
-    assert @chars.include?("")
-    assert @chars.include?("ち")
-    assert @chars.include?("わ")
-    assert !@chars.include?("こちわ")
-    assert !@chars.include?("a")
+    assert_includes @chars, ""
+    assert_includes @chars, "ち"
+    assert_includes @chars, "わ"
+    assert_not_includes @chars, "こちわ"
+    assert_not_includes @chars, "a"
   end
 
   def test_include_raises_when_nil_is_passed
diff --git a/activesupport/test/ordered_hash_test.rb b/activesupport/test/ordered_hash_test.rb
index d2dfc34040..86da9f193a 100644
--- a/activesupport/test/ordered_hash_test.rb
+++ b/activesupport/test/ordered_hash_test.rb
@@ -129,22 +129,22 @@ class OrderedHashTest < ActiveSupport::TestCase
     copy = @ordered_hash.dup
     copy.delete("pink")
     assert_equal copy, @ordered_hash.delete_if { |k, _| k == "pink" }
-    assert !@ordered_hash.keys.include?("pink")
+    assert_not_includes @ordered_hash.keys, "pink"
   end
 
   def test_reject!
     (copy = @ordered_hash.dup).delete("pink")
     @ordered_hash.reject! { |k, _| k == "pink" }
     assert_equal copy, @ordered_hash
-    assert !@ordered_hash.keys.include?("pink")
+    assert_not_includes @ordered_hash.keys, "pink"
   end
 
   def test_reject
     copy = @ordered_hash.dup
     new_ordered_hash = @ordered_hash.reject { |k, _| k == "pink" }
     assert_equal copy, @ordered_hash
-    assert !new_ordered_hash.keys.include?("pink")
-    assert @ordered_hash.keys.include?("pink")
+    assert_not_includes new_ordered_hash.keys, "pink"
+    assert_includes @ordered_hash.keys, "pink"
     assert_instance_of ActiveSupport::OrderedHash, new_ordered_hash
   end
 
@@ -191,7 +191,7 @@ class OrderedHashTest < ActiveSupport::TestCase
   def test_shift
     pair = @ordered_hash.shift
     assert_equal [@keys.first, @values.first], pair
-    assert !@ordered_hash.keys.include?(pair.first)
+    assert_not_includes @ordered_hash.keys, pair.first
   end
 
   def test_keys
@@ -201,7 +201,7 @@ class OrderedHashTest < ActiveSupport::TestCase
   end
 
   def test_inspect
-    assert @ordered_hash.inspect.include?(@hash.inspect)
+    assert_includes @ordered_hash.inspect, @hash.inspect
   end
 
   def test_json
diff --git a/activesupport/test/time_zone_test.rb b/activesupport/test/time_zone_test.rb
index f89b608270..76fee1fdd4 100644
--- a/activesupport/test/time_zone_test.rb
+++ b/activesupport/test/time_zone_test.rb
@@ -505,13 +505,13 @@ class TimeZoneTest < ActiveSupport::TestCase
   end
 
   def test_us_zones
-    assert ActiveSupport::TimeZone.us_zones.include?(ActiveSupport::TimeZone["Hawaii"])
-    assert !ActiveSupport::TimeZone.us_zones.include?(ActiveSupport::TimeZone["Kuala Lumpur"])
+    assert_includes ActiveSupport::TimeZone.us_zones, ActiveSupport::TimeZone["Hawaii"]
+    assert_not_includes ActiveSupport::TimeZone.us_zones, ActiveSupport::TimeZone["Kuala Lumpur"]
   end
 
   def test_country_zones
-    assert ActiveSupport::TimeZone.country_zones("ru").include?(ActiveSupport::TimeZone["Moscow"])
-    assert !ActiveSupport::TimeZone.country_zones(:ru).include?(ActiveSupport::TimeZone["Kuala Lumpur"])
+    assert_includes ActiveSupport::TimeZone.country_zones("ru"), ActiveSupport::TimeZone["Moscow"]
+    assert_not_includes ActiveSupport::TimeZone.country_zones(:ru), ActiveSupport::TimeZone["Kuala Lumpur"]
   end
 
   def test_to_yaml
-- 
cgit v1.2.3