mutineer 1.5.0 → 1.7.0

data/lib/mutineer/minitest_integration.rb

@@ -62,7 +62,12 @@ module Mutineer
       # Drop runnables inherited from the parent suite (this is the child's
       # private copy — the parent is unaffected) so only the target test runs.
       Minitest::Runnable.reset
-      Array(test_files).each { |f| load f }
+      # Each test class's file position: the file that first defined it.
+      rank = {}
+      Array(test_files).each_with_index do |f, i|
+        load f
+        Minitest::Runnable.runnables.each { |klass| rank[klass] ||= i }
+      end
 
       armed =
         if record_to
@@ -73,6 +78,7 @@ module Mutineer
       # Pin the seed only when a hook is armed; an unknown Minitest shape gets
       # the normal full, randomly ordered run.
       args = armed && !ENV["SEED"] ? ["--seed", STOP_AT_FIRST_FAILURE_SEED.to_s] : []
+      keep_file_order(rank) if armed
       # No silencing here: the fork boundary that calls this method has already
       # pointed stdout at File::NULL (see ChildStdout).
       passed = Minitest.run(args)
@@ -86,5 +92,46 @@ module Mutineer
       StopAtFirstFailure.disarm!
       KillRecorder.disarm!
     end
+
+    # Runs the test classes in the order of their files (#203). Minitest
+    # shuffles the classes with the seed, then runs the serial classes before
+    # the parallel (`parallelize_me!`) ones. A stable sort by file position
+    # after that shuffle puts the files in the given order and keeps the
+    # seeded order within one file. The serial-then-parallel split is
+    # unchanged. Only the child's own class list gets {FileOrder}.
+    #
+    # @api private
+    # @param rank [Hash{Class => Integer}] each class's file position.
+    # @return [void]
+    def self.keep_file_order(rank)
+      FileOrder.rank = rank
+      ::Minitest::Runnable.runnables.extend(FileOrder)
+    end
+
+    # Extends the list of test classes: its `shuffle` keeps the file order.
+    module FileOrder
+      class << self
+        # Each test class's file position.
+        #
+        # @return [Hash{Class => Integer}, nil]
+        attr_accessor :rank
+      end
+
+      # The seeded shuffle, then a stable sort by file position.
+      #
+      # @return [Array<Class>]
+      def shuffle(...)
+        rank = FileOrder.rank || {}
+        super.sort_by.with_index { |klass, i| [rank.fetch(klass, rank.size), i] }
+      end
+
+      # Minitest 5.15 and older drop empty classes before the shuffle, so the
+      # filtered list keeps the file order too.
+      #
+      # @return [Array<Class>]
+      def reject(...)
+        super.extend(FileOrder)
+      end
+    end
   end
 end

data/lib/mutineer/mutator_registry.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "config"
 require_relative "mutators/arithmetic"
 require_relative "mutators/comparison"
 require_relative "mutators/boolean_connector"
@@ -15,6 +16,7 @@ require_relative "mutators/safe_navigation"
 require_relative "mutators/range_literal"
 require_relative "mutators/negation_removal"
 require_relative "mutators/chain_link"
+require_relative "mutators/call_to_receiver"
 require_relative "mutators/operand_removal"
 require_relative "mutators/array_literal"
 require_relative "mutators/condition_forcing"
@@ -46,6 +48,7 @@ module Mutineer
       "range"              => Mutators::RangeLiteral,
       "negation_removal"   => Mutators::NegationRemoval,
       "chain_link"         => Mutators::ChainLink,
+      "call_to_receiver"   => Mutators::CallToReceiver,
       "operand_removal"    => Mutators::OperandRemoval,
       "array_literal"      => Mutators::ArrayLiteral,
       "condition_true"     => Mutators::ConditionTrue,
@@ -58,7 +61,7 @@ module Mutineer
     # Tier-2 operators that remain opt-in.
     TIER2_NAMES   = %w[return_nil literal_mutation condition_negation string_literal regex collection_method
                        safe_navigation range negation_removal
-                       chain_link operand_removal array_literal
+                       chain_link call_to_receiver operand_removal array_literal
                        condition_true condition_false operator_assignment].freeze
 
     # Short human-readable descriptions for each operator.
@@ -78,6 +81,7 @@ module Mutineer
       "range"              => ".. <-> ...",
       "negation_removal"   => "!x, not x -> x",
       "chain_link"         => "drop one call from a chain: a.b.c -> a.c",
+      "call_to_receiver"   => "drop the last call of a chain: foo.bar -> foo",
       "operand_removal"    => "a && b -> a, b",
       "array_literal"      => "[a, b] -> []",
       "condition_true"     => "if/elsif/unless/ternary/modifier/case-in guard condition -> true",
@@ -91,7 +95,7 @@ module Mutineer
     # @return [Array<Class>] mutator classes in the requested order.
     # @raise [ArgumentError] when a name is unknown.
     def self.resolve(names = DEFAULT_NAMES)
-      names.map { |n| ALL.fetch(n) { raise ArgumentError, "Unknown operator: #{n.inspect}" } }
+      names.map { |n| ALL.fetch(n) { raise ArgumentError, "Unknown operator: #{n.inspect}#{Mutineer.did_you_mean(n, ALL.keys)}" } }
     end
 
     # Returns whether the operator is part of the default Tier-1 set.

data/lib/mutineer/mutators/base.rb

@@ -52,24 +52,27 @@ module Mutineer
 
       private
 
-      # Drops a mutation that deletes a heredoc opener and leaves its body.
+      # Drops a mutation that splits a heredoc opener from its body.
       #
       # The body sits past the opener's node. Replacing the opener with text
       # that does not contain it turns the body into Ruby, which parses and
       # then raises. A replacement that still contains the opener keeps the
-      # body attached, so that mutation stays.
+      # body attached, so that mutation stays. The reverse also breaks: when
+      # the replaced range holds the body but the replacement keeps only the
+      # opener, the opener has no body and the source does not parse. A
+      # replacement that copies the opener and the body together stays.
       #
       # @return [void]
       def drop_dangling_heredocs
         @mutations.reject! { |mutation| dangling_heredoc?(mutation) }
       end
 
-      # Returns whether the mutation removes a heredoc opener whose body hangs
-      # past the replaced range.
+      # Returns whether the mutation replaces a heredoc opener and keeps the
+      # opener without its body, or the body without its opener.
       #
       # @param mutation [Mutineer::Mutation] candidate edit.
       # @param node [Prism::Node, nil] subtree to search. Defaults to the body.
-      # @return [Boolean] true when the edit would leave a heredoc body behind.
+      # @return [Boolean] true when the edit would split a heredoc from its body.
       def dangling_heredoc?(mutation, node = @body)
         return false if node.nil? || !node.is_a?(Prism::Node)
 
@@ -78,9 +81,13 @@ module Mutineer
           if opening && opening.start_offset >= mutation.start_offset && opening.start_offset < mutation.end_offset
             closing = node.respond_to?(:closing_loc) ? node.closing_loc : nil
             hangs = closing.nil? || closing.end_offset > mutation.end_offset
+            opener = @source.byteslice(opening.start_offset, opening.end_offset - opening.start_offset)
+            kept = !opener.empty? && mutation.replacement.include?(opener)
             if hangs
-              opener = @source.byteslice(opening.start_offset, opening.end_offset - opening.start_offset)
-              return true if opener.empty? || !mutation.replacement.include?(opener)
+              return true unless kept
+            elsif kept
+              whole = @source.byteslice(opening.start_offset, closing.end_offset - opening.start_offset)
+              return true unless mutation.replacement.include?(whole)
             end
           end
         end

data/lib/mutineer/mutators/call_to_receiver.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "chain_link"
+
+module Mutineer
+  module Mutators
+    # Call-to-receiver mutator (Tier-2).
+    #
+    # Replaces the last call of a chain with its receiver, with the arguments
+    # and the block of that call: `user.full_name` becomes `user`, and
+    # `ids.uniq.sort` becomes `ids.uniq`. A chain begins at a receiver that is
+    # not a dotted call, as in {ChainLink}. A call in an argument or a block
+    # starts a chain of its own.
+    #
+    # The mutant survives when no test checks what the last call does: a strip,
+    # a uniq, a compact or a lookup the tests never see.
+    #
+    # The operator does not overlap with {ChainLink}. `chain_link` drops a link
+    # in the middle of a chain, and this operator drops the last call. A call
+    # that is the receiver of a dotted call, or of a call write or a call
+    # target, is a link, so it gets no mutant here. The two operators give the
+    # same source only when the last call repeats the link before it, as in
+    # `node.name.name`.
+    #
+    # Calls in {ChainLink::SKIPPED} are never replaced. On the last call,
+    # `x.to_s` is the same as `x` for the same reason as on a link. `Foo.new`
+    # becomes the class, and almost any use of the class raises.
+    #
+    # A call is not replaced when its name is an operator (`a.+(1)`), or a
+    # setter (`a.b = 1`). A call with no dot (`a + b`, `a[0]`) is not replaced.
+    class CallToReceiver < Base
+      # Matches the name of a call written as a word, not as an operator.
+      WORD_NAME = /\A[[:alpha:]_]/
+
+      # Resets the per-subject record of calls that are links.
+      #
+      # @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. A dotted call that is not a link is the last call of its
+      # chain.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        mark(node)
+        replace(node) if dotted?(node) && !@links.key?(node)
+        super
+      end
+
+      # Visits `a.b.c += 1`. Its receiver is a link.
+      #
+      # @param node [Prism::CallOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_operator_write_node(node)
+        mark(node)
+        super
+      end
+
+      # Visits `a.b.c ||= 1`. Its receiver is a link.
+      #
+      # @param node [Prism::CallOrWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_or_write_node(node)
+        mark(node)
+        super
+      end
+
+      # Visits `a.b.c &&= 1`. Its receiver is a link.
+      #
+      # @param node [Prism::CallAndWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_and_write_node(node)
+        mark(node)
+        super
+      end
+
+      # Visits a call used as an assignment target, as in `a.b.c, d = 1, 2`.
+      # Its receiver is a link.
+      #
+      # @param node [Prism::CallTargetNode] node to inspect.
+      # @return [void]
+      def visit_call_target_node(node)
+        mark(node)
+        super
+      end
+
+      private
+
+      # Records the receiver of a node as a link when the node is a dotted call
+      # or a call write or target. The receiver of a call with no dot is not a
+      # link. It is the last call of a chain of its own.
+      #
+      # @param node [Prism::Node] node that responds to `receiver`.
+      # @return [void]
+      def mark(node)
+        @links[node.receiver] = true if dotted?(node) || !node.is_a?(Prism::CallNode)
+      end
+
+      # Emits the replacement of a call by its receiver, unless the name is an
+      # operator, a setter, or in {ChainLink::SKIPPED}.
+      #
+      # @param node [Prism::CallNode] the dotted call to replace.
+      # @return [void]
+      def replace(node)
+        name = node.name.to_s
+        return unless name.match?(WORD_NAME)
+        return if name.end_with?("=")
+        return if ChainLink::SKIPPED.include?(node.name)
+
+        receiver = node.receiver.location
+        @mutations << Mutation.new(
+          start_offset: node.location.start_offset,
+          end_offset: node.location.end_offset,
+          replacement: @source.byteslice(receiver.start_offset, receiver.end_offset - receiver.start_offset),
+          operator: :call_to_receiver
+        )
+      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/chain_link.rb

@@ -25,7 +25,7 @@ module Mutineer
     # the tests.
     class ChainLink < Base
       # Method names whose link is never dropped: core conversions and copies,
-      # plus `new`.
+      # plus `new`. {CallToReceiver} uses the same list for the last call.
       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

data/lib/mutineer/orphan_guard.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Mutineer
+  # Ends a forked child's process group once the process that forked it is
+  # gone (#101). A mutant or capture child leads its own process group, so a
+  # parent that dies, or is killed by a client that gave up on it, does not
+  # take the child's tests with it; without this, a hung test would run on and
+  # keep its worker database open. Needs no other part of Mutineer, so the
+  # app-side daemon can load it.
+  module OrphanGuard
+    # Seconds between checks. A forked child gets no signal on parent death.
+    POLL = 0.5
+    # `Tempfile.create([".mutineer_daemon", ".rb"])` names the file
+    # `.mutineer_daemon<YYYYMMDD>-<pid>-<rand>.rb` (without the dot before #253).
+    # The pid is the child that is loading the mutant.
+    DAEMON_TEMP_PID = /\A\.?mutineer_daemon\d{8}-(\d+)-/
+
+    # Starts the watchdog in the current (child) process.
+    #
+    # @param parent [Integer] the parent's pid, read in the parent before
+    #   `fork`, so a parent that dies before this call is still noticed.
+    # @return [Thread]
+    def self.start(parent)
+      Thread.new do
+        sleep(POLL) while Process.ppid == parent
+        # Group 0 only when this child leads its own group: a failed setpgid
+        # leaves it in the parent's group, which must not be killed.
+        Process.kill(:KILL, Process.getpgrp == Process.pid ? 0 : Process.pid)
+      end
+    end
+
+    # True when a daemon mutant file still belongs to a live process. A boot
+    # sweep must leave it alone. The database lock is taken later, so the
+    # sweep is the step that used to delete another run's file.
+    #
+    # The creating pid is in the file name. A process that still holds the
+    # file lock counts too, even when that pid is already gone. A dead pid
+    # and a free lock is an orphan a killed child left behind.
+    #
+    # @param path [String] absolute path of a `.mutineer_daemon*.rb` file.
+    # @return [Boolean]
+    def self.mutant_file_in_use?(path)
+      creator_alive?(path) || locked_by_another?(path)
+    end
+
+    # True when the pid embedded in a daemon mutant file name is still running.
+    # Pid 0 is this process group, so it is never treated as an owner.
+    #
+    # @param path [String]
+    # @return [Boolean]
+    def self.creator_alive?(path)
+      pid_text = File.basename(path)[DAEMON_TEMP_PID, 1]
+      return false unless pid_text
+
+      pid = Integer(pid_text, 10)
+      return false if pid <= 0
+
+      Process.kill(0, pid)
+      !zombie?(pid)
+    rescue Errno::ESRCH, Errno::EINVAL, RangeError
+      false
+    rescue SystemCallError
+      true
+    end
+
+    # True when `pid` has exited but nobody reaped it. A container whose pid 1
+    # does not reap orphans keeps a dead mutant child as a zombie for good, and
+    # `Process.kill(0)` still finds it (#250). Linux only: elsewhere there is no
+    # `/proc`, so a zombie still counts as running.
+    #
+    # @param pid [Integer]
+    # @return [Boolean]
+    def self.zombie?(pid)
+      stat = File.read("/proc/#{pid}/stat")
+      # The name before the state is in parentheses and may hold ") " itself.
+      # An empty read (the process exited mid-read) has no ")": not a zombie.
+      close = stat.rindex(")")
+      !close.nil? && stat[close + 2] == "Z"
+    rescue SystemCallError
+      false
+    end
+
+    # True when another process holds an exclusive lock on `path`. A lock the
+    # kernel rejects as unsupported is not ownership: the pid check still applies.
+    # A file we cannot inspect is left in place.
+    #
+    # @param path [String]
+    # @return [Boolean]
+    def self.locked_by_another?(path)
+      File.open(path, File::RDONLY) do |file|
+        file.flock(File::LOCK_EX | File::LOCK_NB) == false
+      end
+    rescue Errno::ENOENT, Errno::ENOTSUP, Errno::EOPNOTSUPP
+      false
+    rescue SystemCallError
+      true
+    end
+    private_class_method :creator_alive?, :zombie?, :locked_by_another?
+  end
+end