mutant 0.8.24 → 0.9.0

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

@@ -1,49 +1,57 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Parallel::Source::Array do
-  let(:object) { described_class.new(jobs) }
+  subject { described_class.new(payloads) }
 
-  let(:job_a) { instance_double(Mutant::Parallel::Job) }
-  let(:job_b) { instance_double(Mutant::Parallel::Job) }
-  let(:job_c) { instance_double(Mutant::Parallel::Job) }
-
-  let(:jobs) { [job_a, job_b, job_c] }
+  let(:payloads) { %i[a b c] }
 
   describe '#next' do
-    subject { object.next }
+    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
-        should be(job_a)
+        expect(apply).to eql(job(index: 0, payload: :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)
+        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(:jobs) { [] }
+      let(:payloads) { [] }
 
       it 'raises error' do
-        expect { subject }.to raise_error(Mutant::Parallel::Source::NoJobError)
+        expect { apply }.to raise_error(Mutant::Parallel::Source::NoJobError)
       end
     end
   end
 
   describe '#next?' do
-    subject { object.next? }
+    def apply
+      subject.next?
+    end
 
     context 'when there is a next job' do
-      it { should be(true) }
+      it 'returns true' do
+        expect(apply).to be(true)
+      end
     end
 
     context 'when there is no next job' do
-      let(:jobs) { [] }
+      let(:payloads) { [] }
 
-      it { should be(false) }
+      it 'returns false' do
+        expect(apply).to be(false)
+      end
     end
   end
 end

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

@@ -1,68 +1,206 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Parallel::Worker do
-  let(:actor_env) do
-    FakeActor::Env.new(message_sequence, actor_names)
-  end
+  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(:message_sequence) { FakeActor::MessageSequence.new    }
-  let(:processor)        { instance_double(Proc)             }
-  let(:mailbox)          { actor_env.mailbox(:worker)        }
-  let(:parent)           { actor_env.mailbox(:parent).sender }
-  let(:payload)          { instance_double(Object)           }
-  let(:result_payload)   { instance_double(Object)           }
-
-  let(:attributes) do
-    {
-      processor: processor,
-      parent:    parent,
-      mailbox:   mailbox
-    }
-  end
+    let(:job_a) do
+      instance_double(
+        Mutant::Parallel::Source::Job,
+        payload: payload_a
+      )
+    end
 
-  before do
-    message_sequence.add(:parent, :ready, mailbox.sender)
-  end
+    let(:job_b) do
+      instance_double(
+        Mutant::Parallel::Source::Job,
+        payload: payload_b
+      )
+    end
 
-  describe '.run' do
-    subject { described_class.run(attributes) }
+    let(:var_active_jobs) do
+      instance_double(Mutant::Variable::IVar, 'active jobs')
+    end
 
-    let(:actor_names) { [:worker] }
+    let(:var_final) do
+      instance_double(Mutant::Variable::IVar, 'final')
+    end
 
-    context 'when receiving :job command' do
+    let(:var_running) do
+      instance_double(Mutant::Variable::MVar, 'running')
+    end
 
-      before do
-        expect(processor).to receive(:call).with(payload).and_return(result_payload)
+    let(:var_sink) do
+      instance_double(Mutant::Variable::IVar, 'sink')
+    end
 
-        message_sequence.add(:worker, :job, job)
-        message_sequence.add(:parent, :result, job_result)
-        message_sequence.add(:parent, :ready, mailbox.sender)
-        message_sequence.add(:worker, :stop)
-      end
+    let(:var_source) do
+      instance_double(Mutant::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
 
-      let(:index)           { instance_double(0.class)                                            }
-      let(:job_result)      { Mutant::Parallel::JobResult.new(job: job, payload: result_payload)  }
-      let(:job)             { Mutant::Parallel::Job.new(index: index, payload: payload)           }
+    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
 
-      it 'signals ready and status to parent' do
-        subject
+    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
 
-      it { should be(described_class) }
+    def modify_running
+      {
+        receiver: var_running,
+        selector: :modify,
+        reaction: { yields: [running] }
+      }
+    end
 
-      it 'consumes all messages' do
-        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+    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 receiving unknown command' do
-      before do
-        message_sequence.add(:worker, :other)
+    context 'when processing jobs till source is empty' do
+      let(:raw_expectations) do
+        [
+          with(var_source, source),
+          source_next?(false),
+          *finalize
+        ]
       end
 
-      it 'raises error' do
-        expect { subject }.to raise_error(Mutant::Actor::ProtocolError, 'Unknown command: :other')
+      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

@@ -2,17 +2,114 @@
 
 RSpec.describe Mutant::Parallel do
   describe '.async' do
-    subject { described_class.async(config) }
+    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(Mutant::Variable::IVar, 'active jobs')
+    end
+
+    let(:var_final) do
+      instance_double(Mutant::Variable::IVar, 'final')
+    end
+
+    let(:var_running) do
+      instance_double(Mutant::Variable::MVar, 'running')
+    end
 
-    let(:config)  { instance_double(Mutant::Parallel::Config, env: env)       }
-    let(:env)     { instance_double(Mutant::Actor::Env, new_mailbox: mailbox) }
-    let(:mailbox) { Mutant::Actor::Mailbox.new                                }
-    let(:master)  { instance_double(Mutant::Parallel::Master)                 }
+    let(:var_sink) do
+      instance_double(Mutant::Variable::IVar, 'sink')
+    end
 
-    before do
-      expect(described_class::Master).to receive(:call).with(config).and_return(master)
+    let(:var_source) do
+      instance_double(Mutant::Variable::IVar, 'source')
     end
 
-    it { should eql(described_class::Driver.new(mailbox.bind(master))) }
+    def ivar(value, **attributes)
+      {
+        receiver:  Mutant::Variable::IVar,
+        selector:  :new,
+        arguments: [
+          condition_variable: condition_variable,
+          mutex:              mutex,
+          **attributes
+        ],
+        reaction:  { return: value }
+      }
+    end
+
+    def mvar(*arguments)
+      ivar(*arguments).merge(receiver: Mutant::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/range_spec.rb

@@ -0,0 +1,141 @@
+# 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