dat-worker-pool 0.5.0 → 0.6.0

data/test/unit/queue_tests.rb

@@ -1,108 +1,131 @@
 require 'assert'
 require 'dat-worker-pool/queue'
 
-class DatWorkerPool::Queue
+module DatWorkerPool::Queue
 
   class UnitTests < Assert::Context
     desc "DatWorkerPool::Queue"
     setup do
-      @queue = DatWorkerPool::Queue.new
-    end
-    subject{ @queue }
+      @queue_class = Class.new do
+        include DatWorkerPool::Queue
 
-    should have_accessors :on_push_callbacks, :on_pop_callbacks
-    should have_imeths :work_items, :push, :pop, :empty?
-    should have_imeths :start, :shutdown, :shutdown?
+        attr_reader :start_called, :shutdown_called
+        attr_reader :push_called_with
+        attr_accessor :pop_result
 
-    should "default its callbacks" do
-      assert_equal [], subject.on_push_callbacks
-      assert_equal [], subject.on_pop_callbacks
-    end
+        def initialize
+          @start_called     = false
+          @shutdown_called  = false
+          @push_called_with = nil
+          @pop_result       = nil
+        end
 
-    should "allow pushing work items onto the queue with #push" do
-      subject.push 'work'
-      assert_equal [ 'work' ], subject.work_items
-    end
+        def start!;    @start_called = true;    end
+        def shutdown!; @shutdown_called = true; end
 
-    should "call its on push callback when work is pushed" do
-      on_push_called = false
-      subject.on_push_callbacks << proc{ on_push_called = true }
-      subject.push 'work'
-      assert_true on_push_called
+        def push!(*args); @push_called_with = args; end
+        def pop!; @pop_result; end
+      end
     end
+    subject{ @queue_class }
 
-    should "raise an exception if trying to push work when shutdown" do
-      subject.shutdown
-      assert_raises(RuntimeError){ subject.push('work') }
+    should "raise a not implemented error for `dwp_push` and `dwp_pop` by default" do
+      queue_class = Class.new{ include DatWorkerPool::Queue }
+      queue = queue_class.new.tap(&:dwp_start)
+
+      assert_raises(NotImplementedError){ queue.dwp_push(Factory.string) }
+      assert_raises(NotImplementedError){ queue.dwp_pop }
     end
 
-    should "pop work items off the queue with #pop" do
-      subject.push 'work1'
-      subject.push 'work2'
+  end
 
-      assert_equal 2, subject.work_items.size
-      assert_equal 'work1', subject.pop
-      assert_equal 1, subject.work_items.size
-      assert_equal 'work2', subject.pop
-      assert_equal 0, subject.work_items.size
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @queue = @queue_class.new
     end
+    subject{ @queue }
+
+    should have_imeths :work_items
+    should have_imeths :dwp_start, :dwp_signal_shutdown, :dwp_shutdown
+    should have_imeths :running?, :shutdown?
+    should have_imeths :dwp_push, :dwp_pop
 
-    should "call its on pop callback when work is popped" do
-      subject.push 'work'
-      on_pop_called = false
-      subject.on_pop_callbacks << proc{ on_pop_called = true }
-      subject.pop
-      assert_true on_pop_called
+    should "raise a not implemented error using `work_items`" do
+      assert_raises(NotImplementedError){ subject.work_items }
     end
 
-    should "return nothing with pop when the queue has been shutdown" do
-      subject.push 'work1'
-      subject.shutdown
-      assert_nil subject.pop
+    should "set its flags using `dwp_start` and `dwp_shutdown`" do
+      assert_false subject.running?
+      assert_true  subject.shutdown?
+      subject.dwp_start
+      assert_true  subject.running?
+      assert_false subject.shutdown?
+      subject.dwp_shutdown
+      assert_false subject.running?
+      assert_true  subject.shutdown?
     end
 
-    should "return whether the queue is empty or not with #empty?" do
-      assert subject.empty?
-      subject.push 'work'
-      assert_not subject.empty?
-      subject.pop
-      assert subject.empty?
+    should "call `start!` using `dwp_start`" do
+      assert_false subject.start_called
+      subject.dwp_start
+      assert_true subject.start_called
     end
 
-    should "reset its shutdown flag when started" do
-      assert_false subject.shutdown?
-      subject.shutdown
-      assert_true subject.shutdown?
-      subject.start
-      assert_false subject.shutdown?
+    should "set its shutdown flag using `dwp_signal_shutdown`" do
+      assert_false subject.running?
+      assert_false subject.shutdown_called
+      subject.dwp_start
+      assert_true  subject.running?
+      assert_false subject.shutdown_called
+      subject.dwp_signal_shutdown
+      assert_false subject.running?
+      assert_false subject.shutdown_called
     end
 
-  end
+    should "call `shutdown!` using `dwp_shutdown`" do
+      assert_false subject.shutdown_called
+      subject.dwp_shutdown
+      assert_true subject.shutdown_called
+    end
 
-  class SignallingTests < UnitTests
-    desc "mutex and condition variable behavior"
-    setup do
-      @thread = Thread.new do
-        Thread.current['work_item'] = @queue.pop || 'got nothing'
-      end
+    should "raise an error if `dwp_push` is called when the queue isn't running" do
+      assert_false subject.running?
+      assert_raise(RuntimeError){ subject.dwp_push(Factory.string) }
+      subject.dwp_start
+      assert_nothing_raised{ subject.dwp_push(Factory.string) }
+      subject.dwp_shutdown
+      assert_raise(RuntimeError){ subject.dwp_push(Factory.string) }
     end
 
-    should "have threads wait for a work item to be added when using pop" do
-      assert_equal "sleep", @thread.status
+    should "call `push!` using `dwp_push`" do
+      subject.dwp_start
+
+      work_item = Factory.string
+      subject.dwp_push(work_item)
+      assert_equal [work_item], subject.push_called_with
+
+      args = Factory.integer(3).times.map{ Factory.string }
+      subject.dwp_push(*args)
+      assert_equal args, subject.push_called_with
     end
 
-    should "wakeup threads when work is pushed onto the queue" do
-      subject.push 'some work'
-      sleep 0.1
-      assert !@thread.alive?
-      assert_equal 'some work', @thread['work_item']
+    should "return nothing if `dwp_pop` is called when the queue isn't running" do
+      subject.pop_result = Factory.string
+      assert_false subject.running?
+      assert_nil subject.dwp_pop
+      subject.dwp_start
+      assert_not_nil subject.dwp_pop
+      subject.dwp_shutdown
+      assert_nil subject.dwp_pop
     end
 
-    should "wakeup thread when the queue is shutdown" do
-      subject.shutdown
-      sleep 0.1
-      assert !@thread.alive?
-      assert_equal 'got nothing', @thread['work_item']
+    should "call `pop!` using `dwp_pop`" do
+      subject.dwp_start
+      subject.pop_result = Factory.string
+
+      value = subject.dwp_pop
+      assert_equal subject.pop_result, value
     end
 
   end

data/test/unit/runner_tests.rb

@@ -0,0 +1,365 @@
+require 'assert'
+require 'dat-worker-pool/runner'
+
+require 'dat-worker-pool/default_queue'
+
+class DatWorkerPool::Runner
+
+  class UnitTests < Assert::Context
+    desc "DatWorkerPool::Runner"
+    setup do
+      @runner_class = DatWorkerPool::Runner
+    end
+    subject{ @runner_class }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      # at least 2 workers, up to 4
+      @num_workers   = Factory.integer(3) + 1
+      @logger        = TEST_LOGGER || Logger.new("/dev/null")
+      @queue         = DatWorkerPool::DefaultQueue.new
+      @worker_class  = TestWorker
+      @worker_params = { Factory.string => Factory.string }
+
+      @workers = DatWorkerPool::LockedArray.new
+      Assert.stub(DatWorkerPool::LockedArray, :new){ @workers }
+
+      @available_workers_spy = DatWorkerPool::LockedSet.new
+      Assert.stub(DatWorkerPool::LockedSet, :new){ @available_workers_spy }
+
+      @options = {
+        :num_workers   => @num_workers,
+        :logger        => @logger,
+        :queue         => @queue,
+        :worker_class  => @worker_class,
+        :worker_params => @worker_params
+      }
+      @runner = @runner_class.new(@options)
+    end
+    teardown do
+      @runner.shutdown(0) rescue false
+    end
+    subject{ @runner }
+
+    should have_readers :num_workers, :worker_class, :worker_params
+    should have_readers :logger_proxy, :queue
+    should have_imeths :workers, :start, :shutdown
+    should have_imeths :available_worker_count, :worker_available?
+    should have_imeths :make_worker_available, :make_worker_unavailable
+    should have_imeths :worker_log
+
+    should "know its attributes" do
+      assert_equal @num_workers,   subject.num_workers
+      assert_equal @worker_class,  subject.worker_class
+      assert_equal @worker_params, subject.worker_params
+      assert_equal @queue,         subject.queue
+
+      assert_instance_of LoggerProxy, subject.logger_proxy
+      assert_equal @logger, subject.logger_proxy.logger
+    end
+
+    should "default its logger" do
+      @options.delete(:logger)
+      runner = @runner_class.new(@options)
+      assert_instance_of NullLoggerProxy, runner.logger_proxy
+    end
+
+    should "know its workers" do
+      assert_equal @workers.values, subject.workers
+      @workers.push(Factory.string)
+      assert_equal @workers.values, subject.workers
+    end
+
+    should "start its queue when its started" do
+      assert_false @queue.running?
+      subject.start
+      assert_true @queue.running?
+    end
+
+    should "build and add workers when its started" do
+      subject.start
+
+      assert_equal @num_workers, subject.workers.size
+      subject.workers.each_with_index do |worker, n|
+        assert_equal subject, worker.dwp_runner
+        assert_equal @queue,  worker.dwp_queue
+        assert_equal n + 1,   worker.dwp_number
+        assert_true worker.dwp_running?
+      end
+    end
+
+    should "allow making workers available/unavailable" do
+      worker = @worker_class.new(@runner, @queue, Factory.integer(10))
+
+      assert_not_includes worker.object_id, @available_workers_spy.values
+      assert_false subject.worker_available?
+      subject.make_worker_available(worker)
+      assert_includes worker.object_id, @available_workers_spy.values
+      assert_true subject.worker_available?
+      subject.make_worker_unavailable(worker)
+      assert_not_includes worker.object_id, @available_workers_spy.values
+      assert_false subject.worker_available?
+    end
+
+    should "know how many workers are available" do
+      worker = @worker_class.new(@runner, @queue, Factory.integer(10))
+
+      assert_equal 0, subject.available_worker_count
+      subject.make_worker_available(worker)
+      assert_equal 1, subject.available_worker_count
+      subject.make_worker_unavailable(worker)
+      assert_equal 0, subject.available_worker_count
+    end
+
+    should "allow logging messages using `log`" do
+      logged_message = nil
+      Assert.stub(subject.logger_proxy, :runner_log) do |&mb|
+        logged_message = mb.call
+      end
+
+      text = Factory.text
+      subject.log{ text }
+      assert_equal text, logged_message
+    end
+
+    should "allow workers to log messages using `worker_log`" do
+      passed_worker  = nil
+      logged_message = nil
+      Assert.stub(subject.logger_proxy, :worker_log) do |w, &mb|
+        passed_worker  = w
+        logged_message = mb.call
+      end
+      worker = @worker_class.new(@runner, @queue, Factory.integer(10))
+
+      text = Factory.text
+      subject.worker_log(worker){ text }
+      assert_same worker, passed_worker
+      assert_equal text, logged_message
+    end
+
+  end
+
+  class ShutdownSetupTests < InitTests
+    desc "and started and shutdown"
+
+  end
+
+  class ShutdownTests < ShutdownSetupTests
+    setup do
+      @timeout_seconds         = nil
+      @optional_timeout_called = false
+      # this acts as a spy but also keeps the shutdown from ever timing out
+      Assert.stub(OptionalTimeout, :new) do |secs, &block|
+        @timeout_seconds         = secs
+        @optional_timeout_called = true
+        block.call
+      end
+
+      @options[:worker_class] = ShutdownSpyWorker
+      @runner = @runner_class.new(@options)
+      @runner.start
+      # we need a reference to the workers, the runners workers will get removed
+      # as they shutdown
+      @running_workers = @runner.workers.dup
+    end
+
+    should "optionally timeout when shutdown" do
+      subject.shutdown
+      assert_nil @timeout_seconds
+      assert_true @optional_timeout_called
+
+      @optional_timeout_called = false
+      seconds = Factory.integer
+      subject.shutdown(seconds)
+      assert_equal seconds, @timeout_seconds
+      assert_true @optional_timeout_called
+    end
+
+    should "shutdown all of its workers" do
+      @running_workers.each do |worker|
+        assert_false worker.dwp_shutdown?
+      end
+      subject.shutdown(Factory.boolean ? Factory.integer : nil)
+      @running_workers.each do |worker|
+        assert_true worker.dwp_shutdown?
+      end
+    end
+
+    should "shutdown its queue" do
+      assert_false @queue.shutdown?
+      subject.shutdown(Factory.boolean ? Factory.integer : nil)
+      assert_true @queue.shutdown?
+    end
+
+    should "join its workers waiting for them to finish" do
+      @running_workers.each do |worker|
+        assert_false worker.join_called
+      end
+      subject.shutdown(Factory.boolean ? Factory.integer : nil)
+      @running_workers.each do |worker|
+        assert_true worker.join_called
+      end
+    end
+
+    should "join all workers even if one raises an error when joined" do
+      @running_workers.choice.join_error = Factory.exception
+      subject.shutdown(Factory.boolean ? Factory.integer : nil)
+      @running_workers.each do |worker|
+        assert_true worker.join_called
+      end
+    end
+
+    should "remove workers as they finish" do
+      assert_false subject.workers.empty?
+      subject.shutdown(Factory.boolean ? Factory.integer : nil)
+      assert_true subject.workers.empty?
+    end
+
+    should "remove workers and make them unavailable even if they error" do
+      @running_workers.each{ |w| w.join_error = Factory.exception }
+
+      assert_false subject.workers.empty?
+      assert_false @available_workers_spy.empty?
+      subject.shutdown(Factory.boolean ? Factory.integer : nil)
+      assert_true subject.workers.empty?
+      assert_true @available_workers_spy.empty?
+    end
+
+    should "force its workers to shutdown if a timeout error occurs" do
+      Assert.stub(OptionalTimeout, :new){ raise TimeoutInterruptError }
+      subject.shutdown(Factory.integer)
+
+      @running_workers.each do |worker|
+        assert_instance_of DatWorkerPool::ShutdownError, worker.raised_error
+        assert_true worker.join_called
+      end
+      assert_true subject.workers.empty?
+      assert_true @available_workers_spy.empty?
+    end
+
+    should "force its workers to shutdown if a non-timeout error occurs" do
+      queue_exception = Factory.exception
+      Assert.stub(@queue, :dwp_shutdown){ raise queue_exception }
+
+      caught_exception = nil
+      begin
+        subject.shutdown(Factory.integer)
+      rescue StandardError => caught_exception
+      end
+      assert_same queue_exception, caught_exception
+
+      @running_workers.each do |worker|
+        assert_instance_of DatWorkerPool::ShutdownError, worker.raised_error
+        assert_true worker.join_called
+      end
+      assert_true subject.workers.empty?
+      assert_true @available_workers_spy.empty?
+    end
+
+    should "force shutdown all of its workers even if one raises an error when joining" do
+      Assert.stub(OptionalTimeout, :new){ raise TimeoutInterruptError }
+      error_class = Factory.boolean ? DatWorkerPool::ShutdownError : RuntimeError
+      @running_workers.choice.join_error = Factory.exception(error_class)
+      subject.shutdown(Factory.boolean ? Factory.integer : nil)
+
+      @running_workers.each do |worker|
+        assert_instance_of DatWorkerPool::ShutdownError, worker.raised_error
+        assert_true worker.join_called
+      end
+      assert_true subject.workers.empty?
+      assert_true @available_workers_spy.empty?
+    end
+
+  end
+
+  class LoggerProxyTests < UnitTests
+    desc "LoggerProxy"
+    setup do
+      @stringio     = StringIO.new
+      @logger       = Logger.new(@stringio)
+      @logger_proxy = LoggerProxy.new(@logger)
+    end
+    subject{ @logger_proxy }
+
+    should have_readers :logger
+    should have_imeths :runner_log, :worker_log
+
+    should "know its logger" do
+      assert_equal @logger, subject.logger
+    end
+
+    should "log a message block for a runner using `runner_log`" do
+      text = Factory.text
+      subject.runner_log{ text }
+      assert_match "[DWP] #{text}", @stringio.string
+    end
+
+    should "log a message block for a worker using `worker_log`" do
+      worker = FakeWorker.new(Factory.integer(10))
+      text   = Factory.text
+      subject.worker_log(worker){ text }
+      assert_match "[DWP-#{worker.dwp_number}] #{text}", @stringio.string
+    end
+
+  end
+
+  class NullLoggerProxyTests < UnitTests
+    desc "NullLoggerProxy"
+    setup do
+      @null_logger_proxy = NullLoggerProxy.new
+    end
+    subject{ @null_logger_proxy }
+
+    should have_imeths :runner_log, :worker_log
+
+  end
+
+  class TestWorker
+    include DatWorkerPool::Worker
+
+    # for testing what is passed to the worker
+    attr_reader :dwp_runner, :dwp_queue
+  end
+
+  FakeWorker = Struct.new(:dwp_number)
+
+  class ShutdownSpyWorker < TestWorker
+    attr_reader :join_called
+    attr_accessor :join_error, :raised_error
+
+    # this pauses the shutdown so we can test that join or raise are called
+    # depending if we are doing a standard or forced shutdown; otherwise the
+    # worker threads can exit before join or raise ever gets called on them and
+    # then there is nothing to test
+    on_shutdown{ wait_for_join_or_raise }
+
+    def initialize(*args)
+      super
+      @mutex        = Mutex.new
+      @cond_var     = ConditionVariable.new
+      @join_called  = false
+      @join_error   = nil
+      @raised_error = nil
+    end
+
+    def dwp_join(*args)
+      @join_called = true
+      raise @join_error if @join_error
+      @mutex.synchronize{ @cond_var.broadcast }
+    end
+
+    def dwp_raise(error)
+      @raised_error = error
+    end
+
+    private
+
+    def wait_for_join_or_raise
+      @mutex.synchronize{ @cond_var.wait(@mutex) }
+    end
+  end
+
+end