mutant 0.8.24 → 0.9.0

data/spec/spec_helper.rb

@@ -16,10 +16,6 @@ if ENV['COVERAGE'] == 'true'
   end
 end
 
-# Require warning support first in order to catch any warnings emitted during boot
-require_relative './support/warning'
-$stderr = MutantSpec::Warning::EXTRACTOR
-
 require 'tempfile'
 require 'concord'
 require 'anima'
@@ -34,8 +30,12 @@ $LOAD_PATH << File.join(TestApp.root, 'lib')
 require 'test_app'
 
 module Fixtures
-  TEST_CONFIG = Mutant::Config::DEFAULT.with(reporter: Mutant::Reporter::Null.new)
-  TEST_ENV    = Mutant::Env::Bootstrap.(TEST_CONFIG)
+  TEST_CONFIG = Mutant::Config::DEFAULT
+    .with(reporter: Mutant::Reporter::Null.new)
+
+  TEST_ENV = Mutant::Bootstrap
+    .apply(Mutant::WORLD, TEST_CONFIG).from_right
+
 end # Fixtures
 
 module ParserHelper
@@ -48,24 +48,28 @@ module ParserHelper
   end
 
   def parse_expression(string)
-    Mutant::Config::DEFAULT.expression_parser.(string)
+    Mutant::Config::DEFAULT.expression_parser.apply(string).from_right
   end
 end # ParserHelper
 
-module MessageHelper
-  def message(*arguments)
-    Mutant::Actor::Message.new(*arguments)
+module XSpecHelper
+  def verify_events
+    expectations = raw_expectations
+      .map(&XSpec::MessageExpectation.method(:parse))
+
+    XSpec::ExpectationVerifier.verify(self, expectations) do
+      yield
+    end
   end
-end # MessageHelper
+
+  def undefined
+    double('undefined')
+  end
+end # XSpecHelper
 
 RSpec.configure do |config|
   config.extend(SharedContext)
-  config.include(MessageHelper)
   config.include(ParserHelper)
   config.include(Mutant::AST::Sexp)
-
-  config.after(:suite) do
-    $stderr = STDERR
-    MutantSpec::Warning.assert_no_warnings
-  end
+  config.include(XSpecHelper)
 end

data/spec/support/corpus.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'anima'
-require 'morpher'
 require 'mutant'
 require 'parallel'
 
@@ -30,11 +29,11 @@ module MutantSpec
       MUTATION_GENERATION_MESSAGE = 'Total Mutations/Time/Parse-Errors: %s/%0.2fs - %0.2f/s'
       START_MESSAGE               = 'Starting - %s'
       FINISH_MESSAGE              = 'Mutations - %4i - %s'
+      RUBY_GLOB_PATTERN           = '**/*.rb'
 
       DEFAULT_MUTATION_COUNT = 0
 
       include Adamantium, Anima.new(
-        :expected_errors,
         :mutation_coverage,
         :mutation_generation,
         :integration,
@@ -42,7 +41,6 @@ module MutantSpec
         :namespace,
         :repo_uri,
         :repo_ref,
-        :ruby_glob_pattern,
         :exclude
       )
 
@@ -64,12 +62,23 @@ module MutantSpec
                 --include lib
                 --require #{name}
                 #{namespace}*
-              ]
+              ] + concurrency_limits
             )
           end
         end
       end
 
+      # The concurrency limits, if any
+      #
+      # @return [Array<String>]
+      def concurrency_limits
+        if ENV.key?('MUTANT_JOBS')
+          %W[--jobs #{ENV.fetch('MUTANT_JOBS')}]
+        else
+          []
+        end
+      end
+
       # Verify mutation generation
       #
       # @return [self]
@@ -130,8 +139,6 @@ module MutantSpec
       #
       # @return [Integer] mutations generated
       def check_generation(path)
-        relative_path = path.relative_path_from(repo_path)
-
         node = Parser::CurrentRuby.parse(path.read)
         fail "Cannot parse: #{path}" unless node
 
@@ -141,13 +148,7 @@ module MutantSpec
           check_generation_invariants(node, mutation)
         end
 
-        expected_errors.assert_success(relative_path)
-
         mutations.length
-      rescue Exception => exception # rubocop:disable Lint/RescueException
-        expected_errors.assert_error(relative_path, exception)
-
-        DEFAULT_MUTATION_COUNT
       end
 
       # Check generation invariants
@@ -196,7 +197,7 @@ module MutantSpec
       # @return [Array<Pathname>]
       def effective_ruby_paths
         Pathname
-          .glob(repo_path.join(ruby_glob_pattern))
+          .glob(repo_path.join(RUBY_GLOB_PATTERN))
           .sort_by(&:size)
           .reverse
           .reject { |path| exclude.include?(path.relative_path_from(repo_path).to_s) }
@@ -269,89 +270,49 @@ module MutantSpec
         end
       end
 
-      # Mapping of files which we expect to cause errors during mutation generation
-      class ErrorWhitelist
-        class UnnecessaryExpectation < StandardError
-          MESSAGE = 'Expected to encounter %s while mutating "%s"'
-
-          def initialize(*error_info)
-            super(MESSAGE % error_info)
-          end
-        end # UnnecessaryExpectation
-
-        include Concord.new(:map), Adamantium
-
-        # Assert that we expect to encounter the provided exception for this path
-        #
-        # @param path [Pathname]
-        # @param exception [Exception]
-        #
-        # @raise provided exception if we are not expecting this error
-        #
-        # This method is reraising exceptions but rubocop can't tell
-        # rubocop:disable Style/SignalException
-        #
-        # @return [undefined]
-        def assert_error(path, exception)
-          original_error = exception.cause || exception
-
-          raise exception unless map.fetch(original_error.inspect, []).include?(path)
-        end
-
-        # Assert that we expect to not encounter an error for the specified path
-        #
-        # @param path [Pathname]
-        #
-        # @raise [UnnecessaryExpectation] if we are expecting an exception for this path
-        #
-        # @return [undefined]
-        def assert_success(path)
-          map.each do |error, paths|
-            fail UnnecessaryExpectation.new(error, path) if paths.include?(path)
-          end
-        end
-
-        # Return representation as hash
-        #
-        # @note this method is necessary for morpher loader to be invertible
-        #
-        # @return [Hash{Pathname => String}]
-        def to_h
-          map
-        end
-      end # ErrorWhitelist
-
-      LOADER = Morpher.build do
-        s(:block,
-          s(:guard, s(:primitive, Array)),
-          s(:map,
-            s(:block,
-              s(:guard, s(:primitive, Hash)),
-              s(:hash_transform,
-                s(:key_symbolize, :repo_uri,            s(:guard, s(:primitive, String))),
-                s(:key_symbolize, :repo_ref,            s(:guard, s(:primitive, String))),
-                s(:key_symbolize, :ruby_glob_pattern,   s(:guard, s(:primitive, String))),
-                s(:key_symbolize, :name,                s(:guard, s(:primitive, String))),
-                s(:key_symbolize, :namespace,           s(:guard, s(:primitive, String))),
-                s(:key_symbolize, :integration,         s(:guard, s(:primitive, String))),
-                s(:key_symbolize, :mutation_coverage,
-                  s(:guard, s(:or, s(:primitive, TrueClass), s(:primitive, FalseClass)))),
-                s(:key_symbolize, :mutation_generation,
-                  s(:guard, s(:or, s(:primitive, TrueClass), s(:primitive, FalseClass)))),
-                s(:key_symbolize, :expected_errors,
-                  s(:block,
-                    s(:guard, s(:primitive, Hash)),
-                    s(:custom,
-                      [
-                        ->(hash) { hash.map { |key, values| [key, values.map(&Pathname.method(:new))] }.to_h },
-                        ->(hash) { hash.map { |key, values| [key, values.map(&:to_s)]                 }.to_h }
-                      ]),
-                    s(:load_attribute_hash, s(:param, ErrorWhitelist)))),
-                s(:key_symbolize, :exclude, s(:map, s(:guard, s(:primitive, String))))),
-              s(:anima_load, Project))))
-      end
+      Transform = Mutant::Transform
+
+      boolean      = Transform::Boolean.new
+      string       = Transform::Primitive.new(String)
+      string_array = Transform::Array.new(string)
+
+      integration = Transform::Sequence.new(
+        [
+          Transform::Hash.new(
+            optional: [],
+            required: [
+              Transform::Hash::Key.new('exclude',             string_array),
+              Transform::Hash::Key.new('integration',         string),
+              Transform::Hash::Key.new('mutation_coverage',   boolean),
+              Transform::Hash::Key.new('mutation_generation', boolean),
+              Transform::Hash::Key.new('name',                string),
+              Transform::Hash::Key.new('namespace',           string),
+              Transform::Hash::Key.new('repo_ref',            string),
+              Transform::Hash::Key.new('repo_uri',            string)
+            ]
+          ),
+          Transform::Hash::Symbolize.new,
+          Transform::Exception.new(RuntimeError, Project.method(:new))
+        ]
+      )
 
-      ALL = LOADER.call(YAML.load_file(ROOT.join('spec', 'integrations.yml')))
+      transform =
+        Transform::Sequence.new(
+          [
+            Transform::Exception.new(SystemCallError, :read.to_proc),
+            Transform::Exception.new(YAML::SyntaxError, YAML.method(:safe_load)),
+            Transform::Array.new(integration)
+          ]
+        )
+
+      path = ROOT.join('spec', 'integrations.yml')
+
+      ALL = Transform::Named
+        .new(path, transform)
+        .apply(path)
+        .lmap(&:compact_message)
+        .lmap(&method(:fail))
+        .from_right
     end # Project
   end # Corpus
 end # MutantSpec

data/spec/support/shared_context.rb

@@ -17,14 +17,6 @@ module SharedContext
     prepend(new_definition)
   end
 
-  def messages(&block)
-    let(:message_sequence) do
-      FakeActor::MessageSequence.new.tap do |sequence|
-        sequence.instance_eval(&block)
-      end
-    end
-  end
-
   def it_reports(expected_content)
     it 'writes expected report to output' do
       described_class.call(output, reportable)
@@ -36,8 +28,6 @@ module SharedContext
   # rubocop:disable MethodLength
   # rubocop:disable AbcSize
   def setup_shared_context
-    let(:job_a)           { Mutant::Parallel::Job.new(index: 0, payload: mutation_a) }
-    let(:job_b)           { Mutant::Parallel::Job.new(index: 1, payload: mutation_b) }
     let(:mutation_a)      { Mutant::Mutation::Evil.new(subject_a, mutation_a_node)   }
     let(:mutation_a_node) { s(:false)                                                }
     let(:mutation_b)      { Mutant::Mutation::Evil.new(subject_a, mutation_b_node)   }
@@ -46,14 +36,47 @@ module SharedContext
     let(:output)          { StringIO.new                                             }
     let(:subject_a_node)  { s(:true)                                                 }
     let(:test_a)          { instance_double(Mutant::Test, identification: 'test-a')  }
+    let(:subjects)        { [subject_a]                                              }
+
+    let(:job_a) do
+      Mutant::Parallel::Source::Job.new(
+        index:   0,
+        payload: mutation_a
+      )
+    end
+
+    let(:job_b) do
+      Mutant::Parallel::Source::Job.new(
+        index:   1,
+        payload: mutation_b
+      )
+    end
 
     let(:env) do
       instance_double(
         Mutant::Env,
-        config:     config,
-        mutations:  mutations,
-        selections: { subject_a => [test_a] },
-        subjects:   [subject_a]
+        amount_mutations:      mutations.length,
+        amount_selected_tests: selections.values.flatten.to_set.length,
+        amount_subjects:       subjects.length,
+        amount_total_tests:    integration.all_tests.length,
+        config:                config,
+        integration:           integration,
+        mutations:             mutations,
+        selected_tests:        [test_a].to_set,
+        selections:            selections,
+        subjects:              subjects,
+        test_subject_ratio:    Rational(1)
+      )
+    end
+
+    let(:selections) do
+      { subject_a => [test_a] }
+    end
+
+    let(:integration) do
+      instance_double(
+        Mutant::Integration,
+        all_tests: [test_a]
       )
     end
 

data/spec/support/xspec.rb

@@ -5,7 +5,7 @@ module XSpec
     include Concord.new(:event_list)
 
     TERMINATE_EVENTS = IceNine.deep_freeze(%i[return exception].to_set)
-    VALID_EVENTS     = IceNine.deep_freeze(%i[return exception yields].to_set)
+    VALID_EVENTS     = IceNine.deep_freeze(%i[return execute exception yields].to_set)
 
     private_constant(*constants(false))
 
@@ -32,6 +32,10 @@ module XSpec
       value
     end
 
+    def execute(_event, block)
+      block.call
+    end
+
     def exception(_event, exception)
       fail exception
     end
@@ -140,12 +144,12 @@ module XSpec
     include Concord.new(:expectations)
 
     def call(observation)
-      expectation = expectations.shift or fail "No expected message but observed #{observation}"
+      expectation = expectations.shift or fail "No expected message but observed #{observation.inspect}"
       expectation.call(observation)
     end
 
     def assert_done
-      expectations.empty? or fail "unconsumed expectations:\n#{expectations.map(&:inspect).join}"
+      expectations.empty? or fail "unconsumed expectations:\n#{expectations.map(&:inspect).join("\n")}"
     end
 
     # rubocop:disable MethodLength

data/spec/unit/mutant/bootstrap_spec.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Bootstrap do
+  let(:integration)          { instance_double(Mutant::Integration)   }
+  let(:integration_name)     { instance_double(String)                }
+  let(:integration_result)   { Mutant::Either::Right.new(integration) }
+  let(:kernel)               { instance_double(Object, 'kernel')      }
+  let(:load_path)            { %w[original]                           }
+  let(:matcher_config)       { Mutant::Matcher::Config::DEFAULT       }
+  let(:object_space)         { class_double(ObjectSpace)              }
+  let(:object_space_modules) { []                                     }
+  let(:warnings)             { instance_double(Mutant::Warnings)      }
+
+  let(:world) do
+    instance_double(
+      Mutant::World,
+      kernel:       kernel,
+      load_path:    load_path,
+      object_space: object_space,
+      pathname:     Pathname,
+      warnings:     warnings
+    )
+  end
+
+  let(:config) do
+    Mutant::Config::DEFAULT.with(
+      includes:    [],
+      integration: integration,
+      jobs:        1,
+      matcher:     matcher_config,
+      reporter:    instance_double(Mutant::Reporter),
+      requires:    []
+    )
+  end
+
+  let(:expected_env) do
+    env_with_scopes.with(
+      integration: integration,
+      selector:    Mutant::Selector::Expression.new(integration)
+    )
+  end
+
+  let(:env_empty) do
+    Mutant::Env.empty(world, config)
+  end
+
+  let(:env_with_scopes) { env_empty }
+
+  shared_examples 'expected warning' do
+    let(:warns) { [] }
+
+    before do
+      allow(config.reporter).to receive(:warn, &warns.method(:<<))
+    end
+
+    it 'warns with expected warning' do
+      expect { apply }.to change(warns, :to_a).from([]).to([expected_warning])
+    end
+  end
+
+  shared_examples_for 'bootstrap call' do
+    it 'returns expected env' do
+      expect(apply).to eql(Mutant::Either::Right.new(expected_env))
+    end
+
+    it 'performs IO in expected sequence' do
+      apply
+
+      expect(object_space)
+        .to have_received(:each_object)
+        .ordered
+
+      expect(Mutant::Integration)
+        .to have_received(:setup)
+        .with(env_with_scopes)
+        .ordered
+    end
+  end
+
+  before do
+    allow(Mutant::Integration).to receive_messages(setup: integration_result)
+
+    allow(object_space).to receive(:each_object) do |argument|
+      expect(argument).to be(Module)
+      object_space_modules.each
+    end
+  end
+
+  describe '.apply' do
+    def apply
+      described_class.apply(world, config)
+    end
+
+    context 'when Module#name calls result in exceptions' do
+      let(:object_space_modules) { [invalid_class] }
+
+      let(:expected_warning) do
+        "Object#name from: #{invalid_class} raised an error: " \
+        "RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
+      end
+
+      # Not really a class, but does not leak a "wrong" class
+      # into later specs.
+      let(:invalid_class) do
+        Object.new.tap do |object|
+          def object.name
+            fail
+          end
+        end
+      end
+
+      include_examples 'expected warning'
+      include_examples 'bootstrap call'
+    end
+
+    context 'when Module#name calls return nil' do
+      let(:anonymous_class)      { Class.new         }
+      let(:object_space_modules) { [anonymous_class] }
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when requires are configured' do
+      let(:config)   { super().with(requires: %w[foo bar]) }
+      let(:requires) { []                                  }
+
+      before do
+        allow(kernel).to receive(:require, &requires.method(:<<))
+      end
+
+      it 'executes requires' do
+        expect { apply }.to change(requires, :to_a).from([]).to(%w[foo bar])
+      end
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when includes are configured' do
+      let(:config) { super().with(includes: %w[foo bar]) }
+
+      it 'appends to load path' do
+        expect { apply }
+          .to change(load_path, :to_a)
+          .from(load_path.dup)
+          .to(%w[original foo bar])
+      end
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when Module#name does not return a String or nil' do
+      let(:object_space_modules) { [invalid_class] }
+
+      let(:invalid_class) do
+        # intentionally an object to not actually pollute object space
+        Object.new.tap do |object|
+          def object.name
+            Object
+          end
+        end
+      end
+
+      let(:expected_warning) do
+        "Object#name from: #{invalid_class} " \
+        "returned Object. #{Mutant::Env::SEMANTICS_MESSAGE}"
+      end
+
+      include_examples 'expected warning'
+      include_examples 'bootstrap call'
+    end
+
+    context 'when object name cannot be parsed as expression' do
+      let(:object_space_modules) { [invalid_class] }
+
+      let(:invalid_class) do
+        # intentionally an object to not actually pollute object space
+        Object.new.tap do |object|
+          def object.name
+            'invalid expression'
+          end
+        end
+      end
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when scope matches expression' do
+      let(:object_space_modules) { [TestApp::Literal, TestApp::Empty]                               }
+      let(:match_expressions)    { object_space_modules.map(&:name).map(&method(:parse_expression)) }
+
+      let(:matcher_config) do
+        super().with(match_expressions: match_expressions)
+      end
+
+      let(:env_with_scopes) do
+        env_empty.with(
+          matchable_scopes: [
+            Mutant::Scope.new(TestApp::Empty,   match_expressions.last),
+            Mutant::Scope.new(TestApp::Literal, match_expressions.first)
+          ]
+        )
+      end
+
+      let(:expected_env) do
+        subjects = Mutant::Matcher::Scope.new(TestApp::Literal).call(env_empty)
+
+        super().with(
+          mutations: subjects.flat_map(&:mutations),
+          subjects:  subjects
+        )
+      end
+
+      include_examples 'bootstrap call'
+    end
+  end
+end