dat-worker-pool 0.5.0 → 0.6.0

data/test/unit/dat-worker-pool_tests.rb

@@ -1,321 +1,198 @@
 require 'assert'
 require 'dat-worker-pool'
 
+require 'system_timer'
+require 'dat-worker-pool/queue'
+require 'dat-worker-pool/runner'
+require 'dat-worker-pool/worker'
+
 class DatWorkerPool
 
   class UnitTests < Assert::Context
     desc "DatWorkerPool"
     setup do
-      @work_pool = DatWorkerPool.new{ }
-    end
-    subject{ @work_pool }
-
-    should have_readers :logger, :spawned, :queue
-    should have_readers :on_worker_error_callbacks
-    should have_readers :on_worker_start_callbacks, :on_worker_shutdown_callbacks
-    should have_readers :on_worker_sleep_callbacks, :on_worker_wakeup_callbacks
-    should have_readers :before_work_callbacks, :after_work_callbacks
-    should have_imeths :add_work, :start, :shutdown
-    should have_imeths :work_items, :waiting
-    should have_imeths :worker_available?, :all_spawned_workers_are_busy?
-    should have_imeths :reached_max_workers?
-    should have_imeths :queue_empty?
-    should have_imeths :on_queue_pop_callbacks, :on_queue_push_callbacks
-    should have_imeths :on_queue_pop, :on_queue_push
-    should have_imeths :on_worker_error
-    should have_imeths :on_worker_start, :on_worker_shutdown
-    should have_imeths :on_worker_sleep, :on_worker_wakeup
-    should have_imeths :before_work, :after_work
-
-    should "know its attributes" do
-      assert_instance_of ::Logger, subject.logger
-      assert_equal 0, subject.spawned
-      assert_instance_of Queue, subject.queue
+      @worker_pool_class = DatWorkerPool
     end
+    subject{ @worker_pool_class }
 
-    should "default its worker callbacks" do
-      assert_equal [], subject.on_worker_error_callbacks
-      assert_equal [], subject.on_worker_start_callbacks
-      assert_equal 1, subject.on_worker_shutdown_callbacks.size
-      assert_instance_of Proc, subject.on_worker_shutdown_callbacks.first
-      assert_equal 1, subject.on_worker_sleep_callbacks.size
-      assert_instance_of Proc, subject.on_worker_sleep_callbacks.first
-      assert_equal 1, subject.on_worker_wakeup_callbacks.size
-      assert_instance_of Proc, subject.on_worker_wakeup_callbacks.first
-      assert_equal [], subject.before_work_callbacks
-      assert_equal [], subject.after_work_callbacks
-    end
-
-    should "demeter its queue's callbacks" do
-      callback = proc{ }
-      subject.on_queue_pop(&callback)
-      assert_equal [callback], subject.on_queue_pop_callbacks
-      callback = proc{ }
-      subject.on_queue_push(&callback)
-      assert_equal [callback], subject.on_queue_push_callbacks
+    should "know its default and min number of workers" do
+      assert_equal 1, DEFAULT_NUM_WORKERS
+      assert_equal 1, MIN_WORKERS
     end
 
   end
 
-  class WorkerBehaviorTests < UnitTests
-    desc "workers"
+  class InitSetupTests < UnitTests
+    desc "when init"
     setup do
-      @work_pool = DatWorkerPool.new(1, 2, true){ |work| sleep(work) }
-      @work_pool.start
-    end
+      @num_workers   = Factory.integer(4)
+      @logger        = TEST_LOGGER
+      @queue         = TestQueue.new
+      @worker_params = { Factory.string => Factory.string }
+
+      @runner_spy = RunnerSpy.new
+      Assert.stub(DatWorkerPool::Runner, :new) do |args|
+        @runner_spy.args = args
+        @runner_spy
+      end
 
-    should "be created as needed and only go up to the maximum number allowed" do
-      # the minimum should be spawned and waiting
-      assert_equal 1, @work_pool.spawned
-      assert_equal 1, @work_pool.waiting
-      assert_equal true,  @work_pool.worker_available?
-      assert_equal false, @work_pool.all_spawned_workers_are_busy?
-      assert_equal false, @work_pool.reached_max_workers?
-
-      # the minimum should be spawned, but no longer waiting
-      @work_pool.add_work 5
-      assert_equal 1, @work_pool.spawned
-      assert_equal 0, @work_pool.waiting
-      assert_equal true,  @work_pool.worker_available?
-      assert_equal true,  @work_pool.all_spawned_workers_are_busy?
-      assert_equal false, @work_pool.reached_max_workers?
-
-      # an additional worker should be spawned
-      @work_pool.add_work 5
-      assert_equal 2, @work_pool.spawned
-      assert_equal 0, @work_pool.waiting
-      assert_equal false, @work_pool.worker_available?
-      assert_equal true,  @work_pool.all_spawned_workers_are_busy?
-      assert_equal true,  @work_pool.reached_max_workers?
-
-      # no additional workers are spawned, the work waits to be processed
-      @work_pool.add_work 5
-      assert_equal 2, @work_pool.spawned
-      assert_equal 0, @work_pool.waiting
-      assert_equal false, @work_pool.worker_available?
-      assert_equal true,  @work_pool.all_spawned_workers_are_busy?
-      assert_equal true, @work_pool.reached_max_workers?
+      @worker_class = Class.new do
+        include DatWorkerPool::Worker
+        def work!(work_item); end
+      end
+      @options = {
+        :num_workers   => @num_workers,
+        :logger        => @logger,
+        :queue         => @queue,
+        :worker_params => @worker_params
+      }
     end
+    subject{ @worker_pool }
 
-    should "go back to waiting when they finish working" do
-      assert_equal 1, @work_pool.spawned
-      assert_equal 1, @work_pool.waiting
+  end
 
-      @work_pool.add_work 1
-      assert_equal 1, @work_pool.spawned
-      assert_equal 0, @work_pool.waiting
+  class InitTests < InitSetupTests
+    desc "when init"
+    setup do
+      @worker_pool = @worker_pool_class.new(@worker_class, @options)
+    end
+    subject{ @worker_pool }
 
-      sleep 1 # allow the worker to run
+    should have_readers :queue
+    should have_imeths :start, :shutdown
+    should have_imeths :add_work, :push, :work_items
+    should have_imeths :available_worker_count, :worker_available?
 
-      assert_equal 1, @work_pool.spawned
-      assert_equal 1, @work_pool.waiting
+    should "know its attributes" do
+      assert_equal @queue,  subject.queue
     end
 
-  end
+    should "build a runner" do
+      exp = {
+        :num_workers   => @num_workers,
+        :logger        => @logger,
+        :queue         => @queue,
+        :worker_class  => @worker_class,
+        :worker_params => @worker_params
+      }
+      assert_equal exp, @runner_spy.args
+    end
 
-  class WorkerCallbackTests < UnitTests
-    desc "worker callbacks"
-    setup do
-      @error_called       = false
-      @start_called       = false
-      @shutdown_called    = false
-      @sleep_called       = false
-      @wakeup_called      = false
-      @before_work_called = false
-      @after_work_called  = false
+    should "default its attributes" do
+      worker_pool = @worker_pool_class.new(@worker_class)
+      assert_instance_of DatWorkerPool::DefaultQueue, worker_pool.queue
 
-      @work_pool = DatWorkerPool.new(1) do |work|
-        raise work if work == 'error'
-      end
-      @work_pool.on_worker_error{ @error_called = true }
-      @work_pool.on_worker_start{ @start_called = true }
-      @work_pool.on_worker_shutdown{ @shutdown_called = true }
-      @work_pool.on_worker_sleep{ @sleep_called = true }
-      @work_pool.on_worker_wakeup{ @wakeup_called = true }
-      @work_pool.before_work{ @before_work_called = true }
-      @work_pool.after_work{ @after_work_called = true }
+      assert_equal DEFAULT_NUM_WORKERS, @runner_spy.args[:num_workers]
+      assert_nil @runner_spy.args[:worker_params]
     end
-    subject{ @work_pool }
 
-    should "call the worker callbacks as workers wait or wakeup" do
-      assert_false @start_called
-      assert_false @sleep_called
+    should "start its runner when its started" do
+      assert_false @runner_spy.start_called
       subject.start
-      assert_true @start_called
-      assert_true @sleep_called
-
-      @sleep_called = false
-      assert_false @wakeup_called
-      assert_false @before_work_called
-      assert_false @after_work_called
-      subject.add_work 'work'
-      assert_true @wakeup_called
-      assert_true @before_work_called
-      assert_true @after_work_called
-      assert_true @sleep_called
-
-      @before_work_called = false
-      @after_work_called  = false
-      assert_false @before_work_called
-      assert_false @error_called
-      assert_false @after_work_called
-      subject.add_work 'error'
-      assert_true @before_work_called
-      assert_true @error_called
-      assert_false @after_work_called
-
-      @wakeup_called = false
-      assert_false @shutdown_called
-      subject.shutdown
-      assert_true @wakeup_called
-      assert_true @shutdown_called
+      assert_true @runner_spy.start_called
     end
 
-  end
+    should "shutdown its runner when its shutdown" do
+      assert_false @runner_spy.shutdown_called
+      subject.shutdown
+      assert_true @runner_spy.shutdown_called
+      assert_nil @runner_spy.shutdown_timeout
+      exp = "test/unit/dat-worker-pool_tests.rb"
+      assert_match exp, @runner_spy.shutdown_backtrace.first
 
-  class AddWorkWithNoWorkersTests < UnitTests
-    setup do
-      @work_pool = DatWorkerPool.new(0, 0){ |work| }
+      timeout = Factory.integer
+      subject.shutdown(timeout)
+      assert_equal timeout, @runner_spy.shutdown_timeout
     end
 
-    should "return whether or not the queue is empty" do
-      assert_equal true, @work_pool.queue_empty?
-      @work_pool.add_work 'test'
-      assert_equal false, @work_pool.queue_empty?
+    should "demeter its runner" do
+      assert_equal @runner_spy.available_worker_count, subject.available_worker_count
+      assert_equal @runner_spy.worker_available?,      subject.worker_available?
     end
 
-  end
-
-  class AddWorkAndProcessItTests < UnitTests
-    desc "add_work and process"
-    setup do
-      @result = nil
-      @work_pool = DatWorkerPool.new(1){|work| @result = (2 / work) }
-      @work_pool.start
+    should "raise an argument error if given an invalid worker class" do
+      assert_raises(ArgumentError){ @worker_pool_class.new(Module.new) }
+      assert_raises(ArgumentError){ @worker_pool_class.new(Class.new) }
     end
 
-    should "have added the work and processed it by calling the passed block" do
-      subject.add_work 2
-      sleep 0.1 # ensure worker thread get's a chance to run
-      assert_equal 1, @result
+    should "raise an argument error if given an invalid number of workers" do
+      assert_raises(ArgumentError) do
+        @worker_pool_class.new(@worker_class, {
+          :num_workers  => [0, (Factory.integer * -1)].choice
+        })
+      end
     end
 
-    should "swallow exceptions, so workers don't end unexpectedly" do
-      subject.add_work 0
-      worker = subject.instance_variable_get("@workers").first
-      sleep 0.1
+  end
 
-      assert_equal 1, subject.spawned
-      assert_equal 1, subject.waiting
-      assert worker.instance_variable_get("@thread").alive?
+  class StartedTests < InitTests
+    desc "and started"
+    setup do
+      @worker_pool.start
     end
 
-  end
+    should "be able to add work onto its queue`" do
+      work_item = Factory.string
+      subject.add_work(work_item)
+      assert_equal work_item, @queue.work_items.last
 
-  class StartTests < UnitTests
-    desc "start"
-    setup do
-      @work_pool = DatWorkerPool.new(1, 2){ |work| sleep(work) }
+      work_item = Factory.string
+      subject.push(work_item)
+      assert_equal work_item, @queue.work_items.last
     end
-    subject{ @work_pool }
 
-    should "start its queue" do
-      assert_false subject.queue.shutdown?
-      subject.start
-      assert_false subject.queue.shutdown?
-      subject.shutdown
-      assert_true subject.queue.shutdown?
-      subject.start
-      assert_false subject.queue.shutdown?
+    should "not add `nil` work onto its queue" do
+      subject.add_work(nil)
+      assert_equal [], @queue.work_items
     end
 
-    should "keep workers from being spawned until its called" do
-      assert_equal 0, subject.spawned
-      subject.add_work 1
-      assert_equal 0, subject.spawned
-      subject.start
-      assert_equal 1, subject.spawned
+    should "know its queue's work items" do
+      Factory.integer(3).times{ @queue.dwp_push(Factory.string) }
+      assert_equal @queue.work_items, subject.work_items
     end
 
   end
 
-  class ShutdownTests < UnitTests
-    desc "shutdown"
-    setup do
-      @mutex = Mutex.new
-      @finished = []
-      @work_pool = DatWorkerPool.new(1, 2, true) do |work|
-        sleep 1
-        @mutex.synchronize{ @finished << work }
-      end
-      @work_pool.start
-      @work_pool.add_work 'a'
-      @work_pool.add_work 'b'
-      @work_pool.add_work 'c'
-    end
+  class TestQueue
+    include DatWorkerPool::Queue
 
-    should "allow any work that has been picked up to be processed" do
-      # make sure the workers haven't processed any work
-      assert_equal [], @finished
-      subject.shutdown(5)
+    attr_reader :work_items
 
-      # NOTE, the last work shouldn't have been processed, as it wasn't
-      # picked up by a worker
-      assert_includes     'a', @finished
-      assert_includes     'b', @finished
-      assert_not_includes 'c', @finished
-
-      assert_equal 0, subject.spawned
-      assert_equal 0, subject.waiting
-      assert_includes 'c', subject.work_items
+    def initialize
+      @work_items = []
     end
 
-    should "allow jobs to finish by not providing a shutdown timeout" do
-      assert_equal [], @finished
-      subject.shutdown
-      assert_includes 'a', @finished
-      assert_includes 'b', @finished
-    end
+    private
 
-    should "reraise shutdown errors in debug mode if workers take to long to finish" do
-      assert_raises(DatWorkerPool::ShutdownError) do
-        subject.shutdown(0.1)
-      end
+    def push!(work_item)
+      @work_items << work_item
     end
-
   end
 
-  class ForcedShutdownTests < UnitTests
-    desc "forced shutdown"
-    setup do
-      @mutex = Mutex.new
-      @finished = []
-      @max_workers = 2
-      # don't put leave the worker pool in debug mode
-      @work_pool = DatWorkerPool.new(1, @max_workers, false) do |work|
-        begin
-          sleep 1
-        rescue ShutdownError => error
-          @mutex.synchronize{ @finished << error }
-          raise error # re-raise it otherwise worker won't shutdown
-        end
-      end
-      @work_pool.start
-      @work_pool.add_work 'a'
-      @work_pool.add_work 'b'
-      @work_pool.add_work 'c'
+  class RunnerSpy < DatWorkerPool::Runner
+    attr_accessor :args
+    attr_reader :start_called, :shutdown_called
+    attr_reader :shutdown_timeout, :shutdown_backtrace
+
+    def initialize
+      super({})
+      @start_called       = false
+      @shutdown_called    = false
+      @shutdown_timeout   = nil
+      @shutdown_backtrace = nil
     end
 
-    should "force workers to shutdown if they take to long to finish" do
-      # make sure the workers haven't processed any work
-      assert_equal [], @finished
-      subject.shutdown(0.1)
-      assert_equal @max_workers, @finished.size
-      @finished.each do |error|
-        assert_instance_of DatWorkerPool::ShutdownError, error
-      end
+    def start
+      @args[:queue].dwp_start
+      @start_called = true
     end
 
+    def shutdown(timeout, backtrace)
+      @args[:queue].dwp_shutdown
+      @shutdown_called    = true
+      @shutdown_timeout   = timeout
+      @shutdown_backtrace = backtrace
+    end
   end
 
 end