mutant 0.10.6 → 0.10.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b5a7d1620b6792fa1cef90ead01124cf50287a165a0bdd415fbc9aab9ecfde8
-  data.tar.gz: 758609938988d4d8de30a6f95a47c603fc4d5365ba98ad1a113a6de11f8e074f
+  metadata.gz: defe26105634d28a81b10e876713ab4e29a53a5d78ac8fe7e2d8a44d32b644c6
+  data.tar.gz: fad9645931798ed165a249e8e8d4a1c032896ceba6b823a1464ff2f60a7cadbb
 SHA512:
-  metadata.gz: 3ecd6aea62e2d01cb68cc9c9c651190305459b7f1b796f4360ce872ce0dbb1871cb40821744d1c09a029a80f39a93cbda9a242591ceae405e47ed971d3d861f9
-  data.tar.gz: '09e132e435163308309c0185abdd39ea9b6be0d2bd0efa0956049c366f0b521df866a3b7fd04d2e13550bd4f2b09993c659530f86b00142adff69ebc14af3a16'
+  metadata.gz: 79da9f75f18510bbf81e43e2b98e43c4b92ddf2e6cb68b66828f9f4240f7d3e8747d6e475130f83a2d1edec8c1dda43a34f48524bd7439372e545a046099c28d
+  data.tar.gz: 7d8aac2776eca84aff051b7a146863bb271c5df4ec7dc344f041d3a22a17b4d87f9f48d5201e2dceec30f548adc7135d443ee78bc00764a9399fb677f2cf0aa5

data/lib/mutant.rb

@@ -179,16 +179,14 @@ require 'mutant/reporter/sequence'
 require 'mutant/reporter/cli'
 require 'mutant/reporter/cli/printer'
 require 'mutant/reporter/cli/printer/config'
+require 'mutant/reporter/cli/printer/coverage_result'
 require 'mutant/reporter/cli/printer/env'
 require 'mutant/reporter/cli/printer/env_progress'
 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/mutation_result'
 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/format'
 require 'mutant/repository'
 require 'mutant/repository/diff'
@@ -219,12 +217,14 @@ module Mutant
     stderr:             $stderr,
     stdout:             $stdout,
     thread:             Thread,
+    timer:              Timer.new(Process),
     warnings:           Warnings.new(Warning)
   )
 
   # Reopen class to initialize constant to avoid dep circle
   class Config
     DEFAULT = new(
+      coverage_criteria: Config::CoverageCriteria::DEFAULT,
       expression_parser: Expression::Parser.new([
         Expression::Method,
         Expression::Methods,
@@ -237,6 +237,7 @@ module Mutant
       isolation:         Mutant::Isolation::Fork.new(WORLD),
       jobs:              nil,
       matcher:           Matcher::Config::DEFAULT,
+      mutation_timeout:  nil,
       reporter:          Reporter::CLI.build(WORLD.stdout),
       requires:          EMPTY_ARRAY,
       zombie:            false

data/lib/mutant/cli/command/run.rb

@@ -35,7 +35,7 @@ module Mutant
 
         def initialize(attributes)
           super(attributes)
-          @config = Config::DEFAULT
+          @config = Config.env
         end
 
         def execute
@@ -49,7 +49,7 @@ module Mutant
         end
 
         def expand(file_config)
-          @config = Config.env.merge(file_config).merge(@config)
+          @config = @config.merge(file_config)
         end
 
         def soft_fail(result)
@@ -153,6 +153,9 @@ module Mutant
           parser.on('-j', '--jobs NUMBER', 'Number of kill jobs. Defaults to number of processors.') do |number|
             set(jobs: Integer(number))
           end
+          parser.on('-t', '--mutation-timeout NUMBER', 'Per mutation analysis timeout') do |number|
+            set(mutation_timeout: Float(number))
+          end
         end
       end # Run
       # rubocop:enable Metrics/ClassLength

data/lib/mutant/config.rb

@@ -7,6 +7,7 @@ module Mutant
   # to current environment is being represented by the Mutant::Env object.
   class Config
     include Adamantium::Flat, Anima.new(
+      :coverage_criteria,
       :expression_parser,
       :fail_fast,
       :includes,
@@ -14,6 +15,7 @@ module Mutant
       :isolation,
       :jobs,
       :matcher,
+      :mutation_timeout,
       :reporter,
       :requires,
       :zombie
@@ -23,30 +25,6 @@ module Mutant
       define_method(:"#{name}?") { public_send(name) }
     end
 
-    boolean = Transform::Boolean.new
-    integer = Transform::Primitive.new(Integer)
-    string  = Transform::Primitive.new(String)
-
-    string_array = Transform::Array.new(string)
-
-    TRANSFORM = Transform::Sequence.new(
-      [
-        Transform::Exception.new(SystemCallError, :read.to_proc),
-        Transform::Exception.new(YAML::SyntaxError, YAML.method(:safe_load)),
-        Transform::Hash.new(
-          optional: [
-            Transform::Hash::Key.new('fail_fast',   boolean),
-            Transform::Hash::Key.new('includes',    string_array),
-            Transform::Hash::Key.new('integration', string),
-            Transform::Hash::Key.new('jobs',        integer),
-            Transform::Hash::Key.new('requires',    string_array)
-          ],
-          required: []
-        ),
-        Transform::Hash::Symbolize.new
-      ]
-    )
-
     MORE_THAN_ONE_CONFIG_FILE = <<~'MESSAGE'
       Found more than one candidate for use as implicit config file: %s
     MESSAGE
@@ -57,6 +35,32 @@ module Mutant
       mutant.yml
     ].freeze
 
+    private_constant(*constants(false))
+
+    class CoverageCriteria
+      include Anima.new(:timeout, :test_result)
+
+      DEFAULT = new(
+        timeout:     false,
+        test_result: true
+      )
+
+      TRANSFORM =
+        Transform::Sequence.new(
+          [
+            Transform::Hash.new(
+              optional: [
+                Transform::Hash::Key.new('timeout',     Transform::BOOLEAN),
+                Transform::Hash::Key.new('test_result', Transform::BOOLEAN)
+              ],
+              required: []
+            ),
+            Transform::Hash::Symbolize.new,
+            ->(value) { Either::Right.new(DEFAULT.with(**value)) }
+          ]
+        )
+    end # CoverageCriteria
+
     # Merge with other config
     #
     # @param [Config] other
@@ -64,18 +68,17 @@ module Mutant
     # @return [Config]
     def merge(other)
       other.with(
-        fail_fast:   fail_fast || other.fail_fast,
-        includes:    includes + other.includes,
-        jobs:        other.jobs || jobs,
-        integration: other.integration || integration,
-        matcher:     matcher.merge(other.matcher),
-        requires:    requires + other.requires,
-        zombie:      zombie || other.zombie
+        fail_fast:        fail_fast || other.fail_fast,
+        includes:         other.includes + includes,
+        jobs:             other.jobs || jobs,
+        integration:      other.integration || integration,
+        mutation_timeout: other.mutation_timeout || mutation_timeout,
+        matcher:          matcher.merge(other.matcher),
+        requires:         other.requires + requires,
+        zombie:           zombie || other.zombie
       )
     end
 
-    private_constant(*constants(false))
-
     # Load config file
     #
     # @param [World] world
@@ -98,7 +101,7 @@ module Mutant
     def self.load_contents(path)
       Transform::Named
         .new(path.to_s, TRANSFORM)
-        .apply(path)
+        .call(path)
         .lmap(&:compact_message)
     end
     private_class_method :load_contents
@@ -109,5 +112,27 @@ module Mutant
     def self.env
       DEFAULT.with(jobs: Etc.nprocessors)
     end
+
+    TRANSFORM = Transform::Sequence.new(
+      [
+        Transform::Exception.new(SystemCallError, :read.to_proc),
+        Transform::Exception.new(YAML::SyntaxError, YAML.method(:safe_load)),
+        Transform::Hash.new(
+          optional: [
+            Transform::Hash::Key.new('coverage_criteria', CoverageCriteria::TRANSFORM),
+            Transform::Hash::Key.new('fail_fast',         Transform::BOOLEAN),
+            Transform::Hash::Key.new('includes',          Transform::STRING_ARRAY),
+            Transform::Hash::Key.new('integration',       Transform::STRING),
+            Transform::Hash::Key.new('jobs',              Transform::INTEGER),
+            Transform::Hash::Key.new('mutation_timeout',  Transform::FLOAT),
+            Transform::Hash::Key.new('requires',          Transform::STRING_ARRAY)
+          ],
+          required: []
+        ),
+        Transform::Hash::Symbolize.new
+      ]
+    )
+
+    private_constant(:TRANSFORM)
   end # Config
 end # Mutant

data/lib/mutant/env.rb

@@ -24,10 +24,15 @@ module Mutant
     # @param [Config] config
     #
     # @return [Env]
+    #
+    # rubocop:disable Metrics/MethodLength
     def self.empty(world, config)
       new(
         config:           config,
-        integration:      Integration::Null.new(config),
+        integration:      Integration::Null.new(
+          expression_parser: config.expression_parser,
+          timer:             world.timer
+        ),
         matchable_scopes: EMPTY_ARRAY,
         mutations:        EMPTY_ARRAY,
         parser:           Parser.new,
@@ -36,6 +41,7 @@ module Mutant
         world:            world
       )
     end
+    # rubocop:enable Metrics/MethodLength
 
     # Kill mutation
     #
@@ -43,14 +49,14 @@ module Mutant
     #
     # @return [Result::Mutation]
     def kill(mutation)
-      start = Timer.now
+      start = timer.now
 
       tests = selections.fetch(mutation.subject)
 
       Result::Mutation.new(
         isolation_result: run_mutation_tests(mutation, tests),
         mutation:         mutation,
-        runtime:          Timer.now - start
+        runtime:          timer.now - start
       )
     end
 
@@ -127,7 +133,7 @@ module Mutant
   private
 
     def run_mutation_tests(mutation, tests)
-      config.isolation.call do
+      config.isolation.call(config.mutation_timeout) do
         result = mutation.insert(world.kernel)
 
         if result.equal?(Loader::Result::VoidValue.instance)
@@ -138,5 +144,9 @@ module Mutant
       end
     end
 
+    def timer
+      world.timer
+    end
+
   end # Env
 end # Mutant

data/lib/mutant/integration.rb

@@ -4,7 +4,7 @@ module Mutant
 
   # Abstract base class mutant test framework integrations
   class Integration
-    include AbstractType, Adamantium::Flat, Concord.new(:config)
+    include AbstractType, Adamantium::Flat, Anima.new(:expression_parser, :timer)
 
     LOAD_MESSAGE = <<~'MESSAGE'
       Unable to load integration mutant-%<integration_name>s:
@@ -27,9 +27,12 @@ module Mutant
     #
     # @return [Either<String, Integration>]
     def self.setup(env)
-      attempt_require(env)
-        .bind { attempt_const_get(env) }
-        .fmap { |klass| klass.new(env.config).setup }
+      attempt_require(env).bind { attempt_const_get(env) }.fmap do |klass|
+        klass.new(
+          expression_parser: env.config.expression_parser,
+          timer:             env.world.timer
+        ).setup
+      end
     end
 
     # rubocop:disable Style/MultilineBlockChain
@@ -80,11 +83,5 @@ module Mutant
     #
     # @return [Enumerable<Test>]
     abstract_method :all_tests
-
-  private
-
-    def expression_parser
-      config.expression_parser
-    end
   end # Integration
 end # Mutant

data/lib/mutant/integration/null.rb

@@ -18,7 +18,6 @@ module Mutant
       # @return [Result::Test]
       def call(tests)
         Result::Test.new(
-          output:  '',
           passed:  true,
           runtime: 0.0,
           tests:   tests

data/lib/mutant/isolation.rb

@@ -7,57 +7,20 @@ module Mutant
 
     # Isolated computation result
     class Result
-      include AbstractType, Adamantium
-
-      NULL_LOG = ''
-
-      private_constant(*constants(false))
-
-      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
-
-      # The log captured from integration
-      #
-      # @return [String]
-      def log
-        NULL_LOG
-      end
-
-      # Test for success
+      include Anima.new(
+        :exception,
+        :log,
+        :process_status,
+        :timeout,
+        :value
+      )
+
+      # Test for successful result
       #
       # @return [Boolean]
-      def success?
-        instance_of?(Success)
+      def valid_value?
+        timeout.nil? && exception.nil? && (process_status.nil? || process_status.success?)
       end
-
-      # Successful result producing value
-      class Success < self
-        include Concord::Public.new(:value, :log)
-
-        def self.new(_value, _log = '')
-          super
-        end
-      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

data/lib/mutant/isolation/fork.rb

@@ -3,22 +3,36 @@
 module Mutant
   class Isolation
     # Isolation via the fork(2) systemcall.
+    #
+    # Communication between parent and child process is done
+    # via anonymous pipes.
+    #
+    # Timeouts are initially handled relatively efficiently via IO.select
+    # but once the child process pipes are on eof via busy looping on
+    # waitpid2 with Process::WNOHANG set.
+    #
+    # Handling timeouts this way is not the conceptually most
+    # efficient solution. But its cross platform.
+    #
+    # Design constraints:
+    #
+    # * Support Linux
+    # * Support MacOSX
+    # * Avoid platform specific APIs and code.
+    # * Only use ruby corelib.
+    # * Do not use any named resource.
+    # * Never block on latency inducing systemcall without a
+    #   timeout.
+    # * Child process freezing before closing the pipes needs to
+    #   be detected by parent process.
+    # * Child process freezing after closing the pipes needs to be
+    #   detected by parent process.
     class Fork < self
       include(Adamantium::Flat, Concord.new(:world))
 
       READ_SIZE = 4096
 
-      ATTRIBUTES = %i[block log_pipe result_pipe world].freeze
-
-      # Unsuccessful result as child exited nonzero
-      class ChildError < Result
-        include Concord::Public.new(:value, :log)
-      end # ChildError
-
-      # Unsuccessful result as fork failed
-      class ForkError < Result
-        include Equalizer.new
-      end # ForkError
+      ATTRIBUTES = %i[block deadline log_pipe result_pipe world].freeze
 
       # Pipe abstraction
       class Pipe
@@ -50,7 +64,6 @@ module Mutant
         end
       end # Pipe
 
-      # ignore :reek:InstanceVariableAssumption
       class Parent
         include(
           Anima.new(*ATTRIBUTES),
@@ -64,15 +77,28 @@ module Mutant
         #
         # @return [Result]
         def call
-          pid = start_child or return ForkError.new
-
-          read_child_result(pid)
-
-          @result
+          @exception     = nil
+          @log_fragments = []
+          @timeout       = nil
+          @value         = nil
+          @pid           = start_child
+
+          read_child_result
+          result
         end
 
       private
 
+        def result
+          Result.new(
+            exception:      @exception,
+            log:            @log_fragments.join,
+            process_status: @process_status,
+            timeout:        @timeout,
+            value:          @value
+          )
+        end
+
         def start_child
           world.process.fork do
             Child.call(
@@ -85,30 +111,43 @@ module Mutant
         end
 
         # rubocop:disable Metrics/MethodLength
-        def read_child_result(pid)
+        def read_child_result
           result_fragments = []
-          log_fragments    = []
 
-          read_fragments(
-            log_pipe.parent    => log_fragments,
-            result_pipe.parent => result_fragments
-          )
+          targets =
+            {
+              log_pipe.parent    => @log_fragments,
+              result_pipe.parent => result_fragments
+            }
 
-          begin
-            result = world.marshal.load(result_fragments.join)
-          rescue ArgumentError => exception
-            add_result(Result::Exception.new(exception))
+          read_targets(targets)
+
+          if targets.empty?
+            load_result(result_fragments)
+            terminate_graceful
           else
-            add_result(Result::Success.new(result, log_fragments.join))
+            @timeout = deadline.allowed_time
+            terminate_ungraceful
           end
-        ensure
-          wait_child(pid, log_fragments)
         end
         # rubocop:enable Metrics/MethodLength
 
-        def read_fragments(targets)
+        def load_result(result_fragments)
+          @value = world.marshal.load(result_fragments.join)
+        rescue ArgumentError => exception
+          @exception = exception
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def read_targets(targets)
           until targets.empty?
-            ready, = world.io.select(targets.keys)
+            status = deadline.status
+
+            break unless status.ok?
+
+            ready, = world.io.select(targets.keys, [], [], status.time_left)
+
+            break unless ready
 
             ready.each do |fd|
               if fd.eof?
@@ -119,14 +158,42 @@ module Mutant
             end
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
-        def wait_child(pid, log_fragments)
-          _pid, status = world.process.wait2(pid)
+        # rubocop:disable Metrics/MethodLength
+        def terminate_graceful
+          status = nil
+
+          loop do
+            status = peek_child
+            break if status || deadline.expired?
+            world.kernel.sleep(0.1)
+          end
 
-          unless status.success? # rubocop:disable Style/GuardClause
-            add_result(ChildError.new(status, log_fragments.join))
+          if status
+            handle_status(status)
+          else
+            terminate_ungraceful
           end
         end
+        # rubocop:enable Metrics/MethodLength
+
+        def terminate_ungraceful
+          world.process.kill('KILL', @pid)
+
+          _pid, status = world.process.wait2(@pid)
+
+          handle_status(status)
+        end
+
+        def handle_status(status)
+          @process_status = status
+        end
+
+        def peek_child
+          _pid, status = world.process.wait2(@pid, Process::WNOHANG)
+          status
+        end
 
         def add_result(result)
           @result = defined?(@result) ? @result.add_error(result) : result
@@ -157,17 +224,16 @@ module Mutant
       # Call block in isolation
       #
       # @return [Result]
-      #   execution result
-      #
-      # ignore :reek:NestedIterators
       #
       # rubocop:disable Metrics/MethodLength
-      def call(&block)
+      def call(timeout, &block)
+        deadline = world.deadline(timeout)
         io = world.io
         Pipe.with(io) do |result|
           Pipe.with(io) do |log|
             Parent.call(
               block:       block,
+              deadline:    deadline,
               log_pipe:    log,
               result_pipe: result,
               world:       world
@@ -176,6 +242,7 @@ module Mutant
         end
       end
       # rubocop:enable Metrics/MethodLength
+
     end # Fork
   end # Isolation
 end # Mutant