mutineer-mongoid 2.0.0

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/operand_removal.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Operand-removal mutator (Tier-2).
+    #
+    # Replaces a boolean expression with one of its operands, two mutations
+    # per `&&`, `||`, `and` or `or`: `a && b` becomes `(a)` and `(b)`. The
+    # parentheses keep the precedence of `and` and `or`. A surviving mutant
+    # shows that no test needs the operand that was removed.
+    class OperandRemoval < Base
+      # Node types for jumps. A jump in a value context does not parse, so
+      # the operator never keeps a jump alone.
+      JUMPS = [Prism::ReturnNode, Prism::BreakNode, Prism::NextNode, Prism::RedoNode, Prism::RetryNode].freeze
+
+      # Visits `and` nodes.
+      #
+      # @param node [Prism::AndNode] node to inspect.
+      # @return [void]
+      def visit_and_node(node)
+        emit(node)
+        super # nested connectors (a && b && c) each get their own mutations
+      end
+
+      # Visits `or` nodes.
+      #
+      # @param node [Prism::OrNode] node to inspect.
+      # @return [void]
+      def visit_or_node(node)
+        emit(node)
+        super
+      end
+
+      private
+
+      # Emits one mutation that keeps the left operand, then one that keeps
+      # the right operand. The order is fixed, because the two mutants share
+      # a token and their occurrence ordinals tell them apart.
+      #
+      # @param node [Prism::AndNode, Prism::OrNode] connector node.
+      # @return [void]
+      def emit(node)
+        [[node.left, node.right], [node.right, node.left]].each do |kept, removed|
+          next if JUMPS.any? { |type| kept.is_a?(type) } || heredoc?(removed)
+
+          @mutations << Mutation.new(
+            start_offset: node.location.start_offset,
+            end_offset: node.location.end_offset,
+            replacement: "(#{kept.slice})",
+            operator: :operand_removal
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/operator_assignment.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Operator-assignment mutator (Tier-2).
+    #
+    # Swaps the operator of a compound assignment, one mutation per
+    # occurrence: `t += x` -> `t -= x`. Prism parses `t += x` as its own
+    # node, not as a CallNode, so the arithmetic mutator never sees it.
+    #
+    # The mapping is the same as for arithmetic. Other compound operators
+    # (`||=`, `&&=`, `|=`, `<<=` and the rest) are not changed.
+    class OperatorAssignment < Base
+      # Token replacements for compound arithmetic operators.
+      REPLACEMENTS = {
+        :+ => "-=", :- => "+=", :* => "/=", :/ => "*=", :% => "*=", :** => "*="
+      }.freeze
+
+      # Visits `t += x`.
+      #
+      # @param node [Prism::LocalVariableOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_local_variable_operator_write_node(node)
+        emit(node)
+        super # the value can hold its own compound assignment
+      end
+
+      # Visits `@t += x`.
+      #
+      # @param node [Prism::InstanceVariableOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_instance_variable_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `@@t += x`.
+      #
+      # @param node [Prism::ClassVariableOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_class_variable_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `$t += x`.
+      #
+      # @param node [Prism::GlobalVariableOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_global_variable_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `T += x`.
+      #
+      # @param node [Prism::ConstantOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_constant_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `A::T += x` and `::T += x`.
+      #
+      # @param node [Prism::ConstantPathOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_constant_path_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `a.b += x` and `a&.b += x`.
+      #
+      # @param node [Prism::CallOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `a[i] += x`.
+      #
+      # @param node [Prism::IndexOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_index_operator_write_node(node)
+        emit(node)
+        super
+      end
+
+      private
+
+      # Emits a mutation when the node's operator has a replacement.
+      #
+      # @param node [Prism::Node] a node with `binary_operator` and `binary_operator_loc`.
+      # @return [void]
+      def emit(node)
+        replacement = REPLACEMENTS[node.binary_operator]
+        return unless replacement
+
+        loc = node.binary_operator_loc
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: replacement,
+          operator: :operator_assignment
+        )
+      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/regex_literal.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Regular-expression literal mutator (Tier-2).
+    #
+    # Conservative, clearly-safe textual swaps inside a plain regex literal:
+    # drop a leading +^+ anchor, drop a trailing +$+ anchor, and swap the +
+    # and * quantifiers. Interpolated regexes use a different node type and are
+    # never visited. Escaped tokens (preceded by a backslash) are left alone.
+    class RegexLiteral < Base
+      # Visits regular-expression literals.
+      #
+      # @param node [Prism::RegularExpressionNode] node to inspect.
+      # @return [void]
+      def visit_regular_expression_node(node)
+        loc = node.content_loc
+        content = @source.byteslice(loc.start_offset...loc.end_offset)
+        scan(content, loc.start_offset)
+        super
+      end
+
+      private
+
+      # Scans the pattern bytes and emits anchor/quantifier mutations.
+      #
+      # @param content [String] regex pattern between the slashes.
+      # @param base [Integer] byte offset of the pattern start in source.
+      # @return [void]
+      def scan(content, base)
+        emit(base, base + 1, "") if content.start_with?("^")
+        emit(base + content.bytesize - 1, base + content.bytesize, "") if trailing_anchor?(content)
+
+        escaped = false
+        offset = base
+        content.each_char do |ch|
+          unless escaped
+            emit(offset, offset + 1, "*") if ch == "+"
+            emit(offset, offset + 1, "+") if ch == "*"
+          end
+          escaped = ch == "\\" && !escaped
+          offset += ch.bytesize
+        end
+      end
+
+      # Whether the pattern ends with an unescaped +$+ anchor.
+      #
+      # @param content [String] regex pattern.
+      # @return [Boolean] true when a trailing anchor is droppable.
+      def trailing_anchor?(content)
+        content.end_with?("$") && !content.end_with?("\\$")
+      end
+
+      # Emits a regex mutation.
+      #
+      # @param start_offset [Integer] byte start.
+      # @param end_offset [Integer] byte end.
+      # @param replacement [String] replacement text.
+      # @return [void]
+      def emit(start_offset, end_offset, replacement)
+        @mutations << Mutation.new(
+          start_offset: start_offset,
+          end_offset: end_offset,
+          replacement: replacement,
+          operator: :regex
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/return_nil.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Return-nil mutator.
+    #
+    # Replaces explicit return values and final expressions with nil.
+    class ReturnNil < Base
+      # Collects return-nil mutations for a subject.
+      #
+      # @param subject [Mutineer::Subject] subject to inspect.
+      # @param source [String] full source text.
+      # @return [Array<Mutineer::Mutation>] collected mutations.
+      def mutations_for(subject, source)
+        @source = source
+        @mutations = []
+        @body = subject.def_node.body
+        if @body
+          @body.accept(self)       # rule 1 (explicit return nodes in this body)
+          final_expression_nil(@body) # rule 2 (method's final expression)
+        end
+        drop_dangling_heredocs
+        @mutations
+      end
+
+      # Visits return nodes.
+      #
+      # @param node [Prism::ReturnNode] node to inspect.
+      # @return [void]
+      def visit_return_node(node)
+        args = node.arguments
+        if args
+          values = args.arguments
+          unless values.size == 1 && values.first.is_a?(Prism::NilNode)
+            emit(args.location)
+          end
+        end
+        super
+      end
+
+      private
+
+      # Mutates a method's final expression to nil when eligible.
+      #
+      # @param body [Prism::Node] method body node.
+      # @return [void]
+      def final_expression_nil(body)
+        return unless body.is_a?(Prism::StatementsNode)
+
+        last = body.body.last
+        return if last.nil? || last.is_a?(Prism::ReturnNode) || last.is_a?(Prism::NilNode)
+
+        emit(last.location)
+      end
+
+      # Emits a return-nil mutation.
+      #
+      # @param loc [Prism::Location] source location.
+      # @return [void]
+      def emit(loc)
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: "nil",
+          operator: :return_nil
+        )
+      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/mutators/statement_removal.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Statement-removal mutator.
+    #
+    # Replaces each non-final method statement with `nil`.
+    class StatementRemoval < Base
+      # Visits statement nodes and emits removals.
+      #
+      # @param node [Prism::StatementsNode] statement list to inspect.
+      # @return [void]
+      def visit_statements_node(node)
+        stmts = node.body
+        if stmts.length >= 2
+          stmts[0...-1].each do |stmt|
+            loc = stmt.location
+            @mutations << Mutation.new(
+              start_offset: loc.start_offset,
+              end_offset: loc.end_offset,
+              replacement: "nil",
+              operator: :statement_removal
+            )
+          end
+        end
+        # Nested statement lists (if/begin/while bodies) are separate StatementsNodes.
+        super
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/string_literal.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # String literal mutator (Tier-2).
+    #
+    # Empties a non-empty string literal and fills an empty one. Only plain
+    # quoted strings are touched; interpolated strings, heredocs and %-literals
+    # are skipped for safety (they re-parse unpredictably).
+    class StringLiteral < Base
+      # Visits string literals.
+      #
+      # @param node [Prism::StringNode] node to inspect.
+      # @return [void]
+      def visit_string_node(node)
+        # Only plain "..." / '...' quotes. opening is nil for
+        # interpolation parts and %w[] elements; heredocs/%-literals use a
+        # different opening token. Skipping them keeps mutants re-parseable.
+        if %w[" '].include?(node.opening)
+          loc = node.content_loc
+          @mutations << Mutation.new(
+            start_offset: loc.start_offset,
+            end_offset: loc.end_offset,
+            replacement: node.unescaped.empty? ? "mutineer" : "",
+            operator: :string_literal
+          )
+        end
+        super
+      end
+    end
+  end
+end

data/lib/mutineer/orphan_guard.rb

@@ -0,0 +1,28 @@
+# 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
+
+    # 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
+  end
+end