1 files changed, 181 insertions, 78 deletions

diff --git a/activesupport/test/test_case_test.rb b/activesupport/test/test_case_test.rb
index dfe9f3c11c..5e852c8050 100644
--- a/activesupport/test/test_case_test.rb
+++ b/activesupport/test/test_case_test.rb
@@ -1,118 +1,221 @@
 require 'abstract_unit'
 
-module ActiveSupport
-  class TestCaseTest < ActiveSupport::TestCase
-    class FakeRunner
-      attr_reader :puked
-
-      def initialize
-        @puked = []
+class AssertDifferenceTest < ActiveSupport::TestCase
+  def setup
+    @object = Class.new do
+      attr_accessor :num
+      def increment
+        self.num += 1
       end
 
-      def puke(klass, name, e)
-        @puked << [klass, name, e]
+      def decrement
+        self.num -= 1
       end
+    end.new
+    @object.num = 0
+  end
+
+  def test_assert_not
+    assert_equal true, assert_not(nil)
+    assert_equal true, assert_not(false)
+
+    e = assert_raises(Minitest::Assertion) { assert_not true }
+    assert_equal 'Expected true to be nil or false', e.message
+
+    e = assert_raises(Minitest::Assertion) { assert_not true, 'custom' }
+    assert_equal 'custom', e.message
+  end
+
+  def test_assert_no_difference_pass
+    assert_no_difference '@object.num' do
+      # ...
+    end
+  end
 
-      def options
-        nil
+  def test_assert_no_difference_fail
+    error = assert_raises(Minitest::Assertion) do
+      assert_no_difference '@object.num' do
+        @object.increment
       end
+    end
+    assert_equal "\"@object.num\" didn't change by 0.\nExpected: 0\n  Actual: 1", error.message
+  end
 
-      def record(*args)
+  def test_assert_no_difference_with_message_fail
+    error = assert_raises(Minitest::Assertion) do
+      assert_no_difference '@object.num', 'Object Changed' do
+        @object.increment
       end
     end
+    assert_equal "Object Changed.\n\"@object.num\" didn't change by 0.\nExpected: 0\n  Actual: 1", error.message
+  end
 
-    def test_standard_error_raised_within_setup_callback_is_puked
-      tc = Class.new(TestCase) do
-        def self.name; nil; end
+  def test_assert_difference
+    assert_difference '@object.num', +1 do
+      @object.increment
+    end
+  end
 
-        setup :bad_callback
-        def bad_callback; raise 'oh noes' end
-        def test_true; assert true end
-      end
+  def test_assert_difference_with_implicit_difference
+    assert_difference '@object.num' do
+      @object.increment
+    end
+  end
 
-      test_name = 'test_true'
-      fr = FakeRunner.new
+  def test_arbitrary_expression
+    assert_difference '@object.num + 1', +2 do
+      @object.increment
+      @object.increment
+    end
+  end
 
-      test = tc.new test_name
-      test.run fr
-      klass, name, exception = *fr.puked.first
+  def test_negative_differences
+    assert_difference '@object.num', -1 do
+      @object.decrement
+    end
+  end
 
-      assert_equal tc, klass
-      assert_equal test_name, name
-      assert_equal 'oh noes', exception.message
+  def test_expression_is_evaluated_in_the_appropriate_scope
+    silence_warnings do
+      local_scope = local_scope = 'foo'
+      assert_difference('local_scope; @object.num') { @object.increment }
     end
+  end
 
-    def test_standard_error_raised_within_teardown_callback_is_puked
-      tc = Class.new(TestCase) do
-        def self.name; nil; end
+  def test_array_of_expressions
+    assert_difference [ '@object.num', '@object.num + 1' ], +1 do
+      @object.increment
+    end
+  end
 
-        teardown :bad_callback
-        def bad_callback; raise 'oh noes' end
-        def test_true; assert true end
+  def test_array_of_expressions_identify_failure
+    assert_raises(Minitest::Assertion) do
+      assert_difference ['@object.num', '1 + 1'] do
+        @object.increment
       end
+    end
+  end
 
-      test_name = 'test_true'
-      fr = FakeRunner.new
+  def test_array_of_expressions_identify_failure_when_message_provided
+    assert_raises(Minitest::Assertion) do
+      assert_difference ['@object.num', '1 + 1'], 1, 'something went wrong' do
+        @object.increment
+      end
+    end
+  end
+end
 
-      test = tc.new test_name
-      test.run fr
-      klass, name, exception = *fr.puked.first
+class AlsoDoingNothingTest < ActiveSupport::TestCase
+end
 
-      assert_equal tc, klass
-      assert_equal test_name, name
-      assert_equal 'oh noes', exception.message
-    end
+# Setup and teardown callbacks.
+class SetupAndTeardownTest < ActiveSupport::TestCase
+  setup :reset_callback_record, :foo
+  teardown :foo, :sentinel
 
-    def test_passthrough_exception_raised_within_test_method_is_not_rescued
-      tc = Class.new(TestCase) do
-        def self.name; nil; end
+  def test_inherited_setup_callbacks
+    assert_equal [:reset_callback_record, :foo], self.class._setup_callbacks.map(&:raw_filter)
+    assert_equal [:foo], @called_back
+    assert_equal [:foo, :sentinel], self.class._teardown_callbacks.map(&:raw_filter)
+  end
 
-        def test_which_raises_interrupt; raise Interrupt; end
-      end
+  def setup
+  end
+
+  def teardown
+  end
 
-      test_name = 'test_which_raises_interrupt'
-      fr = FakeRunner.new
+  protected
 
-      test = tc.new test_name
-      assert_raises(Interrupt) { test.run fr }
+    def reset_callback_record
+      @called_back = []
     end
 
-    def test_passthrough_exception_raised_within_setup_callback_is_not_rescued
-      tc = Class.new(TestCase) do
-        def self.name; nil; end
+    def foo
+      @called_back << :foo
+    end
 
-        setup :callback_which_raises_interrupt
-        def callback_which_raises_interrupt; raise Interrupt; end
-        def test_true; assert true end
-      end
+    def sentinel
+      assert_equal [:foo], @called_back
+    end
+end
 
-      test_name = 'test_true'
-      fr = FakeRunner.new
+class SubclassSetupAndTeardownTest < SetupAndTeardownTest
+  setup :bar
+  teardown :bar
 
-      test = tc.new test_name
-      assert_raises(Interrupt) { test.run fr }
+  def test_inherited_setup_callbacks
+    assert_equal [:reset_callback_record, :foo, :bar], self.class._setup_callbacks.map(&:raw_filter)
+    assert_equal [:foo, :bar], @called_back
+    assert_equal [:foo, :sentinel, :bar], self.class._teardown_callbacks.map(&:raw_filter)
+  end
+
+  protected
+    def bar
+      @called_back << :bar
+    end
+
+    def sentinel
+      assert_equal [:foo, :bar, :bar], @called_back
     end
+end
 
-    def test_passthrough_exception_raised_within_teardown_callback_is_not_rescued
-      tc = Class.new(TestCase) do
-        def self.name; nil; end
+class TestCaseTaggedLoggingTest < ActiveSupport::TestCase
+  def before_setup
+    require 'stringio'
+    @out = StringIO.new
+    self.tagged_logger = ActiveSupport::TaggedLogging.new(Logger.new(@out))
+    super
+  end
 
-        teardown :callback_which_raises_interrupt
-        def callback_which_raises_interrupt; raise Interrupt; end
-        def test_true; assert true end
-      end
+  def test_logs_tagged_with_current_test_case
+    assert_match "#{self.class}: #{name}\n", @out.string
+  end
+end
 
-      test_name = 'test_true'
-      fr = FakeRunner.new
+class TestOrderTest < ActiveSupport::TestCase
+  def setup
+    @original_test_order = ActiveSupport::TestCase.test_order
+  end
 
-      test = tc.new test_name
-      assert_raises(Interrupt) { test.run fr }
-    end
+  def teardown
+    ActiveSupport::TestCase.test_order = @original_test_order
+  end
 
-    def test_pending_deprecation
-      assert_deprecated do
-        pending "should use #skip instead"
-      end
+  def test_defaults_to_sorted_with_warning
+    ActiveSupport::TestCase.test_order = nil
+
+    assert_equal :sorted, assert_deprecated { ActiveSupport::TestCase.test_order }
+
+    # It should only produce a deprecation warning the first time this is accessed
+    assert_equal :sorted, assert_not_deprecated { ActiveSupport::TestCase.test_order }
+    assert_equal :sorted, assert_not_deprecated { ActiveSupport.test_order }
+  end
+
+  def test_test_order_is_global
+    ActiveSupport::TestCase.test_order = :random
+
+    assert_equal :random, ActiveSupport.test_order
+    assert_equal :random, ActiveSupport::TestCase.test_order
+    assert_equal :random, self.class.test_order
+    assert_equal :random, Class.new(ActiveSupport::TestCase).test_order
+
+    ActiveSupport.test_order = :sorted
+
+    assert_equal :sorted, ActiveSupport.test_order
+    assert_equal :sorted, ActiveSupport::TestCase.test_order
+    assert_equal :sorted, self.class.test_order
+    assert_equal :sorted, Class.new(ActiveSupport::TestCase).test_order
+  end
+
+  def test_i_suck_and_my_tests_are_order_dependent!
+    ActiveSupport::TestCase.test_order = :random
+
+    klass = Class.new(ActiveSupport::TestCase) do
+      i_suck_and_my_tests_are_order_dependent!
     end
+
+    assert_equal :alpha, klass.test_order
+    assert_equal :random, ActiveSupport::TestCase.test_order
   end
 end