mutant 0.8.22 → 0.8.23

data/lib/mutant/reporter/cli/printer/mutation_result.rb

@@ -9,7 +9,7 @@ module Mutant
         # :reek:TooManyConstants
         class MutationResult < self
 
-          delegate :mutation, :test_result
+          delegate :mutation, :isolation_result
 
           MAP = {
             Mutant::Mutation::Evil    => :evil_details,
@@ -25,7 +25,6 @@ module Mutant
             %s
             Unparsed Source:
             %s
-            Test Result:
           MESSAGE
 
           NO_DIFF_MESSAGE = <<~'MESSAGE'
@@ -47,7 +46,6 @@ module Mutant
             ---- Noop failure -----
             No code was inserted. And the test did NOT PASS.
             This is typically a problem of your specs not passing unmutated.
-            Test Result:
           MESSAGE
 
           FOOTER = '-----------------------'
@@ -68,6 +66,8 @@ module Mutant
           # @return [undefined]
           def print_details
             __send__(MAP.fetch(mutation.class))
+
+            visit_isolation_result unless isolation_result.success?
           end
 
           # Evil mutation details
@@ -101,7 +101,6 @@ module Mutant
           # @return [String]
           def noop_details
             info(NOOP_MESSAGE)
-            visit_test_result
           end
 
           # Neutral details
@@ -109,14 +108,13 @@ module Mutant
           # @return [String]
           def neutral_details
             info(NEUTRAL_MESSAGE, original_node.inspect, mutation.source)
-            visit_test_result
           end
 
           # Visit failed test results
           #
           # @return [undefined]
-          def visit_test_result
-            visit(TestResult, test_result)
+          def visit_isolation_result
+            visit(IsolationResult, isolation_result)
           end
 
           # Original node

data/lib/mutant/result.rb

@@ -108,6 +108,14 @@ module Mutant
         env.subjects.length
       end
 
+      # Test if processing needs to stop
+      #
+      # @return [Boolean]
+      #
+      def stop?
+        env.config.fail_fast && !subject_results.all?(&:success?)
+      end
+
     end # Env
 
     # Test result
@@ -189,30 +197,30 @@ module Mutant
     # Mutation result
     class Mutation
       include Result, Anima.new(
+        :isolation_result,
         :mutation,
-        :test_result
+        :runtime
       )
 
-      # The runtime
+      # Time the tests had been running
       #
       # @return [Float]
-      def runtime
-        test_result.runtime
+      def killtime
+        if isolation_result.success?
+          isolation_result.value.runtime
+        else
+          0.0
+        end
       end
 
-      # The time spent on killing
-      #
-      # @return [Float]
-      #
-      # @api private
-      alias_method :killtime, :runtime
-
       # Test if mutation was handled successfully
       #
       # @return [Boolean]
       def success?
-        mutation.class.success?(test_result)
+        isolation_result.success? &&
+          mutation.class.success?(isolation_result.value)
       end
+      memoize :success?
 
     end # Mutation
   end # Result

data/lib/mutant/runner/sink.rb

@@ -29,7 +29,7 @@ module Mutant
       #
       # @return [Boolean]
       def stop?
-        env.config.fail_fast && !status.subject_results.all?(&:success?)
+        status.stop?
       end
 
       # Handle mutation finish
@@ -43,7 +43,7 @@ module Mutant
         @subject_results[subject] = Result::Subject.new(
           subject:          subject,
           mutation_results: previous_mutation_results(subject) + [mutation_result],
-          tests:            mutation_result.test_result.tests
+          tests:            env.selections.fetch(subject)
         )
 
         self

data/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # Current mutant version
-  VERSION = '0.8.22'.freeze
+  VERSION = '0.8.23'.freeze
 end # Mutant

data/spec/support/shared_context.rb

@@ -36,17 +36,26 @@ module SharedContext
   # rubocop:disable MethodLength
   # rubocop:disable AbcSize
   def setup_shared_context
-    let(:env)              { instance_double(Mutant::Env, config: config, subjects: [subject_a], mutations: mutations) }
-    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(:test_a)           { instance_double(Mutant::Test, identification: 'test-a')                                   }
-    let(:output)           { StringIO.new                                                                              }
-    let(:mutations)        { [mutation_a, mutation_b]                                                                  }
-    let(:mutation_a_node)  { s(:false)                                                                                 }
-    let(:mutation_b_node)  { s(:nil)                                                                                   }
-    let(:mutation_b)       { Mutant::Mutation::Evil.new(subject_a, mutation_b_node)                                    }
-    let(:mutation_a)       { Mutant::Mutation::Evil.new(subject_a, mutation_a_node)                                    }
-    let(:subject_a_node)   { s(:true)                                                                                  }
+    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)   }
+    let(:mutation_b_node) { s(:nil)                                                  }
+    let(:mutations)       { [mutation_a, mutation_b]                                 }
+    let(:output)          { StringIO.new                                             }
+    let(:subject_a_node)  { s(:true)                                                 }
+    let(:test_a)          { instance_double(Mutant::Test, identification: 'test-a')  }
+
+    let(:env) do
+      instance_double(
+        Mutant::Env,
+        config:     config,
+        mutations:  mutations,
+        selections: { subject_a => [test_a] },
+        subjects:   [subject_a]
+      )
+    end
 
     let(:status) do
       Mutant::Parallel::Status.new(
@@ -86,18 +95,24 @@ module SharedContext
 
     let(:mutation_a_result) do
       Mutant::Result::Mutation.new(
-        mutation:    mutation_a,
-        test_result: mutation_a_test_result
+        mutation:         mutation_a,
+        isolation_result: mutation_a_isolation_result,
+        runtime:          1.0
       )
     end
 
     let(:mutation_b_result) do
       Mutant::Result::Mutation.new(
-        mutation:    mutation_a,
-        test_result: mutation_b_test_result
+        isolation_result: mutation_b_isolation_result,
+        mutation:         mutation_b,
+        runtime:          1.0
       )
     end
 
+    let(:mutation_a_isolation_result) do
+      Mutant::Isolation::Result::Success.new(mutation_a_test_result)
+    end
+
     let(:mutation_a_test_result) do
       Mutant::Result::Test.new(
         tests:   [test_a],
@@ -116,6 +131,10 @@ module SharedContext
       )
     end
 
+    let(:mutation_b_isolation_result) do
+      Mutant::Isolation::Result::Success.new(mutation_b_test_result)
+    end
+
     let(:subject_a_result) do
       Mutant::Result::Subject.new(
         subject:          subject_a,

data/spec/unit/mutant/env_spec.rb

@@ -1,73 +1,70 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Env do
-  context '#kill' do
-    let(:object) do
-      described_class.new(
-        actor_env:        Mutant::Actor::Env.new(Thread),
-        config:           config,
-        integration:      integration,
-        matchable_scopes: [],
-        mutations:        [],
-        selector:         selector,
-        subjects:         [],
-        parser:           Mutant::Parser.new
-      )
-    end
+  let(:object) do
+    described_class.new(
+      actor_env:        Mutant::Actor::Env.new(Thread),
+      config:           config,
+      integration:      integration,
+      matchable_scopes: [],
+      mutations:        [],
+      selector:         selector,
+      subjects:         [mutation_subject],
+      parser:           Mutant::Parser.new
+    )
+  end
 
-    let(:integration)       { instance_double(Mutant::Integration)     }
-    let(:test_a)            { instance_double(Mutant::Test)            }
-    let(:test_b)            { instance_double(Mutant::Test)            }
-    let(:tests)             { [test_a, test_b]                         }
-    let(:selector)          { instance_double(Mutant::Selector)        }
-    let(:integration_class) { Mutant::Integration::Null                }
-    let(:isolation)         { instance_double(Mutant::Isolation::Fork) }
-    let(:mutation_subject)  { instance_double(Mutant::Subject)         }
-
-    let(:mutation) do
-      instance_double(
-        Mutant::Mutation,
-        subject: mutation_subject
-      )
-    end
+  let(:integration)       { instance_double(Mutant::Integration) }
+  let(:test_a)            { instance_double(Mutant::Test)        }
+  let(:test_b)            { instance_double(Mutant::Test)        }
+  let(:tests)             { [test_a, test_b]                     }
+  let(:selector)          { instance_double(Mutant::Selector)    }
+  let(:integration_class) { Mutant::Integration::Null            }
+  let(:isolation)         { Mutant::Isolation::None.new          }
+  let(:mutation_subject)  { instance_double(Mutant::Subject)     }
+
+  let(:mutation) do
+    instance_double(
+      Mutant::Mutation,
+      subject: mutation_subject
+    )
+  end
 
-    let(:config) do
-      Mutant::Config::DEFAULT.with(
-        isolation:   isolation,
-        integration: integration_class,
-        kernel:      class_double(Kernel)
-      )
-    end
+  let(:config) do
+    Mutant::Config::DEFAULT.with(
+      isolation:   isolation,
+      integration: integration_class,
+      kernel:      class_double(Kernel)
+    )
+  end
 
+  before do
+    allow(selector).to receive(:call)
+      .with(mutation_subject)
+      .and_return(tests)
+
+    allow(Mutant::Timer).to receive(:now).and_return(2.0, 3.0)
+  end
+
+  describe '#kill' do
     subject { object.kill(mutation) }
 
     shared_examples_for 'mutation kill' do
       specify do
         should eql(
           Mutant::Result::Mutation.new(
-            mutation:    mutation,
-            test_result: test_result
+            isolation_result: isolation_result,
+            mutation:         mutation,
+            runtime:          1.0
           )
         )
       end
     end
 
-    before do
-      expect(selector).to receive(:call)
-        .with(mutation_subject)
-        .and_return(tests)
-
-      allow(Mutant::Timer).to receive(:now).and_return(2.0, 3.0)
-    end
-
     context 'when isolation does not raise error' do
       let(:test_result) { instance_double(Mutant::Result::Test) }
 
       before do
-        expect(isolation).to receive(:call)
-          .ordered
-          .and_yield
-
         expect(mutation).to receive(:insert)
           .ordered
           .with(config.kernel)
@@ -78,25 +75,33 @@ RSpec.describe Mutant::Env do
           .and_return(test_result)
       end
 
+      let(:isolation_result) do
+        Mutant::Isolation::Result::Success.new(test_result)
+      end
+
       include_examples 'mutation kill'
     end
 
-    context 'when isolation does raise error' do
+    context 'when code does raise error' do
+      let(:exception) { RuntimeError.new('foo') }
+
       before do
-        expect(isolation).to receive(:call)
-          .and_raise(Mutant::Isolation::Error, 'test-error')
+        expect(mutation).to receive(:insert).and_raise(exception)
       end
 
-      let(:test_result) do
-        Mutant::Result::Test.new(
-          output:  'test-error',
-          passed:  false,
-          runtime: 1.0,
-          tests:   tests
-        )
+      let(:isolation_result) do
+        Mutant::Isolation::Result::Exception.new(exception)
       end
 
       include_examples 'mutation kill'
     end
   end
+
+  describe '#selections' do
+    subject { object.selections }
+
+    it 'returns expected selections' do
+      expect(subject).to eql(mutation_subject => tests)
+    end
+  end
 end

data/spec/unit/mutant/isolation/fork_spec.rb

@@ -23,6 +23,95 @@ RSpec.describe Mutant::Isolation::Fork do
   let(:writer)            { instance_double(IO, :writer)                }
   let(:nullio)            { instance_double(IO, :nullio)                }
 
+  let(:status_success) do
+    instance_double(Process::Status, success?: true)
+  end
+
+  let(:fork_success) do
+    {
+      receiver: process,
+      selector: :fork,
+      reaction: {
+        yields: [],
+        return: pid
+      }
+    }
+  end
+
+  let(:child_wait) do
+    {
+      receiver:  process,
+      selector:  :wait2,
+      arguments: [pid],
+      reaction:  {
+        return: [pid, status_success]
+      }
+    }
+  end
+
+  let(:writer_close) do
+    {
+      receiver: writer,
+      selector: :close
+    }
+  end
+
+  let(:load_success) do
+    {
+      receiver:  marshal,
+      selector:  :load,
+      arguments: [reader],
+      reaction:  {
+        return: block_return
+      }
+    }
+  end
+
+  let(:killfork) do
+    [
+      # Inside the killfork
+      {
+        receiver: reader,
+        selector: :close
+      },
+      {
+        receiver: writer,
+        selector: :binmode
+      },
+      {
+        receiver: devnull,
+        selector: :call,
+        reaction: {
+          yields: [nullio]
+        }
+      },
+      {
+        receiver:  stderr,
+        selector:  :reopen,
+        arguments: [nullio]
+      },
+      {
+        receiver:  stdout,
+        selector:  :reopen,
+        arguments: [nullio]
+      },
+      {
+        receiver:  marshal,
+        selector:  :dump,
+        arguments: [block_return],
+        reaction:  {
+          return: block_return_blob
+        }
+      },
+      {
+        receiver:  writer,
+        selector:  :syswrite,
+        arguments: [block_return_blob]
+      },
+      writer_close
+    ]
+  end
+
   describe '#call' do
     let(:object) do
       described_class.new(
@@ -51,6 +140,57 @@ RSpec.describe Mutant::Isolation::Fork do
     end
 
     context 'when no IO operation fails' do
+      let(:expectations) do
+        [
+          *prefork_expectations,
+          fork_success,
+          *killfork,
+          writer_close,
+          load_success,
+          child_wait
+        ].map(&XSpec::MessageExpectation.method(:parse))
+      end
+
+      specify do
+        XSpec::ExpectationVerifier.verify(self, expectations) do
+          expect(subject).to eql(Mutant::Isolation::Result::Success.new(block_return))
+        end
+      end
+    end
+
+    context 'when expected exception was raised when reading from child' do
+      [ArgumentError, EOFError].each do |exception_class|
+        context "on #{exception_class}" do
+          let(:exception) { exception_class.new }
+
+          let(:expectations) do
+            [
+              *prefork_expectations,
+              fork_success,
+              *killfork,
+              {
+                receiver: writer,
+                selector: :close,
+                reaction: {
+                  exception: exception
+                }
+              },
+              child_wait
+            ].map(&XSpec::MessageExpectation.method(:parse))
+          end
+
+          specify do
+            XSpec::ExpectationVerifier.verify(self, expectations) do
+              expect(subject).to eql(Mutant::Isolation::Result::Exception.new(exception))
+            end
+          end
+        end
+      end
+    end
+
+    context 'when fork fails' do
+      let(:result_class) { described_class::ForkError }
+
       let(:expectations) do
         [
           *prefork_expectations,
@@ -58,90 +198,44 @@ RSpec.describe Mutant::Isolation::Fork do
             receiver: process,
             selector: :fork,
             reaction: {
-              yields: [],
-              return: pid
-            }
-          },
-          # Inside the killfork
-          {
-            receiver: reader,
-            selector: :close
-          },
-          {
-            receiver: writer,
-            selector: :binmode
-          },
-          {
-            receiver: devnull,
-            selector: :call,
-            reaction: {
-              yields: [nullio]
+              return: nil
             }
-          },
-          {
-            receiver:  stderr,
-            selector:  :reopen,
-            arguments: [nullio]
-          },
-          {
-            receiver:  stdout,
-            selector:  :reopen,
-            arguments: [nullio]
-          },
-          {
-            receiver:  marshal,
-            selector:  :dump,
-            arguments: [block_return],
-            reaction:  {
-              return: block_return_blob
-            }
-          },
-          {
-            receiver:  writer,
-            selector:  :syswrite,
-            arguments: [block_return_blob]
-          },
-          {
-            receiver: writer,
-            selector: :close
-          },
-          # Outside the killfork
-          {
-            receiver: writer,
-            selector: :close
-          },
-          {
-            receiver:  marshal,
-            selector:  :load,
-            arguments: [reader],
-            reaction:  {
-              return: block_return
-            }
-          },
-          {
-            receiver:  process,
-            selector:  :waitpid,
-            arguments: [pid]
           }
         ].map(&XSpec::MessageExpectation.method(:parse))
       end
 
       specify do
         XSpec::ExpectationVerifier.verify(self, expectations) do
-          expect(subject).to be(block_return)
+          expect(subject).to eql(result_class.new)
         end
       end
     end
 
-    context 'when fork fails' do
+    context 'when child exits nonzero' do
+      let(:status_error) do
+        instance_double(Process::Status, success?: false)
+      end
+
+      let(:expected_result) do
+        Mutant::Isolation::Result::ErrorChain.new(
+          described_class::ChildError.new(status_error),
+          Mutant::Isolation::Result::Success.new(block_return)
+        )
+      end
+
       let(:expectations) do
         [
           *prefork_expectations,
+          fork_success,
+          *killfork,
+          writer_close,
+          load_success,
           {
-            receiver: process,
-            selector: :fork,
-            reaction: {
-              exception: RuntimeError.new('fork(2)')
+            receiver:  process,
+            selector:  :wait2,
+            arguments: [pid],
+            reaction:  {
+              return: [pid, status_error]
             }
           }
         ].map(&XSpec::MessageExpectation.method(:parse))
@@ -149,7 +243,7 @@ RSpec.describe Mutant::Isolation::Fork do
 
       specify do
         XSpec::ExpectationVerifier.verify(self, expectations) do
-          expect { expect(subject) }.to raise_error(described_class::Error, 'fork(2)')
+          expect(subject).to eql(expected_result)
         end
       end
     end