test/unit/pigeon_queue_test.rb in pigeon-0.4.1 vs test/unit/pigeon_queue_test.rb in pigeon-0.4.2

@@ -2,23 +2,29 @@
 
 class PigeonQueueTest < Test::Unit::TestCase
   class TaggedTask < Pigeon::Task
     attr_accessor :tag
     
-    def initialize(engine, tag)
-      super(engine)
+    def initialize(tag, options = nil)
+      super(options)
       @tag = tag
     end
     
     def inspect
       "<#{@tag}>"
     end
   end
   
-  def engine
-    @engine ||= Pigeon::Engine.new
+  def setup
+    @engine = Pigeon::Engine.new
+
+    Pigeon::Engine.register_engine(@engine)
   end
+  
+  def teardown
+    Pigeon::Engine.unregister_engine(@engine)
+  end
 
   def test_empty_state
     queue = Pigeon::Queue.new
     
     assert_equal 0, queue.length
@@ -28,11 +34,11 @@
   end
   
   def test_cycling
     queue = Pigeon::Queue.new
     
-    task = Pigeon::Task.new(engine)
+    task = Pigeon::Task.new
     
     assert_equal task, queue << task
     
     assert queue.peek
     assert_equal 1, queue.length
@@ -48,11 +54,11 @@
     
   def test_filtering
     queue = Pigeon::Queue.new
 
     tasks = (0..9).to_a.collect do |n|
-      queue << TaggedTask.new(engine, n)
+      queue << TaggedTask.new(n)
     end
     
     assert_equal (0..9).to_a, tasks.to_a.collect(&:tag)
     
     assert_equal tasks[0], queue.peek
@@ -81,11 +87,11 @@
 
     assert_equal nil, queue.peek(:over_7)
     assert_equal 0, queue.length(:over_7)
     assert_equal true, queue.empty?(:over_7)
     
-    new_task = queue << TaggedTask.new(engine, 10)
+    new_task = queue << TaggedTask.new(10)
     
     assert_equal new_task, queue.peek(:over_7)
     assert_equal 1, queue.length(:over_7)
     assert_equal false, queue.empty?(:over_7)
     
@@ -98,11 +104,11 @@
 
   def test_observe
     queue = Pigeon::Queue.new
     
     tasks = (0..9).to_a.collect do |n|
-      queue << TaggedTask.new(engine, n)
+      queue << TaggedTask.new(n)
     end
     
     queue.filter(:odd) do |task|
       task.tag % 2 == 1
     end
@@ -119,15 +125,15 @@
     
     queue.observe(:odd) do |task|
       added_odd = task
     end
     
-    queue << TaggedTask.new(engine, 10)
+    queue << TaggedTask.new(10)
     
     assert_equal nil, added_odd
 
-    odd_1 = queue << TaggedTask.new(engine, 11)
+    odd_1 = queue << TaggedTask.new(11)
     
     assert_equal odd_1, added_odd
 
     claimed_task = nil
     has_run = false
@@ -142,17 +148,17 @@
     assert_equal false, has_run
     assert_equal nil, claimed_task
     assert_equal 7, queue.length
     assert_equal 1, queue.length(:odd)
 
-    queue << TaggedTask.new(engine, 12)
+    queue << TaggedTask.new(12)
     
     assert_equal nil, claimed_task
     assert_equal 8, queue.length
     assert_equal 1, queue.length(:odd)
 
-    odd_2 = queue << TaggedTask.new(engine, 13)
+    odd_2 = queue << TaggedTask.new(13)
     
     # Adding a task that matches the filter triggers the callback.
     assert_equal odd_2, claimed_task
     assert_equal true, has_run
     
@@ -160,16 +166,16 @@
     queue.pull(:odd)
     
     claimed_task = nil
     has_run = false
 
-    queue << TaggedTask.new(engine, 14)
+    queue << TaggedTask.new(14)
 
     assert_equal nil, claimed_task
     assert_equal false, has_run
 
-    odd_2 = queue << TaggedTask.new(engine, 15)
+    odd_2 = queue << TaggedTask.new(15)
     
     assert_equal odd_2, claimed_task
     assert_equal true, has_run
 
     assert_equal 8, queue.length
@@ -181,14 +187,14 @@
     
     queue.observe do |task|
       if (task.tag < 10)
         queue.claim(task)
 
-        queue << TaggedTask.new(engine, task.tag + 1)
+        queue << TaggedTask.new(task.tag + 1)
       end
     end
     
-    queue << TaggedTask.new(engine, 0)
+    queue << TaggedTask.new(0)
 
     assert queue.peek
     assert_equal 10, queue.peek.tag
     assert_equal 1, queue.length
     assert queue.peek