test-unit 3.3.8 → 3.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6224bf9af9a66e5759319b2b4f9fdb650f970ad4010c4f1b92cf85410df307e8
-  data.tar.gz: d22117bf9f061839dea08df766256c7982e13d7eb1d6428c2fedff9583cd5b45
+  metadata.gz: '096e65b8d56779e795090f5e56e10a10bcef4f666f45702da71acb1e0e0e769e'
+  data.tar.gz: 31402966d552fe2c7cd960185929963e7358296e9ff5727be4c7a72781d070b7
 SHA512:
-  metadata.gz: dfd3a287fa4496d89b11e0dc7e1d9488156ecf0158611421df03f49da3cb3130aab76ca0ecab631a00261f7766a77cde596786380b0236039dcbe0209bb29603
-  data.tar.gz: 217463364d02fc2b93e1f689ba269345d4300519781ef6f9cf3dc3f8d8b0263d70e3065c69651398e1aec18e1b5c40e7f78e693e0eb2586e002523ba7ec43d1e
+  metadata.gz: e46ad14d93dadac17224d10ab58617acc4dfaae61f06067c400308d9c1b3ad060201e88a7fd097d94d93c053a1d5bed0a9f56e765bb573fe960c7086251a891c
+  data.tar.gz: cfa5f1b593e993ff2643cab4989428817fdae1258a357797b2e42d0d563022351349eb3648056305df8ddb6f5e9847a1084646f2edec93b7a1c519bba96c9d11

data/doc/text/news.md

@@ -1,5 +1,52 @@
 # News
 
+## 3.4.3 - 2021-06-04 {#version-3-4-3}
+
+### Improvements
+
+  * Stopped to change result value of `Test::Unit::TestCase#include`.
+
+  * Added `assert_all?`.
+
+  * Added support for `assert_raise_with_message`.
+
+## 3.4.2 - 2021-05-30 {#version-3-4-2}
+
+### Improvements
+
+  * [UI][console]: Improved diff readability for no color
+    case. Character based diff marks are always showed.
+
+## 3.4.1 - 2021-04-19 {#version-3-4-1}
+
+### Fixes
+
+  * Fixed a bug that `setup`/`cleanup`/`teardown` with block may be
+    overwritten by another `setup`/`cleanup`/`teardown` with
+    block. It's caused only with Ruby 2.6 or earlier.
+    [GitHub#179][Reported by akira yamada]
+
+### Thanks
+
+  * akira yamada
+
+## 3.4.0 - 2021-01-30 {#version-3-4-0}
+
+### Improvements
+
+  * Enable deprecated warnings by default.
+
+## 3.3.9 - 2020-12-29 {#version-3-3-9}
+
+### Improvements
+
+  * `assert_not_match`: Add support for `String` as pattern.
+    [GitHub#178][Patch by David Rodríguez]
+
+### Thanks
+
+  * David Rodríguez
+
 ## 3.3.8 - 2020-12-25 {#version-3-3-8}
 
 ### Improvements

data/lib/test-unit.rb

@@ -1,5 +1,7 @@
 # Copyright (C) 2012-2015  Kouhei Sutou <kou@clear-code.com>
 
+require "test/unit/warning"
+
 module Test
   module Unit
     autoload :TestCase, "test/unit/testcase"

data/lib/test/unit.rb

@@ -1,3 +1,5 @@
+require "test/unit/warning"
+
 require 'test/unit/testcase'
 require 'test/unit/autorunner'
 

data/lib/test/unit/assertions.rb

@@ -289,6 +289,71 @@ EOT
       # Just for minitest compatibility. :<
       alias_method :assert_raises, :assert_raise
 
+      # Passes if the block raises `expected_exception` with
+      # `expected_message`. `expected_message` can be a `String` or
+      # `Regexp`.
+      #
+      # @example Pass pattern: String
+      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
+      #     raise "Boom!!!"
+      #   end # -> pass
+      #
+      # @example Pass pattern: Regexp
+      #   assert_raise_with_message(RuntimeError, /!!!/) do
+      #     raise "Boom!!!"
+      #   end # -> pass
+      #
+      # @example Failure pattern: Exception class isn't matched
+      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
+      #     raise ArgumentError, "Boom!!!"
+      #   end # -> failure
+      #
+      # @example Failure pattern: Exception message isn't matched
+      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
+      #     raise "Hello"
+      #   end # -> failure
+      #
+      # @since 3.4.3
+      def assert_raise_with_message(expected_exception_class,
+                                    expected_message,
+                                    message=nil,
+                                    &block)
+        assert_expected_exception = Proc.new do |*_args|
+          _message, assert_exception_helper, actual_exception = _args
+          diff = AssertionMessage.delayed_diff([
+                                                 expected_exception_class,
+                                                 expected_message,
+                                               ],
+                                               [
+                                                 actual_exception.class,
+                                                 actual_exception.message,
+                                               ])
+          full_message = build_message(message,
+                                       "<?>(<?>) exception expected but was\n" +
+                                       "<?>(<?>).?",
+                                       expected_exception_class,
+                                       expected_message,
+                                       actual_exception.class,
+                                       actual_exception.message,
+                                       diff)
+          begin
+            assert_block(full_message) do
+              assert_exception_helper.expected?(actual_exception) and
+                expected_message === actual_exception.message
+            end
+          rescue AssertionFailedError => failure
+            _set_failed_information(failure,
+                                    expected_exception_class,
+                                    actual_exception)
+            raise failure # For JRuby. :<
+          end
+          actual_exception
+        end
+        args = [expected_exception_class]
+        args << message if message
+        _assert_raise(assert_expected_exception, *args, &block)
+      end
+
       ##
       # Passes if the block raises one of the given
       # exceptions or sub exceptions of the given exceptions.
@@ -534,12 +599,7 @@ EOT
       #   assert_match(/\d+/, 'five, 6, seven')
       def assert_match(pattern, string, message=nil)
         _wrap_assertion do
-          pattern = case(pattern)
-            when String
-              Regexp.new(Regexp.escape(pattern))
-            else
-              pattern
-          end
+          pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
           full_message = build_message(message,
                                        "<?> was expected to be =~\n<?>.",
                                        pattern, string)
@@ -711,15 +771,13 @@ EOT
       # @example
       #   assert_not_match(/two/, 'one 2 three')   # -> pass
       #   assert_not_match(/three/, 'one 2 three') # -> fail
-      def assert_not_match(regexp, string, message=nil)
+      def assert_not_match(pattern, string, message=nil)
         _wrap_assertion do
-          assert_instance_of(Regexp, regexp,
-                             "<REGEXP> in assert_not_match(<REGEXP>, ...) " +
-                             "should be a Regexp.")
+          pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
           full_message = build_message(message,
                                        "<?> was expected to not match\n<?>.",
-                                       regexp, string)
-          assert_block(full_message) { regexp !~ string }
+                                       pattern, string)
+          assert_block(full_message) { pattern !~ string }
         end
       end
 
@@ -1619,6 +1677,53 @@ EOT
       # @since 3.0.0
       alias_method :refute_empty, :assert_not_empty
 
+      # @overload assert_all?(collection, message=nil, &block)
+      #
+      #   Asserts that all `block.call(item)` where `item` is each
+      #   item in `collection` are not false nor nil.
+      #
+      #   If `collection` is empty, this assertion is always passed
+      #   with any `block`.
+      #
+      #   @example Pass patterns
+      #     assert_all?([1, 2, 3]) {|item| item > 0} # => pass
+      #     assert_all?([1, 2, 3], &:positive?)      # => pass
+      #     assert_all?([]) {|item| false}           # => pass
+      #
+      #   @example Failure pattern
+      #     assert_all?([0, 1, 2], &:zero?) # => failure
+      #
+      #   @param [#each] collection The check target.
+      #   @param [String] message The additional user message. It is
+      #     showed when the assertion is failed.
+      #   @yield [Object] Give each item in `collection` to the block.
+      #   @yieldreturn [Object] The checked object.
+      #   @return [void]
+      #
+      # @since 3.4.3
+      def assert_all?(collection, message=nil)
+        _wrap_assertion do
+          failed = false
+          result = {}
+          collection.each do |item|
+            element_result = yield(item)
+            failed = true unless element_result
+            result[item] = element_result
+          end
+          format = <<-FORMAT
+<?> was expected to be all true values with the given block but was
+<?>
+          FORMAT
+          full_message = build_message(message,
+                                       format,
+                                       collection,
+                                       result)
+          assert_block(full_message) do
+            not failed
+          end
+        end
+      end
+
       ##
       # Builds a failure message.  `user_message` is added before the
       # `template` and `arguments` replaces the '?'s positionally in

data/lib/test/unit/fixture.rb

@@ -103,6 +103,7 @@ module Test
           @test_case = test_case
           @type = type
           @default_options = default_options
+          @callbacks = {}
           @before_prepend_callbacks = []
           @before_append_callbacks = []
           @after_prepend_callbacks = []
@@ -130,6 +131,11 @@ module Test
             @test_case.attribute(:source_location,
                                  callback.source_location,
                                  method_name)
+            # For Ruby 2.6 or earlier. callback may be GC-ed. If
+            # callback is GC-ed, callback_method_name may be
+            # duplicated because callback_method_name uses callback.object_id.
+            # See also: https://github.com/test-unit/test-unit/issues/179
+            @callbacks[callback] = true
             @test_case.__send__(:define_method, method_name, &callback)
           else
             method_name = method_name_or_callback

data/lib/test/unit/testcase.rb

@@ -131,12 +131,13 @@ module Test
         end
 
         def include(*modules, &block) # :nodoc:
-          super
+          result = super
           modules.each do |mod|
             mod.public_instance_methods(false).each do |method_name|
               AutoRunnerLoader.check(self, method_name.to_s)
             end
           end
+          result
         end
 
         @@added_method_names = {}

data/lib/test/unit/ui/console/testrunner.rb

@@ -660,6 +660,7 @@ module Test
 
           def diff_line(from_line, to_line)
             to_operations = []
+            mark_operations = []
             from_line, to_line, _operations = line_operations(from_line, to_line)
 
             no_replace = true
@@ -689,11 +690,22 @@ module Test
                     output_single(" " * (from_width - to_width))
                   end
                 end
+                mark_operations << Proc.new do
+                  output_single("?" * from_width,
+                                color("diff-difference-tag"))
+                  if (to_width < from_width)
+                    output_single(" " * (from_width - to_width))
+                  end
+                end
               when :delete
                 output_single(from_line[from_start...from_end],
                               color("diff-deleted"))
                 unless no_replace
                   to_operations << Proc.new {output_single(" " * from_width)}
+                  mark_operations << Proc.new do
+                    output_single("-" * from_width,
+                                  color("diff-deleted"))
+                  end
                 end
               when :insert
                 if no_replace
@@ -705,11 +717,16 @@ module Test
                     output_single(to_line[to_start...to_end],
                                   color("diff-inserted"))
                   end
+                  mark_operations << Proc.new do
+                    output_single("+" * to_width,
+                                  color("diff-inserted"))
+                  end
                 end
               when :equal
                 output_single(from_line[from_start...from_end])
                 unless no_replace
                   to_operations << Proc.new {output_single(" " * to_width)}
+                  mark_operations << Proc.new {output_single(" " * to_width)}
                 end
               else
                 raise "unknown tag: #{tag}"
@@ -725,6 +742,15 @@ module Test
               end
               output("")
             end
+
+            unless mark_operations.empty?
+              output_single("?", color("diff-difference-tag"))
+              output_single(" ")
+              mark_operations.each do |operation|
+                operation.call
+              end
+              output("")
+            end
           end
         end
       end

data/lib/test/unit/version.rb

@@ -1,5 +1,5 @@
 module Test
   module Unit
-    VERSION = "3.3.8"
+    VERSION = "3.4.3"
   end
 end

data/lib/test/unit/warning.rb

@@ -0,0 +1,3 @@
+if defined?(Warning) and Warning.respond_to?(:[]=)
+  Warning[:deprecated] = true
+end

data/test/test-assertions.rb

@@ -98,7 +98,8 @@ module Test
 
       def check_fail_exception(expected_message, options={}, &proc)
         normalizer = lambda do |actual_message|
-          actual_message.gsub(/^(?:<internal:core> )?[^:\n]+:\d+:.+\n/, "")
+          actual_message.gsub(/^(?:[a-zA-Z]:|<internal:core> )?[^:\n]+:\d+:.+\n/,
+                              "")
         end
         check_assertions(true,
                          options.merge(:expected_message => expected_message,
@@ -956,16 +957,6 @@ EOM
         end
       end
 
-      def test_assert_not_match_fail_not_regexp
-        check_fail("<REGEXP> in assert_not_match(<REGEXP>, ...) " +
-                    "should be a Regexp.\n" +
-                    "<\"asdf\"> was expected to be instance_of?\n" +
-                    "<Regexp> but was\n" +
-                    "<String>.") do
-          assert_not_match("asdf", "asdf")
-        end
-      end
-
       def test_assert_not_match_fail_match
         check_fail("</string/> was expected to not match\n" +
                     "<\"string\">.") do
@@ -973,6 +964,13 @@ EOM
         end
       end
 
+      def test_assert_not_match_fail_match_string
+        check_fail("</asdf/> was expected to not match\n" +
+                    "<\"asdf\">.") do
+          assert_not_match("asdf", "asdf")
+        end
+      end
+
       def test_assert_not_match_fail_match_with_message
         check_fail("message.\n" +
                     "</string/> was expected to not match\n" +
@@ -1609,6 +1607,66 @@ MESSAGE
       end
     end
 
+    class TestAssertRaiseWithMessage < Test::Unit::TestCase
+      include AssertionCheckable
+
+      def test_pass_string
+        check_nothing_fails(true) do
+          assert_raise_with_message(RuntimeError, "Boom!!!") do
+            raise "Boom!!!"
+          end
+        end
+      end
+
+      def test_pass_regexp
+        check_nothing_fails(true) do
+          assert_raise_with_message(RuntimeError, /!!!/) do
+            raise "Boom!!!"
+          end
+        end
+      end
+
+      def test_pass_message
+        check_nothing_fails(true) do
+          assert_raise_with_message(RuntimeError, "Boom!!!", "message") do
+            raise "Boom!!!"
+          end
+        end
+      end
+
+      def test_fail_unmatch_class
+        expected_message = <<-MESSAGE.chomp
+message.
+<LoadError>(<"Boom!!!">) exception expected but was
+<RuntimeError>(<"Boom!!!">).
+
+diff:
+- [LoadError, "Boom!!!"]
+?  ^^^^
++ [RuntimeError, "Boom!!!"]
+?  ^^^^^^^
+        MESSAGE
+        check_fail(expected_message) do
+          assert_raise_with_message(LoadError, "Boom!!!", "message") do
+            raise "Boom!!!"
+          end
+        end
+      end
+
+      def test_fail_unmatch_message
+        expected_message = <<-MESSAGE.chomp
+message.
+<RuntimeError>(</Hello/>) exception expected but was
+<RuntimeError>(<"Boom!!!">).
+        MESSAGE
+        check_fail(expected_message) do
+          assert_raise_with_message(RuntimeError, /Hello/, "message") do
+            raise "Boom!!!"
+          end
+        end
+      end
+    end
+
     class TestAssertInDelta < TestCase
       include AssertionCheckable
 
@@ -2172,6 +2230,39 @@ EOM
       end
     end
 
+    class TestAssertAll < Test::Unit::TestCase
+      include AssertionCheckable
+
+      def test_pass
+        check_nothing_fails do
+          assert_all?([1, 2]) {|item| item > 0}
+        end
+      end
+
+      def test_pass_message
+        check_nothing_fails do
+          assert_all?([1, 2], "positive") {|item| item > 0}
+        end
+      end
+
+      def test_pass_empty
+        check_nothing_fails do
+          assert_all?([]) {|item| false}
+        end
+      end
+
+      def test_fail
+        expected_message = <<-EOM
+message.
+<[0, 1]> was expected to be all true values with the given block but was
+<{0=>true, 1=>false}>
+EOM
+        check_fail(expected_message.chomp) do
+          assert_all?([0, 1], "message", &:zero?)
+        end
+      end
+    end
+
     class TestTemplate < Test::Unit::TestCase
       def test_incompatible_encoding_by_diff
         need_encoding

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: test-unit
 version: !ruby/object:Gem::Version
-  version: 3.3.8
+  version: 3.4.3
 platform: ruby
 authors:
 - Kouhei Sutou
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-24 00:00:00.000000000 Z
+date: 2021-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: power_assert
@@ -164,6 +164,7 @@ files:
 - lib/test/unit/util/output.rb
 - lib/test/unit/util/procwrapper.rb
 - lib/test/unit/version.rb
+- lib/test/unit/warning.rb
 - sample/adder.rb
 - sample/subtracter.rb
 - sample/test_adder.rb
@@ -231,7 +232,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0.rc.2
+rubygems_version: 3.3.0.dev
 signing_key: 
 specification_version: 4
 summary: An xUnit family unit testing framework for Ruby.