mutant 0.6.7 → 0.7.1

data/spec/support/shared_context.rb

@@ -0,0 +1,135 @@
+module SharedContext
+  def update(name, &block)
+    define_method(name) do
+      super().update(instance_eval(&block))
+    end
+  end
+
+  def messages(&block)
+    let(:message_sequence) do
+      FakeActor::MessageSequence.new.tap do |sequence|
+         sequence.instance_eval(&block)
+      end
+    end
+  end
+
+  # rubocop:disable MethodLength
+  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_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]                                                   }
+    let(:matchable_scopes) { double('matchable scopes', length: 10)                                     }
+    let(:test_a)           { double('test a', identification: 'test-a')                                 }
+    let(:test_b)           { double('test b', identification: 'test-b')                                 }
+    let(:actor_names)      { []                                                                         }
+    let(:message_sequence) { FakeActor::MessageSequence.new                                             }
+
+    let(:config) do
+      Mutant::Config::DEFAULT.update(
+        actor_env: actor_env,
+        jobs:      1,
+        reporter:  Mutant::Reporter::Trace.new
+      )
+    end
+
+    let(:actor_env) do
+      FakeActor::Env.new(message_sequence, actor_names)
+    end
+
+    let(:subject_a) do
+      double(
+        'subject a',
+        node:           s(:true),
+        source:         'true',
+        tests:          [test_a],
+        identification: 'subject-a'
+      )
+    end
+
+    before do
+      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,
+        runtime:         4.0,
+        subject_results: [subject_a_result]
+      )
+    end
+
+    let(:mutation_a_node) { s(:false) }
+    let(:mutation_b_node) { s(:nil)   }
+
+    let(:mutation_b) { Mutant::Mutation::Evil.new(subject_a, mutation_b_node) }
+    let(:mutation_a) { Mutant::Mutation::Evil.new(subject_a, mutation_a_node) }
+
+    let(:mutation_a_result) do
+      Mutant::Result::Mutation.new(
+        index:       1,
+        mutation:    mutation_a,
+        test_result: mutation_a_test_result
+      )
+    end
+
+    let(:mutation_b_result) do
+      Mutant::Result::Mutation.new(
+        index:       1,
+        mutation:    mutation_a,
+        test_result: mutation_b_test_result
+      )
+    end
+
+    let(:mutation_a_test_result) do
+      Mutant::Result::Test.new(
+        tests:    [test_a],
+        passed:   false,
+        runtime:  1.0,
+        output:  'mutation a test result output'
+      )
+    end
+
+    let(:mutation_b_test_result) do
+      Mutant::Result::Test.new(
+        tests:    [test_a],
+        passed:   false,
+        runtime:  1.0,
+        output:   'mutation b test result output'
+      )
+    end
+
+    let(:subject_a_result) do
+      Mutant::Result::Subject.new(
+        subject:          subject_a,
+        mutation_results: [mutation_a_result, mutation_b_result]
+      )
+    end
+
+    let(:empty_subject_a_result) do
+      subject_a_result.update(mutation_results: [])
+    end
+
+    let(:partial_subject_a_result) do
+      subject_a_result.update(mutation_results: [mutation_a_result])
+    end
+  end
+end

data/spec/unit/mutant/actor/actor_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Mutant::Actor do
+  let(:mutex) { double('Mutex') }
+  let(:thread)  { double('Thread') }
+
+  before do
+    expect(Mutex).to receive(:new).and_return(mutex)
+  end
+
+  describe Mutant::Actor::Actor do
+    let(:mailbox) { Mutant::Actor::Mailbox.new }
+
+    let(:object) { described_class.new(thread, mailbox) }
+
+    describe '#bind' do
+      let(:other) { double('Sender') }
+
+      subject { object.bind(other) }
+
+      it { should eql(Mutant::Actor::Binding.new(object, other)) }
+    end
+
+    describe '#sender' do
+      subject { object.sender }
+      it { should eql(Mutant::Actor::Sender.new(thread, mutex, [])) }
+    end
+
+    describe '#receiver' do
+      subject { object.receiver }
+
+      it 'returns receiver' do
+        should eql(Mutant::Actor::Receiver.new(mutex, []))
+      end
+    end
+  end
+end

data/spec/unit/mutant/actor/binding_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Mutant::Actor::Binding do
+  let(:actor_a)    { double('Actor-A', sender: sender_a, receiver: receiver_a) }
+  let(:sender_a)   { double('Sender-A')                                        }
+  let(:sender_b)   { double('Sender-B')                                        }
+  let(:receiver_a) { double('Receiver-A')                                      }
+  let(:payload)    { double('Payload')                                         }
+  let(:type)       { double('Type')                                            }
+
+  let(:object) { described_class.new(actor_a, sender_b) }
+
+  describe '#call' do
+    subject { object.call(type) }
+
+    before do
+      expect(sender_b).to receive(:call).with(message(type, sender_a)).ordered
+      expect(receiver_a).to receive(:call).ordered.and_return(message(response_type, payload))
+    end
+
+    context 'when return type equals request type' do
+      let(:response_type) { type }
+      it { should be(payload) }
+    end
+
+    context 'when return type NOT equals request type' do
+      let(:response_type) { double('Other Type') }
+
+      it 'raises error' do
+        expect { subject }.to raise_error(Mutant::Actor::ProtocolError, "Expected #{type} but got #{response_type}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+RSpec.describe Mutant::Actor::Env do
+  let(:mutex)       { double('Mutex')                           }
+  let(:thread)      { double('Thread')                          }
+  let(:thread_root) { double('Thread Root')                     }
+  let(:actor)       { Mutant::Actor::Actor.new(thread, mailbox) }
+
+  let(:object) { described_class.new(thread_root) }
+
+  before do
+    expect(Mutex).to receive(:new).and_return(mutex)
+  end
+
+  describe '#current' do
+    subject { object.current }
+
+    let!(:mailbox)    { Mutant::Actor::Mailbox.new                }
+
+    before do
+      expect(Mutant::Actor::Mailbox).to receive(:new).and_return(mailbox).ordered
+      expect(thread_root).to receive(:current).and_return(thread)
+    end
+
+    it { should eql(actor) }
+  end
+
+  describe '#spawn' do
+    subject { object.spawn(&block) }
+
+    let!(:mailbox)    { Mutant::Actor::Mailbox.new                }
+
+    let(:yields) { [] }
+
+    let(:block) { ->(actor) { yields << actor } }
+
+    before do
+      expect(Mutant::Actor::Mailbox).to receive(:new).and_return(mailbox).ordered
+      expect(thread_root).to receive(:new).and_yield.and_return(thread).ordered
+      expect(thread_root).to receive(:current).and_return(thread).ordered
+    end
+
+    it 'returns sender' do
+      should eql(actor.sender)
+    end
+
+    it 'yields actor' do
+      expect { subject }.to change { yields }.from([]).to([actor])
+    end
+  end
+end

data/spec/unit/mutant/actor/message_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Mutant::Actor::Message do
+
+  let(:type)    { double('Type')    }
+  let(:payload) { double('Payload') }
+
+  describe '.new' do
+    subject { described_class.new(*arguments) }
+
+    context 'with one argument' do
+      let(:arguments) { [type] }
+
+      its(:type)    { should be(type) }
+      its(:payload) { should be(Mutant::Actor::Undefined) }
+    end
+
+    context 'with two arguments' do
+      let(:arguments) { [type, payload] }
+
+      its(:type)    { should be(type)    }
+      its(:payload) { should be(payload) }
+    end
+  end
+end

data/spec/unit/mutant/actor/receiver_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe Mutant::Actor::Receiver do
+  let(:mailbox) { double('Mailbox') }
+  let(:mutex)   { double('Mutex')   }
+  let(:message) { double('Message') }
+
+  let(:object) { described_class.new(mutex, mailbox) }
+
+  describe '#call' do
+    subject { object.call }
+
+    context 'when mailbox contains a message' do
+      before do
+        expect(mutex).to receive(:lock).ordered
+        expect(mailbox).to receive(:empty?).and_return(false).ordered
+        expect(mailbox).to receive(:shift).and_return(message).ordered
+        expect(mutex).to receive(:unlock).ordered
+      end
+
+      it { should be(message) }
+    end
+
+    context 'when mailbox initially contains no message' do
+      before do
+        # 1rst failing try
+        expect(mutex).to receive(:lock).ordered
+        expect(mailbox).to receive(:empty?).and_return(true).ordered
+        expect(mutex).to receive(:unlock).ordered
+        expect(Thread).to receive(:stop).ordered
+        # 2nd successful try
+        expect(mutex).to receive(:lock).ordered
+        expect(mailbox).to receive(:empty?).and_return(false).ordered
+        expect(mailbox).to receive(:shift).and_return(message).ordered
+        expect(mutex).to receive(:unlock).ordered
+      end
+
+      it 'waits for message' do
+        should be(message)
+      end
+    end
+
+    context 'when mailbox contains no message but thread gets waken without message arrived' do
+      before do
+        # 1rst failing try
+        expect(mutex).to receive(:lock).ordered
+        expect(mailbox).to receive(:empty?).and_return(true).ordered
+        expect(mutex).to receive(:unlock).ordered
+        expect(Thread).to receive(:stop).ordered
+        # 2nd failing try
+        expect(mutex).to receive(:lock).ordered
+        expect(mailbox).to receive(:empty?).and_return(true).ordered
+        expect(mutex).to receive(:unlock).ordered
+        expect(Thread).to receive(:stop).ordered
+      end
+
+      it 'waits for message' do
+        expect { subject }.to raise_error(Mutant::Actor::ProtocolError)
+      end
+    end
+  end
+end

data/spec/unit/mutant/actor/sender_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Mutant::Actor::Sender do
+  let(:object)   { described_class.new(thread, mutex, mailbox) }
+
+  let(:thread)   { double('Thread')       }
+  let(:mutex)    { double('Mutex')        }
+  let(:mailbox)  { double('Mailbox')      }
+  let(:type)     { double('Type')         }
+  let(:payload)  { double('Payload')      }
+  let(:_message) { message(type, payload) }
+
+  describe '#call' do
+    subject { object.call(_message) }
+
+    before do
+      expect(mutex).to receive(:synchronize).ordered.and_yield
+      expect(mailbox).to receive(:<<).with(_message)
+      expect(thread).to receive(:run)
+    end
+
+    it_should_behave_like 'a command method'
+  end
+end

data/spec/unit/mutant/cli_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe Mutant::CLI do
       expect(Mutant::Runner).to receive(:call).with(env).and_return(report)
     end
 
-    context 'when report signalls success' do
+    context 'when report signals success' do
       let(:report_success) { true }
 
       it 'exits failure' do
@@ -155,11 +155,24 @@ Options:
     end
 
     context 'with use flag' do
-      let(:flags) { %w[--use rspec] }
+      context 'when integration exists' do
+        let(:flags) { %w[--use rspec] }
 
-      it_should_behave_like 'a cli parser'
+        it_should_behave_like 'a cli parser'
+
+        let(:expected_integration) { Mutant::Integration::Rspec.new }
+      end
 
-      let(:expected_integration) { Mutant::Integration::Rspec.build }
+      context 'when integration does NOT exist' do
+        let(:flags) { %w[--use other] }
+
+        it 'raises error' do
+          expect { subject }.to raise_error(
+            Mutant::CLI::Error,
+            'Could not load integration "other" (you may want to try installing the gem mutant-other)'
+          )
+        end
+      end
     end
 
     context 'with version flag' do

data/spec/unit/mutant/env_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe Mutant::Env do
           end
         end
 
-        expected_warnings = ["Class#name from: #{klass} raised an error: RuntimeError fix your lib to follow normal ruby semantics!"]
+        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)
 
@@ -33,7 +33,7 @@ RSpec.describe Mutant::Env do
           end
         end
 
-        expected_warnings = ["Class#name from: #{klass.inspect} returned #{Object.inspect} instead String or nil. Fix your lib to follow normal ruby semantics!"]
+        expected_warnings = ["Class#name from: #{klass.inspect} returned Object. #{Mutant::Env::SEMANTICS_MESSAGE}"]
 
         expect { subject }.to change { config.reporter.warn_calls }.from([]).to(expected_warnings)
 

data/spec/unit/mutant/mailbox_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe Mutant::Actor::Mailbox do
+  describe '.new' do
+    subject { described_class.new }
+
+    its(:frozen?) { should be(true) }
+  end
+
+  before do
+    allow(Mutex).to receive(:new).and_return(mutex)
+  end
+
+  let(:mutex)  { double('Mutex')     }
+  let(:object) { described_class.new }
+  let(:thread) { double('Thread') }
+
+  describe '#sender' do
+    subject { object.sender(thread) }
+
+    it { should eql(Mutant::Actor::Sender.new(thread, mutex, [])) }
+  end
+
+  describe '#receiver' do
+    subject { object.receiver }
+
+    it { should eql(Mutant::Actor::Receiver.new(mutex, [])) }
+  end
+
+  describe '#actor' do
+    subject { object.actor(thread) }
+
+    it { should eql(Mutant::Actor::Actor.new(thread, object)) }
+  end
+end