mutant 0.6.7 → 0.7.1

data/spec/unit/mutant/result/env_spec.rb

@@ -0,0 +1,55 @@
+RSpec.describe Mutant::Result::Env do
+  let(:object) do
+    described_class.new(
+      env:              double('Env', config: config),
+      runtime:          double('Runtime'),
+      subject_results:  subject_results
+    )
+  end
+
+  let(:config) { double('Config', fail_fast: fail_fast) }
+
+  describe '#continue?' do
+    subject { object.continue? }
+
+    context 'config sets fail_fast flag' do
+      let(:fail_fast) { true }
+
+      context 'when mutation results are empty' do
+        let(:subject_results) { [] }
+
+        it { should be(true) }
+      end
+
+      context 'with failing mutation result' do
+        let(:subject_results) { [double('Subject Result', success?: false)] }
+
+        it { should be(false) }
+      end
+
+      context 'with successful mutation result' do
+        let(:subject_results) { [double('Subject Result', success?: true)] }
+
+        it { should be(true) }
+      end
+
+      context 'with failed and successful mutation result' do
+        let(:subject_results) do
+          [
+            double('Subject Result', success?: true),
+            double('Subject Result', success?: false)
+          ]
+        end
+
+        it { should be(false) }
+      end
+    end
+
+    context 'config does not set fail fast flag' do
+      let(:fail_fast)       { false                     }
+      let(:subject_results) { double('subject results') }
+
+      it { should be(true) }
+    end
+  end
+end

data/spec/unit/mutant/result/subject_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe Mutant::Result::Subject do
+  let(:object) do
+    described_class.new(
+      subject:          mutation_subject,
+      mutation_results: mutation_results
+    )
+  end
+
+  let(:mutation_subject) { double('Subject') }
+
+  describe '#continue?' do
+    subject { object.continue? }
+
+    context 'when mutation results are empty' do
+      let(:mutation_results) { [] }
+
+      it { should be(true) }
+    end
+
+    context 'with failing mutation result' do
+      let(:mutation_results) { [double('Mutation Result', success?: false)] }
+
+      it { should be(false) }
+    end
+
+    context 'with successful mutation result' do
+      let(:mutation_results) { [double('Mutation Result', success?: true)] }
+
+      it { should be(true) }
+    end
+
+    context 'with failed and successful mutation result' do
+      let(:mutation_results) do
+        [
+          double('Mutation Result', success?: true),
+          double('Mutation Result', success?: false)
+        ]
+      end
+
+      it { should be(false) }
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+RSpec.describe Mutant::Runner::Master do
+  setup_shared_context
+
+  describe 'object initialization' do
+    subject { described_class.__send__(:new, env, double('actor')) }
+
+    it 'initialized instance variables' do
+      expect(subject.instance_variable_get(:@stop)).to be(false)
+      expect(subject.instance_variable_get(:@stopping)).to be(false)
+    end
+  end
+
+  describe '.call' do
+    let(:actor_names) { [:master, :worker_a]              }
+    let(:worker_a)    { actor_env.actor(:worker_a).sender }
+    let(:worker_b)    { actor_env.actor(:worker_b).sender }
+    let(:parent)      { actor_env.actor(:parent).sender   }
+
+    let(:job) { double('Job') }
+
+    before do
+      expect(Time).to receive(:now).and_return(Time.at(0)).at_most(5).times
+      expect(Mutant::Runner::Worker).to receive(:run).with(
+        id: 0,
+        config: env.config,
+        parent: actor_env.actor(:master).sender
+      ).and_return(worker_a)
+    end
+
+    subject { described_class.call(env) }
+
+    context 'jobs done before external stop' do
+      before do
+        message_sequence.add(:master,   :ready,  worker_a)
+        message_sequence.add(:worker_a, :job,    job_a)
+        message_sequence.add(:master,   :result, job_a_result)
+
+        message_sequence.add(:master,   :ready,  worker_a)
+        message_sequence.add(:worker_a, :job,    job_b)
+        message_sequence.add(:master,   :result, job_b_result)
+
+        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.actor(:master).sender) }
+
+      it 'consumes all messages' do
+        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+      end
+    end
+
+    context 'stop by fail fast trigger first' do
+      update(:config)                 { { fail_fast: true } }
+      update(:mutation_b_test_result) { { passed: true }    }
+
+      before do
+        message_sequence.add(:master,   :ready,  worker_a)
+        message_sequence.add(:worker_a, :job,    job_a)
+        message_sequence.add(:master,   :result, job_a_result)
+
+        message_sequence.add(:master,   :ready,  worker_a)
+        message_sequence.add(:worker_a, :job,    job_b)
+        message_sequence.add(:master,   :result, job_b_result)
+
+        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.actor(:master).sender) }
+
+      it 'consumes all messages' do
+        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+      end
+    end
+
+    context 'stop by fail fast trigger last' do
+      update(:config)                 { { fail_fast: true } }
+      update(:mutation_a_test_result) { { passed: true }    }
+
+      before do
+        message_sequence.add(:master,   :ready,  worker_a)
+        message_sequence.add(:worker_a, :job,    job_a)
+        message_sequence.add(:master,   :result, job_a_result)
+
+        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.actor(:master).sender) }
+
+      it 'consumes all messages' do
+        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+      end
+    end
+
+    context 'jobs active while external stop' do
+      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_a_result)
+
+        message_sequence.add(:master,   :status, parent)
+        message_sequence.add(:parent,   :status, empty_status.update(active_jobs: [job_a].to_set))
+
+        message_sequence.add(:master,   :ready,  worker_a)
+        message_sequence.add(:worker_a, :stop)
+
+        message_sequence.add(:parent,   :stop)
+      end
+
+      it { should eql(actor_env.actor(:master).sender) }
+
+      it 'consumes all messages' do
+        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+      end
+    end
+
+    context 'stop with pending jobs' do
+      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
+
+      it { should eql(actor_env.actor(:master).sender) }
+
+      it 'consumes all messages' do
+        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+      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
+
+    context 'request status late' do
+      let(:expected_status) { status.update(env_result: env_result.update(runtime: 0.0)) }
+
+      before do
+        message_sequence.add(:master,   :ready,  worker_a)
+        message_sequence.add(:worker_a, :job,    job_a)
+        message_sequence.add(:master,   :result, job_a_result)
+
+        message_sequence.add(:master,   :ready,  worker_a)
+        message_sequence.add(:worker_a, :job,    job_b)
+        message_sequence.add(:master,   :result, job_b_result)
+
+        message_sequence.add(:master,   :ready,  worker_a)
+        message_sequence.add(:worker_a, :stop)
+
+        message_sequence.add(:master,   :status, parent)
+        message_sequence.add(:parent,   :status, expected_status)
+        message_sequence.add(:master,   :stop,   parent)
+        message_sequence.add(:parent,   :stop)
+      end
+
+      it { should eql(actor_env.actor(:master).sender) }
+
+      it 'consumes all messages' do
+        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+      end
+    end
+
+    context 'request status early' do
+      before do
+        message_sequence.add(:master,   :status, parent)
+        message_sequence.add(:parent,   :status, empty_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
+
+      it { should eql(actor_env.actor(:master).sender) }
+
+      it 'consumes all messages' do
+        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+      end
+    end
+  end
+end

data/spec/unit/mutant/runner/scheduler_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe Mutant::Runner::Scheduler do
+  let(:object) { described_class.new(env) }
+
+  before do
+    allow(Time).to receive(:now).and_return(Time.now)
+  end
+
+  setup_shared_context
+
+  let(:active_subject_a_result) do
+    subject_a_result.update(mutation_results: [])
+  end
+
+  describe '#job_result' do
+    subject { object.job_result(job_a_result) }
+
+    before do
+      expect(object.next_job).to eql(job_a)
+    end
+
+    it 'removes the tracking of job as active' do
+      expect { subject }.to change { object.status.active_jobs }.from([job_a].to_set).to(Set.new)
+    end
+
+    it 'aggregates results in #status' do
+      subject
+      object.job_result(job_b_result)
+      expect(object.status.env_result).to eql(
+        Mutant::Result::Env.new(
+          env: env,
+          runtime: 0.0,
+          subject_results: [subject_a_result]
+        )
+      )
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+  describe '#next_job' do
+    subject { object.next_job }
+
+    context 'when there is a next job' do
+      let(:mutations) { [mutation_a, mutation_b] }
+
+      it { should eql(job_a) }
+
+      it 'does not return the same job again' do
+        subject
+        expect(object.next_job).to eql(job_b)
+        expect(object.next_job).to be(nil)
+      end
+
+      it 'does record job as active' do
+        expect { subject }.to change { object.status.active_jobs }.from(Set.new).to([job_a].to_set)
+      end
+    end
+
+    context 'when there is no next job' do
+      let(:mutations) { [] }
+      it { should be(nil) }
+    end
+  end
+
+  describe '#status' do
+    subject { object.status }
+
+    context 'when empty' do
+      let(:expected_status) do
+        Mutant::Runner::Status.new(
+          env_result:             Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: []),
+          active_jobs:            Set.new,
+          done:                   false
+        )
+      end
+
+      it { should eql(expected_status) }
+    end
+
+    context 'when jobs are active' do
+      before do
+        object.next_job
+        object.next_job
+      end
+
+      let(:expected_status) do
+        Mutant::Runner::Status.new(
+          env_result:             Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: []),
+          active_jobs:            [job_a, job_b].to_set,
+          done:                   false
+        )
+      end
+
+      it { should eql(expected_status) }
+    end
+
+    context 'remaining jobs are active' do
+      before do
+        object.next_job
+        object.next_job
+        object.job_result(job_a_result)
+      end
+
+      update(:subject_a_result) { { mutation_results: [mutation_a_result] } }
+
+      let(:expected_status) do
+        Mutant::Runner::Status.new(
+          env_result:             Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: [subject_a_result]),
+          active_jobs:            [job_b].to_set,
+          done:                   false
+        )
+      end
+
+      it { should eql(expected_status) }
+    end
+
+    context 'under fail fast config with failed result' do
+      before do
+        object.next_job
+        object.next_job
+        object.job_result(job_a_result)
+      end
+
+      update(:subject_a_result)       { { mutation_results: [mutation_a_result] } }
+      update(:mutation_a_test_result) { { passed:           true                } }
+      update(:config)                 { { fail_fast:        true                } }
+
+      let(:expected_status) do
+        Mutant::Runner::Status.new(
+          env_result:             Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: [subject_a_result]),
+          active_jobs:            [job_b].to_set,
+          done:                   true
+        )
+      end
+
+      it { should eql(expected_status) }
+    end
+
+    context 'when done' do
+      before do
+        object.next_job
+        object.next_job
+        object.status
+        object.job_result(job_a_result)
+        object.job_result(job_b_result)
+      end
+
+      let(:expected_status) do
+        Mutant::Runner::Status.new(
+          env_result:             Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: [subject_a_result]),
+          active_jobs:            Set.new,
+          done:                   true
+        )
+      end
+
+      it { should eql(expected_status) }
+    end
+  end
+end