mutant 0.8.22 → 0.8.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 544623c000b4f06105f72af9d4c33fcf08191ca2e25c330b96ddb876ec70adaa
-  data.tar.gz: a2841e24767a138d0abc848528b5cf8fbf9c48b336b2aaf7854d3de72faa0aa1
+  metadata.gz: da1d34448bf320507db377b41c46f591022e69e02597f4097a9a8ff52cf7b7a8
+  data.tar.gz: fd4a4c3d03d89ec53e5e7a040c0f3e4854d58d2bd1347404f06cae2541db742c
 SHA512:
-  metadata.gz: 476f0f3ba2af5bb6d900d196838935835c03f03bf13dc46c272fb71991496b4b97a98a648d7a55e327b040a1dfde1af0ddb6c2ff0e28cd315e56e4dc7e511d88
-  data.tar.gz: 01ea1d5759f695df5d1fc52119d24d779d7ce686e04ad8f98d7618f435f77472bcd2b5482141a420238347826e8c7e29707ede272b7534a1b0ccd261833333f7
+  metadata.gz: e64e8ed9f28ee391b704aa37d18c4ec204ad3c73af56e3fed7d4430399bea663a599a0561d8e567b7d4fa9416b53ba810a5df95529c47345dfe18781a2367be0
+  data.tar.gz: be1ec3a98dfbf5b55dbc8543cf61a0dcf6a187232d0fd3d640ddc31533aaa1ed658a433f36bdc1158eb81df4774da13df737a8c59dd4e331369045957da7d226

data/Changelog.md

@@ -1,3 +1,8 @@
+# v0.8.23 2018-12-23
+
+* Improved isolation error reporting
+* Errors between isolation and tests do not kill mutations anymore.
+
 # v0.8.22 2018-12-04
 
 * Remove hard ruby version requirement. 2.5 is still the only officially supported version.

data/lib/mutant.rb

@@ -195,14 +195,15 @@ require 'mutant/reporter/sequence'
 require 'mutant/reporter/cli'
 require 'mutant/reporter/cli/printer'
 require 'mutant/reporter/cli/printer/config'
-require 'mutant/reporter/cli/printer/env_result'
 require 'mutant/reporter/cli/printer/env_progress'
-require 'mutant/reporter/cli/printer/mutation_result'
+require 'mutant/reporter/cli/printer/env_result'
+require 'mutant/reporter/cli/printer/isolation_result'
 require 'mutant/reporter/cli/printer/mutation_progress_result'
-require 'mutant/reporter/cli/printer/subject_progress'
-require 'mutant/reporter/cli/printer/subject_result'
+require 'mutant/reporter/cli/printer/mutation_result'
 require 'mutant/reporter/cli/printer/status'
 require 'mutant/reporter/cli/printer/status_progressive'
+require 'mutant/reporter/cli/printer/subject_progress'
+require 'mutant/reporter/cli/printer/subject_result'
 require 'mutant/reporter/cli/printer/test_result'
 require 'mutant/reporter/cli/tput'
 require 'mutant/reporter/cli/format'

data/lib/mutant/env.rb

@@ -24,13 +24,25 @@ module Mutant
     #
     # @return [Result::Mutation]
     def kill(mutation)
-      test_result = run_mutation_tests(mutation)
+      start = Timer.now
+
       Result::Mutation.new(
-        mutation:    mutation,
-        test_result: test_result
+        isolation_result: run_mutation_tests(mutation),
+        mutation:         mutation,
+        runtime:          Timer.now - start
       )
     end
 
+    # The test selections
+    #
+    # @return Hash{Mutation => Enumerable<Test>}
+    def selections
+      subjects.map do |subject|
+        [subject, selector.call(subject)]
+      end.to_h
+    end
+    memoize :selections
+
   private
 
     # Kill mutation under isolation with integration
@@ -38,24 +50,12 @@ module Mutant
     # @param [Isolation] isolation
     # @param [Integration] integration
     #
-    # @return [Result::Test]
-    #
-    # rubocop:disable MethodLength
+    # @return [Result::Isolation]
     def run_mutation_tests(mutation)
-      start = Timer.now
-      tests = selector.call(mutation.subject)
-
       config.isolation.call do
         mutation.insert(config.kernel)
-        integration.call(tests)
+        integration.call(selections.fetch(mutation.subject))
       end
-    rescue Isolation::Error => error
-      Result::Test.new(
-        output:  error.message,
-        passed:  false,
-        runtime: Timer.now - start,
-        tests:   tests
-      )
     end
 
   end # Env

data/lib/mutant/isolation.rb

@@ -1,12 +1,53 @@
 # frozen_string_literal: true
 
 module Mutant
+  # Isolation mechanism
   class Isolation
     include AbstractType
 
+    # Isolated computation result
+    class Result
+      include AbstractType, Adamantium
+
+      abstract_method :error
+      abstract_method :next
+      abstract_method :value
+
+      # Add error on top of current result
+      #
+      # @param [Result] error
+      #
+      # @return [Result]
+      def add_error(error)
+        ErrorChain.new(error, self)
+      end
+
+      # Test for success
+      #
+      # @return [Boolean]
+      def success?
+        instance_of?(Success)
+      end
+
+      # Succesful result producing value
+      class Success < self
+        include Concord::Public.new(:value)
+      end # Success
+
+      # Unsuccessful result by unexpected exception
+      class Exception < self
+        include Concord::Public.new(:value)
+      end # Error
+
+      # Result when there where many results
+      class ErrorChain < Result
+        include Concord::Public.new(:value, :next)
+      end # ChainError
+    end # Result
+
     # Call block in isolation
     #
-    # @return [Object]
+    # @return [Result]
     #   the blocks result
     abstract_method :call
   end # Isolation

data/lib/mutant/isolation/fork.rb

@@ -3,72 +3,136 @@
 module Mutant
   class Isolation
     # Isolation via the fork(2) systemcall.
-    #
-    # We do inject so many globals and common patterns to make this unit
-    # specifiable without mocking the globals and more important: Not having
-    # mutations that bypass mocks into a real world side effect.
     class Fork < self
-      include Anima.new(:process, :stderr, :stdout, :io, :devnull, :marshal)
+      include(
+        Adamantium::Flat,
+        Anima.new(:devnull, :io, :marshal, :process, :stderr, :stdout)
+      )
 
-      # Prevent mutation from `process.fork` to `fork` to call Kernel#fork
-      undef_method :fork
+      ATTRIBUTES = (anima.attribute_names + %i[block reader writer]).freeze
 
-      # Call block in isolation
-      #
-      # @return [Object]
-      #   returns block execution result
-      #
-      # @raise [Error]
-      #   if block terminates abnormal
-      def call(&block)
-        io.pipe(binmode: true) do |pipes|
-          parent(*pipes, &block)
+      # Unsucessful result as child exited nonzero
+      class ChildError < Result
+        include Concord::Public.new(:value)
+      end # ChildError
+
+      # Unsucessful result as fork failed
+      class ForkError < Result
+        include Equalizer.new
+      end # ForkError
+
+      # ignore :reek:InstanceVariableAssumption
+      class Parent
+        include(
+          Anima.new(*ATTRIBUTES),
+          Procto.call
+        )
+
+        # Prevent mutation from `process.fork` to `fork` to call Kernel#fork
+        undef_method :fork
+
+        # Parent process
+        #
+        # @param [IO] reader
+        # @param [IO] writer
+        #
+        # @return [Result]
+        def call
+          pid = start_child or return ForkError.new
+
+          read_child_result(pid)
+
+          @result
         end
-      rescue => exception
-        raise Error, exception
-      end
 
-      # Handle parent process
-      #
-      # @param [IO] reader
-      # @param [IO] writer
-      #
-      # @return [undefined]
-      def parent(reader, writer, &block)
-        pid = process.fork do
-          child(reader, writer, &block)
+      private
+
+        # Start child process
+        #
+        # @return [Integer]
+        def start_child
+          process.fork { Child.call(to_h) }
         end
 
-        writer.close
-        marshal.load(reader)
-      ensure
-        process.waitpid(pid) if pid
-      end
+        # Read child result
+        #
+        # @param [Integer] pid
+        #
+        # @return [undefined]
+        def read_child_result(pid)
+          writer.close
 
-      # Handle child process
-      #
-      # @param [IO] reader
-      # @param [IO] writer
-      #
-      # @return [undefined]
-      def child(reader, writer, &block)
-        reader.close
-        writer.binmode
-        writer.syswrite(marshal.dump(result(&block)))
-        writer.close
-      end
+          add_result(Result::Success.new(marshal.load(reader)))
+        rescue ArgumentError, EOFError => exception
+          add_result(Result::Exception.new(exception))
+        ensure
+          wait_child(pid)
+        end
+
+        # Wait for child process
+        #
+        # @param [Integer] pid
+        #
+        # @return [undefined]
+        def wait_child(pid)
+          _pid, status = process.wait2(pid)
+
+          add_result(ChildError.new(status)) unless status.success?
+        end
 
-      # The block result computed under silencing
+        # Add a result
+        #
+        # @param [Result]
+        def add_result(result)
+          @result = defined?(@result) ? @result.add_error(result) : result
+        end
+      end # Parent
+
+      class Child
+        include(
+          Adamantium::Flat,
+          Anima.new(*ATTRIBUTES),
+          Procto.call
+        )
+
+        # Handle child process
+        #
+        # @param [IO] reader
+        # @param [IO] writer
+        #
+        # @return [undefined]
+        def call
+          reader.close
+          writer.binmode
+          writer.syswrite(marshal.dump(result(&block)))
+          writer.close
+        end
+
+      private
+
+        # The block result computed under silencing
+        #
+        # @return [Object]
+        def result
+          devnull.call do |null|
+            stderr.reopen(null)
+            stdout.reopen(null)
+            yield
+          end
+        end
+      end # Child
+
+      private_constant(*(constants(false) - %i[ChildError ForkError]))
+
+      # Call block in isolation
       #
-      # @return [Object]
-      def result
-        devnull.call do |null|
-          stderr.reopen(null)
-          stdout.reopen(null)
-          yield
+      # @return [Result]
+      #   execution result
+      def call(&block)
+        io.pipe(binmode: true) do |(reader, writer)|
+          Parent.call(to_h.merge(block: block, reader: reader, writer: writer))
         end
       end
-
     end # Fork
   end # Isolation
 end # Mutant

data/lib/mutant/isolation/none.rb

@@ -3,8 +3,6 @@
 module Mutant
   # Module providing isolation
   class Isolation
-    Error = Class.new(RuntimeError)
-
     # Absolutly no isolation
     #
     # Only useful for debugging.
@@ -12,14 +10,13 @@ module Mutant
 
       # Call block in no isolation
       #
-      # @return [Object]
+      # @return [Result]
       #
-      # @raise [Error]
-      #   if block terminates abnormal
+      # ignore :reek:UtilityFunction
       def call
-        yield
+        Result::Success.new(yield)
       rescue => exception
-        raise Error, exception
+        Result::Exception.new(exception)
       end
 
     end # None

data/lib/mutant/loader.rb

@@ -3,7 +3,7 @@
 module Mutant
   # Base class for code loaders
   class Loader
-    include Anima.new(:binding, :kernel, :node, :subject)
+    include Anima.new(:binding, :kernel, :source, :subject)
 
     # Call loader
     #
@@ -19,7 +19,7 @@ module Mutant
     # @return [undefined]
     def call
       kernel.eval(
-        Unparser.unparse(node),
+        source,
         binding,
         subject.source_path.to_s,
         subject.source_line

data/lib/mutant/mutation.rb

@@ -33,6 +33,14 @@ module Mutant
     end
     memoize :source
 
+    # The monkeypatch to insert the mutation
+    #
+    # @return [String]
+    def monkeypatch
+      Unparser.unparse(subject.context.root(node))
+    end
+    memoize :monkeypatch
+
     # Normalized original source
     #
     # @return [String]
@@ -59,7 +67,7 @@ module Mutant
       Loader.call(
         binding: TOPLEVEL_BINDING,
         kernel:  kernel,
-        node:    root,
+        source:  monkeypatch,
         subject: subject
       )
       self
@@ -75,13 +83,6 @@ module Mutant
     end
     memoize :sha1
 
-    # Mutated root node
-    #
-    # @return [Parser::AST::Node]
-    def root
-      subject.context.root(node)
-    end
-
     # Evil mutation that should case mutations to fail tests
     class Evil < self
 

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Reporter
+    class CLI
+      class Printer
+        # Reporter for mutation results
+        #
+        # :reek:TooManyConstants
+        class IsolationResult < self
+          CHILD_ERROR_MESSAGE = <<~'MESSAGE'
+            Killfork exited nonzero. Its result (if any) was ignored:
+            %s
+          MESSAGE
+
+          EXCEPTION_ERROR_MESSAGE = <<~'MESSAGE'
+            Killing the mutation resulted in an integration error.
+            This is the case when the tests selected for the current mutation
+            did not produce a test result, but instead an exception was raised.
+
+            This may point to the following problems:
+            * Bug in mutant
+            * Bug in the ruby interpreter
+            * Bug in your test suite
+            * Bug in your test suite under concurrency
+
+            The following exception was raised:
+
+            ```
+            %s
+            %s
+            ```
+          MESSAGE
+
+          FORK_ERROR_MESSAGE = <<~'MESSAGE'
+            Forking the child process to isolate the mutation in failed.
+            This meant that either the RubyVM or your OS was under too much
+            pressure to add another child process.
+
+            Possible solutions are:
+            * Reduce concurrency
+            * Reduce locks
+          MESSAGE
+
+          MAP = {
+            Isolation::Fork::ChildError   => :visit_child_error,
+            Isolation::Fork::ForkError    => :visit_fork_error,
+            Isolation::Result::ErrorChain => :visit_chain,
+            Isolation::Result::Exception  => :visit_exception,
+            Isolation::Result::Success    => :visit_success
+          }.freeze
+
+          private_constant(*constants(false))
+
+          # Run report printer
+          #
+          # @return [undefined]
+          def run
+            __send__(MAP.fetch(object.class))
+          end
+
+        private
+
+          # Visit successful isolation result
+          #
+          # @return [undefined]
+          def visit_success
+            visit(TestResult, object.value)
+          end
+
+          # Visit child error isolation result
+          #
+          # @return [undefined]
+          def visit_child_error
+            puts(CHILD_ERROR_MESSAGE % object.value.inspect)
+          end
+
+          # Visit fork error isolation result
+          #
+          # @return [undefined]
+          def visit_fork_error
+            puts(FORK_ERROR_MESSAGE)
+          end
+
+          # Visit exception isolation result
+          #
+          # @return [undefined]
+          def visit_exception
+            exception = object.value
+
+            puts(
+              EXCEPTION_ERROR_MESSAGE % [
+                exception.inspect,
+                exception.backtrace.join("\n")
+              ]
+            )
+          end
+
+          # Visit chain
+          #
+          # @return [undefined]
+          def visit_chain
+            printer = self.class
+
+            visit(printer, object.value)
+            visit(printer, object.next)
+          end
+        end # IsolationResult
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutant