spinel_test-unit 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f445b0e6c7e31a0821e0ac04121407864475e56e85ae48326e548ded202b94d2
-  data.tar.gz: f541193fc3cda7755d9a4d233367846af00822a84daf209d8015c1f5b5326304
+  metadata.gz: ef62e948140f04c676b0709a5780239556c38dd521fbdd0fce4968f82b643fe4
+  data.tar.gz: 3212cc091c366bc33b3fc1854f3fbd6a4a164248baa20cdc3816d3896dcd8519
 SHA512:
-  metadata.gz: 1d3e3ec35074600ed21fb5765bc60b72e77235567850c5ecff1811f9ceb9d7b3fd8db73be99817f39dde0864e5a20b6962c5a6f943c4fabe4f4475a5525290a8
-  data.tar.gz: 892971495ea188d9e80c4f962cb6121cfab754d4db98c7a2c8f8e8809d161166522586d0b15a0bee6837068dbc0daa0ece5ff2ecb79ccdaa0d9412bd14f64d0e
+  metadata.gz: 9dcc12b871aa16d10cea18c038de5d335a4e07121098f3de6b3449be0020e82274d39593698b79a39457dd9049ccdb1fcc06c740458d536151dd592ba93b66e9
+  data.tar.gz: 588963b23dc23425e40721efad1070800e577aec65d9dbba959aa537f3055ddb0a06db18df1671ae484733d5d7055f2f0da8e102213cbc2598897a618be0e43b

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## Unreleased
 
+## 0.3.0
+
+* Add `match:` to `assert_raise` to check the exception message, as in `assert_match` (a Regexp, or a String meaning a substring)
+* `assert_raise` passes only for the given class itself, not a subclass, as in test-unit. Use the new `assert_raise_kind_of` to also accept a subclass
+* Add `-t`/`--testcase CLASS` to run only the tests of the class named exactly CLASS (`-n FooTest#` also selects `MyFooTest`)
+* `-n` and `-t` take a regexp written as `/regexp/`, as in test-unit
+
 ## 0.2.0
 
 * Report where a test failed: `at file:line` lines after the message (the test method's line with Spinel, the filtered backtrace with `--ruby`)

data/README.md

@@ -39,6 +39,9 @@ end
 $ bundle exec spinel_test-unit                 # test/**/*_test.rb and test/**/test_*.rb
 $ bundle exec spinel_test-unit test/calc_test.rb
 $ bundle exec spinel_test-unit -n test_add     # only tests whose "Class#method" name includes it
+$ bundle exec spinel_test-unit -n '/#test_add\z/'  # or matches the regexp
+$ bundle exec spinel_test-unit -t CalcTest     # only the tests of the class named exactly CalcTest
+$ bundle exec spinel_test-unit -t '/\ACalc/'   # or of the classes whose name matches the regexp
 $ bundle exec spinel_test-unit --ruby          # run the same tests with the current Ruby, no Spinel needed
 ```
 
@@ -93,7 +96,8 @@ Available assertions:
 - `assert_include(collection, item, message = nil)` (`assert_includes` is an alias)
 - `assert_not_include(collection, item, message = nil)`
 - `refute(test, message = nil)`
-- `assert_raise(klass) { ... }` (passes for `klass` or a subclass; returns the exception; assertion failures raised inside the block propagate)
+- `assert_raise(klass, match: nil) { ... }` (passes for `klass` itself, not a subclass, as in test-unit; returns the exception; assertion failures raised inside the block propagate). With `match:`, the exception's message must also match it, as in `assert_match` (a Regexp, or a String meaning a substring)
+- `assert_raise_kind_of(klass, match: nil) { ... }` (as `assert_raise`, but also passes for a subclass of `klass`)
 
 `setup` and `teardown` hooks are supported.
 

data/lib/spinel_test/unit/cli.rb

@@ -10,7 +10,7 @@ require_relative "toolchain"
 
 module SpinelTest
   module Unit
-    # spinel_test-unit [PATH...] [-n NAME] [-I DIR] [--ruby]
+    # spinel_test-unit [PATH...] [-n NAME] [-t CLASS] [-I DIR] [--ruby]
     #
     # Scans the test files with Prism, generates a main.rb that calls every
     # test, compiles it with Spinel and runs the binary. With --ruby it runs the
@@ -25,7 +25,7 @@ module SpinelTest
         @root = File.expand_path(root)
         @paths = []
         @filter = nil
-        @keep = false
+        @testcase = nil
         @ruby = false
         @includes = []
         @exit = nil
@@ -33,13 +33,17 @@ module SpinelTest
       end
 
       USAGE = <<~TEXT
-        Usage: spinel_test-unit [PATH...] [-n NAME] [-I DIR] [--ruby]
+        Usage: spinel_test-unit [PATH...] [-n NAME] [-t CLASS] [-I DIR] [--ruby]
 
         Compiles the tests with Spinel and runs them (with --ruby, runs them with the
         current Ruby instead).
 
           PATH             test file or directory (default: test)
-          -n, --name NAME  run only the tests whose "Class#test_name" includes NAME
+          -n, --name NAME  run only the tests whose "Class#test_name" includes NAME,
+                           or matches it when NAME is /regexp/
+          -t, --testcase CLASS
+                           run only the tests of the class named CLASS (exact match),
+                           or whose class name matches it when CLASS is /regexp/
           -I DIR           add DIR to the load path (repeatable)
           --ruby           run with the current Ruby instead of compiling with Spinel
           -h, --help       show this help
@@ -93,7 +97,9 @@ module SpinelTest
       end
 
       def run_command(command)
-        args = @filter ? ["-n", @filter] : []
+        args = []
+        args += ["-n", @filter] if @filter
+        args += ["-t", @testcase] if @testcase
         system(*command, *args) ? 0 : ($?.exitstatus || 1)
       end
 
@@ -106,17 +112,27 @@ module SpinelTest
             @exit = 0
             return
           when "-n", "--name"
-            if args.empty?
-              return usage_error("#{arg} requires a value")
-            end
+            return usage_error("#{arg} requires a value") if args.empty?
+
             @filter = args.shift
+            return unless valid_pattern?(@filter)
+          when "-t", "--testcase"
+            return usage_error("#{arg} requires a value") if args.empty?
+
+            @testcase = args.shift
+            return unless valid_pattern?(@testcase)
           when "--ruby" then @ruby = true
           when "-I"
             return usage_error("-I requires a value") if args.empty?
 
             @includes << File.expand_path(args.shift, @root)
           when /\A-I(.+)\z/ then @includes << File.expand_path($1, @root)
-          when /\A--name=(.*)\z/ then @filter = $1
+          when /\A--name=(.*)\z/
+            @filter = $1
+            return unless valid_pattern?(@filter)
+          when /\A--testcase=(.*)\z/
+            @testcase = $1
+            return unless valid_pattern?(@testcase)
           when "--" then @paths.concat(args.shift(args.size))
           when /\A-/ then return usage_error("unknown option: #{arg}")
           else @paths << arg
@@ -124,6 +140,16 @@ module SpinelTest
         end
       end
 
+      def valid_pattern?(value)
+        return true unless value.length >= 2 && value.start_with?("/") && value.end_with?("/")
+
+        Regexp.new(value[1..-2])
+        true
+      rescue RegexpError => e
+        usage_error("invalid regexp #{value}: #{e.message}")
+        false
+      end
+
       def usage_error(message)
         warn "spinel_test-unit: #{message}"
         warn USAGE
@@ -245,7 +271,13 @@ module SpinelTest
 
       def compile(spinel, main, bin, entries)
         cmd = [spinel] + Toolchain.compile_flags + include_dirs(entries).flat_map { |d| ["-I", d] } + [main, "-o", bin]
-        output, status = Open3.capture2e(*cmd)
+        begin
+          output, status = Open3.capture2e(*cmd)
+        rescue SystemCallError => e
+          hint = ENV["SPINEL"].to_s.empty? ? "" : " (check SPINEL)"
+          warn "spinel_test-unit: cannot run Spinel: #{e.message}#{hint}"
+          return false
+        end
         unless status.success?
           warn output unless output.empty?
           warn "spinel_test-unit: compilation failed (#{cmd.join(" ")})"

data/lib/spinel_test/unit/diff.rb

@@ -59,10 +59,14 @@ module SpinelTest
       end
 
       def ambiguous?(line)
-        line == "" || line == "..." || line.include?("\r") || line.start_with?("\"") ||
+        line == "" || line == "..." || control?(line) || line.start_with?("\"") ||
           line.start_with?(" ", "\t") || line.end_with?(" ", "\t")
       end
 
+      def control?(line)
+        line.bytes.any? { |b| (b < 32 && b != 9) || b == 127 }
+      end
+
       def edits
         lengths = lcs_lengths
         entries = []

data/lib/spinel_test/unit/generator.rb

@@ -9,7 +9,7 @@ module SpinelTest
         out = +"require \"spinel_test/unit\"\n"
         files.each { |f| out << "require #{f[:require].dump}\n" }
         out << ARGV_PARSER
-        out << "runner = SpinelTest::Unit::Runner.new(filter, #{root.dump})\n"
+        out << "runner = SpinelTest::Unit::Runner.new(filter, #{root.dump}, testcase)\n"
         files.each do |f|
           f[:classes].each do |klass|
             locations = klass.locations || {}
@@ -25,11 +25,15 @@ module SpinelTest
 
       ARGV_PARSER = <<~RUBY
         filter = ""
+        testcase = ""
         i = 0
         while i < ARGV.length
           if ARGV[i] == "-n" && i + 1 < ARGV.length
             filter = ARGV[i + 1]
             i += 1
+          elsif ARGV[i] == "-t" && i + 1 < ARGV.length
+            testcase = ARGV[i + 1]
+            i += 1
           end
           i += 1
         end

data/lib/spinel_test/unit/runner.rb

@@ -6,9 +6,10 @@ module SpinelTest
       MAX_FRAMES = 3
       FRAMEWORK_DIR = File.dirname(File.expand_path(__FILE__)) + "/"
 
-      def initialize(filter = "", root = "")
+      def initialize(filter = "", root = "", testcase = "")
         @filter = filter
         @root = root
+        @testcase = testcase
         @tests = 0
         @assertions = 0
         @failures = 0
@@ -17,7 +18,20 @@ module SpinelTest
       end
 
       def selected?(name)
-        @filter == "" || name.include?(@filter)
+        index = name.index("#")
+        klass = index ? name[0, index] : name
+        matches?(@testcase, klass, true) && matches?(@filter, name, false)
+      end
+
+      def matches?(filter, text, exact)
+        return true if filter == ""
+        return Regexp.new(filter[1, filter.length - 2]).match?(text) if pattern?(filter)
+
+        exact ? text == filter : text.include?(filter)
+      end
+
+      def pattern?(filter)
+        filter.length >= 2 && filter.start_with?("/") && filter.end_with?("/")
       end
 
       # Runs one test: setup, the block (which calls the test method), teardown.
@@ -120,6 +134,13 @@ module SpinelTest
         e.is_a?(SystemExit) || e.is_a?(Interrupt)
       end
 
+      def filter_description
+        parts = []
+        parts.push("testcase: " + @testcase) if @testcase != ""
+        parts.push("filter: " + @filter) if @filter != ""
+        parts.empty? ? "" : " (" + parts.join(", ") + ")"
+      end
+
       def passed?
         @failures == 0 && @errors == 0
       end
@@ -138,7 +159,7 @@ module SpinelTest
         puts ""
         puts summary
         if @tests == 0
-          puts "No tests were run#{@filter == "" ? "" : " (filter: " + @filter + ")"}"
+          puts "No tests were run#{filter_description}"
           return 1
         end
         passed? ? 0 : 1

data/lib/spinel_test/unit/test_case.rb

@@ -38,55 +38,42 @@ module SpinelTest
         @assertions += 1
         return true if expected == actual
 
-        msg = "Expected: #{expected.inspect}\n  Actual: #{actual.inspect}"
-        msg += diff_section(expected, actual)
-        msg = message + "\n" + msg if message
-        raise AssertionFailedError, msg
+        failure("Expected: #{expected.inspect}\n  Actual: #{actual.inspect}" + diff_section(expected, actual), message)
       end
 
       def assert_not_equal(expected, actual, message = nil)
         @assertions += 1
         return true unless expected == actual
 
-        msg = "Expected #{actual.inspect} not to equal #{expected.inspect}"
-        msg = message + "\n" + msg if message
-        raise AssertionFailedError, msg
+        failure("Expected #{actual.inspect} not to equal #{expected.inspect}", message)
       end
 
       def assert_match(pattern, string, message = nil)
         @assertions += 1
         return true if pattern_matches?(pattern, string)
 
-        msg = "Expected #{pattern.inspect} to match #{string.inspect}"
-        msg = message + "\n" + msg if message
-        raise AssertionFailedError, msg
+        failure("Expected #{pattern.inspect} to match #{string.inspect}", message)
       end
 
       def assert_nil(value, message = nil)
         @assertions += 1
         return true if value.nil?
 
-        msg = "Expected nil, got #{value.inspect}"
-        msg = message + "\n" + msg if message
-        raise AssertionFailedError, msg
+        failure("Expected nil, got #{value.inspect}", message)
       end
 
       def assert_not_nil(value, message = nil)
         @assertions += 1
         return true unless value.nil?
 
-        msg = "Expected a value other than nil"
-        msg = message + "\n" + msg if message
-        raise AssertionFailedError, msg
+        failure("Expected a value other than nil", message)
       end
 
       def assert_include(collection, item, message = nil)
         @assertions += 1
         return true if collection.include?(item)
 
-        msg = "#{collection.inspect} does not include #{item.inspect}"
-        msg = message + "\n" + msg if message
-        raise AssertionFailedError, msg
+        failure("#{collection.inspect} does not include #{item.inspect}", message)
       end
 
       def assert_includes(collection, item, message = nil)
@@ -97,12 +84,10 @@ module SpinelTest
         @assertions += 1
         return true unless collection.include?(item)
 
-        msg = "#{collection.inspect} includes #{item.inspect}"
-        msg = message + "\n" + msg if message
-        raise AssertionFailedError, msg
+        failure("#{collection.inspect} includes #{item.inspect}", message)
       end
 
-      def assert_raise(klass)
+      def assert_raise(klass, match: nil)
         @assertions += 1
         begin
           yield
@@ -110,15 +95,36 @@ module SpinelTest
           # a failed assertion inside the block is not "the expected error"
           raise e
         rescue StandardError => e
-          return e if e.is_a?(klass)
+          return expected_exception(e, klass, match, e.instance_of?(klass))
+        end
+        raise AssertionFailedError, "Expected #{klass} but nothing was raised"
+      end
 
-          raise AssertionFailedError, "Expected #{klass} but got #{e.class}"
+      def assert_raise_kind_of(klass, match: nil)
+        @assertions += 1
+        begin
+          yield
+        rescue AssertionFailedError => e
+          raise e
+        rescue StandardError => e
+          return expected_exception(e, klass, match, e.is_a?(klass))
         end
         raise AssertionFailedError, "Expected #{klass} but nothing was raised"
       end
 
       private
 
+      def failure(text, message)
+        raise AssertionFailedError, message ? message + "\n" + text : text
+      end
+
+      def expected_exception(e, klass, match, class_matches)
+        raise AssertionFailedError, "Expected #{klass} but got #{e.class}" unless class_matches
+        return e if match.nil? || pattern_matches?(match, e.message)
+
+        raise AssertionFailedError, "Expected #{klass} with a message matching #{match.inspect} but got #{e.message.inspect}"
+      end
+
       def diff_section(expected, actual)
         return "" unless multiline_strings?(expected, actual)
 

data/lib/spinel_test/unit/version.rb

@@ -2,6 +2,6 @@
 
 module SpinelTest
   module Unit
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spinel_test-unit
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Yuji Yaginuma
@@ -71,6 +71,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/y-yagi/spinel_test-unit
   source_code_uri: https://github.com/y-yagi/spinel_test-unit
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib