sisyphus 0.2.3 → 0.2.5

data/spec/sisyphus/master_spec.rb

@@ -1,192 +1,112 @@
+require 'spec_helper'
 require_relative '../../lib/sisyphus/master'
 
 module Sisyphus
   describe Master do
-    subject(:master) { Master.new job }
+    subject(:master) { Master.new job, worker_pool: worker_pool }
 
-    before(:each) { master.stub :puts }
+    let(:worker_pool) { double :worker_pool }
+
+    before(:each) {
+      allow(master).to receive(:puts)
+      allow(master).to receive(:sleep)
+    }
 
     let(:job) { double(:job) }
     let(:pipes) { [double(:reader_pipe), double(:writer_pipe)] }
 
-    describe 'when receiving the start_worker message' do
-      it 'forks' do
-        master.should_receive(:fork) { 666 }
-        master.start_worker
-      end
-
-      describe 'in the worker process' do
-        let(:worker) { double :worker }
-
-        before :each do
-          master.stub(:fork) { nil }
-          IO.stub(:pipe) { pipes }
-          pipes.first.stub(:close)
-          Process.stub(:pid) { 666 }
-          master.stub :exit!
-          Worker.stub(:new) { worker }
-          worker.stub(:setup)
-          worker.stub(:start)
-        end
-
-        it 'should setup the worker' do
-          worker.should_receive :setup
-          master.start_worker
-        end
+    it 'creates a worker' do
+      execution_strategy = double :execution_strategy
+      master = Master.new job
+      allow(master).to receive(:execution_strategy) { execution_strategy }
+      worker = master.create_worker
+      expect(worker.job).to eq(job)
+      expect(worker.execution_strategy).to eq(execution_strategy)
+    end
 
-        it 'should rename the process' do
-          master.should_receive(:process_name=).with("Worker #{666}")
-          master.start_worker
-        end
+    describe 'when it has running workers' do
 
-        it 'starts a worker after forking' do
-          worker.should_receive :start
-          master.start_worker
-        end
+      let(:workers) { double :workers }
 
-        it 'gives the writer pipe to the worker' do
-          Worker.should_receive(:new).with(job, pipes.last, master.logger) { worker }
-          master.start_worker
-        end
+      it 'stops all workers when receiving stop_all' do
+        allow(worker_pool).to receive(:workers) { workers }
+        allow(workers).to receive(:each).and_yield({ pid: 666 }).and_yield({ pid: 667 })
+        allow(workers).to receive(:length).and_return(2, 1, 0)
 
-        it 'closes the reader pipe' do
-          pipes.first.should_receive :close
-          master.start_worker
-        end
+        expect(master).to receive(:stop_worker).with(666).ordered
+        expect(master).to receive(:stop_worker).with(667).ordered
 
-        describe 'when an exception is raised' do
-          let(:logger) { double(:logger) }
-
-          it 'should log the exception' do
-            master.stub(:logger).and_return logger
-            pipes.last.stub(:write)
-            worker.stub(:setup).and_raise :raised_by_spec
-            logger.should_receive :warn
-            master.start_worker
-          end
-
-          it 'should write to the writer pipe' do
-            master.stub(:logger).and_return logger
-            worker.stub(:setup).and_raise :raised_by_spec
-            logger.stub :warn
-            pipes.last.should_receive(:write).with Worker::UNCAUGHT_ERROR
-            master.start_worker
-          end
-        end
+        master.stop_all
       end
 
-      describe 'in the master process' do
+      describe 'and it receives stop_worker message' do
         before :each do
-          master.stub(:fork) { 666 }
-          IO.stub(:pipe) { pipes }
-          pipes.last.stub(:close)
-        end
-
-        it 'increases worker_count' do
-          master.start_worker
-          master.worker_count.should eq(1)
-        end
-
-        it 'should open a pipe' do
-          IO.should_receive(:pipe) { pipes }
-          master.start_worker
+          allow(worker_pool).to receive(:workers) { workers }
+          allow(workers).to receive(:find) { |&block| block.call({ pid: 666 }) }
         end
 
-        it 'should close the writer pipe' do
-          pipes.last.should_receive :close
-          master.start_worker
-        end
-      end
-    end
-
-    describe 'when it has running workers' do
-      before :each do
-        pipes.each { |p| p.stub :close }
-        IO.stub(:pipe) { pipes }
-        master.stub(:fork) { 666 }
-        master.start_worker
-        Process.stub(:kill).with('INT', 666)
-        Process.stub(:waitpid2).with(666)
-      end
-
-      describe 'and it receives stop_worker message' do
         it 'kills a child with the INT signal' do
-          Process.should_receive(:kill).with('INT', 666)
+          expect(Process).to receive(:kill).with('INT', 666)
           master.stop_worker(666)
         end
-      end
-
-      it 'stops all workers when receiving stop_all' do
-        Process.stub(:kill).with('INT', 666)
-        Process.stub(:wait2) { 666 }
 
-        master.should_receive(:stop_worker).with(666).exactly(master.worker_count).times.and_call_original
-
-        master.stop_all
-      end
-    end
-
-    describe 'when there are no running workers' do
-      describe 'and it receives stop_worker' do
-        it 'raises an error' do
-          expect { master.stop_worker(666) }.not_to raise_error
+        it 'kills nothing if no worker corresponds to the pid' do
+          expect(Process).not_to receive(:kill).with('INT', 667)
+          master.stop_worker(667)
         end
       end
 
-      describe 'and it receives stop_all' do
-        it 'does nothing' do
-          master.should_not_receive(:stop_worker)
-          master.stop_all
-        end
-      end
     end
 
     it 'starts the specified number of workers when started' do
-      master = Master.new nil, workers: 3
-      master.stub :puts
-      master.stub :watch_for_output
-      master.should_receive(:start_worker).exactly(3).times
+      master = Master.new nil, workers: 3, worker_pool: worker_pool
+      allow(master).to receive(:puts)
+      allow(master).to receive(:watch_for_output)
+      allow(master).to receive(:sleep)
+      expect(worker_pool).to receive(:spawn_worker).exactly(3).times
       master.start
     end
 
     describe 'when number of workers is zero' do
-      let(:master) { Master.new nil, workers: 0 }
+      let(:master) { Master.new nil, workers: 0, worker_pool: worker_pool }
 
-      before(:each) { master.stub :puts }
+      before(:each) { allow(master).to receive(:puts) }
 
       it 'should not start workers' do
-        master.stub :watch_for_output
-        master.should_not_receive :start_worker
+        allow(master).to receive(:trap_signals)
+        allow(master).to receive(:watch_for_output)
+        expect(worker_pool).not_to receive(:spawn_worker)
         master.start
       end
     end
 
     it 'attaches a signal handler when started' do
-      Signal.should_receive(:trap).with(:INT)
-      Signal.should_receive(:trap).with(:TTIN)
-      Signal.should_receive(:trap).with(:TTOU)
-      master.stub :start_worker
-      master.stub :watch_for_output
+      allow(worker_pool).to receive(:spawn_worker)
+      allow(master).to receive(:watch_for_output)
+
+      expect(Signal).to receive(:trap).with(:TTIN)
+      expect(Signal).to receive(:trap).with(:INT)
+      expect(Signal).to receive(:trap).with(:TTOU)
+
       master.start
     end
 
     it 'should watch for output' do
-      master.stub :start_worker
-      master.should_receive :watch_for_output
+      allow(worker_pool).to receive(:spawn_worker)
+      allow(master).to receive(:trap_signals)
+      expect(master).to receive(:watch_for_output)
       master.start
     end
 
     it 'can resolve a wpid from a reader pipe' do
-      IO.stub(:pipe) { pipes }
-      pipes.each { |p| p.stub(:close) }
-      pipes.first.stub(:fileno) { 213 }
-      master.stub(:fork) { 666 }
-      master.start_worker
-
-      master.send(:worker_pid, pipes.first).should eq(666)
+      pipe = double :pipe
+      allow(pipe).to receive(:fileno) { 123 }
+      allow(worker_pool).to receive(:workers) { [{ pid: 666, reader: pipe }] }
+      expect(master.send(:worker_pid, pipe)).to eq(666)
     end
 
     it 'raises if it can\'t resolve a wpid from a reader pipe' do
+      allow(worker_pool).to receive(:workers) { [] }
       expect { master.send(:worker_pid, pipes.first) }.to raise_error("Unknown worker pipe")
     end
   end

data/spec/sisyphus/simple_execution_strategy_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require_relative '../../lib/sisyphus/simple_execution_strategy'
+
+module Sisyphus
+  describe SimpleExecutionStrategy do
+
+    let(:job) { double :job }
+    let(:strategy) { SimpleExecutionStrategy.new }
+
+    it 'should perform the job when executed' do
+      expect(job).to receive(:perform)
+      strategy.execute job
+    end
+
+    it 'should call the error_handler if the job fails' do
+      error_message = "This is a horrible failure.. The Universe is probably ending!"
+      error = Exception.new(error_message)
+      process_name = "uber awesome process name"
+      allow(job).to receive(:perform) { fail error }
+      allow(strategy).to receive(:process_name) { process_name }
+      strategy.execute job, ->(name, raised_error) {
+        expect(name).to eq(process_name)
+        expect(raised_error).to eq(error)
+      }
+    end
+
+  end
+end

data/spec/sisyphus/worker_pool_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require_relative '../../lib/sisyphus/master'
+require_relative '../../lib/sisyphus/worker_pool'
+
+module Sisyphus
+  describe WorkerPool do
+
+    subject(:worker_pool) { WorkerPool.new worker_factory }
+
+    describe 'when receiving the spawn_worker message' do
+
+      let(:job) { double :job }
+      let(:worker_factory) { Master.new(job) }
+      let(:pipes) { [double(:output), double(:input)] }
+
+      it 'retrieves a worker from the worker_factory' do
+        allow(worker_pool).to receive(:fork) { 3267 }
+        expect(worker_factory).to receive(:create_worker).and_call_original
+        worker_pool.spawn_worker
+      end
+
+      it 'forks' do
+        expect(worker_pool).to receive(:fork) { 666 }
+        worker_pool.spawn_worker
+      end
+
+      describe 'in the worker process' do
+
+        let(:worker) { double :worker }
+
+        before :each do
+          allow(worker_pool).to receive(:fork) { nil }
+          allow(worker_pool).to receive(:process_name=)
+          allow(worker).to receive(:start)
+          allow(worker).to receive(:atfork_child)
+        end
+
+        it 'runs Worker#atfork_child' do
+          allow(worker_factory).to receive(:create_worker) { worker }
+          expect(worker).to receive(:atfork_child).with(no_args)
+          worker_pool.spawn_worker
+        end
+
+        it 'renames the process' do
+          allow(worker_factory).to receive(:create_worker) { worker }
+          expect(worker_pool).to receive(:process_name=).with("Worker #{Process.pid}")
+          worker_pool.spawn_worker
+        end
+
+        it 'starts the worker' do
+          allow(worker_factory).to receive(:create_worker) { worker }
+          allow(worker).to receive(:atfork_child)
+          expect(worker).to receive(:start)
+          worker_pool.spawn_worker
+        end
+
+      end
+
+      describe 'in the master process' do
+
+        before :each do
+          allow(worker_pool).to receive(:fork) { Process.pid }
+          allow(pipes.last).to receive(:close)
+          allow(IO).to receive(:pipe) { pipes }
+        end
+
+        it 'closes the input pipe' do
+          worker = double :worker
+          allow(worker).to receive(:to_master)
+          allow(worker_factory).to receive(:create_worker) { worker }
+          expect(worker).to receive(:atfork_parent).with(no_args)
+          worker_pool.spawn_worker
+        end
+
+        it 'adds the worker pid and output pipe to the list of workers' do
+          expect(worker_pool.workers).to receive(:<<).with({ pid: Process.pid, reader: pipes.first })
+          worker_pool.spawn_worker
+        end
+      end
+    end
+  end
+end

data/spec/sisyphus/worker_spec.rb

@@ -1,126 +1,128 @@
+require 'spec_helper'
 require_relative '../../lib/sisyphus/worker'
 
 module Sisyphus
   describe Worker do
     let(:job) { double :job }
-    let(:output) { double :pipe }
+    let(:execution_strategy) { double :execution_strategy }
     let(:logger) { double :logger }
-    let(:worker) { Worker.new job, output, logger }
 
-    it 'traps signals when started' do
-      worker.stub :exit!
-      worker.instance_variable_set(:@stopped, true)
-      worker.should_receive :trap_signals
+    subject(:worker) { Worker.new job, execution_strategy, logger }
+
+    it 'sets up itself and executes run when started' do
+      expect(worker).to receive(:setup).ordered
+      expect(worker).to receive(:run).ordered
       worker.start
     end
 
-    it 'exits when it has been stopped' do
-      worker.instance_variable_set(:@stopped, true)
-      worker.should_receive :exit!
-      worker.start
+    it 'traps INT signals before setting up the job' do
+      allow(job).to receive(:respond_to?).with(:setup) { true }
+      expect(Signal).to receive(:trap).with('INT').ordered
+      expect(job).to receive(:setup).ordered
+      worker.setup
     end
 
-    context 'when job does not respond to :setup' do
-      it 'does not call job.setup' do
-        job.stub(:respond_to?).with(:setup) { false }
-        job.should_not_receive :setup
-        Worker.new job, output, logger
-      end
+    it 'does not perform the job when it has been stopped' do
+      worker.stop
+      allow(worker).to receive(:exit!)
+      expect(worker).not_to receive(:perform_job)
+      worker.run
     end
 
-    context 'when job responds to :setup' do
-      it 'sets up the job' do
-        job.stub(:respond_to?).with(:setup) { true }
-        job.should_receive :setup
-        worker.setup
-      end
+    it 'will not run if it has not been set up' do
+      expect(worker).not_to receive(:perform_job)
+      allow(worker).to receive(:exit!)
+      worker.run
     end
 
-    context 'in the child process' do
-      before :each do
-        worker.stub(:fork) { nil }
-      end
+    it 'uses execution_strategy to perform the job' do
+      expect(execution_strategy).to receive(:execute).with job, an_instance_of(Proc)
+      worker.perform_job
+    end
+
+    it 'passes the error_handler to the execution strategy' do
+      allow(execution_strategy).to receive(:execute).with job, an_instance_of(Proc)
+      expect(worker).to receive(:error_handler) { ->{} }
+      worker.perform_job
+    end
+
+    it 'only closes the output in atfork_parent' do
+      expect(worker.output).to receive(:close)
+      expect(worker.to_master).not_to receive(:close)
+      worker.atfork_parent
+    end
+
+    it 'only closes the to_master in atfork_child' do
+      expect(worker.to_master).to receive(:close)
+      expect(worker.output).not_to receive(:close)
+      worker.atfork_child
+    end
 
-      it 'should perform the job' do
-        job.should_receive :perform
-        worker.stub :exit!
-        worker.send :perform_job
+    context 'the error_handler' do
+
+      it 'writes the UNCAUGHT_ERROR to output' do
+        allow(logger).to receive(:warn)
+        expect(worker.output).to receive(:write).with Worker::UNCAUGHT_ERROR
+        worker.error_handler.call(:name, :error)
       end
 
-      it 'should exit after having performed the job' do
-        job.stub :perform
-        worker.should_receive(:exit!).with 0
-        worker.send :perform_job
+      it 'logs the error being thrown' do
+        the_name = :the_name
+        the_exception = :the_exception
+        expect(worker.logger).to receive(:warn) do |name, &block|
+          expect(name).to eq(the_name)
+          expect(block.call).to eq(the_exception)
+        end
+        worker.error_handler.call(the_name, the_exception)
       end
 
-      it 'should change process name' do
-        job.stub :perform
-        worker.stub :exit!
-        Process.stub(:ppid) { 666 }
-        worker.should_receive(:process_name=).with "Child of worker 666"
-        worker.send :perform_job
+      it 'does not write UNCAUGHT_ERROR to output if the worker is stopped' do
+        allow(worker).to receive(:stopped?) { true }
+        expect(worker.output).to_not receive(:write)
+        worker.error_handler.call(:name, :error)
+        expect(worker.output).to_not receive(:write)
+        worker.error_handler.call(:name, :error)
       end
 
-      context 'when job.perform raises an error' do
-        it 'should exit with a non-zero status' do
-          logger.stub :warn
-          job.stub(:perform).and_raise Exception.new "should be rescued!"
-          worker.should_receive(:exit!).with(1)
-          worker.send :perform_job
-        end
+    end
 
-        it 'should log the raised error' do
-          worker.stub(:exit!).with(1)
-          job.stub(:perform).and_raise Exception.new "should be rescued!"
-          logger.should_receive :warn
-          worker.send :perform_job
-        end
+    context 'when job does not respond to :setup' do
+      it 'does not call job.setup' do
+        allow(job).to receive(:respond_to?).with(:setup) { false }
+        expect(job).not_to receive(:setup)
+        worker.setup
       end
     end
 
-    context 'in the worker process' do
-      let(:status) { double(:status) }
+    context 'when job responds to :setup' do
 
       before :each do
-        worker.stub(:fork) { 666 }
+        allow(job).to receive(:respond_to?).with(:setup) { true }
       end
 
-      it 'spawns a process and waits for it to finish' do
-        worker.should_receive(:fork) { 666 }
-        status.stub(:success?) { true }
-        Process.should_receive(:waitpid2).with(666) { [666, status] }
-        worker.send :perform_job
+      it 'sets up the job' do
+        expect(job).to receive(:setup)
+        worker.setup
       end
 
-      context 'when exit status from the child is non-zero' do
+      context 'and job#setup raises an exception' do
+
         before :each do
-          status.stub(:success?) { false }
-          Process.stub(:waitpid2) { [666, status] }
+          allow(job).to receive(:setup).and_raise(Exception)
+          allow(logger).to receive(:warn)
         end
 
-        it 'writes an error message to the output' do
-          output.should_receive(:write).with Worker::UNCAUGHT_ERROR
-          worker.send :perform_job
+        it 'handles the exception' do
+          expect { worker.setup }.not_to raise_error(Exception)
         end
 
-        it "doesn't write error byte to output when it has been stopped" do
-          worker.stub(:stopped?) { true }
-          output.should_not_receive :write
-          worker.send :perform_job
+        it 'calls the error_handler in the rescue block' do
+          expect(worker.output).to receive(:write).with(Worker::UNCAUGHT_ERROR)
+          worker.setup
         end
-      end
 
-      context 'when exit status from child is zero' do
-        before :each do
-          status.stub(:success?) { true }
-          Process.stub(:waitpid2) { [666, status] }
-        end
-
-        it "doesn't write error byte to output" do
-          output.should_not_receive :write
-          worker.send :perform_job
-        end
       end
     end
+
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end