mutest 0.0.1 → 0.0.2

data/spec/unit/mutest/meta/example_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Mutest::Meta::Example do
+  let(:object) do
+    described_class.new(
+      file:      file,
+      node:      node,
+      node_type: node.type,
+      expected:  mutation_nodes
+    )
+  end
+
+  let(:file)           { 'foo/bar.rb'         }
+  let(:node)           { s(:true)             }
+  let(:mutation_nodes) { [s(:nil), s(:false)] }
+
+  let(:mutations) do
+    mutation_nodes.map do |node|
+      Mutest::Mutation::Evil.new(object, node)
+    end
+  end
+
+  describe '#source' do
+    subject { object.source }
+
+    it { is_expected.to eql('true') }
+  end
+
+  describe '#verification' do
+    subject { object.verification }
+
+    it { is_expected.to eql(Mutest::Meta::Example::Verification.new(object, mutations)) }
+  end
+end

data/spec/unit/mutest/mutation_spec.rb

@@ -0,0 +1,129 @@
+RSpec.describe Mutest::Mutation do
+  let(:mutation_class) do
+    Class.new(Mutest::Mutation) do
+      const_set(:SYMBOL, 'test'.freeze)
+      const_set(:TEST_PASS_SUCCESS, true)
+    end
+  end
+
+  let(:context) { instance_double(Mutest::Context) }
+
+  let(:object) do
+    mutation_class.new(mutation_subject, Mutest::AST::Nodes::N_NIL)
+  end
+
+  let(:mutation_subject) do
+    instance_double(
+      Mutest::Subject,
+      identification: 'subject',
+      context:        context,
+      source:         'original'
+    )
+  end
+
+  describe '#insert' do
+    subject { object.insert(kernel) }
+
+    let(:root_node) { s(:foo)                 }
+    let(:kernel)    { instance_double(Kernel) }
+
+    before do
+      expect(context).to receive(:root)
+        .with(object.node)
+        .and_return(root_node)
+
+      expect(mutation_subject).to receive(:prepare)
+        .ordered
+        .and_return(mutation_subject)
+
+      expect(Mutest::Loader).to receive(:call)
+        .ordered
+        .with(
+          binding: TOPLEVEL_BINDING,
+          kernel:  kernel,
+          node:    root_node,
+          subject: mutation_subject
+        )
+        .and_return(Mutest::Loader)
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+  describe '#code' do
+    subject { object.code }
+
+    it { is_expected.to eql('8771a') }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#original_source' do
+    subject { object.original_source }
+
+    it { is_expected.to eql('original') }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#source' do
+    subject { object.source }
+
+    it { is_expected.to eql('nil') }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '.success?' do
+    subject { mutation_class.success?(test_result) }
+
+    let(:test_result) do
+      instance_double(
+        Mutest::Result::Test,
+        passed: passed
+      )
+    end
+
+    context 'on mutation with positive pass expectation' do
+      context 'when Result::Test#passed equals expectation' do
+        let(:passed) { true }
+
+        it { is_expected.to be(true) }
+      end
+
+      context 'when Result::Test#passed NOT equals expectation' do
+        let(:passed) { false }
+
+        it { is_expected.to be(false) }
+      end
+    end
+
+    context 'on mutation with negative pass expectation' do
+      let(:mutation_class) do
+        Class.new(super()) do
+          const_set(:TEST_PASS_SUCCESS, false)
+        end
+      end
+
+      context 'when Result::Test#passed equals expectation' do
+        let(:passed) { true }
+
+        it { is_expected.to be(false) }
+      end
+
+      context 'when Result::Test#passed NOT equals expectation' do
+        let(:passed) { false }
+
+        it { is_expected.to be(true) }
+      end
+    end
+  end
+
+  describe '#identification' do
+    subject { object.identification }
+
+    it { is_expected.to eql('test:subject:8771a') }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

data/spec/unit/mutest/mutator/node_spec.rb

@@ -0,0 +1,43 @@
+Mutest::Meta::Example::ALL.each.group_by(&:node_type).each do |type, examples|
+  RSpec.describe Mutest::Mutator::REGISTRY.lookup(type) do
+    toplevel_nodes = examples.map { |example| example.node.type }.uniq
+
+    it "generates the correct mutations on #{toplevel_nodes} toplevel examples" do
+      examples.each do |example|
+        verification = example.verification
+        fail verification.error_report unless verification.success?
+      end
+    end
+  end
+end
+
+RSpec.describe Mutest::Mutator::Node do
+  describe 'internal DSL' do
+    let(:klass) do
+      Class.new(described_class) do
+        children(:left, :right)
+
+        def dispatch
+          left
+          emit_left(s(:nil))
+          emit_right_mutations do |node|
+            node.eql?(s(:nil))
+          end
+        end
+      end
+    end
+
+    def apply
+      klass.call(s(:and, s(:true), s(:true)), ->(_) {})
+    end
+
+    specify do
+      expect(apply).to eql(
+        [
+          s(:and, s(:nil), s(:true)),
+          s(:and, s(:true), s(:nil))
+        ].to_set
+      )
+    end
+  end
+end

data/spec/unit/mutest/mutator_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Mutest::Mutator do
+  subject do
+    Class.new(described_class) do
+      const_set(:REGISTRY, Mutest::Registry.new)
+
+      handle :send
+
+      def dispatch
+        emit(parent)
+      end
+    end
+  end
+
+  describe '.handle' do
+    it 'registers mutator' do
+      mutations = subject.mutate(s(:send), ->(_) {}, s(:parent))
+      expect(mutations).to eql([s(:parent)].to_set)
+    end
+  end
+
+  context 'when dispatch is disabled' do
+    it 'does not produce mutations' do
+      input     = s(:send)
+      filter    = ->(node) { node.equal?(input) }
+      mutations = subject.mutate(input, filter, s(:parent))
+
+      expect(mutations.empty?).to be(true)
+    end
+  end
+end

data/spec/unit/mutest/parallel/driver_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe Mutest::Parallel::Driver do
+  let(:object) { described_class.new(binding) }
+
+  let(:binding) { instance_double(Mutest::Actor::Binding) }
+  let(:value)   { instance_double(Object, 'value')        }
+
+  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(value)
+    end
+
+    it { is_expected.to be(value) }
+  end
+end

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

@@ -0,0 +1,335 @@
+RSpec.describe Mutest::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)                { Mutest::Parallel::Job.new(index: 0, payload: job_payload_a)                }
+  let(:job_b)                { Mutest::Parallel::Job.new(index: 1, payload: job_payload_b)                }
+  let(:job_result_a)         { Mutest::Parallel::JobResult.new(job: job_a, payload: job_result_payload_a) }
+  let(:job_result_b)         { Mutest::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 { is_expected.to 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
+    Mutest::Parallel::Config.new(
+      env:       actor_env,
+      jobs:      1,
+      processor: processor,
+      sink:      sink,
+      source:    Mutest::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(Mutest::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(Mutest::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 { is_expected.to 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)  { Mutest::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)  { Mutest::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)  { Mutest::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)  { Mutest::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(Mutest::Actor::ProtocolError, 'Unexpected message: :foo')
+      end
+    end
+  end
+end