mutant 0.9.9 → 0.9.14

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

data/spec/unit/mutant/parallel_spec.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Parallel do
-  describe '.async' do
-    def apply
-      described_class.async(config)
-    end
-
-    let(:condition_variable) { class_double(ConditionVariable)          }
-    let(:jobs)               { 2                                        }
-    let(:mutex)              { class_double(Mutex)                      }
-    let(:processor)          { instance_double(Proc)                    }
-    let(:sink)               { instance_double(described_class::Sink)   }
-    let(:source)             { instance_double(described_class::Source) }
-    let(:thread)             { class_double(Thread)                     }
-    let(:thread_a)           { instance_double(Thread)                  }
-    let(:thread_b)           { instance_double(Thread)                  }
-    let(:worker)             { -> {}                                    }
-
-    let(:config) do
-      Mutant::Parallel::Config.new(
-        condition_variable: condition_variable,
-        jobs:               jobs,
-        mutex:              mutex,
-        processor:          processor,
-        sink:               sink,
-        source:             source,
-        thread:             thread
-      )
-    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
-
-    def ivar(value, **attributes)
-      {
-        receiver:  Variable::IVar,
-        selector:  :new,
-        arguments: [
-          condition_variable: condition_variable,
-          mutex:              mutex,
-          **attributes
-        ],
-        reaction:  { return: value }
-      }
-    end
-
-    def mvar(*arguments)
-      ivar(*arguments).merge(receiver: Variable::MVar)
-    end
-
-    let(:raw_expectations) do
-      [
-        ivar(var_active_jobs, value: Set.new),
-        ivar(var_final),
-        ivar(var_sink, value: sink),
-        mvar(var_running, value: 2),
-        ivar(var_source, value: source),
-        {
-          receiver:  Mutant::Parallel::Worker,
-          selector:  :new,
-          arguments: [
-            processor:       processor,
-            var_active_jobs: var_active_jobs,
-            var_final:       var_final,
-            var_running:     var_running,
-            var_sink:        var_sink,
-            var_source:      var_source
-          ],
-          reaction:  { return: worker }
-        },
-        {
-          receiver: thread,
-          selector: :new,
-          reaction: { yields: [], return: thread_a }
-        },
-        {
-          receiver: thread,
-          selector: :new,
-          reaction: { yields: [], return: thread_b }
-        }
-      ]
-    end
-
-    it 'returns driver' do
-      verify_events do
-        expect(apply).to eql(
-          described_class::Driver.new(
-            threads:         [thread_a, thread_b],
-            var_active_jobs: var_active_jobs,
-            var_final:       var_final,
-            var_sink:        var_sink
-          )
-        )
-      end
-    end
-  end
-end

data/spec/unit/mutant/parser_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Parser do
-  let(:object) { described_class.new }
-
-  describe '#call' do
-    let(:path) { instance_double(Pathname) }
-
-    subject { object.call(path) }
-
-    before do
-      expect(path).to receive(:read)
-        .with(no_args)
-        .and_return(':source')
-    end
-
-    it 'returns parsed source' do
-      expect(subject).to eql(s(:sym, :source))
-    end
-
-    it 'is idempotent' do
-      source = object.call(path)
-      expect(subject).to be(source)
-    end
-  end
-end

data/spec/unit/mutant/range_spec.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-describe Mutant::Range do
-  describe '.overlap?' do
-    def apply
-      described_class.overlap?(left, right)
-    end
-
-    context 'no overlap left before right' do
-      # |---|
-      #       |---|
-      let(:left)  { 1..2 }
-      let(:right) { 3..4 }
-
-      it 'returns false' do
-        expect(apply).to be(false)
-      end
-    end
-
-    context 'no overlap right before left' do
-      #       |---|
-      # |---|
-      let(:left)  { 3..4 }
-      let(:right) { 1..2 }
-
-      it 'returns false' do
-        expect(apply).to be(false)
-      end
-    end
-
-    context 'left includes right' do
-      # |----------------|
-      #       |---|
-      let(:left)  { 1..4 }
-      let(:right) { 2..3 }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'right includes left' do
-      #       |---|
-      # |----------------|
-      let(:left)  { 2..3 }
-      let(:right) { 1..4 }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'right starts with left end' do
-      # |----|
-      #      |----|
-      let(:left)  { 1..2 }
-      let(:right) { 2..3 }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'left starts with right end' do
-      #      |----|
-      # |----|
-      let(:left)  { 2..3 }
-      let(:right) { 1..2 }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'left starts with right start' do
-      # |----|
-      # |---------|
-      let(:left)  { 1..2 }
-      let(:right) { 1..3 }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'left starts with right start' do
-      # |---------|
-      # |----|
-      let(:left)  { 1..3 }
-      let(:right) { 1..2 }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'left ends with right end' do
-      #      |----|
-      # |---------|
-      let(:left)  { 2..3 }
-      let(:right) { 1..3 }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'right ends with left end' do
-      # |---------|
-      #      |----|
-      let(:left)  { 1..3 }
-      let(:right) { 2..3 }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'left end intersects with right' do
-      # |---------|
-      #      |----------|
-      let(:left)  { 1..3 }
-      let(:right) { 2..4 }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-
-    context 'right end intersects with left' do
-      #      |----------|
-      # |---------|
-      let(:left)  { 2..4 }
-      let(:right) { 1..2 }
-
-      it 'returns true' do
-        expect(apply).to be(true)
-      end
-    end
-  end
-end