mutant 0.7.3 → 0.7.4

data/lib/mutant/version.rb

@@ -1,4 +1,4 @@
 module Mutant
   # The current mutant version
-  VERSION = '0.7.3'.freeze
+  VERSION = '0.7.4'.freeze
 end # Mutant

data/lib/mutant/zombifier/file.rb

@@ -10,6 +10,10 @@ module Mutant
       #
       # @api private
       #
+      # Probably one of the only valid uses of eval.
+      #
+      # rubocop:disable Lint/Eval
+      #
       def zombify(namespace)
         $stderr.puts("Zombifying #{path}")
         eval(
@@ -33,15 +37,7 @@ module Mutant
       # @api private
       #
       def self.find(logical_name)
-        file_name =
-          case ::File.extname(logical_name)
-          when '.so'
-            return
-          when '.rb'
-            logical_name
-          else
-            "#{logical_name}.rb"
-          end
+        file_name = expand_file_name(logical_name)
 
         $LOAD_PATH.each do |path|
           path = Pathname.new(path).join(file_name)
@@ -52,6 +48,29 @@ module Mutant
         nil
       end
 
+      # Return expanded file name
+      #
+      # @param [String] logical_name
+      #
+      # @return [nil]
+      #   if no expansion is possible
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def self.expand_file_name(logical_name)
+        case ::File.extname(logical_name)
+        when '.so'
+          return
+        when '.rb'
+          logical_name
+        else
+          "#{logical_name}.rb"
+        end
+      end
+      private_class_method :expand_file_name
+
     private
 
       # Return node

data/meta/if.rb

@@ -14,6 +14,12 @@ Mutant::Meta::Example.add do
   # Deleted else branch
   mutation 'if condition; true end'
 
+  # Promote if branch
+  mutation 'true'
+
+  # Promote else branch
+  mutation 'false'
+
   # Deleted if branch resulting in unless rendering
   mutation 'unless condition; false; end'
 
@@ -39,6 +45,7 @@ Mutant::Meta::Example.add do
   mutation 'if true;       true;  end'
   mutation 'if false;      true;  end'
   mutation 'if nil;        true;  end'
+  mutation 'true'
 end
 
 Mutant::Meta::Example.add do
@@ -52,4 +59,5 @@ Mutant::Meta::Example.add do
   mutation 'unless condition;  false; end'
   mutation 'unless condition;  nil;   end'
   mutation 'if     condition;  true;  end'
+  mutation 'true'
 end

data/meta/match_current_line.rb

@@ -11,4 +11,5 @@ Mutant::Meta::Example.add do
   mutation 'true if false'
   mutation 'true if nil'
   mutation 'true if /a\A/'
+  mutation 'true'
 end

data/spec/integration/mutant/corpus_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'Mutant on ruby corpus' do
+RSpec.describe 'Mutant on ruby corpus', mutant: false do
 
   before do
     skip 'Corpus test is deactivated on < 2.1' if RUBY_VERSION < '2.1'

data/spec/integration/mutant/null_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'null integration' do
+RSpec.describe 'null integration', mutant: false do
 
   let(:base_cmd) { 'bundle exec mutant -I lib --require test_app "TestApp*"' }
 

data/spec/integration/mutant/rspec_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'rspec integration' do
+RSpec.describe 'rspec integration', mutant: false do
 
   let(:base_cmd) { 'bundle exec mutant -I lib --require test_app --use rspec' }
 

data/spec/integration/mutant/test_mutator_handles_types_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe do
+RSpec.describe 'AST type coverage', mutant: false do
 
   specify 'mutant should not crash for any node parser can generate' do
     Mutant::AST::Types::ALL.each do |type|

data/spec/integration/mutant/zombie_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'as a zombie' do
+RSpec.describe 'as a zombie', mutant: false do
   specify 'it allows to create zombie from mutant' do
     expect { Mutant.zombify }.to change { defined?(Zombie) }.from(nil).to('constant')
     expect(Zombie.constants).to include(:Mutant)

data/spec/support/corpus.rb

@@ -47,6 +47,8 @@ module Corpus
     #   otherwise
     #
     # rubocop:disable MethodLength
+    # rubocop:disable AbcSize
+    #
     def verify_mutation_generation
       checkout
       start = Time.now

data/spec/support/fake_actor.rb

@@ -3,34 +3,44 @@ require 'mutant/actor'
 # A fake actor used from specs
 module FakeActor
   class Expectation
-    include Concord::Public.new(:name, :message)
+    include Concord::Public.new(:name, :message, :block)
+    include Equalizer.new(:name, :message)
+
+    def self.new(_name, _message, _block = nil)
+      super
+    end
+
+    def verify(other)
+      unless eql?(other)
+        fail "Got:\n#{other.inspect}\nExpected:\n#{inspect}"
+      end
+      block.call(other.message) if block
+    end
   end
 
   class MessageSequence
-    include Adamantium::Flat, Concord.new(:messages)
+    include Adamantium::Flat, Concord::Public.new(:messages)
 
     def self.new
       super([])
     end
 
-    def add(name, *message_arguments)
-      messages << Expectation.new(name, Mutant::Actor::Message.new(*message_arguments))
+    def add(name, *message_arguments, &block)
+      messages << Expectation.new(name, Mutant::Actor::Message.new(*message_arguments), block)
       self
     end
 
     def sending(expectation)
-      raise "Unexpected send: #{expectation.inspect}" if messages.empty?
+      fail "Unexpected send: #{expectation.inspect}" if messages.empty?
       expected = messages.shift
-      unless expectation.eql?(expected)
-        raise "Got:\n#{expectation.inspect}\nExpected:\n#{expected.inspect}"
-      end
+      expected.verify(expectation)
       self
     end
 
     def receiving(name)
-      raise "No message to read for #{name.inspect}" if messages.empty?
+      fail "No message to read for #{name.inspect}" if messages.empty?
       expected = messages.shift
-      raise "Unexpected message #{expected.inspect} for #{name.inspect}" unless expected.name.eql?(name)
+      fail "Unexpected message #{expected.inspect} for #{name.inspect}" unless expected.name.eql?(name)
       expected.message
     end
 

data/spec/support/mutation_verifier.rb

@@ -43,6 +43,8 @@ private
   #
   # @api private
   #
+  # rubocop:disable AbcSize
+  #
   def mutation_report
     message = ['Original-AST:', original_node.inspect, 'Original-Source:', Unparser.unparse(original_node)]
     if missing.any?

data/spec/support/shared_context.rb

@@ -8,16 +8,17 @@ module SharedContext
   def messages(&block)
     let(:message_sequence) do
       FakeActor::MessageSequence.new.tap do |sequence|
-         sequence.instance_eval(&block)
+        sequence.instance_eval(&block)
       end
     end
   end
 
   # rubocop:disable MethodLength
+  # rubocop:disable AbcSize
   def setup_shared_context
     let(:env)              { double('env', config: config, subjects: [subject_a], mutations: mutations) }
-    let(:job_a)            { Mutant::Runner::Job.new(index: 0, mutation: mutation_a)                    }
-    let(:job_b)            { Mutant::Runner::Job.new(index: 1, mutation: mutation_b)                    }
+    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(:job_a_result)     { Mutant::Runner::JobResult.new(job: job_a, result: mutation_a_result)       }
     let(:job_b_result)     { Mutant::Runner::JobResult.new(job: job_b, result: mutation_b_result)       }
     let(:mutations)        { [mutation_a, mutation_b]                                                   }
@@ -27,6 +28,14 @@ module SharedContext
     let(:actor_names)      { []                                                                         }
     let(:message_sequence) { FakeActor::MessageSequence.new                                             }
 
+    let(:status) do
+      Mutant::Parallel::Status.new(
+        active_jobs: [].to_set,
+        payload:     env_result,
+        done:        true
+      )
+    end
+
     let(:config) do
       Mutant::Config::DEFAULT.update(
         actor_env: actor_env,
@@ -53,22 +62,6 @@ module SharedContext
       allow(subject_a).to receive(:mutations).and_return([mutation_a, mutation_b])
     end
 
-    let(:empty_status) do
-      Mutant::Runner::Status.new(
-        active_jobs: Set.new,
-        env_result:  env_result.update(subject_results: [], runtime: 0.0),
-        done:        false
-      )
-    end
-
-    let(:status) do
-      Mutant::Runner::Status.new(
-        active_jobs: Set.new,
-        env_result:  env_result,
-        done:        true
-      )
-    end
-
     let(:env_result) do
       Mutant::Result::Env.new(
         env:             env,

data/spec/unit/mutant/env_spec.rb

@@ -8,11 +8,13 @@ RSpec.describe Mutant::Env do
       it 'warns via reporter' do
         klass = Class.new do
           def self.name
-            raise
+            fail
           end
         end
 
-        expected_warnings = ["Class#name from: #{klass} raised an error: RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"]
+        expected_warnings = [
+          "Class#name from: #{klass} raised an error: RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
+        ]
 
         expect { subject }.to change { config.reporter.warn_calls }.from([]).to(expected_warnings)
 
@@ -46,4 +48,20 @@ RSpec.describe Mutant::Env do
       end
     end
   end
+
+  context '#kill_mutation' do
+    let(:object)   { described_class.new(config) }
+    let(:result)   { double('Result')            }
+    let(:mutation) { double('Mutation')          }
+
+    subject { object.kill_mutation(mutation) }
+
+    before do
+      expect(mutation).to receive(:kill).with(config.isolation, config.integration).and_return(result)
+    end
+
+    it 'uses the configured integration and isolation to kill mutation' do
+      should eql(Mutant::Result::Mutation.new(mutation: mutation, test_result: result))
+    end
+  end
 end

data/spec/unit/mutant/expression_spec.rb

@@ -51,7 +51,10 @@ RSpec.describe Mutant::Expression do
       let(:input) { 'foo bar' }
 
       it 'raises an exception' do
-        expect { subject }.to raise_error(Mutant::Expression::InvalidExpressionError, 'Expression: "foo bar" is not valid')
+        expect { subject }.to raise_error(
+          Mutant::Expression::InvalidExpressionError,
+          'Expression: "foo bar" is not valid'
+        )
       end
     end
 

data/spec/unit/mutant/parallel/master_spec.rb

@@ -0,0 +1,339 @@
+RSpec.describe Mutant::Parallel::Master do
+  let(:message_sequence)     { FakeActor::MessageSequence.new                                             }
+  let(:actor_names)          { [:master, :worker_a, :worker_b]                                            }
+  let(:status)               { double('Status')                                                           }
+  let(:sink)                 { FakeSink.new                                                               }
+  let(:processor)            { double('Processor')                                                        }
+  let(:worker_a)             { actor_env.mailbox(:worker_a).sender                                        }
+  let(:worker_b)             { actor_env.mailbox(:worker_b).sender                                        }
+  let(:parent)               { actor_env.mailbox(:parent).sender                                          }
+  let(:job_payload_a)        { double('Job Payload A')                                                    }
+  let(:job_payload_b)        { double('Job Payload B')                                                    }
+  let(:job_result_payload_a) { double('Job Result Payload A')                                             }
+  let(:job_result_payload_b) { double('Job Result Payload B')                                             }
+  let(:job_a)                { Mutant::Parallel::Job.new(index: 0, payload: job_payload_a)                }
+  let(:job_b)                { Mutant::Parallel::Job.new(index: 1, payload: job_payload_b)                }
+  let(:job_result_a)         { Mutant::Parallel::JobResult.new(job: job_a, payload: job_result_payload_a) }
+  let(:job_result_b)         { Mutant::Parallel::JobResult.new(job: job_b, payload: job_result_payload_b) }
+
+  let(:actor_env) do
+    FakeActor::Env.new(message_sequence, actor_names)
+  end
+
+  shared_examples_for 'master behavior' do
+    it { should eql(actor_env.mailbox(:master).sender) }
+
+    it 'has expected results in sink' do
+      subject
+      expect(sink.results).to eql(expected_results)
+    end
+
+    it 'consumes all messages' do
+      subject
+      expect(message_sequence.messages).to eql([])
+    end
+  end
+
+  let(:config) do
+    Mutant::Parallel::Config.new(
+      jobs:      1,
+      env:       actor_env,
+      source:    Mutant::Parallel::Source::Array.new([job_payload_a, job_payload_b]),
+      sink:      sink,
+      processor: processor
+    )
+  end
+
+  class FakeSink
+    def initialize
+      @results = []
+      @stop    = false
+    end
+
+    attr_reader :results
+
+    def status
+      @results.length
+    end
+
+    def result(result)
+      @results << result
+    end
+
+    def stop
+      @stop = true
+      self
+    end
+
+    def stop?
+      @stop
+    end
+  end
+
+  # Needed because of rubies undefined-ivar-read-is-nil stuff
+  describe 'object initialization' do
+    let(:object) { described_class.send(:new, config, actor_env.mailbox(:master)) }
+
+    it 'initializes falsy ivars'do
+      expect(object.instance_variable_get(:@stop)).to be(false)
+    end
+  end
+
+  describe '.call' do
+
+    before do
+      expect(Mutant::Parallel::Worker).to receive(:run).with(
+        actor:     actor_env.mailbox(:worker_a),
+        processor: processor,
+        parent:    actor_env.mailbox(:master).sender
+      ).and_return(worker_a)
+    end
+
+    subject { described_class.call(config) }
+
+    context 'with multiple workers configured' do
+      let(:config)           { super().update(jobs: 2) }
+      let(:expected_results) { []                      }
+
+      before do
+        expect(Mutant::Parallel::Worker).to receive(:run).with(
+          actor:     actor_env.mailbox(:worker_b),
+          processor: processor,
+          parent:    actor_env.mailbox(:master).sender
+        ).and_return(worker_b)
+
+        sink.stop
+
+        message_sequence.add(:master,   :ready,  worker_a)
+        message_sequence.add(:worker_a, :stop)
+
+        message_sequence.add(:master,   :ready,  worker_b)
+        message_sequence.add(:worker_b, :stop)
+
+        message_sequence.add(:master,   :stop,   parent)
+        message_sequence.add(:parent,   :stop)
+      end
+
+      include_examples 'master behavior'
+    end
+
+    context 'explicit stop by scheduler state' do
+      context 'before jobs are processed' do
+        let(:expected_results) { [] }
+
+        before do
+          sink.stop
+
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :stop)
+
+          message_sequence.add(:master,   :stop,   parent)
+          message_sequence.add(:parent,   :stop)
+        end
+
+        include_examples 'master behavior'
+      end
+
+      context 'while jobs are processed' do
+        let(:expected_results) { [job_result_payload_a] }
+
+        let(:sink) do
+          super().instance_eval do
+            def stop?
+              @results.length.equal?(1)
+            end
+            self
+          end
+        end
+
+        before do
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :job,    job_a)
+          message_sequence.add(:master,   :result, job_result_a)
+
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :stop)
+
+          message_sequence.add(:master,   :stop,   parent)
+          message_sequence.add(:parent,   :stop)
+        end
+
+        it { should eql(actor_env.mailbox(:master).sender) }
+
+        it 'consumes all messages' do
+          expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+        end
+      end
+    end
+
+    context 'external stop' do
+      context 'after jobs are done' do
+        let(:expected_results) { [job_result_payload_a, job_result_payload_b] }
+
+        before do
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :job,    job_a)
+          message_sequence.add(:master,   :result, job_result_a)
+
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :job,    job_b)
+          message_sequence.add(:master,   :result, job_result_b)
+
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :stop)
+
+          message_sequence.add(:master,   :stop,   parent)
+          message_sequence.add(:parent,   :stop)
+        end
+
+        include_examples 'master behavior'
+      end
+
+      context 'when no jobs are active' do
+        let(:expected_results) { [job_result_payload_a] }
+
+        before do
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :job,    job_a)
+          message_sequence.add(:master,   :stop,   parent)
+          message_sequence.add(:master,   :result, job_result_a)
+
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :stop)
+
+          message_sequence.add(:parent,   :stop)
+        end
+
+        include_examples 'master behavior'
+      end
+
+      context 'before any job got processed' do
+        let(:expected_results) { [] }
+
+        before do
+          message_sequence.add(:master,   :stop,   parent)
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :stop)
+          message_sequence.add(:parent,   :stop)
+        end
+
+        include_examples 'master behavior'
+      end
+    end
+
+    context 'requesting status' do
+      context 'when jobs are done' do
+        let(:expected_status)  { Mutant::Parallel::Status.new(payload: 2, active_jobs: Set.new, done: true) }
+        let(:expected_results) { [job_result_payload_a, job_result_payload_b] }
+
+        before do
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :job,    job_a)
+          message_sequence.add(:master,   :result, job_result_a)
+
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :job,    job_b)
+          message_sequence.add(:master,   :result, job_result_b)
+
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :stop)
+
+          message_sequence.add(:master,   :status, parent)
+
+          # Special bit to kill a mutation that results in mutable active_jobs being passed.
+          message_sequence.add(:parent,   :status, expected_status) do |message|
+            expect(message.payload.active_jobs.frozen?).to be(true)
+          end
+          message_sequence.add(:master,   :stop,   parent)
+          message_sequence.add(:parent,   :stop)
+        end
+
+        include_examples 'master behavior'
+      end
+
+      context 'just after scheduler stops' do
+        let(:expected_status)  { Mutant::Parallel::Status.new(payload: 1, active_jobs: [].to_set, done: true) }
+        let(:expected_results) { [job_result_payload_a] }
+
+        let(:sink) do
+          super().instance_eval do
+            def stop?
+              @results.length.equal?(1)
+            end
+            self
+          end
+        end
+
+        before do
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :job,    job_a)
+          message_sequence.add(:master,   :result, job_result_a)
+
+          message_sequence.add(:master,   :status, parent)
+          message_sequence.add(:parent,   :status, expected_status)
+
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :stop)
+
+          message_sequence.add(:master,   :stop,   parent)
+          message_sequence.add(:parent,   :stop)
+        end
+
+        include_examples 'master behavior'
+      end
+
+      context 'when jobs are active' do
+        let(:expected_status)  { Mutant::Parallel::Status.new(payload: 1, active_jobs: [job_b].to_set, done: false) }
+        let(:expected_results) { [job_result_payload_a, job_result_payload_b] }
+
+        before do
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :job,    job_a)
+          message_sequence.add(:master,   :result, job_result_a)
+
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :job,    job_b)
+
+          message_sequence.add(:master,   :status, parent)
+          message_sequence.add(:parent,   :status, expected_status)
+
+          message_sequence.add(:master,   :result, job_result_b)
+
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :stop)
+
+          message_sequence.add(:master,   :stop,   parent)
+          message_sequence.add(:parent,   :stop)
+        end
+
+        include_examples 'master behavior'
+      end
+
+      context 'before jobs are done' do
+        let(:expected_status)  { Mutant::Parallel::Status.new(payload: 0, active_jobs: Set.new, done: false) }
+        let(:expected_results) { [] }
+
+        before do
+          message_sequence.add(:master,   :status, parent)
+          message_sequence.add(:parent,   :status, expected_status)
+          message_sequence.add(:master,   :stop,   parent)
+          message_sequence.add(:master,   :ready,  worker_a)
+          message_sequence.add(:worker_a, :stop)
+          message_sequence.add(:parent,   :stop)
+        end
+
+        include_examples 'master behavior'
+      end
+    end
+
+    context 'unhandled message received' do
+      before do
+        message_sequence.add(:master, :foo, parent)
+      end
+
+      it 'raises message' do
+        expect { subject }.to raise_error(Mutant::Actor::ProtocolError, 'Unexpected message: :foo')
+      end
+    end
+  end
+end