mutation_tester 1.2.0

data/lib/mutation_tester/reporters/json_reporter.rb

@@ -0,0 +1,67 @@
+require 'time'
+
+module MutationTester
+  module Reporters
+    class JsonReporter < BaseReporter
+      SCHEMA_VERSION = 1
+
+      def generate
+        output_file = File.join(@config.output_dir, 'mutation_report.json')
+
+        File.write(output_file, render)
+        puts Rainbow("✓ JSON report saved to: #{output_file}").green
+        output_file
+      end
+
+      def render
+        @render ||= JSON.pretty_generate(report_data)
+      end
+
+      def report_data
+        {
+          schema_version: SCHEMA_VERSION,
+          interrupted: interrupted?,
+          metadata: {
+            version: MutationTester::VERSION,
+            generated_at: Time.now.iso8601,
+            source_file: @source_file,
+            spec_file: @spec_file
+          },
+          summary: {
+            total: total_count,
+            killed: effective_killed_count,
+            survived: survived_count,
+            mutation_score: mutation_score,
+            quality_rating: quality_rating,
+            categories: {
+              killed: killed_count,
+              survived: survived_count,
+              timeout: timeout_count,
+              stillborn: stillborn_count,
+              error: error_count
+            }
+          },
+          mutations: @results.map { |r| mutation_entry(r) }
+        }
+      end
+
+      private
+
+      def mutation_entry(result)
+        status = status_of(result)
+        entry = result.merge(status: status)
+        entry.delete(:kill_phase)
+        entry[:diff] = diff_text(result) if DIFF_DETAIL_STATUSES.include?(status)
+        entry
+      end
+
+      def diff_text(result)
+        diff_lines([result]).map { |kind, text, _| "#{diff_prefix(kind)}#{text}" }.join("\n")
+      end
+
+      def diff_prefix(kind)
+        { removed: '- ', added: '+ ', context: '  ' }.fetch(kind, '')
+      end
+    end
+  end
+end

data/lib/mutation_tester/test_command.rb

@@ -0,0 +1,165 @@
+require 'tempfile'
+
+module MutationTester
+  class TestCommand
+    Result = Struct.new(:passed, :timed_out, :output) do
+      alias_method :passed?, :passed
+      alias_method :timed_out?, :timed_out
+    end
+
+    POLL_INTERVAL = 0.05
+
+    attr_reader :spec_file, :framework, :use_bundle_exec, :example_filters
+
+    def initialize(spec_file, use_bundle_exec:, framework: nil, runner: :spawn, example_filters: [], worker_env_var: nil)
+      @spec_file = spec_file
+      @framework = framework || self.class.detect_framework(spec_file)
+      @use_bundle_exec = use_bundle_exec
+      @runner = runner
+      @example_filters = @framework == :rspec ? Array(example_filters) : []
+      @worker_env_var = worker_env_var
+    end
+
+    def argv
+      parts = [runner, spec_file, *filter_args]
+      @use_bundle_exec ? ['bundle', 'exec', *parts] : parts
+    end
+
+    def command
+      cmd = ([runner, spec_file] + example_filters.flat_map { |f| ['-e', "'#{f}'"] }).join(' ')
+      @use_bundle_exec ? "bundle exec #{cmd}" : cmd
+    end
+
+    def shell_command(timeout: nil, quiet: false)
+      cmd = command
+      cmd = "timeout #{timeout}s #{cmd}" if timeout
+      cmd = "#{cmd} > /dev/null 2>&1" if quiet
+      cmd
+    end
+
+    def run(timeout: nil, chdir: nil, capture: false)
+      if fork_execution?
+        fork_runner = ForkRunner.acquire(use_bundle_exec: @use_bundle_exec)
+        return fork_runner.execute(spec_file, timeout: timeout, chdir: chdir || Dir.pwd, capture: capture, args: filter_args) if fork_runner
+      end
+
+      return run_captured(timeout: timeout, chdir: chdir) if capture
+
+      spawn_options = { pgroup: true, %i[out err] => File::NULL }
+      spawn_options[:chdir] = chdir if chdir
+
+      pid = Process.spawn(*spawn_argv, spawn_options)
+      wait_with_deadline(pid, timeout)
+    end
+
+    def fork_execution?
+      return false if @framework == :minitest
+      return false if @runner == :spawn
+
+      ForkRunner.available?
+    end
+
+    def self.detect_framework(spec_file)
+      FrameworkDetector.detect(spec_file)
+    end
+
+    def self.use_bundle_exec?(path)
+      dir = File.dirname(File.expand_path(path))
+
+      loop do
+        return true if File.exist?(File.join(dir, 'Gemfile'))
+
+        parent = File.dirname(dir)
+        break if parent == dir
+
+        dir = parent
+      end
+
+      false
+    end
+
+    private
+
+    def spawn_argv
+      overrides = worker_env_overrides
+      overrides ? [overrides, *argv] : argv
+    end
+
+    def worker_env_overrides
+      return nil unless @worker_env_var
+
+      index = defined?(Parallel) && Parallel.respond_to?(:worker_number) ? Parallel.worker_number : nil
+      { @worker_env_var => Configuration.worker_env_value(index) }
+    end
+
+    def runner
+      @framework == :minitest ? 'ruby' : 'rspec'
+    end
+
+    def filter_args
+      example_filters.flat_map { |filter| ['-e', filter] }
+    end
+
+    def run_captured(timeout:, chdir:)
+      log = Tempfile.new(['mutation_tester_baseline', '.log'])
+      spawn_options = { pgroup: true, %i[out err] => log.path }
+      spawn_options[:chdir] = chdir if chdir
+
+      pid = Process.spawn(*spawn_argv, spawn_options)
+      result = wait_with_deadline(pid, timeout)
+      result.output = File.read(log.path)
+      result
+    ensure
+      log&.close
+      log&.unlink
+    end
+
+    def wait_with_deadline(pid, timeout)
+      unless timeout
+        _pid, status = Process.waitpid2(pid)
+        return Result.new(status.success?, false)
+      end
+
+      deadline = monotonic_time + timeout
+      loop do
+        _pid, status = Process.waitpid2(pid, Process::WNOHANG)
+        return Result.new(status.success?, false) if status
+
+        break if monotonic_time >= deadline
+
+        sleep(POLL_INTERVAL)
+      end
+
+      _pid, status = Process.waitpid2(pid, Process::WNOHANG)
+      return Result.new(status.success?, false) if status
+
+      terminate_process_group(pid)
+      Result.new(false, true)
+    ensure
+      terminate_process_group(pid) if pid && process_running?(pid)
+    end
+
+    def terminate_process_group(pid)
+      Process.kill('KILL', -pid)
+    rescue Errno::ESRCH
+    ensure
+      reap(pid)
+    end
+
+    def reap(pid)
+      Process.waitpid(pid)
+    rescue Errno::ECHILD, Errno::ESRCH
+    end
+
+    def process_running?(pid)
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/mutation_tester/version.rb

@@ -0,0 +1,3 @@
+module MutationTester
+  VERSION = '1.2.0'.freeze
+end

data/lib/mutation_tester.rb

@@ -0,0 +1,52 @@
+require 'parser/current'
+require 'unparser'
+require 'parallel'
+require 'rainbow'
+require 'fileutils'
+require 'erb'
+require 'json'
+
+require_relative 'mutation_tester/version'
+require_relative 'mutation_tester/configuration'
+require_relative 'mutation_tester/framework_detector'
+require_relative 'mutation_tester/in_memory_loader'
+require_relative 'mutation_tester/fork_runner'
+require_relative 'mutation_tester/test_command'
+require_relative 'mutation_tester/core'
+require_relative 'mutation_tester/batch_runner'
+require_relative 'mutation_tester/mutator'
+require_relative 'mutation_tester/mutation_runner'
+require_relative 'mutation_tester/reporters/base_reporter'
+require_relative 'mutation_tester/reporters/console_reporter'
+require_relative 'mutation_tester/reporters/html_reporter'
+require_relative 'mutation_tester/reporters/json_reporter'
+require_relative 'mutation_tester/reporters/batch_json_reporter'
+require_relative 'mutation_tester/progress_display'
+
+require_relative 'mutation_tester/railtie' if defined?(Rails::Railtie)
+
+module MutationTester
+  class Error < StandardError; end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    def run(source_file, spec_file, options = {})
+      config = configuration.merge(options)
+      core = Core.new(source_file, spec_file, config)
+      core.run
+    end
+  end
+end

data/lib/tasks/mutation_tester.rake

@@ -0,0 +1,80 @@
+task :environment unless Rake::Task.task_defined?(:environment)
+
+namespace :mutation do
+  desc 'Run mutation tests on a specific file'
+  task :test, %i[source_file spec_file] => :environment do |_t, args|
+    require 'mutation_tester'
+
+    unless args[:source_file] && args[:spec_file]
+      puts Rainbow('Usage: rake mutation:test[app/models/user.rb,spec/models/user_spec.rb]').yellow
+      abort
+    end
+
+    source_file = args[:source_file]
+    spec_file = args[:spec_file]
+
+    unless File.exist?(source_file)
+      puts Rainbow("❌ Source file not found: #{source_file}").red
+      abort
+    end
+
+    unless File.exist?(spec_file)
+      puts Rainbow("❌ Spec file not found: #{spec_file}").red
+      abort
+    end
+
+    abort unless MutationTester.run(source_file, spec_file)
+  end
+
+  desc 'Run mutation tests on all models'
+  task test_models: :environment do
+    require 'mutation_tester'
+
+    all_passed = true
+
+    Dir.glob('app/models/**/*.rb').each do |source_file|
+      spec_file = source_file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb')
+
+      next unless File.exist?(spec_file)
+
+      puts "\n" + Rainbow('=' * 80).bright
+      puts Rainbow("Testing: #{source_file}").cyan
+      puts Rainbow('=' * 80).bright
+
+      all_passed = false unless MutationTester.run(source_file, spec_file)
+    end
+
+    unless all_passed
+      puts Rainbow("\n❌ One or more files did not meet the mutation score threshold").red
+      abort
+    end
+  end
+end
+
+desc 'Run mutation tests (usage: rake "mutation_test[SOURCE_FILE,TEST_FILE]")'
+task :mutation_test, [:source_file, :spec_file] do |_t, args|
+  require 'mutation_tester'
+
+  unless args[:source_file] && args[:spec_file]
+    puts Rainbow('Usage: rake "mutation_test[SOURCE_FILE,TEST_FILE]"').yellow
+    puts Rainbow('Example: rake "mutation_test[app/models/user.rb,spec/models/user_spec.rb]"').cyan
+    abort
+  end
+
+  source_file = args[:source_file]
+  spec_file = args[:spec_file]
+
+  unless File.exist?(source_file)
+    puts Rainbow("❌ Source file not found: #{source_file}").red
+    puts Rainbow('💡 Tip: Make sure the path is correct and the file exists').yellow
+    abort
+  end
+
+  unless File.exist?(spec_file)
+    puts Rainbow("❌ Test file not found: #{spec_file}").red
+    puts Rainbow('💡 Tip: Make sure the path is correct and the file exists').yellow
+    abort
+  end
+
+  abort unless MutationTester.run(source_file, spec_file)
+end