mutant 0.7.3 → 0.7.4

data/spec/unit/mutant/parallel/source/array_spec.rb

@@ -0,0 +1,47 @@
+RSpec.describe Mutant::Parallel::Source::Array do
+  let(:object) { described_class.new(jobs) }
+
+  let(:job_a) { double('Job A') }
+  let(:job_b) { double('Job B') }
+  let(:job_c) { double('Job B') }
+
+  let(:jobs) { [job_a, job_b, job_c] }
+
+  describe '#next' do
+    subject { object.next }
+
+    context 'when there is a next job' do
+      it 'returns that job' do
+        should be(job_a)
+      end
+
+      it 'does not return the same job twice' do
+        expect(object.next).to be(job_a)
+        expect(object.next).to be(job_b)
+        expect(object.next).to be(job_c)
+      end
+    end
+
+    context 'when there is no next job' do
+      let(:jobs) { [] }
+
+      it 'raises error' do
+        expect { subject }.to raise_error(Mutant::Parallel::Source::NoJobError)
+      end
+    end
+  end
+
+  describe '#next?' do
+    subject { object.next? }
+
+    context 'when there is a next job' do
+      it { should be(true) }
+    end
+
+    context 'when there is no next job' do
+      let(:jobs) { [] }
+
+      it { should be(false) }
+    end
+  end
+end

data/spec/unit/mutant/{runner → parallel}/worker_spec.rb

@@ -1,21 +1,27 @@
-RSpec.describe Mutant::Runner::Worker do
-  setup_shared_context
-
-  let(:actor)  { actor_env.mailbox(:worker)        }
-  let(:parent) { actor_env.mailbox(:parent).sender }
-
-  before do
-    message_sequence.add(:parent, :ready, actor.sender)
+RSpec.describe Mutant::Parallel::Worker do
+  let(:actor_env) do
+    FakeActor::Env.new(message_sequence, actor_names)
   end
 
+  let(:message_sequence) { FakeActor::MessageSequence.new    }
+  let(:processor)        { double('Processor')               }
+  let(:actor)            { actor_env.mailbox(:worker)        }
+  let(:parent)           { actor_env.mailbox(:parent).sender }
+  let(:payload)          { double('Payload')                 }
+  let(:result_payload)   { double('Result Payload')          }
+
   let(:attributes) do
     {
-      config: config,
-      parent: parent,
-      id:     1
+      processor: processor,
+      parent:    parent,
+      actor:     actor
     }
   end
 
+  before do
+    message_sequence.add(:parent, :ready, actor.sender)
+  end
+
   describe '.run' do
     subject { described_class.run(attributes) }
 
@@ -26,7 +32,7 @@ RSpec.describe Mutant::Runner::Worker do
       let(:test_result) { double('Test Result') }
 
       before do
-        expect(mutation).to receive(:kill).with(config.isolation, config.integration).and_return(test_result).ordered
+        expect(processor).to receive(:call).with(payload).and_return(result_payload)
 
         message_sequence.add(:worker, :job, job)
         message_sequence.add(:parent, :result, job_result)
@@ -34,25 +40,16 @@ RSpec.describe Mutant::Runner::Worker do
         message_sequence.add(:worker, :stop)
       end
 
-      let(:test)            { double('Test')                                                   }
-      let(:index)           { double('Index')                                                  }
-      let(:test_result)     { double('Test Result')                                            }
-      let(:mutation)        { double('Mutation')                                               }
-      let(:job_result)      { Mutant::Runner::JobResult.new(job: job, result: mutation_result) }
-      let(:job)             { Mutant::Runner::Job.new(index: index, mutation: mutation)        }
-
-      let(:mutation_result) do
-        Mutant::Result::Mutation.new(
-          mutation:    mutation,
-          test_result: test_result
-        )
-      end
+      let(:index)           { double('Index')                                                     }
+      let(:test_result)     { double('Test Result')                                               }
+      let(:job_result)      { Mutant::Parallel::JobResult.new(job: job, payload: result_payload)  }
+      let(:job)             { Mutant::Parallel::Job.new(index: index, payload: payload)           }
 
       it 'signals ready and status to parent' do
         subject
       end
 
-      it { should eql(actor.sender) }
+      it { should be(described_class) }
 
       it 'consumes all messages' do
         expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)

data/spec/unit/mutant/parallel_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Mutant::Parallel do
+  describe '.async' do
+    subject { described_class.async(config) }
+
+    let(:config)  { double('Config', env: env)          }
+    let(:env)     { double('ENV', new_mailbox: mailbox) }
+    let(:mailbox) { Mutant::Actor::Mailbox.new          }
+    let(:master)  { double('Master')                    }
+
+    before do
+      expect(described_class::Master).to receive(:call).with(config).and_return(master)
+    end
+
+    it { should eql(described_class::Driver.new(mailbox.bind(master))) }
+  end
+end

data/spec/unit/mutant/reporter/cli_spec.rb

@@ -254,7 +254,7 @@ RSpec.describe Mutant::Reporter::CLI do
     end
 
     describe '#report' do
-      subject { object.report(status.env_result) }
+      subject { object.report(status.payload) }
 
       context 'with full coverage' do
         it_reports(<<-REPORT)

data/spec/unit/mutant/reporter/trace_spec.rb

@@ -0,0 +1,9 @@
+RSpec.describe Mutant::Reporter::Trace do
+  let(:object) { described_class.new }
+
+  describe '#delay' do
+    subject { object.delay }
+
+    it { should equal(0.0) }
+  end
+end

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

@@ -1,55 +0,0 @@
-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/runner/driver_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe Mutant::Parallel::Driver do
+  let(:object) { described_class.new(binding) }
+
+  let(:binding) { double('Binding') }
+  let(:result)  { double('Result') }
+
+  describe '#stop' do
+    subject { object.stop }
+
+    before do
+      expect(binding).to receive(:call).with(:stop)
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+  describe '#status' do
+    subject { object.status }
+
+    before do
+      expect(binding).to receive(:call).with(:status).and_return(result)
+    end
+
+    it { should be(result) }
+  end
+end

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

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe Mutant::Runner::Sink do
+  setup_shared_context
+
+  shared_context 'one result' do
+    before do
+      object.result(mutation_a_result)
+    end
+  end
+
+  shared_context 'two results' do
+    before do
+      object.result(mutation_a_result)
+      object.result(mutation_b_result)
+    end
+  end
+
+  let(:object) { described_class.new(env) }
+
+  before do
+    allow(Time).to receive(:now).and_return(Time.now)
+  end
+
+  describe '#result' do
+    subject { object.result(mutation_a_result) }
+
+    it 'aggregates results in #status' do
+      subject
+      object.result(mutation_b_result)
+      expect(object.status).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 '#status' do
+    subject { object.status }
+
+    context 'no results' do
+      let(:expected_status) do
+        Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: [])
+      end
+
+      it { should eql(expected_status) }
+    end
+
+    context 'one result' do
+      include_context 'one result'
+
+      update(:subject_a_result) { { mutation_results: [mutation_a_result] } }
+
+      let(:expected_status) do
+        Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: [subject_a_result])
+      end
+
+      it { should eql(expected_status) }
+    end
+
+    context 'two results' do
+      include_context 'two results'
+
+      let(:expected_status) do
+        Mutant::Result::Env.new(env: env, runtime: 0.0, subject_results: [subject_a_result])
+      end
+
+      it { should eql(expected_status) }
+    end
+  end
+
+  describe '#stop?' do
+    subject { object.stop? }
+
+    context 'without fail fast' do
+      context 'no results' do
+        it { should be(false) }
+      end
+
+      context 'one result' do
+        include_context 'one result'
+
+        context 'when result is successful' do
+          it { should be(false) }
+        end
+
+        context 'when result failed' do
+          update(:mutation_a_test_result) { { passed: true } }
+
+          it { should be(false) }
+        end
+      end
+
+      context 'two results' do
+        include_context 'two results'
+
+        context 'when results are successful' do
+          it { should be(false) }
+        end
+
+        context 'when first result is unsuccessful' do
+          update(:mutation_a_test_result) { { passed: true } }
+
+          it { should be(false) }
+        end
+
+        context 'when second result is unsuccessful' do
+          update(:mutation_b_test_result) { { passed: true } }
+
+          it { should be(false) }
+        end
+      end
+    end
+
+    context 'with fail fast' do
+      update(:config) { { fail_fast: true } }
+
+      context 'no results' do
+        it { should be(false) }
+      end
+
+      context 'one result' do
+        include_context 'one result'
+
+        context 'when result is successful' do
+          it { should be(false) }
+        end
+
+        context 'when result failed' do
+          update(:mutation_a_test_result) { { passed: true } }
+
+          it { should be(true) }
+        end
+      end
+
+      context 'two results' do
+        include_context 'two results'
+
+        context 'when results are successful' do
+          it { should be(false) }
+        end
+
+        context 'when first result is unsuccessful' do
+          update(:mutation_a_test_result) { { passed: true } }
+
+          it { should be(true) }
+        end
+
+        context 'when second result is unsuccessful' do
+          update(:mutation_b_test_result) { { passed: true } }
+
+          it { should be(true) }
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutant/runner_spec.rb

@@ -1,87 +1,84 @@
 RSpec.describe Mutant::Runner do
-  setup_shared_context
-
-  let(:integration)    { double('Integration')      }
-  let(:master_sender)  { actor_env.spawn            }
-  let(:runner_actor)   { actor_env.mailbox(:runner) }
+  # setup_shared_context
+  class FakeEnv
+    def self.kill_mutation
+    end
 
-  before do
-    expect(integration).to receive(:setup).ordered
-    expect(Mutant::Runner::Master).to receive(:call).with(env).and_return(master_sender).ordered
+    def self.mutations
+      []
+    end
   end
 
   describe '.call' do
-    update(:config) { { integration: integration } }
-    let(:actor_names) { [:runner, :master] }
-
-    subject { described_class.call(env) }
+    let(:integration) { double('Integration')            }
+    let(:reporter)    { double('Reporter', delay: delay) }
+    let(:driver)      { double('Driver')                 }
+    let(:delay)       { double('Delay')                  }
+    let(:env)         { FakeEnv                          }
+    let(:env_result)  { double('Env Result')             }
+    let(:actor_env)   { double('Actor ENV')              }
+
+    let(:config) do
+      double(
+        'Config',
+        integration: integration,
+        reporter:    reporter,
+        actor_env:   actor_env,
+        jobs:        1
+      )
+    end
 
-    context 'when status done gets returned immediately' do
-      before do
-        message_sequence.add(:runner, :status, actor_env.mailbox(:current).sender)
-        message_sequence.add(:current, :status, status)
-        message_sequence.add(:runner, :stop, actor_env.mailbox(:current).sender)
-        message_sequence.add(:current, :stop)
-      end
+    before do
+      allow(FakeEnv).to receive(:config).and_return(config)
+    end
 
-      it 'returns env result' do
-        should be(status.env_result)
-      end
+    let(:parallel_config) do
+      Mutant::Parallel::Config.new(
+        jobs:      1,
+        env:       actor_env,
+        source:    Mutant::Parallel::Source::Array.new(env.mutations),
+        sink:      Mutant::Runner::Sink.new(env),
+        processor: env.method(:kill_mutation)
+      )
+    end
 
-      it 'logs start' do
-        expect { subject }.to change { config.reporter.start_calls }.from([]).to([env])
-      end
+    before do
+      expect(reporter).to receive(:start).with(env).ordered
+      expect(integration).to receive(:setup).ordered
+      expect(Mutant::Parallel).to receive(:async).with(parallel_config).and_return(driver).ordered
+    end
 
-      it 'logs process' do
-        expect { subject }.to change { config.reporter.progress_calls }.from([]).to([status])
-      end
+    subject { described_class.call(env) }
 
-      it 'logs result' do
-        expect { subject }.to change { config.reporter.report_calls }.from([]).to([status.env_result])
-      end
+    context 'when runner finishes immediately' do
+      let(:status) { double('Status', done: true, payload: env_result) }
 
-      it 'consumes all messages' do
-        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+      before do
+        expect(driver).to receive(:status).and_return(status)
+        expect(reporter).to receive(:progress).with(status).ordered
+        expect(driver).to receive(:stop).ordered
+        expect(reporter).to receive(:report).with(env_result).ordered
       end
     end
 
-    context 'when status done gets returned immediately' do
-      let(:incomplete_status) { status.update(done: false) }
+    context 'when report iterations are done' do
+      let(:status_a) { double('Status A', done: false)                     }
+      let(:status_b) { double('Status B', done: true, payload: env_result) }
 
       before do
-        expect(Kernel).to receive(:sleep).with(0.0).exactly(2).times.ordered
+        expect(driver).to receive(:status).and_return(status_a).ordered
+        expect(reporter).to receive(:progress).with(status_a).ordered
+        expect(Kernel).to receive(:sleep).with(reporter.delay).ordered
 
-        current_sender = actor_env.mailbox(:current).sender
+        expect(driver).to receive(:status).and_return(status_b).ordered
+        expect(reporter).to receive(:progress).with(status_b).ordered
+        expect(driver).to receive(:stop).ordered
 
-        message_sequence.add(:runner,  :status, current_sender)
-        message_sequence.add(:current, :status, incomplete_status)
-        message_sequence.add(:runner,  :status, current_sender)
-        message_sequence.add(:current, :status, incomplete_status)
-        message_sequence.add(:runner,  :status, current_sender)
-        message_sequence.add(:current, :status, status)
-        message_sequence.add(:runner,  :stop,   current_sender)
-        message_sequence.add(:current, :stop)
+        expect(reporter).to receive(:report).with(env_result).ordered
       end
 
       it 'returns env result' do
-        should be(status.env_result)
-      end
-
-      it 'logs start' do
-        expect { subject }.to change { config.reporter.start_calls }.from([]).to([env])
-      end
-
-      it 'logs result' do
-        expect { subject }.to change { config.reporter.report_calls }.from([]).to([status.env_result])
-      end
-
-      it 'logs process' do
-        expected = [incomplete_status, incomplete_status, status]
-        expect { subject }.to change { config.reporter.progress_calls }.from([]).to(expected)
-      end
-
-      it 'consumes all messages' do
-        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+        should be(env_result)
       end
     end
   end