mutineer-mongoid 2.0.0

data/lib/mutineer/worker_pool.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative "result"
+
+module Mutineer
+  # Fixed-size fork pool. `run` forks up to `size` children at once; each child
+  # runs the block on one work item, marshals its Result to a private pipe, and
+  # exits. The parent drains pipes with IO.select and reaps each finished child
+  # by known pid (never wait2(-1), which would steal the host suite's children),
+  # opening exactly one slot per reap, then refills. Results are returned in the
+  # SAME ORDER as `items` regardless of finish order, so verdicts are identical
+  # to a serial run and downstream output is stable.
+  #
+  # The block is run inside the child via `yield(*items[i])`; whatever it
+  # returns (a Result) is the marshaled payload. Per-mutant timeout is handled
+  # one level down by Isolation. The pool adds no separate wall clock.
+  class WorkerPool
+    # Builds a pool.
+    #
+    # @param size [Integer] desired pool size.
+    def initialize(size)
+      @size = [size.to_i, 1].max
+    end
+
+    # Runs the work items through the pool.
+    #
+    # @param items [Array<Array>] work items.
+    # @param stop_when [Proc, nil] called with each collected Result; when it
+    #   returns truthy, no further items are scheduled and the run drains and
+    #   returns early (--fail-fast). Unscheduled slots stay nil.
+    # @param on_result [Proc, nil] called in the parent with each collected
+    #   Result as it is reaped, in finish order (progress reporting); its
+    #   return value is ignored. Must be fast and non-blocking: it runs on the
+    #   pool's single reap thread, so a slow callback stalls draining the other
+    #   in-flight children's pipes (the #4 deadlock discipline).
+    # @yieldparam item [Array] one work item.
+    # @return [Array<Mutineer::Result>] results in input order (nil for any item
+    #   left unscheduled by an early stop).
+    def run(items, stop_when: nil, on_result: nil)
+      results  = Array.new(items.size)
+      queue    = (0...items.size).to_a
+      running  = {} # pid => [index, read_io, buffer]
+      stopping = false
+
+      until queue.empty? && running.empty?
+        fill(items, queue, running) { |*args| yield(*args) } unless stopping
+        result = reap(results, running)
+        on_result&.call(result) if result
+        if !stopping && stop_when && result && stop_when.call(result)
+          stopping = true
+          queue.clear # schedule no more; let in-flight workers drain
+        end
+      end
+
+      results
+    end
+
+    private
+
+    # The child must ALWAYS hard-exit. If yield raises, marshal an error Result
+    # and exit! in `ensure`. Otherwise the child unwinds normally and our
+    # Minitest at_exit autorun re-runs the parent suite inside the worker,
+    # losing the real error.
+    def fill(items, queue, running)
+      while running.size < @size && !queue.empty?
+        idx = queue.shift
+        rd, wr = IO.pipe
+        rd.binmode # Marshal output is binary: keep the pipe byte-exact
+        wr.binmode
+        begin
+          pid = fork do
+            rd.close
+            payload =
+              begin
+                yield(*items[idx])
+              rescue Exception => e # rubocop:disable Lint/RescueException
+                Result.error("worker crashed: #{e.class}: #{e.message}")
+              end
+            begin
+              wr.write(Marshal.dump(payload))
+            rescue StandardError # rubocop:disable Lint/SuppressedException
+              # pipe gone; parent will record "no result"
+            ensure
+              wr.close
+              exit!(0)
+            end
+          end
+        rescue Errno::EAGAIN
+          # Process table is full. Put the item back and reap before retrying;
+          # if nothing is running we cannot make progress, so re-raise.
+          rd.close
+          wr.close
+          raise if running.empty?
+
+          queue.unshift(idx)
+          return
+        end
+        wr.close
+        running[pid] = [idx, rd, +""] # idx, read end, accumulated bytes
+      end
+    end
+
+    # Drain pipes with IO.select and reap a child only on EOF. The old code
+    # reaped first and read after, but a child whose payload exceeds the OS pipe
+    # buffer (~64KB) blocks on `write` before it can exit, so it was never reaped
+    # and the pool deadlocked. Reading concurrently keeps the pipe drained so the
+    # child can finish and exit; EOF means it closed its write end (done writing).
+    # We waitpid only OUR known pids (never wait2(-1), which would steal the host
+    # suite's children).
+    def reap(results, running)
+      return if running.empty?
+
+      loop do
+        rds = running.values.map { |v| v[1] }
+        ready, = IO.select(rds, nil, nil)
+        ready.each do |rd|
+          pid, (idx, _io, buf) = running.find { |_, v| v[1].equal?(rd) }
+          chunk = rd.read_nonblock(65_536, exception: false)
+          next if chunk == :wait_readable
+
+          if chunk.nil? # EOF: child closed wr; it is done writing and exiting
+            rd.close
+            Process.waitpid(pid) # reap the now-finished child (no zombie)
+            running.delete(pid)
+            # Return the collected Result so the caller's stop_when can see it.
+            return results[idx] = decode(buf)
+          end
+          buf << chunk
+        end
+      end
+    end
+
+    # A partial/garbage Marshal stream (dead worker) must not crash the pool.
+    # Degrade to an error Result. The payload loads frozen, which also shares
+    # equal strings across payloads (the test names of a --matrix run repeat
+    # in every row).
+    # @param data [String] marshaled payload.
+    # @return [Mutineer::Result] decoded result or error result.
+    def decode(data)
+      return Result.error("worker produced no result") if data.empty?
+
+      Marshal.load(data, freeze: true)
+    rescue StandardError => e
+      Result.error("worker result unreadable: #{e.class}: #{e.message}")
+    end
+  end
+end

data/lib/mutineer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "mutineer/version"
+require_relative "mutineer/config"
+require_relative "mutineer/parser"
+require_relative "mutineer/subject"
+require_relative "mutineer/mutation"
+require_relative "mutineer/project"
+require_relative "mutineer/pairing"
+require_relative "mutineer/result"
+require_relative "mutineer/coverage_map"
+require_relative "mutineer/changed_lines"
+require_relative "mutineer/isolation"
+require_relative "mutineer/minitest_integration"
+require_relative "mutineer/test_runners"
+require_relative "mutineer/mutators/base"
+require_relative "mutineer/mutators/arithmetic"
+require_relative "mutineer/mutators/comparison"
+require_relative "mutineer/mutators/boolean_connector"
+require_relative "mutineer/mutators/boolean_literal"
+require_relative "mutineer/mutators/statement_removal"
+require_relative "mutineer/mutators/return_nil"
+require_relative "mutineer/mutators/literal_mutation"
+require_relative "mutineer/mutators/condition_negation"
+require_relative "mutineer/mutators/string_literal"
+require_relative "mutineer/mutators/regex_literal"
+require_relative "mutineer/mutators/collection_method"
+require_relative "mutineer/mutators/safe_navigation"
+require_relative "mutineer/mutators/range_literal"
+require_relative "mutineer/mutators/negation_removal"
+require_relative "mutineer/mutators/chain_link"
+require_relative "mutineer/mutators/operand_removal"
+require_relative "mutineer/mutators/array_literal"
+require_relative "mutineer/mutators/condition_forcing"
+require_relative "mutineer/mutators/operator_assignment"
+require_relative "mutineer/mutator_registry"
+require_relative "mutineer/worker_pool"
+require_relative "mutineer/progress"
+require_relative "mutineer/job_plan"
+require_relative "mutineer/runner"
+require_relative "mutineer/kill_matrix"
+require_relative "mutineer/reporter"
+require_relative "mutineer/baseline"
+require_relative "mutineer/cli"
+
+# Mutineer is the top-level namespace for the mutation-testing library.
+module Mutineer
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: mutineer-mongoid
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- David Teren
+- Justin Allen Marsh
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Mutineer mutates your source one change at a time and runs your Minitest
+  or RSpec suite against each mutant to find tests that don't actually test anything.
+  Prism-based, fork-isolated, zero runtime dependencies.
+email:
+- 48605824+justinallenmarsh@users.noreply.github.com
+executables:
+- mutineer
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- bin/mutineer
+- lib/mutineer.rb
+- lib/mutineer/baseline.rb
+- lib/mutineer/changed_lines.rb
+- lib/mutineer/child_stdout.rb
+- lib/mutineer/cli.rb
+- lib/mutineer/config.rb
+- lib/mutineer/coverage_map.rb
+- lib/mutineer/daemon_backend.rb
+- lib/mutineer/daemon_client.rb
+- lib/mutineer/daemon_server.rb
+- lib/mutineer/external_backend.rb
+- lib/mutineer/file_swap.rb
+- lib/mutineer/isolation.rb
+- lib/mutineer/job_plan.rb
+- lib/mutineer/kill_channel.rb
+- lib/mutineer/kill_matrix.rb
+- lib/mutineer/minitest_integration.rb
+- lib/mutineer/minitest_integration/kill_recorder.rb
+- lib/mutineer/minitest_integration/outer_reporter.rb
+- lib/mutineer/minitest_integration/stop_at_first_failure.rb
+- lib/mutineer/mongoid_failures.rb
+- lib/mutineer/mongoid_worker_db.rb
+- lib/mutineer/mutant_id.rb
+- lib/mutineer/mutation.rb
+- lib/mutineer/mutator_registry.rb
+- lib/mutineer/mutators/arithmetic.rb
+- lib/mutineer/mutators/array_literal.rb
+- lib/mutineer/mutators/base.rb
+- lib/mutineer/mutators/boolean_connector.rb
+- lib/mutineer/mutators/boolean_literal.rb
+- lib/mutineer/mutators/chain_link.rb
+- lib/mutineer/mutators/collection_method.rb
+- lib/mutineer/mutators/comparison.rb
+- lib/mutineer/mutators/condition_forcing.rb
+- lib/mutineer/mutators/condition_negation.rb
+- lib/mutineer/mutators/literal_mutation.rb
+- lib/mutineer/mutators/negation_removal.rb
+- lib/mutineer/mutators/operand_removal.rb
+- lib/mutineer/mutators/operator_assignment.rb
+- lib/mutineer/mutators/range_literal.rb
+- lib/mutineer/mutators/regex_literal.rb
+- lib/mutineer/mutators/return_nil.rb
+- lib/mutineer/mutators/safe_navigation.rb
+- lib/mutineer/mutators/statement_removal.rb
+- lib/mutineer/mutators/string_literal.rb
+- lib/mutineer/orphan_guard.rb
+- lib/mutineer/pairing.rb
+- lib/mutineer/parser.rb
+- lib/mutineer/progress.rb
+- lib/mutineer/project.rb
+- lib/mutineer/project_path.rb
+- lib/mutineer/rails_worker_db.rb
+- lib/mutineer/reporter.rb
+- lib/mutineer/result.rb
+- lib/mutineer/runner.rb
+- lib/mutineer/statement_lines.rb
+- lib/mutineer/subject.rb
+- lib/mutineer/test_runners.rb
+- lib/mutineer/test_runners/minitest.rb
+- lib/mutineer/test_runners/rspec.rb
+- lib/mutineer/version.rb
+- lib/mutineer/worker_pool.rb
+homepage: https://github.com/justinallenmarsh/mutineer-mongoid
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/justinallenmarsh/mutineer-mongoid
+  changelog_uri: https://github.com/justinallenmarsh/mutineer-mongoid/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/justinallenmarsh/mutineer-mongoid/issues
+  documentation_uri: https://github.com/justinallenmarsh/mutineer-mongoid#readme
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Mutation testing with parallel Mongoid/RSpec support, based on Mutineer.
+test_files: []