dat-worker-pool 0.5.0 → 0.6.0

data/test/unit/default_queue_tests.rb

@@ -0,0 +1,217 @@
+require 'assert'
+require 'dat-worker-pool/default_queue'
+
+require 'thread'
+require 'dat-worker-pool/queue'
+require 'test/support/thread_spies'
+
+class DatWorkerPool::DefaultQueue
+
+  class UnitTests < Assert::Context
+    desc "DatWorkerPool::DefaultQueue"
+    setup do
+      @queue_class = DatWorkerPool::DefaultQueue
+    end
+    subject{ @queue_class }
+
+    should "be a dat-worker-pool queue" do
+      assert_includes DatWorkerPool::Queue, subject
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @work_items = DatWorkerPool::LockedArray.new
+      Assert.stub(DatWorkerPool::LockedArray, :new){ @work_items }
+
+      @cond_var_spy = ConditionVariableSpy.new
+      Assert.stub(ConditionVariable, :new){ @cond_var_spy }
+
+      @queue = @queue_class.new
+    end
+    subject{ @queue }
+
+    should have_readers :on_push_callbacks, :on_pop_callbacks
+    should have_imeths :work_items, :empty?
+    should have_imeths :on_push, :on_pop
+
+    should "default its callbacks" do
+      assert_equal [], subject.on_push_callbacks
+      assert_equal [], subject.on_pop_callbacks
+    end
+
+    should "allow adding custom push and pop callbacks" do
+      callback = proc{ Factory.string }
+      subject.on_push(&callback)
+      assert_includes callback, subject.on_push_callbacks
+
+      callback = proc{ Factory.string }
+      subject.on_pop(&callback)
+      assert_includes callback, subject.on_pop_callbacks
+    end
+
+    should "know its work items and demeter them" do
+      assert_equal @work_items.values, subject.work_items
+      assert_true subject.empty?
+
+      @work_items.push(Factory.string)
+      assert_equal @work_items.values, subject.work_items
+      assert_false subject.empty?
+    end
+
+  end
+
+  class StartedTests < InitTests
+    desc "and started"
+    setup do
+      @queue.dwp_start
+    end
+
+    should "broadcast to all threads when shutdown" do
+      assert_false @cond_var_spy.broadcast_called
+      subject.dwp_shutdown
+      assert_true @cond_var_spy.broadcast_called
+    end
+
+    should "be able to add work items" do
+      work_item = Factory.string
+      subject.dwp_push(work_item)
+      assert_equal 1, subject.work_items.size
+      assert_equal work_item, subject.work_items.last
+
+      subject.dwp_push(work_item)
+      assert_equal 2, subject.work_items.size
+      assert_equal work_item, subject.work_items.last
+    end
+
+    should "signal threads waiting on its lock when adding work items" do
+      assert_false @cond_var_spy.signal_called
+      subject.dwp_push(Factory.string)
+      assert_true @cond_var_spy.signal_called
+    end
+
+    should "run on push callbacks when adding work items" do
+      on_push_queue     = nil
+      on_push_work_item = nil
+      subject.on_push do |queue, work_item|
+        on_push_queue     = queue
+        on_push_work_item = work_item
+      end
+
+      work_item = Factory.string
+      subject.dwp_push(work_item)
+      assert_equal subject,   on_push_queue
+      assert_equal work_item, on_push_work_item
+    end
+
+    should "be able to pop work items" do
+      values = (Factory.integer(3) + 1).times.map{ Factory.string }
+      values.each{ |v| subject.dwp_push(v) }
+
+      assert_equal values.first, subject.dwp_pop
+      exp = values - [values.first]
+      assert_equal exp, subject.work_items
+    end
+
+    should "run on pop callbacks when popping work items" do
+      subject.dwp_push(Factory.string)
+
+      on_pop_queue     = nil
+      on_pop_work_item = nil
+      subject.on_pop do |queue, work_item|
+        on_pop_queue     = queue
+        on_pop_work_item = work_item
+      end
+
+      popped_work_item = subject.dwp_pop
+      assert_equal subject,          on_pop_queue
+      assert_equal popped_work_item, on_pop_work_item
+    end
+
+    should "not run on pop callbacks when there isn't a work item" do
+      subject.dwp_push(nil)
+
+      on_pop_called = false
+      subject.on_pop{ on_pop_called = true }
+      subject.dwp_pop
+      assert_false on_pop_called
+    end
+
+  end
+
+  class ThreadTests < StartedTests
+    desc "with a thread using it"
+    setup do
+      @on_pop_called = false
+      @queue.on_pop{ @on_pop_called = true }
+
+      @thread = Thread.new{ Thread.current['popped_value'] = @queue.dwp_pop }
+      @thread.join(JOIN_SECONDS)
+    end
+    subject{ @thread }
+
+    should "sleep the thread if empty when popping work items" do
+      assert_equal 'sleep', subject.status
+      assert_equal @work_items.mutex, @cond_var_spy.wait_called_on
+    end
+
+    should "wakeup the thread (from waiting on pop) when work items are added" do
+      assert_equal 'sleep', subject.status
+
+      value = Factory.string
+      @queue.dwp_push(value)
+
+      assert_not subject.alive?
+      assert_equal value, subject['popped_value']
+    end
+
+    should "re-sleep the thread if woken up while the queue is empty" do
+      assert_equal 'sleep', subject.status
+      assert_equal 1, @cond_var_spy.wait_call_count
+
+      # wakeup the thread (like `push` does) but we don't want to add anything
+      # to the queue, its possible this can happen if another worker never
+      # sleeps and grabs the lock and work item before the thread being woken
+      # up
+      @work_items.with_lock{ @cond_var_spy.signal }
+
+      assert_equal 'sleep', subject.status
+      assert_equal 2, @cond_var_spy.wait_call_count
+    end
+
+    should "wakeup the thread (from waiting on pop) when its shutdown" do
+      assert_equal 'sleep', subject.status
+      assert_equal 1, @cond_var_spy.wait_call_count
+
+      @queue.dwp_shutdown
+
+      assert_not subject.alive?
+      assert_equal 1, @cond_var_spy.wait_call_count
+    end
+
+    should "not run on pop callbacks when shutdown" do
+      @queue.dwp_shutdown
+      assert_false @on_pop_called
+    end
+
+    should "not pop a work item when shutdown and not empty" do
+      assert_equal 'sleep', subject.status
+
+      # this is to simulate a specific situation where there is work on the
+      # queue and the queue gets shutdown while a worker is still sleeping (it
+      # hasn't gotten a chance to wakeup and pull work off the queue yet), if
+      # this happens we don't want it to pull work off the queue; to set up this
+      # scenario we can't use `push` because it will wakeup the thread; so this
+      # accesses the array directly and pushes an item on it
+      @work_items.push(Factory.string)
+      @queue.dwp_shutdown
+
+      assert_not subject.alive?
+      assert_nil subject['popped_value']
+    end
+
+  end
+
+end

data/test/unit/locked_object_tests.rb

@@ -0,0 +1,260 @@
+require 'assert'
+require 'dat-worker-pool/locked_object'
+
+require 'test/support/thread_spies'
+
+class DatWorkerPool::LockedObject
+
+  class UnitTests < Assert::Context
+    setup do
+      @mutex_spy = MutexSpy.new
+      Assert.stub(Mutex, :new){ @mutex_spy }
+    end
+
+  end
+
+  class LockedObjectTests < UnitTests
+    desc "DatWorkerPool::LockedObject"
+    setup do
+      @passed_value = Factory.string
+      @locked_object = DatWorkerPool::LockedObject.new(@passed_value)
+    end
+    subject{ @locked_object }
+
+    should have_readers :mutex
+    should have_imeths :value, :set
+    should have_imeths :with_lock
+
+    should "know its value" do
+      assert_equal @passed_value, subject.value
+    end
+
+    should "default its value to `nil`" do
+      assert_nil DatWorkerPool::LockedObject.new.value
+    end
+
+    should "lock access to its value" do
+      assert_false @mutex_spy.synchronize_called
+      subject.value
+      assert_true @mutex_spy.synchronize_called
+    end
+
+    should "allow setting its value" do
+      new_value = Factory.string
+      subject.set(new_value)
+      assert_equal new_value, subject.value
+    end
+
+    should "lock access to its value when setting it" do
+      assert_false @mutex_spy.synchronize_called
+      subject.set(Factory.string)
+      assert_true @mutex_spy.synchronize_called
+    end
+
+    should "allow accessing its mutex and value with the lock using `with_lock`" do
+      yielded_mutex, yielded_value = [nil, nil]
+      assert_false @mutex_spy.synchronize_called
+      subject.with_lock{ |m, v| yielded_mutex, yielded_value = [m, v] }
+      assert_true @mutex_spy.synchronize_called
+
+      assert_equal subject.mutex, yielded_mutex
+      assert_equal subject.value, yielded_value
+    end
+
+  end
+
+  class LockedArrayTests < UnitTests
+    desc "DatWorkerPool::LockedArray"
+    setup do
+      @locked_array = DatWorkerPool::LockedArray.new
+    end
+    subject{ @locked_array }
+
+    should have_imeths :values
+    should have_imeths :first, :last
+    should have_imeths :size, :empty?
+    should have_imeths :push, :pop
+    should have_imeths :shift, :unshift
+    should have_imeths :delete
+
+    should "be a dat-worker-pool locked object" do
+      assert DatWorkerPool::LockedArray < DatWorkerPool::LockedObject
+    end
+
+    should "use an empty array for its value" do
+      assert_equal [], subject.value
+    end
+
+    should "alias its value method as values" do
+      assert_same subject.value, subject.values
+    end
+
+    should "know its first and last items" do
+      assert_nil subject.first
+      assert_nil subject.last
+
+      subject.value.push(Factory.string)
+      subject.value.push(Factory.string)
+
+      assert_equal subject.values.first, subject.first
+      assert_equal subject.values.last,  subject.last
+    end
+
+    should "lock access to getting its first item" do
+      assert_false @mutex_spy.synchronize_called
+      subject.first
+      assert_true @mutex_spy.synchronize_called
+    end
+
+    should "lock access to getting its last item" do
+      assert_false @mutex_spy.synchronize_called
+      subject.last
+      assert_true @mutex_spy.synchronize_called
+    end
+
+    should "know its size" do
+      assert_equal 0, subject.size
+      subject.value.push(Factory.string)
+      assert_equal 1, subject.size
+    end
+
+    should "lock access to reading its size" do
+      assert_false @mutex_spy.synchronize_called
+      subject.size
+      assert_true @mutex_spy.synchronize_called
+    end
+
+    should "know if its empty or not" do
+      assert_true subject.empty?
+      subject.value.push(Factory.string)
+      assert_false subject.empty?
+    end
+
+    should "lock access to checking if its empty" do
+      assert_false @mutex_spy.synchronize_called
+      subject.empty?
+      assert_true @mutex_spy.synchronize_called
+    end
+
+    should "allow pushing and popping to its array" do
+      new_item = Factory.string
+      subject.push(new_item)
+      assert_same new_item, subject.value.last
+
+      result = subject.pop
+      assert_same new_item, result
+    end
+
+    should "lock accessing when pushing/popping" do
+      assert_false @mutex_spy.synchronize_called
+      subject.push(Factory.string)
+      assert_true @mutex_spy.synchronize_called
+
+      @mutex_spy.synchronize_called = false
+      subject.pop
+      assert_true @mutex_spy.synchronize_called
+    end
+
+    should "allow shifting and unshifting to its array" do
+      new_item = Factory.string
+      subject.unshift(new_item)
+      assert_same new_item, subject.value.first
+
+      result = subject.shift
+      assert_same new_item, result
+    end
+
+    should "lock accessing when shifting/unshifting" do
+      assert_false @mutex_spy.synchronize_called
+      subject.unshift(Factory.string)
+      assert_true @mutex_spy.synchronize_called
+
+      @mutex_spy.synchronize_called = false
+      subject.shift
+      assert_true @mutex_spy.synchronize_called
+    end
+
+    should "allow deleting items from its array" do
+      item = Factory.string
+      (Factory.integer(3) + 1).times{ subject.push(item) }
+
+      subject.delete(item)
+      assert_true subject.empty?
+    end
+
+    should "lock access to when deleting" do
+      assert_false @mutex_spy.synchronize_called
+      subject.delete(Factory.string)
+      assert_true @mutex_spy.synchronize_called
+    end
+
+  end
+
+  class LockedSetTests < UnitTests
+    desc "DatWorkerPool::LockedSet"
+    setup do
+      @locked_set = DatWorkerPool::LockedSet.new
+    end
+    subject{ @locked_set }
+
+    should have_imeths :values, :size, :empty?, :add, :remove
+
+    should "be a dat-worker-pool locked object" do
+      assert DatWorkerPool::LockedSet < DatWorkerPool::LockedObject
+    end
+
+    should "use an empty set for its value" do
+      assert_instance_of Set, subject.value
+      assert_true subject.value.empty?
+    end
+
+    should "alias its value method as values" do
+      assert_same subject.value, subject.values
+    end
+
+    should "know its size" do
+      assert_equal 0, subject.size
+      subject.value.add(Factory.string)
+      assert_equal 1, subject.size
+    end
+
+    should "lock access to reading its size" do
+      assert_false @mutex_spy.synchronize_called
+      subject.size
+      assert_true @mutex_spy.synchronize_called
+    end
+
+    should "know if its empty or not" do
+      assert_true subject.empty?
+      subject.value.add(Factory.string)
+      assert_false subject.empty?
+    end
+
+    should "lock access to checking if its empty" do
+      assert_false @mutex_spy.synchronize_called
+      subject.empty?
+      assert_true @mutex_spy.synchronize_called
+    end
+
+    should "allow adding and removing on its set" do
+      new_item = Factory.string
+      subject.add(new_item)
+      assert_includes new_item, subject.value
+
+      subject.remove(new_item)
+      assert_not_includes new_item, subject.value
+    end
+
+    should "lock accessing when pushing/popping" do
+      assert_false @mutex_spy.synchronize_called
+      subject.add(Factory.string)
+      assert_true @mutex_spy.synchronize_called
+
+      @mutex_spy.synchronize_called = false
+      subject.remove(Factory.string)
+      assert_true @mutex_spy.synchronize_called
+    end
+
+  end
+
+end