minitest-utils 0.5.7 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad42d4b5af4fedb67bd32f1ef6c501c7c1668b2738b06c556a24c66fc739bf29
-  data.tar.gz: 65415517cbda393258ea30112037d627eb322c0cd5ed641e0a80d76f35e8d4f9
+  metadata.gz: 220b58299506fd3ec789a5dc73b982f295863e3cd67cf9c807c94e08dad82f3f
+  data.tar.gz: fba7b309f9ee1c7b8f6ddc13bbbadc828b683c22d84ac2ad4c0c1ae9ff0a63e4
 SHA512:
-  metadata.gz: 53fc67af42f5149f0c79d9c80d9427ce0779ac4f4f3bd456f030e47b2cc3f812c70c248ae5d9352dbb41e7d3aa99ebda5135b2593b078c4b308e9964df2e2984
-  data.tar.gz: 96cc057b759be11e2b84e732b277d3fc8e1a965ee4cbb7d35898938bbdd44da74a78794dadb960d7104508c7968a3dfbce99a62fc39a8c01860d495bbff2ed96
+  metadata.gz: 1c860200135f3ebbe01b8e6edc3ed77ea1ea2be5e03e73acee06396d916d6e09898eb98a6e1c0f6234a9b399acc192a56446655371182aef6b66199ee7154115
+  data.tar.gz: c6899dfce5f2aa135aa385a4fae57ea31387d29a673dcfd8daf857d54eb4e9cdf014d684f3820c29e0fef81a7898a4ab04677d572c6640e56515a6bc39f5c01c

data/.github/workflows/ruby.yml

@@ -0,0 +1,54 @@
+---
+name: ruby-tests
+
+on:
+  pull_request_target:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+    inputs: {}
+
+jobs:
+  build:
+    name: Tests with Ruby ${{ matrix.ruby }} and ${{ matrix.gemfile }}
+    runs-on: "ubuntu-latest"
+    if: |
+      github.actor == 'dependabot[bot]' && github.event_name == 'pull_request_target' ||
+      github.actor != 'dependabot[bot]'
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["3.4", "3.3"]
+        gemfile:
+          - Gemfile
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/cache@v4
+        with:
+          path: vendor/bundle
+          key: >
+            ${{ runner.os }}-${{ matrix.ruby }}-gems-${{
+            hashFiles(matrix.gemfile) }}-${{hashFiles('zee.gemspec')}}
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+
+      - name: Install gem dependencies
+        env:
+          BUNDLE_GEMFILE: ${{ matrix.gemfile }}
+        run: |
+          gem install bundler
+          bundle config set with default:development:test
+          bundle config path vendor/bundle
+          bundle update --jobs 4 --retry 3
+
+      - name: Run Tests
+        env:
+          BUNDLE_GEMFILE: ${{ matrix.gemfile }}
+        run: |
+          exe/mt

data/.rubocop.yml

@@ -3,7 +3,11 @@ inherit_gem:
   rubocop-fnando: .rubocop.yml
 
 AllCops:
-  TargetRubyVersion: 3.2
+  TargetRubyVersion: 3.3
+  NewCops: enable
+  Exclude:
+    - vendor/**/*
+    - gemfiles/**/*
 
 Style/GlobalVars:
   Exclude:

data/README.md

@@ -32,7 +32,7 @@ methods like the following:
 
 ```ruby
 class SampleTest < Minitest::Test
-  test 'useless test' do
+  test "useless test" do
     assert true
   end
 end
@@ -55,7 +55,45 @@ class SampleTest < Minitest::Test
     DB.disconnect
   end
 
-  test 'useless test' do
+  test "useless test" do
+    assert true
+  end
+end
+```
+
+If you want to skip slow tests, you can use the `slow_test` method, which only
+runs the test when `MT_RUN_SLOW_TESTS` environment variable is set.
+
+```ruby
+# Only run slow tests in CI. You can bypass it locally by using
+# something like `MT_RUN_SLOW_TESTS=1 rake`.
+ENV["MT_RUN_SLOW_TESTS"] ||= ENV["CI"]
+
+class SampleTest < Minitest::Test
+  test "useless test" do
+    slow_test
+    sleep 1
+    assert true
+  end
+end
+```
+
+You can change the default threshold by setting `Minitest::Test.slow_threshold`.
+The default value is `0.1` (100ms).
+
+```ruby
+Minitest::Test.slow_threshold = 0.1
+```
+
+This config can also be changed per class:
+
+```ruby
+class SampleTest < Minitest::Test
+  self.slow_threshold = 0.1
+
+  test "useless test" do
+    slow_test
+    sleep 1
     assert true
   end
 end
@@ -65,14 +103,51 @@ Finally, you can also use `let`.
 
 ```ruby
 class SampleTest < Minitest::Test
-  let(:token) { 'secret' }
+  let(:token) { "secret" }
 
-  test 'set token' do
-    assert_equal 'secret', token
+  test "set token" do
+    assert_equal "secret", token
   end
 end
 ```
 
+## Running tests
+
+`minitest-utils` comes with a runner: `mt`.
+
+You can run specific files by using `file:number`.
+
+```console
+$ mt test/models/user_test.rb:42
+```
+
+You can also run files by the test name (caveat: you need to underscore the
+name):
+
+```console
+$ mt test/models/user_test.rb --name /validations/
+```
+
+You can also run specific directories:
+
+```console
+$ mt test/models
+```
+
+To exclude tests by name, use --exclude:
+
+```console
+$ mt test/models --exclude /validations/
+```
+
+It supports `.minitestignore`, which only matches file names partially. Comments
+starting with `#` are ignored.
+
+```
+# Ignore all tests in test/fixtures
+test/fixtures
+```
+
 ## Screenshots
 
 ![](https://raw.githubusercontent.com/fnando/minitest-utils/main/screenshots/light-failing.png)

data/exe/mt

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/minitest/utils/cli"
+Minitest::Utils::CLI.loaded_via_bundle_exec = ENV.key?("BUNDLER_VERSION")
+Minitest::Utils::CLI.new(ARGV.dup).start

data/lib/minitest/utils/cli.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+gem "minitest"
+require "minitest"
+require_relative "../utils"
+require "optparse"
+require "io/console"
+
+module Minitest
+  module Utils
+    class CLI
+      MATCHER =
+        /^(\s+(?:(?<short>-[a-zA-Z]+), )?(?<long>[^ ]+) +)(?<description>.*?)$/ # rubocop:disable Lint/MixedRegexpCaptureTypes
+
+      class << self
+        attr_accessor :loaded_via_bundle_exec
+      end
+
+      def initialize(args)
+        @args = args
+      end
+
+      def indent(text)
+        text.gsub(/^/, "  ")
+      end
+
+      def start
+        OptionParser.new do |parser|
+          parser.banner = ""
+
+          parser.on_tail("-h", "--help", "Show this message") do
+            matches = parser.to_a.map do |line|
+              line.match(MATCHER).named_captures.transform_keys(&:to_sym)
+            end
+            print_help(matches)
+            exit
+          end
+
+          parser.on("-n", "--name=NAME",
+                    "Run tests that match this name") do |v|
+            options[:name] = v
+          end
+
+          parser.on("-s", "--seed=SEED", "Sets fixed seed.") do |v|
+            options[:seed] = v
+          end
+
+          parser.on("--slow", "Run slow tests.") do |v|
+            options[:slow] = v
+          end
+
+          parser.on("--hide-slow", "Hide list of slow tests.") do |v|
+            options[:hide_slow] = v
+          end
+
+          parser.on("--slow-threshold=THRESHOLD",
+                    "Set the slow threshold (in seconds)") do |v|
+            options[:slow_threshold] = v.to_f
+          end
+
+          parser.on(
+            "-e",
+            "--exclude=PATTERN",
+            "Exclude /regexp/ or string from run."
+          ) do |v|
+            options[:exclude] = v
+          end
+        end.parse!(@args)
+
+        run
+      end
+
+      def test_dir
+        File.join(Dir.pwd, "test")
+      end
+
+      def spec_dir
+        File.join(Dir.pwd, "spec")
+      end
+
+      def lib_dir
+        File.join(Dir.pwd, "lib")
+      end
+
+      def test_dir?
+        File.directory?(test_dir)
+      end
+
+      def spec_dir?
+        File.directory?(spec_dir)
+      end
+
+      def lib_dir?
+        File.directory?(lib_dir)
+      end
+
+      def run
+        $LOAD_PATH << lib_dir if lib_dir?
+        $LOAD_PATH << test_dir if test_dir?
+        $LOAD_PATH << spec_dir if spec_dir?
+
+        puts "\nNo tests found." if files.empty?
+
+        files.each {|file| require(file) }
+
+        bundler = "bundle exec " if self.class.loaded_via_bundle_exec
+
+        ENV["MT_TEST_COMMAND"] =
+          "#{bundler}mt %{location}:%{line} # %{description}"
+
+        ARGV.clear
+        ARGV.push(*minitest_args)
+        Minitest.autorun
+      end
+
+      def minitest_args
+        args = []
+        args += ["--seed", options[:seed]]
+        args += ["--exclude", options[:exclude]] if options[:exclude]
+        args += ["--slow", options[:slow]] if options[:slow]
+        args += ["--name", "/#{only.join('|')}/"] unless only.empty?
+        args += ["--hide-slow"] if options[:hide_slow]
+
+        if options[:slow_threshold]
+          threshold = options[:slow_threshold].to_s
+          threshold = threshold.gsub(/\.0+$/, "").delete_suffix(".")
+          args += ["--slow-threshold", threshold]
+        end
+
+        args.map(&:to_s)
+      end
+
+      def files
+        @files ||= begin
+          files = @args
+          files += %w[test spec] if files.empty?
+          files
+            .flat_map { expand_entry(_1) }
+            .reject { ignored_file?(_1) }
+        end
+      end
+
+      def ignored_files
+        @ignored_files ||= if File.file?(".minitestignore")
+                             File.read(".minitestignore")
+                                 .lines
+                                 .map(&:strip)
+                                 .reject { _1.start_with?("#") }
+                           else
+                             []
+                           end
+      end
+
+      def ignored_file?(file)
+        ignored_files.any? { file.include?(_1) }
+      end
+
+      def only
+        @only ||= []
+      end
+
+      def expand_entry(entry)
+        entry = extract_entry(entry)
+
+        if File.directory?(entry)
+          Dir[
+            File.join(entry, "**", "*_test.rb"),
+            File.join(entry, "**", "*_spec.rb")
+          ]
+        else
+          Dir[entry]
+        end
+      end
+
+      def extract_entry(entry)
+        entry = File.expand_path(entry)
+        return entry unless entry.match?(/:\d+$/)
+
+        entry, line = entry.split(":")
+        line = line.to_i
+        return entry unless File.file?(entry)
+
+        content = File.read(entry)
+        text = content.lines[line - 1].chomp.strip
+
+        method_name = if text =~ /^\s*test\s+(['"])(.*?)\1\s+do\s*$/
+                        Test.test_method_name(::Regexp.last_match(2))
+                      elsif text =~ /^def\s+(test_.+)$/
+                        ::Regexp.last_match(1)
+                      end
+
+        if method_name
+          class_names =
+            content.scan(/^\s*class\s+([^<]+)/).flatten.map(&:strip)
+
+          class_name = class_names.find do |name|
+            name.end_with?("Test")
+          end
+
+          only << "#{class_name}##{method_name}" if class_name
+        end
+
+        entry
+      end
+
+      def options
+        @options ||= {
+          seed: (ENV["SEED"] || srand).to_i % 0xFFFF
+        }
+      end
+
+      BANNER = <<~TEXT
+        A better test runner for Minitest.
+
+        You can run specific files by using `file:number`.
+
+        $ mt test/models/user_test.rb:42
+
+        You can also run files by the test name (caveat: you need to underscore the name):
+
+        $ mt test/models/user_test.rb --name /validations/
+
+        You can also run specific directories:
+
+        $ mt test/models
+
+        To exclude tests by name, use --exclude:
+
+        $ mt test/models --exclude /validations/
+      TEXT
+
+      COLOR = {
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
+        gray: 37
+      }.freeze
+
+      private def color(string, color = :default)
+        return string if string.empty?
+
+        if $stdout.tty?
+          color = COLOR.fetch(color, 0)
+          "\e[#{color}m#{string}\e[0m"
+        else
+          string
+        end
+      end
+
+      def print_help(matches)
+        io = StringIO.new
+        matches.sort_by! { _1["long"] }
+        short_size = matches.map { _1[:short].to_s.size }.max
+        long_size = matches.map { _1[:long].to_s.size }.max
+
+        io << indent(color("Usage:", :green))
+        io << indent(color("mt [OPTIONS] [FILES|DIR]...", :blue))
+        io << "\n\n"
+        io << indent("A better test runner for Minitest.")
+        io << "\n\n"
+        file_line = color("file:number", :yellow)
+        io << indent("You can run specific files by using #{file_line}.")
+        io << "\n\n"
+        io << indent(color("$ mt test/models/user_test.rb:42", :yellow))
+        io << "\n\n"
+        io << indent("You can run files by the test name.")
+        io << "\n"
+        io << indent("Caveat: you need to underscore the name.")
+        io << "\n\n"
+        io << indent(
+          color("$ mt test/models/user_test.rb --name /validations/", :yellow)
+        )
+        io << "\n\n"
+        io << indent("You can also run specific directories:")
+        io << "\n\n"
+        io << indent(color("To exclude tests by name, use --exclude:", :yellow))
+        io << "\n\n"
+        io << indent("To ignore files, you can use a `.minitestignore`.")
+        io << "\n"
+        io << indent("Each line can be a partial file/dir name.")
+        io << "\n"
+        io << indent("Lines startin with # are ignored.")
+        io << "\n\n"
+        io << indent(color("# This is a comment", :yellow))
+        io << "\n"
+        io << indent(color("test/fixtures", :yellow))
+        io << "\n\n"
+        io << indent(color("Options:", :green))
+        io << "\n"
+
+        matches.each do |match|
+          match => { short:, long:, description: }
+
+          io << "  "
+          io << (" " * (short_size - short.to_s.size))
+          io << color(short, :blue) if short
+          io << "  " unless short
+          io << ", " if short
+          io << color(long.to_s, :blue)
+          io << (" " * (long_size - long.to_s.size + 4))
+          io << description
+          io << "\n"
+        end
+
+        puts io.tap(&:rewind).read
+      end
+    end
+  end
+end

data/lib/minitest/utils/extension.rb

@@ -5,12 +5,12 @@ module Minitest
     module Assertions
       def assert(test, message = nil)
         message ||= "expected: truthy value\ngot: #{mu_pp(test)}"
-        super(test, message)
+        super
       end
 
       def refute(test, message = nil)
         message ||= "expected: falsy value\ngot: #{mu_pp(test)}"
-        super(test, message)
+        super
       end
     end
   end
@@ -22,13 +22,19 @@ module Minitest
       @tests ||= {}
     end
 
+    def slow_test
+      return if ENV["MT_RUN_SLOW_TESTS"] || Minitest.options[:slow]
+
+      skip "slow test"
+    end
+
     def self.test_method_name(description)
       method_name = description.downcase
                                .gsub(/[^a-z0-9]+/, "_")
                                .gsub(/^_+/, "")
                                .gsub(/_+$/, "")
                                .squeeze("_")
-      "test_#{method_name}".to_sym
+      :"test_#{method_name}"
     end
 
     def self.test(description, &block)
@@ -48,12 +54,19 @@ module Minitest
         description:,
         name: test_name,
         source_location:,
-        benchmark: nil
+        time: nil,
+        slow_threshold:
       }
 
       testable = proc do
-        benchmark = Benchmark.measure { instance_eval(&block) }
-        Test.tests["#{klass}##{test_name}"][:benchmark] = benchmark
+        err = nil
+        t0 = Minitest.clock_time
+        instance_eval(&block)
+      rescue StandardError => error
+        err = error
+      ensure
+        Test.tests["#{klass}##{test_name}"][:time] = Minitest.clock_time - t0
+        raise err if err
       end
 
       raise "#{test_name} is already defined in #{self}" if defined

data/lib/minitest/utils/rails.rb

@@ -23,12 +23,12 @@ module ActiveSupport
 
     require "minitest/utils/rails/capybara" if defined?(Capybara)
 
-    def t(*args, **kwargs)
-      I18n.t(*args, **kwargs)
+    def t(*, **)
+      I18n.t(*, **)
     end
 
-    def l(*args, **kwargs)
-      I18n.l(*args, **kwargs)
+    def l(*, **)
+      I18n.l(*, **)
     end
   end
 end

data/lib/minitest/utils/reporter.rb

@@ -1,10 +1,21 @@
 # frozen_string_literal: true
 
 module Minitest
+  class Test
+    class << self
+      attr_accessor :slow_threshold
+    end
+
+    def self.inherited(child)
+      child.slow_threshold = slow_threshold
+      super
+    end
+  end
+
   module Utils
     class Reporter < Minitest::StatisticsReporter
       def self.filters
-        @filters ||= [/'Benchmark.measure'/]
+        @filters ||= []
       end
 
       COLOR_FOR_RESULT_CODE = {
@@ -32,17 +43,9 @@ module Minitest
         print_result_code(result.result_code)
       end
 
-      def start
-        super
-        io.puts "Run options: #{options[:args]}"
-        io.puts
-        io.puts "# Running:"
-        io.puts
-      end
-
       def report
         super
-        io.sync = true
+        io.sync = true if io.respond_to?(:sync)
 
         failing_results = results.reject(&:skipped?)
         skipped_results = results.select(&:skipped?)
@@ -51,17 +54,8 @@ module Minitest
         color = :yellow if skipped_results.any?
         color = :red if failing_results.any?
 
-        if failing_results.any? || skipped_results.any?
-          failing_results.each.with_index(1) do |result, index|
-            display_failing(result, index)
-          end
-
-          skipped_results
-            .each
-            .with_index(failing_results.size + 1) do |result, index|
-            display_skipped(result, index)
-          end
-        end
+        print_failing_results(failing_results)
+        print_skipped_results(skipped_results, failing_results.size)
 
         io.print "\n\n"
         io.puts statistics
@@ -72,46 +66,78 @@ module Minitest
           failing_results.each {|result| display_replay_command(result) }
           io.puts "\n\n"
         else
-          threshold = 0.1 # 100ms
-          test_results =
-            Test
-            .tests
-            .values
-            .select { _1[:benchmark] }
-            .sort_by { _1[:benchmark].total }
-            .reverse
-            .take(10).filter { _1[:benchmark].total > threshold }
-
-          return unless test_results.any?
-
-          io.puts "\nSlow Tests:\n"
-
-          test_results.each_with_index do |info, index|
-            location = info[:source_location].join(":")
-            duration = humanize_duration(info[:benchmark].total * 1_000_000_000)
-
-            prefix = "#{index + 1}) "
-            padding = " " * prefix.size
-
-            io.puts color("#{prefix}#{info[:description]} (#{duration})", :red)
-            io.puts color("#{padding}#{location}", :gray)
-            io.puts
-          end
+          print_slow_results
         end
       end
 
-      private def humanize_duration(duration_ns)
-        if duration_ns < 1000
-          format("%.2f ns", duration_ns)
-        elsif duration_ns < 1_000_000
-          format("%.2f μs", (duration_ns / 1000))
-        elsif duration_ns < 1_000_000_000
-          format("%.2f ms", (duration_ns / 1_000_000))
-        else
-          format("%.2f s", (duration_ns / 1_000_000_000))
+      def slow_threshold_for(test_case)
+        test_case[:slow_threshold] || Minitest.options[:slow_threshold] || 0.1
+      end
+
+      def slow_tests
+        Test
+          .tests
+          .values
+          .select { _1[:time] }
+          .filter { _1[:time] > slow_threshold_for(_1) }
+          .sort_by { _1[:time] }
+          .reverse
+      end
+
+      def print_failing_results(results, initial_index = 1)
+        results.each.with_index(initial_index) do |result, index|
+          display_failing(result, index)
         end
       end
 
+      def print_skipped_results(results, initial_index)
+        results
+          .each
+          .with_index(initial_index + 1) do |result, index|
+          display_skipped(result, index)
+        end
+      end
+
+      def print_slow_results
+        test_results = slow_tests.take(10)
+
+        return if Minitest.options[:hide_slow]
+        return unless test_results.any?
+
+        io.puts "\nSlow Tests:\n"
+
+        test_results.each_with_index do |info, index|
+          location = info[:source_location].join(":")
+          duration = format_duration(info[:time])
+
+          prefix = "#{index + 1}) "
+          padding = " " * prefix.size
+
+          io.puts color("#{prefix}#{info[:description]} (#{duration})", :red)
+          io.puts color("#{padding}#{location}", :blue)
+          io.puts
+        end
+      end
+
+      def format_duration(duration_in_seconds)
+        duration_ns = duration_in_seconds * 1_000_000_000
+
+        number, unit = if duration_ns < 1000
+                         [duration_ns, "ns"]
+                       elsif duration_ns < 1_000_000
+                         [duration_ns / 1000, "μs"]
+                       elsif duration_ns < 1_000_000_000
+                         [duration_ns / 1_000_000, "ms"]
+                       else
+                         [duration_ns / 1_000_000_000, "s"]
+                       end
+
+        number =
+          format("%.2f", number).gsub(/0+$/, "").delete_suffix(".")
+
+        "#{number}#{unit}"
+      end
+
       private def statistics
         format(
           "Finished in %.6fs, %.4f runs/s, %.4f assertions/s.",
@@ -140,25 +166,42 @@ module Minitest
         message = result.failure.message
         message = message.lines.tap(&:pop).join.chomp if result.error?
 
+        test = find_test_info(result)
+
         output = ["\n\n"]
-        output << color(format("%4d) %s", index, result_name(result.name)))
+        output << color(format("%4d) %s", index, test[:description]))
         output << "\n" << color(indent(message), :red)
         output << "\n" << color(backtrace, :blue)
         io.print output.join
       end
 
       private def display_skipped(result, index)
-        location = location(result.failure.location)
+        location = filter_backtrace(
+          result
+            .failure
+            .backtrace_locations
+            .map {|l| [l.path, l.lineno].join(":") }
+        ).first
+
+        location, line = location.to_s.split(":")
+        location = Pathname(location).relative_path_from(Pathname.pwd)
+        location = "#{location}:#{line}"
+
+        test = find_test_info(result)
         output = ["\n\n"]
         output << color(
-          format("%4d) %s [SKIPPED]", index, result_name(result.name)), :yellow
+          format("%4d) %s [SKIPPED]", index, test[:description]), :yellow
         )
+
+        message = "Reason: #{result.failure.message}"
+        output << "\n" << indent(color(message, :yellow))
         output << "\n" << indent(color(location, :yellow))
+
         io.print output.join
       end
 
       private def display_replay_command(result)
-        test = find_test_file(result)
+        test = find_test_info(result)
         return if test[:source_location].empty?
 
         command = build_test_command(test, result)
@@ -169,7 +212,7 @@ module Minitest
         io.print output.join
       end
 
-      private def find_test_file(result)
+      private def find_test_info(result)
         Test.tests.fetch("#{result.klass}##{result.name}")
       end
 
@@ -207,12 +250,6 @@ module Minitest
                 .select {|line| line.start_with?(Dir.pwd) }
       end
 
-      private def result_name(name)
-        name
-          .gsub(/^test(_\d+)?_/, "")
-          .tr("_", " ")
-      end
-
       private def print_result_code(result_code)
         result_code = color(result_code, COLOR_FOR_RESULT_CODE[result_code])
         io.print result_code
@@ -248,12 +285,18 @@ module Minitest
         Rails.version >= "5.0.0"
       end
 
+      def bundler
+        "bundle exec " if ENV.key?("BUNDLE_BIN_PATH")
+      end
+
       private def build_test_command(test, result)
         location, line = test[:source_location]
 
-        if ENV["MINITEST_TEST_COMMAND"]
+        if ENV["MT_TEST_COMMAND"]
+          cmd = ENV["MT_TEST_COMMAND"]
+
           return format(
-            ENV["MINITEST_TEST_COMMAND"],
+            cmd,
             location: location,
             line: line,
             description: test[:description],
@@ -264,8 +307,7 @@ module Minitest
         if running_rails?
           %[bin/rails test #{location}:#{line}]
         else
-          bundle = "bundle exec " if defined?(Bundler)
-          %[#{bundle}rake TEST=#{location} TESTOPTS="--name=#{result.name}"]
+          %[#{bundler}rake TEST=#{location} TESTOPTS="--name=#{result.name}"]
         end
       end
     end

data/lib/minitest/utils/version.rb

@@ -2,6 +2,6 @@
 
 module Minitest
   module Utils
-    VERSION = "0.5.7"
+    VERSION = "0.6.0"
   end
 end

data/lib/minitest/utils.rb

@@ -3,12 +3,11 @@
 module Minitest
   module Utils
     require "minitest"
-    require "benchmark"
     require "pathname"
-    require "minitest/utils/version"
-    require "minitest/utils/reporter"
-    require "minitest/utils/extension"
-    require "minitest/utils/test_notifier_reporter"
+    require_relative "utils/version"
+    require_relative "utils/reporter"
+    require_relative "utils/extension"
+    require_relative "utils/test_notifier_reporter"
 
     load_lib = lambda do |path, &block|
       require path
@@ -23,21 +22,21 @@ module Minitest
     load_lib.call "capybara"
 
     load_lib.call "webmock" do
-      require "minitest/utils/setup/webmock"
+      require_relative "utils/setup/webmock"
     end
 
     load_lib.call "database_cleaner" do
-      require "minitest/utils/setup/database_cleaner"
+      require_relative "utils/setup/database_cleaner"
     end
 
     load_lib.call "factory_girl" do
-      require "minitest/utils/setup/factory_girl"
+      require_relative "utils/setup/factory_girl"
     end
 
     load_lib.call "factory_bot" do
-      require "minitest/utils/setup/factory_bot"
+      require_relative "utils/setup/factory_bot"
     end
 
-    require "minitest/utils/railtie" if defined?(Rails)
+    require_relative "utils/railtie" if defined?(Rails)
   end
 end

data/lib/minitest/utils_plugin.rb

@@ -1,9 +1,32 @@
 # frozen_string_literal: true
 
-require "minitest/utils/reporter"
-require "minitest/utils/test_notifier_reporter"
+require_relative "utils/reporter"
+require_relative "utils/test_notifier_reporter"
 
 module Minitest
+  class << self
+    attr_accessor :options
+  end
+
+  self.options = {}
+
+  def self.plugin_utils_options(opts, options)
+    Minitest.options = options
+
+    opts.on("--slow", "Run slow tests") do
+      options[:slow] = true
+    end
+
+    opts.on("--hide-slow", "Hide list of slow tests") do
+      options[:hide_slow] = true
+    end
+
+    opts.on("--slow-threshold=THRESHOLD",
+            "Set the slow threshold (in seconds)") do |v|
+      options[:slow_threshold] = v.to_f
+    end
+  end
+
   def self.plugin_utils_init(options)
     reporters = Minitest.reporter.reporters
     reporters.clear
@@ -11,8 +34,10 @@ module Minitest
 
     begin
       require "test_notifier"
-      reporters << Minitest::Utils::TestNotifierReporter.new(options[:io],
-                                                             options)
+      reporters << Minitest::Utils::TestNotifierReporter.new(
+        options[:io],
+        options
+      )
     rescue LoadError
       # noop
     end

data/minitest-utils.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.summary       = "Some utilities for your Minitest day-to-day usage."
   spec.description   = spec.summary
   spec.homepage      = "http://github.com/fnando/minitest-utils"
-  spec.required_ruby_version = Gem::Requirement.new(">= 3.2.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.3.0")
 
   spec.files         = `git ls-files -z`
                        .split("\x0")
@@ -19,12 +19,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) {|f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "benchmark"
   spec.add_dependency "minitest"
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "pry-meta"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rubocop"
   spec.add_development_dependency "rubocop-fnando"
+  spec.add_development_dependency "simplecov"
   spec.add_development_dependency "test_notifier"
+  spec.metadata["rubygems_mfa_required"] = "true"
 end

metadata

@@ -1,28 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-utils
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.6.0
 platform: ruby
 authors:
 - Nando Vieira
 bindir: exe
 cert_chain: []
-date: 2025-03-11 00:00:00.000000000 Z
+date: 2025-03-15 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: benchmark
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-meta
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -66,7 +52,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,7 +66,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rubocop-fnando
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,7 +80,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-fnando
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -124,11 +110,13 @@ dependencies:
 description: Some utilities for your Minitest day-to-day usage.
 email:
 - fnando.vieira@gmail.com
-executables: []
+executables:
+- mt
 extensions: []
 extra_rdoc_files: []
 files:
 - ".github/FUNDING.yml"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - Gemfile
@@ -138,9 +126,11 @@ files:
 - bin/console
 - bin/rake
 - bin/setup
+- exe/mt
 - lib/minitest/utils.rb
 - lib/minitest/utils/capybara/chrome_headless.rb
 - lib/minitest/utils/capybara/screenshot_on_failures.rb
+- lib/minitest/utils/cli.rb
 - lib/minitest/utils/extension.rb
 - lib/minitest/utils/rails.rb
 - lib/minitest/utils/rails/capybara.rb
@@ -161,7 +151,8 @@ files:
 - screenshots/light-success.png
 homepage: http://github.com/fnando/minitest-utils
 licenses: []
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -169,14 +160,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.4
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Some utilities for your Minitest day-to-day usage.
 test_files: []