mutant 0.9.7 → 0.9.12

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Meta::Example do
-  let(:object) do
-    described_class.new(
-      file:     file,
-      node:     node,
-      types:    [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|
-      Mutant::Mutation::Evil.new(object, node)
-    end
-  end
-
-  describe '#source' do
-    subject { object.source }
-
-    it { should eql('true') }
-  end
-
-  describe '#verification' do
-    subject { object.verification }
-
-    it { should eql(Mutant::Meta::Example::Verification.new(object, mutations)) }
-  end
-end

data/spec/unit/mutant/mutation_spec.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Mutation do
-  let(:mutation_class) do
-    Class.new(Mutant::Mutation) do
-      const_set(:SYMBOL, 'test')
-      const_set(:TEST_PASS_SUCCESS, true)
-    end
-  end
-
-  let(:context) { instance_double(Mutant::Context) }
-
-  let(:object) do
-    mutation_class.new(mutation_subject, Mutant::AST::Nodes::N_NIL)
-  end
-
-  let(:mutation_subject) do
-    instance_double(
-      Mutant::Subject,
-      identification: 'subject',
-      context:        context,
-      source:         'original'
-    )
-  end
-
-  describe '#insert' do
-    subject { object }
-
-    def apply
-      subject.insert(kernel)
-    end
-
-    let(:expected_source) { '1'                                     }
-    let(:kernel)          { instance_double(Kernel)                 }
-    let(:loader_result)   { instance_double(Mutant::Loader::Result) }
-    let(:root_node)       { s(:int, 1)                              }
-
-    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(Mutant::Loader).to receive(:call)
-        .ordered
-        .with(
-          binding: TOPLEVEL_BINDING,
-          kernel:  kernel,
-          source:  expected_source,
-          subject: mutation_subject
-        )
-        .and_return(loader_result)
-    end
-
-    it 'returns loader result' do
-      expect(apply).to be(loader_result)
-    end
-  end
-
-  describe '#code' do
-    subject { object.code }
-
-    it { should eql('8771a') }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#original_source' do
-    subject { object.original_source }
-
-    it { should eql('original') }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#source' do
-    subject { object.source }
-
-    it { should 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(
-        Mutant::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 { should be(true) }
-      end
-
-      context 'when Result::Test#passed NOT equals expectation' do
-        let(:passed) { false }
-
-        it { should 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 { should be(false) }
-      end
-
-      context 'when Result::Test#passed NOT equals expectation' do
-        let(:passed) { false }
-
-        it { should be(true) }
-      end
-    end
-  end
-
-  describe '#identification' do
-
-    subject { object.identification }
-
-    it { should eql('test:subject:8771a') }
-
-    it_should_behave_like 'an idempotent method'
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-aggregate = Hash.new { |hash, key| hash[key] = [] }
-
-Mutant::Meta::Example::ALL
-  .each_with_object(aggregate) do |example, agg|
-    example.types.each do |type|
-      agg[Mutant::Mutator::REGISTRY.lookup(type)] << example
-    end
-  end
-
-aggregate.each do |mutator, examples|
-  RSpec.describe mutator do
-    it 'generates expected mutations' do
-      examples.each do |example|
-        verification = example.verification
-        fail verification.error_report unless verification.success?
-      end
-    end
-  end
-end
-
-RSpec.describe Mutant::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/mutant/mutator_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Mutator do
-  describe '.handle' do
-    subject do
-      Class.new(described_class) do
-        const_set(:REGISTRY, Mutant::Registry.new)
-
-        handle :send
-
-        def dispatch
-          emit(parent)
-        end
-      end
-    end
-
-    it 'should register mutator' do
-      expect(subject.mutate(s(:send), s(:parent))).to eql([s(:parent)].to_set)
-    end
-  end
-end

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

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Parallel::Driver do
-  let(:active_jobs) { []                                    }
-  let(:thread_a)    { instance_double(Thread, alive?: true) }
-  let(:thread_b)    { instance_double(Thread, alive?: true) }
-  let(:threads)     { [thread_a, thread_b]                  }
-  let(:timeout)     { instance_double(Float)                }
-  let(:sink_status) { instance_double(Object)               }
-
-  let(:sink) do
-    instance_double(
-      Mutant::Parallel::Sink,
-      status: sink_status
-    )
-  end
-
-  let(:var_active_jobs) do
-    instance_double(Variable::IVar, 'active jobs')
-  end
-
-  let(:var_final) do
-    instance_double(Variable::IVar, 'final')
-  end
-
-  let(:var_sink) do
-    instance_double(Variable::IVar, 'sink')
-  end
-
-  subject do
-    described_class.new(
-      threads:         threads,
-      var_active_jobs: var_active_jobs,
-      var_final:       var_final,
-      var_sink:        var_sink
-    )
-  end
-
-  describe '#wait_timeout' do
-    def apply
-      subject.wait_timeout(timeout)
-    end
-
-    shared_examples 'returns expected status' do
-      it 'returns expected status' do
-        verify_events do
-          expect(apply).to eql(expected_status)
-        end
-      end
-
-      it 'returns frozen copy of active jobs' do
-        verify_events do
-          returned_active_jobs = apply.active_jobs
-
-          expect(returned_active_jobs).to_not be(active_jobs)
-          expect(returned_active_jobs.frozen?).to be(true)
-        end
-      end
-    end
-
-    let(:raw_expectations) do
-      [
-        {
-          receiver:  var_final,
-          selector:  :take_timeout,
-          arguments: [timeout],
-          reaction:  { return: Variable.const_get(:Result)::Timeout.new }
-        },
-        {
-          receiver: var_active_jobs,
-          selector: :with,
-          reaction: { yields: [active_jobs] }
-        },
-        {
-          receiver: var_sink,
-          selector: :with,
-          reaction: { yields: [sink] }
-        }
-      ]
-    end
-
-    context 'when not done' do
-      let(:expected_status) do
-        Mutant::Parallel::Status.new(
-          active_jobs: active_jobs,
-          done:        false,
-          payload:     sink_status
-        )
-      end
-
-      include_examples 'returns expected status'
-    end
-
-    context 'when done' do
-      before do
-        allow(thread_a).to receive_messages(alive?: false)
-        allow(thread_b).to receive_messages(alive?: false)
-      end
-
-      let(:raw_expectations) do
-        [
-          *super(),
-          {
-            receiver: thread_a,
-            selector: :join
-          },
-          {
-            receiver: thread_b,
-            selector: :join
-          }
-        ]
-
-      end
-
-      let(:expected_status) do
-        Mutant::Parallel::Status.new(
-          active_jobs: active_jobs,
-          done:        true,
-          payload:     sink_status
-        )
-      end
-
-      include_examples 'returns expected status'
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Parallel::Source::Array do
-  subject { described_class.new(payloads) }
-
-  let(:payloads) { %i[a b c] }
-
-  describe '#next' do
-    def job(**attributes)
-      Mutant::Parallel::Source::Job.new(attributes)
-    end
-
-    def apply
-      subject.next
-    end
-
-    context 'when there is a next job' do
-      it 'returns that job' do
-        expect(apply).to eql(job(index: 0, payload: :a))
-      end
-
-      it 'does not return the same job twice' do
-        expect(apply).to eql(job(index: 0, payload: :a))
-        expect(apply).to eql(job(index: 1, payload: :b))
-        expect(apply).to eql(job(index: 2, payload: :c))
-      end
-    end
-
-    context 'when there is no next job' do
-      let(:payloads) { [] }
-
-      it 'raises error' do
-        expect { apply }.to raise_error(Mutant::Parallel::Source::NoJobError)
-      end
-    end
-  end
-
-  describe '#next?' do
-    def apply
-      subject.next?
-    end
-
-    context 'when there is a next job' do
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'when there is no next job' do
-      let(:payloads) { [] }
-
-      it 'returns false' do
-        expect(apply).to be(false)
-      end
-    end
-  end
-end

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

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Parallel::Worker do
-  describe '#call' do
-    let(:active_jobs)  { instance_double(Set)                      }
-    let(:payload_a)    { instance_double(Object)                   }
-    let(:payload_b)    { instance_double(Object)                   }
-    let(:processor)    { instance_double(Proc)                     }
-    let(:result_a)     { instance_double(Object)                   }
-    let(:result_b)     { instance_double(Object)                   }
-    let(:running)      { 1                                         }
-    let(:sink)         { instance_double(Mutant::Parallel::Sink)   }
-    let(:source)       { instance_double(Mutant::Parallel::Source) }
-    let(:thread_a)     { instance_double(Thread, alive?: true)     }
-    let(:thread_b)     { instance_double(Thread, alive?: true)     }
-    let(:threads)      { [thread_a, thread_b]                      }
-    let(:timeout)      { instance_double(Float)                    }
-
-    let(:job_a) do
-      instance_double(
-        Mutant::Parallel::Source::Job,
-        payload: payload_a
-      )
-    end
-
-    let(:job_b) do
-      instance_double(
-        Mutant::Parallel::Source::Job,
-        payload: payload_b
-      )
-    end
-
-    let(:var_active_jobs) do
-      instance_double(Variable::IVar, 'active jobs')
-    end
-
-    let(:var_final) do
-      instance_double(Variable::IVar, 'final')
-    end
-
-    let(:var_running) do
-      instance_double(Variable::MVar, 'running')
-    end
-
-    let(:var_sink) do
-      instance_double(Variable::IVar, 'sink')
-    end
-
-    let(:var_source) do
-      instance_double(Variable::IVar, 'source')
-    end
-
-    subject do
-      described_class.new(
-        processor:       processor,
-        var_active_jobs: var_active_jobs,
-        var_final:       var_final,
-        var_running:     var_running,
-        var_sink:        var_sink,
-        var_source:      var_source
-      )
-    end
-
-    def apply
-      subject.call
-    end
-
-    def sink_result(result)
-      {
-        receiver:  sink,
-        selector:  :result,
-        arguments: [result]
-      }
-    end
-
-    def sink_stop?(value)
-      {
-        receiver: sink,
-        selector: :stop?,
-        reaction: { return: value }
-      }
-    end
-
-    def source_next?(value)
-      {
-        receiver: source,
-        selector: :next?,
-        reaction: { return: value }
-      }
-    end
-
-    def source_next(value)
-      {
-        receiver: source,
-        selector: :next,
-        reaction: { return: value }
-      }
-    end
-
-    def with(var, value)
-      {
-        receiver: var,
-        selector: :with,
-        reaction: { yields: [value] }
-      }
-    end
-
-    def process(payload, result)
-      {
-        receiver:  processor,
-        selector:  :call,
-        arguments: [payload],
-        reaction:  { return: result }
-      }
-    end
-
-    def add_job(job)
-      {
-        receiver:  active_jobs,
-        selector:  :<<,
-        arguments: [job]
-      }
-    end
-
-    def remove_job(job)
-      {
-        receiver:  active_jobs,
-        selector:  :delete,
-        arguments: [job]
-      }
-    end
-
-    shared_examples 'worker execution' do
-      it 'terminates after processing all jobs' do
-        verify_events { expect(apply).to be(subject) }
-      end
-    end
-
-    def modify_running
-      {
-        receiver: var_running,
-        selector: :modify,
-        reaction: { yields: [running] }
-      }
-    end
-
-    def finalize
-      [
-        modify_running,
-        {
-          receiver:  var_final,
-          selector:  :put,
-          arguments: [nil]
-        }
-      ]
-    end
-
-    context 'when processing jobs till sink stops accepting' do
-      let(:raw_expectations) do
-        [
-          with(var_source, source),
-          source_next?(true),
-          source_next(job_a),
-          with(var_active_jobs, active_jobs),
-          add_job(job_a),
-          process(payload_a, result_a),
-          with(var_active_jobs, active_jobs),
-          remove_job(job_a),
-          with(var_sink, sink),
-          sink_result(result_a),
-          sink_stop?(true),
-          *finalize
-        ]
-      end
-
-      include_examples 'worker execution'
-    end
-
-    context 'when processing jobs till source is empty' do
-      let(:raw_expectations) do
-        [
-          with(var_source, source),
-          source_next?(false),
-          *finalize
-        ]
-      end
-
-      include_examples 'worker execution'
-    end
-
-    context 'when worker exits as others are still going' do
-      let(:running) { 2 }
-
-      let(:raw_expectations) do
-        [
-          with(var_source, source),
-          source_next?(false),
-          modify_running
-          # no finalize
-        ]
-      end
-
-      include_examples 'worker execution'
-    end
-  end
-end