mutant 0.8.24 → 0.9.0

data/spec/unit/mutant/env/bootstrap_spec.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-# This spec is a good example for:
-#
-# If test look that ugly the class under test sucks.
-#
-# As the bootstrap needs to infect global VM state
-# this is to some degree acceptable.
-#
-# Still the bootstrap needs to be cleaned up.
-# And the change that added this warning did the groundwork.
-RSpec.describe Mutant::Env::Bootstrap do
-  let(:matcher_config)       { Mutant::Matcher::Config::DEFAULT     }
-  let(:integration)          { instance_double(Mutant::Integration) }
-  let(:integration_class)    { instance_double(Class)               }
-  let(:object_space_modules) { []                                   }
-
-  let(:config) do
-    Mutant::Config::DEFAULT.with(
-      includes:    [],
-      integration: integration_class,
-      jobs:        1,
-      matcher:     matcher_config,
-      reporter:    instance_double(Mutant::Reporter),
-      requires:    []
-    )
-  end
-
-  let(:expected_env) do
-    Mutant::Env.new(
-      actor_env:        Mutant::Actor::Env.new(Thread),
-      config:           config,
-      integration:      integration,
-      matchable_scopes: [],
-      mutations:        [],
-      parser:           Mutant::Parser.new,
-      selector:         Mutant::Selector::Expression.new(integration),
-      subjects:         []
-    )
-  end
-
-  shared_examples_for 'bootstrap call' do
-    it { should eql(expected_env) }
-  end
-
-  def expect_warning
-    expect(config.reporter).to receive(:warn)
-      .with(expected_warning)
-      .and_return(config.reporter)
-  end
-
-  before do
-    expect(integration_class).to receive(:new)
-      .with(config)
-      .and_return(integration)
-
-    expect(integration).to receive_messages(setup: integration)
-
-    expect(ObjectSpace).to receive(:each_object)
-      .with(Module)
-      .and_return(object_space_modules.each)
-  end
-
-  describe '#warn' do
-    let(:object)           { described_class.new(config) }
-    let(:expected_warning) { instance_double(String)     }
-
-    subject { object.warn(expected_warning) }
-
-    before { expect_warning }
-
-    it_behaves_like 'a command method'
-  end
-
-  describe '.call' do
-    subject { described_class.call(config) }
-
-    context 'when Module#name calls result in exceptions' do
-      let(:object_space_modules) { [invalid_class] }
-
-      let(:expected_warning) do
-        "Class#name from: #{invalid_class} raised an error: " \
-        "RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
-      end
-
-      let(:invalid_class) do
-        Class.new do
-          def self.name
-            fail
-          end
-        end
-      end
-
-      after do
-        # Fix Class#name so other specs do not see this one
-        class << invalid_class
-          undef :name
-          def name; end
-        end
-      end
-
-      before { expect_warning }
-
-      include_examples 'bootstrap call'
-    end
-
-    context 'when requires are configured' do
-      let(:config) { super().with(requires: %w[foo bar]) }
-
-      before do
-        %w[foo bar].each do |component|
-          expect(Kernel).to receive(:require)
-            .with(component)
-            .and_return(true)
-        end
-      end
-
-      include_examples 'bootstrap call'
-    end
-
-    context 'when includes are configured' do
-      let(:config) { super().with(includes: %w[foo bar]) }
-
-      before do
-        %w[foo bar].each do |component|
-          expect($LOAD_PATH).to receive(:<<)
-            .with(component)
-            .and_return($LOAD_PATH)
-        end
-      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
-        Class.new do
-          def self.name
-            Object
-          end
-        end
-      end
-
-      let(:expected_warning) do
-        "Class#name from: #{invalid_class} " \
-        "returned Object. #{Mutant::Env::SEMANTICS_MESSAGE}"
-      end
-
-      after do
-        # Fix Class#name so other specs do not see this one
-        class << invalid_class
-          undef :name
-          def name; end
-        end
-      end
-
-      before { expect_warning }
-
-      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(:expected_env) do
-        subjects = Mutant::Matcher::Scope.new(TestApp::Literal).call(Fixtures::TEST_ENV)
-
-        super().with(
-          matchable_scopes: [
-            Mutant::Scope.new(TestApp::Empty,   match_expressions.last),
-            Mutant::Scope.new(TestApp::Literal, match_expressions.first)
-          ],
-          mutations:        subjects.flat_map(&:mutations),
-          subjects:         subjects
-        )
-      end
-
-      include_examples 'bootstrap call'
-    end
-  end
-end

data/spec/unit/mutant/matcher/compiler/subject_prefix_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Matcher::Compiler::SubjectPrefix, '#call' do
-  let(:object)   { described_class.new(parse_expression('Foo*')) }
-
-  let(:_subject) do
-    instance_double(
-      Mutant::Subject,
-      expression: parse_expression(subject_expression)
-    )
-  end
-
-  subject { object.call(_subject) }
-
-  context 'when subject expression is prefixed by expression' do
-    let(:subject_expression) { 'Foo::Bar' }
-
-    it { should be(true) }
-  end
-
-  context 'when subject expression is NOT prefixed by expression' do
-    let(:subject_expression) { 'Bar' }
-
-    it { should be(false) }
-  end
-end

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

@@ -1,338 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Parallel::Master do
-  let(:message_sequence)     { FakeActor::MessageSequence.new                                             }
-  let(:actor_names)          { %i[master worker_a worker_b]                                               }
-  let(:sink)                 { FakeSink.new                                                               }
-  let(:processor)            { instance_double(Proc)                                                      }
-  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)        { instance_double(Object)                                                    }
-  let(:job_payload_b)        { instance_double(Object)                                                    }
-  let(:job_result_payload_a) { instance_double(Object)                                                    }
-  let(:job_result_payload_b) { instance_double(Object)                                                    }
-  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(
-      env:       actor_env,
-      jobs:      1,
-      processor: processor,
-      sink:      sink,
-      source:    Mutant::Parallel::Source::Array.new([job_payload_a, job_payload_b])
-    )
-  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 # FakeSink
-
-  # 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(
-        mailbox:   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().with(jobs: 2) }
-      let(:expected_results) { []                    }
-
-      before do
-        expect(Mutant::Parallel::Worker).to receive(:run).with(
-          mailbox:   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(: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