mutineer 1.0.1 → 1.1.0

data/lib/mutineer/minitest_integration/stop_at_first_failure.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Mutineer
+  class MinitestIntegration
+    # Stops a Minitest run at the first failing test: one failure already
+    # kills the mutant. Child-process only, like MinitestIntegration.
+    #
+    # It sets a flag instead of unwinding the stack, so that class-level
+    # wrappers (`after_all`, a block-form transaction) still finish. The
+    # remaining tests and classes then return before they start.
+    #
+    # Minitest 5 and 6 need different hook points. An unknown shape installs
+    # no hook, and the run is a full run.
+    module StopAtFirstFailure
+      # Prepended on `Minitest::CompositeReporter`.
+      module RecordFailure
+        # Records the result, then sets the stop flag on a failure or an
+        # error. Only the outer reporter counts: a test can build and record
+        # on its own reporter.
+        #
+        # @param result [Minitest::Result] the result of one test.
+        # @return [void]
+        def record(result)
+          super
+          return if result.passed? || result.skipped?
+          return unless equal?(StopAtFirstFailure.armed_reporter)
+          return unless StopAtFirstFailure.armed_here?
+
+          StopAtFirstFailure.stopped = true
+        end
+      end
+
+      # Prepended on the `Minitest` singleton class for Minitest 6.
+      module OuterReporter6
+        # Keeps the outer reporter. Only the first call counts, because a test
+        # can call this method with its own reporter.
+        #
+        # @param reporter [Minitest::CompositeReporter] the outer reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object] whatever Minitest returns.
+        def run_all_suites(reporter, options)
+          StopAtFirstFailure.armed_reporter ||= reporter if StopAtFirstFailure.armed_here?
+          super
+        end
+      end
+
+      # Prepended on the `Minitest` singleton class for Minitest 5.
+      module OuterReporter5
+        # The Minitest 5 form of OuterReporter6#run_all_suites.
+        #
+        # @param reporter [Minitest::CompositeReporter] the outer reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object] whatever Minitest returns.
+        def __run(reporter, options)
+          StopAtFirstFailure.armed_reporter ||= reporter if StopAtFirstFailure.armed_here?
+          super
+        end
+      end
+
+      # Prepended on the singleton class of each test class for Minitest 6.
+      module SkipAfterStop6
+        # Skips the test class after a stop.
+        #
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run_suite(reporter, options = {})
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+
+        # Skips one test after a stop, without a record.
+        #
+        # @param klass [Class] the test class.
+        # @param method_name [String] the test method.
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run(klass, method_name, reporter)
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+      end
+
+      # Prepended on the singleton class of each test class for Minitest 5.
+      module SkipAfterStop5
+        # Skips the test class after a stop.
+        #
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @param options [Hash] the Minitest options.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run(reporter, options = {})
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+
+        # Skips one test after a stop, without a record.
+        #
+        # @param klass [Class] the test class.
+        # @param method_name [String] the test method.
+        # @param reporter [Minitest::CompositeReporter] the reporter.
+        # @return [Object, nil] whatever Minitest returns, or nil when skipped.
+        def run_one_method(klass, method_name, reporter)
+          return if StopAtFirstFailure.stopped_here?
+
+          super
+        end
+      end
+
+      class << self
+        # The pid of the armed process. Forked workers inherit the other
+        # state, and the pid keeps them from acting on it.
+        #
+        # @return [Integer, nil]
+        attr_accessor :armed_pid
+
+        # The outer reporter of the armed run.
+        #
+        # @return [Minitest::CompositeReporter, nil]
+        attr_accessor :armed_reporter
+
+        # True after the outer reporter records a failure or an error.
+        #
+        # @return [Boolean, nil]
+        attr_accessor :stopped
+
+        # Installs the hooks and arms the stop for this process. Call it after
+        # the test files load, so that every test class gets its prepend.
+        #
+        # @param runnables [Array<Class>] the loaded test classes.
+        # @return [Boolean] false when the Minitest shape is unknown.
+        def arm!(runnables)
+          outer, skip = hooks_for_loaded_minitest
+          return false unless outer
+
+          prepend_once(::Minitest::CompositeReporter, RecordFailure)
+          prepend_once(::Minitest.singleton_class, outer)
+          runnables.each { |klass| prepend_once(klass.singleton_class, skip) }
+          self.armed_pid = Process.pid
+          self.armed_reporter = nil
+          self.stopped = false
+          true
+        end
+
+        # Clears the armed state.
+        #
+        # @return [void]
+        def disarm!
+          self.armed_pid = nil
+          self.armed_reporter = nil
+          self.stopped = false
+        end
+
+        # True when the run is armed in this process.
+        #
+        # @return [Boolean]
+        def armed_here?
+          armed_pid == Process.pid
+        end
+
+        # True when the armed run in this process has stopped.
+        #
+        # @return [Boolean]
+        def stopped_here?
+          stopped == true && armed_here?
+        end
+
+        private
+
+        # Picks the hook modules for the loaded Minitest.
+        #
+        # @return [Array(Module, Module), nil] the outer reporter hook and the
+        #   skip hook, or nil for an unknown shape.
+        def hooks_for_loaded_minitest
+          runnable = ::Minitest::Runnable
+          if ::Minitest.respond_to?(:run_all_suites) && runnable.respond_to?(:run_suite)
+            [OuterReporter6, SkipAfterStop6]
+          elsif ::Minitest.respond_to?(:__run) && runnable.respond_to?(:run_one_method)
+            [OuterReporter5, SkipAfterStop5]
+          end
+        end
+
+        # Prepends `mod` on `target` once. A copy on a superclass does not
+        # count, because it comes after the own methods of `target`.
+        #
+        # @param target [Module] the class or singleton class.
+        # @param mod [Module] the module to prepend.
+        # @return [void]
+        def prepend_once(target, mod)
+          return if target.ancestors.take_while { |a| !a.equal?(target) }.include?(mod)
+
+          target.prepend(mod)
+        end
+      end
+    end
+  end
+end

data/lib/mutineer/minitest_integration.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "stringio"
+require_relative "minitest_integration/stop_at_first_failure"
 
 module Mutineer
   # Child-process-only: loads a test file in the current process and runs it
@@ -10,20 +10,29 @@ module Mutineer
   # Never call this in the parent — it manipulates global Minitest state
   # (autorun, runnables) that only makes sense in a throwaway forked child.
   #
-  # No `rescue` here: Isolation.run's fork block is the single exception
-  # boundary (any exception there becomes exit 2). Adding a rescue would
-  # create a second exit-2 path and break this method's 0/1 return contract.
+  # A missing minitest is rescued as FrameworkUnavailable (Isolation.run
+  # still turns that raise into exit 2). There is no rescue around the
+  # suite run itself: Isolation.run's fork block is the single exception
+  # boundary for unexpected errors. Swallowing those here would create a
+  # second exit-2 path and break this method's 0/1 return contract.
   class MinitestIntegration
-    # ponytail: tested via runner_test.rb (U6), not in isolation — a direct
-    # unit test would require forking and duplicate isolation_test's coverage.
+    # The seed of a run that stops at the first failure, unless `SEED` is set.
+    # With the stop, the test order can decide `killed` vs `timeout`; a fixed
+    # order keeps the verdict stable for a `--baseline` gate.
+    STOP_AT_FIRST_FAILURE_SEED = 1
+
+    # Tested via runner_test.rb, not in isolation — a direct unit test
+    # would require forking and duplicate isolation_test's coverage.
     #
-    # `test_files` is one path or an Array of paths (M3 coverage selection
+    # `test_files` is one path or an Array of paths (coverage selection
     # passes the covering subset); each is loaded before the single
     # Minitest.run.
     #
     # @param test_files [String, Array<String>] one file or many files.
+    # @param stop_at_first_failure [Boolean] end the run at the first failing
+    #   test. Only the mutant path passes true.
     # @return [Integer] 0 on success, 1 on failure.
-    def self.run(test_files)
+    def self.run(test_files, stop_at_first_failure: false)
       begin
         require "minitest"
       rescue LoadError
@@ -45,13 +54,20 @@ module Mutineer
       Minitest::Runnable.reset
       Array(test_files).each { |f| load f }
 
-      orig = $stdout
-      # Silence the child's test output; the parent only cares about pass/fail.
-      $stdout = StringIO.new
-      passed = Minitest.run([])
-      $stdout = orig
+      args = []
+      if stop_at_first_failure && StopAtFirstFailure.arm!(Minitest::Runnable.runnables)
+        # Pin the seed only when the stop is armed; an unknown Minitest shape
+        # gets the normal full, randomly ordered run.
+        args = ["--seed", STOP_AT_FIRST_FAILURE_SEED.to_s] unless ENV["SEED"]
+      end
+      # No silencing here: the fork boundary that calls this method has already
+      # pointed stdout at File::NULL (see ChildStdout).
+      passed = Minitest.run(args)
 
-      passed ? 0 : 1
+      # A plugin can replace the summary reporter, so a stop decides by itself.
+      passed && !StopAtFirstFailure.stopped_here? ? 0 : 1
+    ensure
+      StopAtFirstFailure.disarm!
     end
   end
 end

data/lib/mutineer/mutant_id.rb

@@ -19,7 +19,7 @@ module Mutineer
     # Computes the stable id for a single mutant.
     #
     # NUL-joined so token delimiters (`||=`, spaces, `::`, `#`) can never collide
-    # with the separator; SHA256[0,12] gives a fixed-length, copy-pasteable key.
+    # with the separator; `SHA256[0,12]` gives a fixed-length, copy-pasteable key.
     #
     # @param subject [Mutineer::Subject] the subject (method) the mutant lives in;
     #   its `qualified_name` anchors the id to a method rather than a byte position.

data/lib/mutineer/mutator_registry.rb

@@ -11,16 +11,19 @@ require_relative "mutators/condition_negation"
 require_relative "mutators/string_literal"
 require_relative "mutators/regex_literal"
 require_relative "mutators/collection_method"
+require_relative "mutators/safe_navigation"
+require_relative "mutators/range_literal"
+require_relative "mutators/negation_removal"
+require_relative "mutators/chain_link"
 
 module Mutineer
   # Maps operator names to operator classes.
   #
-  # DEFAULT_NAMES is the v1 default set
-  # (the M4 Tier-1 + statement-removal operators per locked decision #2). The
-  # three Tier-2 operators live in ALL but are OFF by default — they only run
-  # when named via --operators or `operators:` in .mutineer.yml (KTD8). Keeping
-  # DEFAULT_NAMES an explicit subset (not ALL.keys) is what keeps the M4 default
-  # survivor set unchanged.
+  # DEFAULT_NAMES is the v1 default set (Tier-1 plus statement-removal).
+  # The Tier-2 operators live in ALL but are OFF by default — they only
+  # run when named via `--operators` or `operators:` in `.mutineer.yml`.
+  # Keeping DEFAULT_NAMES an explicit subset (not ALL.keys) is what keeps
+  # the default survivor set unchanged.
   class MutatorRegistry
     # All available mutator classes keyed by operator name.
     ALL = {
@@ -34,13 +37,19 @@ module Mutineer
       "condition_negation" => Mutators::ConditionNegation,
       "string_literal"     => Mutators::StringLiteral,
       "regex"              => Mutators::RegexLiteral,
-      "collection_method"  => Mutators::CollectionMethod
+      "collection_method"  => Mutators::CollectionMethod,
+      "safe_navigation"    => Mutators::SafeNavigation,
+      "range"              => Mutators::RangeLiteral,
+      "negation_removal"   => Mutators::NegationRemoval,
+      "chain_link"         => Mutators::ChainLink
     }.freeze
 
     # The default Tier-1 operator set.
     DEFAULT_NAMES = %w[arithmetic comparison boolean_connector boolean_literal statement_removal].freeze
     # Tier-2 operators that remain opt-in.
-    TIER2_NAMES   = %w[return_nil literal_mutation condition_negation string_literal regex collection_method].freeze
+    TIER2_NAMES   = %w[return_nil literal_mutation condition_negation string_literal regex collection_method
+                       safe_navigation range negation_removal
+                       chain_link].freeze
 
     # Short human-readable descriptions for each operator.
     DESCRIPTIONS = {
@@ -54,7 +63,11 @@ module Mutineer
       "condition_negation" => "wrap if/unless/ternary condition in !( ... )",
       "string_literal"     => "non-empty string -> \"\", empty string -> \"mutineer\"",
       "regex"              => "drop leading ^ / trailing $, swap + <-> *",
-      "collection_method"  => "map<->each, all?<->any?, first<->last, min<->max, select<->reject"
+      "collection_method"  => "map<->each, all?<->any?, first<->last, min<->max, select<->reject",
+      "safe_navigation"    => "&. -> .",
+      "range"              => ".. <-> ...",
+      "negation_removal"   => "!x, not x -> x",
+      "chain_link"         => "drop one call from a chain: a.b.c -> a.c"
     }.freeze
 
     # Resolves operator names to classes.

data/lib/mutineer/mutators/chain_link.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Chain-link mutator (Tier-2).
+    #
+    # Drops one dotted call from a chain of calls, with its arguments and block:
+    # `user.account.owner.name` becomes `user.owner.name` and `user.account.name`.
+    # The chain's receiver and its final call stay, so a chain of n dotted calls
+    # gives at most n - 1 mutations. A chain begins at a receiver that is not a
+    # dotted call: a local, a constant, `self`, `list[i]`, `(a + b)`. A call in
+    # an argument or a block starts a chain of its own.
+    #
+    # The mutant survives when no test tells the chain apart from the same chain
+    # without that step: a scope, a filter or a lookup the tests never see.
+    #
+    # Links in {SKIPPED} are never dropped. On a value that already has the
+    # target type or needs no copy, a conversion (`name.to_s.strip`) or a copy
+    # (`list.dup.sort`) is a no-op, so dropping it most often makes an
+    # equivalent mutant. Dropping `new` sends the next call to the class, which
+    # raises (killed by any test that runs the line) or reaches a class method
+    # that builds the instance itself (equivalent); neither says anything about
+    # the tests.
+    class ChainLink < Base
+      # Method names whose link is never dropped: core conversions and copies,
+      # plus `new`.
+      SKIPPED = %i[
+        to_s to_str to_sym to_i to_int to_f to_r to_c to_a to_ary to_h to_hash to_proc to_set
+        dup clone freeze itself
+        new
+      ].freeze
+
+      # Resets the per-subject record of calls already placed in a chain.
+      #
+      # @param subject [Mutineer::Subject] subject whose body is visited.
+      # @param source [String] full source text for byte-based slicing.
+      # @return [Array<Mutineer::Mutation>] collected mutations.
+      def mutations_for(subject, source)
+        @links = {}.compare_by_identity
+        super
+      end
+
+      # Visits a call. The outermost dotted call of a chain is its final call;
+      # the dotted calls below it in the receiver are its links.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        chain(node) if dotted?(node) && !@links.key?(node)
+        super
+      end
+
+      # Visits `a.b.c += 1`, whose final call Prism parses as its own node.
+      #
+      # @param node [Prism::CallOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_operator_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits `a.b.c ||= 1`.
+      #
+      # @param node [Prism::CallOrWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_or_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits `a.b.c &&= 1`.
+      #
+      # @param node [Prism::CallAndWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_and_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits a call used as an assignment target, as in `a.b.c, d = 1, 2`.
+      #
+      # @param node [Prism::CallTargetNode] node to inspect.
+      # @return [void]
+      def visit_call_target_node(node)
+        chain(node)
+        super
+      end
+
+      # Nested method definitions are discovered as their own subjects; do not
+      # recurse into them (prevents double-counting their chains).
+      #
+      # @param node [Prism::DefNode] nested definition node.
+      # @return [void]
+      def visit_def_node(node); end
+
+      private
+
+      # Walks a final call's receiver chain, recording each link so it is not
+      # taken for the final call of a chain of its own, and dropping each link
+      # not in {SKIPPED}.
+      #
+      # @param top [Prism::Node] the chain's final call; responds to `receiver`.
+      # @return [void]
+      def chain(top)
+        link = top.receiver
+        while dotted?(link)
+          @links[link] = true
+          drop(link) unless SKIPPED.include?(link.name)
+          link = link.receiver
+        end
+      end
+
+      # Emits the removal of one link: from the end of its receiver to the end
+      # of its arguments and block, so a chain split across lines keeps the
+      # layout of the lines that remain.
+      #
+      # @param link [Prism::CallNode] the dotted call to drop.
+      # @return [void]
+      def drop(link)
+        @mutations << Mutation.new(
+          start_offset: link.receiver.location.end_offset,
+          end_offset: link.location.end_offset,
+          replacement: "",
+          operator: :chain_link
+        )
+      end
+
+      # Returns whether a node is a call through `.`, `&.` or `::`.
+      #
+      # @param node [Prism::Node, nil] node to inspect.
+      # @return [Boolean] true for a call node with a call operator.
+      def dotted?(node)
+        node.is_a?(Prism::CallNode) && !node.call_operator_loc.nil?
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/negation_removal.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Negation-removal mutator (Tier-2).
+    #
+    # Removes the `!` or `not` of a negation, one mutation per occurrence:
+    # `!x` becomes `x` and `not x` becomes ` x`. The mutant survives when no
+    # test depends on the negated value.
+    class NegationRemoval < Base
+      # Visits call nodes and emits negation-removal mutations.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        emit(node)
+        super # nested negations (!!x) each get their own mutation
+      end
+
+      private
+
+      # Emits a mutation when the node is a prefix `!` or `not`.
+      #
+      # The explicit form `x.!` is skipped: without its message, `x.` does
+      # not parse.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def emit(node)
+        return unless node.name == :! && node.call_operator_loc.nil?
+
+        loc = node.message_loc
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: "",
+          operator: :negation_removal
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/range_literal.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Range mutator (Tier-2).
+    #
+    # Swaps `..` with `...` and `...` with `..`, one mutation per range. The
+    # `..` -> `...` mutant survives when no test checks the last element.
+    # Flip-flops are FlipFlopNode, not RangeNode, so this mutator skips them.
+    #
+    # Endless ranges (`1..`, `1..nil`) are skipped. `(1..)` and `(1...)` give
+    # the same result for slicing, `include?`, `===`, `size` and patterns, so
+    # the mutant is equivalent and no normal test can kill it.
+    class RangeLiteral < Base
+      # Maps each range operator to its opposite.
+      SWAPS = { ".." => "...", "..." => ".." }.freeze
+
+      # Visits range nodes and emits range mutations.
+      #
+      # @param node [Prism::RangeNode] range node to inspect.
+      # @return [void]
+      def visit_range_node(node)
+        emit(node) unless endless?(node)
+        super # nested ranges ((1..2)...(3..4)) each get their own mutation
+      end
+
+      private
+
+      # Whether the range has no end: `1..` or `1..nil`.
+      #
+      # @param node [Prism::RangeNode] range node to inspect.
+      # @return [Boolean]
+      def endless?(node)
+        node.right.nil? || node.right.is_a?(Prism::NilNode)
+      end
+
+      # Emits the mutation that swaps the range operator.
+      #
+      # @param node [Prism::RangeNode] range node to mutate.
+      # @return [void]
+      def emit(node)
+        loc = node.operator_loc
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: SWAPS.fetch(loc.slice),
+          operator: :range
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/safe_navigation.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Safe-navigation mutator (Tier-2).
+    #
+    # Replaces `&.` with `.`, one mutation per occurrence. The mutant raises
+    # NoMethodError on a nil receiver, so it survives when no test passes nil.
+    class SafeNavigation < Base
+      # Visits call nodes and emits safe-navigation mutations.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        emit(node)
+        super # chained calls (a&.b&.c) each get their own mutation
+      end
+
+      # Visits `a&.b += 1`, which Prism parses as its own node, not a CallNode.
+      #
+      # @param node [Prism::CallOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `a&.b ||= 1`.
+      #
+      # @param node [Prism::CallOrWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_or_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `a&.b &&= 1`.
+      #
+      # @param node [Prism::CallAndWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_and_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits a call used as an assignment target, as in `for a&.b in list`.
+      #
+      # @param node [Prism::CallTargetNode] node to inspect.
+      # @return [void]
+      def visit_call_target_node(node)
+        emit(node)
+        super
+      end
+
+      private
+
+      # Emits a mutation when the node's call operator is `&.`.
+      #
+      # @param node [Prism::Node] a node with `safe_navigation?` and `call_operator_loc`.
+      # @return [void]
+      def emit(node)
+        return unless node.safe_navigation?
+
+        loc = node.call_operator_loc
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: ".",
+          operator: :safe_navigation
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/runner.rb

@@ -434,7 +434,8 @@ module Mutineer
         else
           Isolation.apply_whole_file(mutated, source_file)
         end
-        TestRunners.for(framework).run(abs_tests)
+        # One failing test already kills the mutant, so the child stops there.
+        TestRunners.for(framework).run(abs_tests, stop_at_first_failure: true)
       end
     end
 

data/lib/mutineer/test_runners/minitest.rb

@@ -9,8 +9,12 @@ module Mutineer
       # Runs the given Minitest files.
       #
       # @param test_files [String, Array<String>] one file or many files.
+      # @param stop_at_first_failure [Boolean] when true, the run ends at the
+      #   first failing test.
       # @return [Integer] 0 on success, 1 on failure.
-      def self.run(test_files) = MinitestIntegration.run(test_files)
+      def self.run(test_files, stop_at_first_failure: false)
+        MinitestIntegration.run(test_files, stop_at_first_failure: stop_at_first_failure)
+      end
     end
   end
 end