wireframe-resque_unit 0.4.1.1

data/lib/resque_unit/scheduler.rb

@@ -0,0 +1,41 @@
+module ResqueUnit
+  
+  # ResqueUnit::Scheduler is a group of functions mocking the behavior
+  # of resque-scheduler. It is included into Resque when
+  # 'resque_unit_scheduler' is required.
+  module Scheduler
+
+    # takes a timestamp which will be used to schedule the job
+    # for queueing.  Until timestamp is in the past, the job will
+    # sit in the schedule list.
+    def enqueue_at(timestamp, klass, *args)
+      enqueue_with_timestamp(timestamp, klass, *args)
+    end
+    
+    # Identical to enqueue_at but takes number_of_seconds_from_now
+    # instead of a timestamp.
+    def enqueue_in(number_of_seconds_from_now, klass, *args)
+      enqueue_at(Time.now + number_of_seconds_from_now, klass, *args)
+    end
+    
+    def enqueue_with_timestamp(timestamp, klass, *args)
+      enqueue_unit(queue_for(klass), {"class" => klass.name, "args" => args, "timestamp" => timestamp})
+    end
+
+    def remove_delayed(klass, *args)
+      # points to real queue
+      encoded_job_payloads = Resque.queue(queue_for(klass))
+      args ||= []
+      encoded_job_payloads.delete_if { |e| e = Resque.decode(e); e["class"] == klass.to_s && e["args"] == args }
+    end
+
+    def remove_delayed_job_from_timestamp(timestamp, klass, *args)
+      encoded_job_payloads = Resque.queue(queue_for(klass))
+      args ||= []
+      encoded_job_payloads.delete_if { |e| e = Resque.decode(e); e["class"] == klass.to_s && e["timestamp"] == timestamp.to_s && e["args"] == args }
+    end
+  end
+
+  Resque.send(:extend, Scheduler)
+end
+

data/lib/resque_unit/scheduler_assertions.rb

@@ -0,0 +1,49 @@
+# These are a group of assertions you can use in your unit tests to
+# verify that your code is using resque-scheduler correctly.
+require 'time'
+
+module ResqueUnit::SchedulerAssertions
+  
+  # Asserts that +klass+ has been queued into its appropriate queue at
+  # least once, with a +timestamp+ less than or equal to
+  # +expected_timestamp+. If the job wasn't queued with a timestamp,
+  # the assertion fails.. If +args+ is nil, it only asserts that the
+  # klass has been queued. Otherwise, it asserts that the klass has
+  # been queued with the correct arguments. Pass an empty array for
+  # +args+ if you want to assert that klass has been queued without
+  # arguments.
+  def assert_queued_at(expected_timestamp, klass, args = nil, message = nil)
+    queue = Resque.queue_for(klass)
+    assert_block (message || "#{klass} should have been queued in #{queue} before #{expected_timestamp}: #{Resque.queue(queue).inspect}.") do 
+      in_timestamped_queue?(queue, expected_timestamp, klass, args)
+    end
+  end
+
+  # Similar to +assert_queued_at+, except it takes an expected time
+  # difference (in seconds) instead of a timestamp.
+  def assert_queued_in(expected_time_difference, klass, args = nil, message = nil)
+    assert_queued_at(Time.now + expected_time_difference, klass, args, message)
+  end
+  
+  # opposite of +assert_queued_at+
+  def assert_not_queued_at(expected_timestamp, klass, args = nil, message = nil)
+    queue = Resque.queue_for(klass)
+    assert_block (message || "#{klass} should not have been queued in #{queue} before #{expected_timestamp}.") do 
+      !in_timestamped_queue?(queue, expected_timestamp, klass, args)
+    end
+  end
+
+  # opposite of +assert_queued_in+
+  def assert_not_queued_in(expected_time_difference, klass, args = nil, message = nil)
+    assert_not_queued_at(Time.now + expected_time_difference, klass, args, message)
+  end
+
+  private
+
+  def in_timestamped_queue?(queue_name, expected_timestamp, klass, args = nil)
+    # check if we have any matching jobs with a timestamp less than
+    # expected_timestamp
+    !matching_jobs(Resque.all(queue_name), klass, args).select {|e| e["timestamp"] && Time.parse(e["timestamp"]) <= expected_timestamp}.empty?
+  end
+  
+end

data/lib/resque_unit_scheduler.rb

@@ -0,0 +1,4 @@
+require 'resque_unit/scheduler'
+require 'resque_unit/scheduler_assertions'
+
+Test::Unit::TestCase.send(:include, ResqueUnit::SchedulerAssertions)

data/test/resque_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+class ResqueTest < Test::Unit::TestCase
+
+  def setup
+    Resque.reset!
+  end
+
+  context "with one queued job" do
+    setup do
+      Resque.enqueue(MediumPriorityJob, "some args")
+      @job_payload = {"args"=>["some args"], "class"=>"MediumPriorityJob"}
+    end
+
+    should "return job payload when peek method called with count equal 1" do
+      assert_equal @job_payload, Resque.peek(MediumPriorityJob.queue, 0, 1)
+    end
+
+    should "return array of jobs' payloads when peek method called with count different than 1" do
+      assert_equal [@job_payload], Resque.peek(MediumPriorityJob.queue, 0, 5)
+    end
+  end
+
+  context "with few queued jobs" do
+    setup do
+      Resque.enqueue(MediumPriorityJob, "1")
+      Resque.enqueue(MediumPriorityJob, "2")
+      Resque.enqueue(MediumPriorityJob, "3")
+    end
+
+    should "return jobs' payloads 2 and 3 when peek method called with start equal 1 and count equal 2" do
+      assert_equal [["2"], ["3"]], Resque.peek(MediumPriorityJob.queue, 1, 2).map{|h| h["args"]}
+    end
+
+    should "return empty array when peek method called with start higher than queue size" do
+      assert_equal [], Resque.peek(MediumPriorityJob.queue, 4, 2)
+    end
+
+    should "return empty array when peek method called with count equal 0" do
+      assert_equal [], Resque.peek(MediumPriorityJob.queue, 0, 0)
+    end
+
+    should "return all jobs' payloads when all method called" do
+      assert Resque.all(MediumPriorityJob.queue).length == 3, "should return all 3 elements"
+    end
+  end
+
+  context "without queued jobs" do
+    should "return nil when peek method called with count equal 1" do
+      assert_equal nil, Resque.peek(MediumPriorityJob.queue, 0, 1)
+    end
+
+    should "return empty array when peek method called with count not equal 1" do
+      assert_equal [], Resque.peek(MediumPriorityJob.queue, 0, 999)
+    end
+
+    should "return empty array when all method called" do
+      assert_equal [], Resque.all(MediumPriorityJob.queue)
+    end
+  end
+end

data/test/resque_unit_scheduler_test.rb

@@ -0,0 +1,201 @@
+require 'test_helper'
+require 'resque_unit_scheduler'
+
+class ResqueUnitSchedulerTest < Test::Unit::TestCase
+
+  def setup
+    Resque.reset!
+  end
+
+  context "A task that schedules a resque job in 5 minutes" do
+    setup { Resque.enqueue_in(600, MediumPriorityJob) }
+    should "pass the assert_queued(job) assertion" do
+      assert_queued(MediumPriorityJob)
+    end
+
+    should "pass the assert_queued_in(600, job) assertion" do
+      assert_queued_in(600, MediumPriorityJob)
+    end
+
+    should "fail the assert_queued_in(300, job) assertion" do
+      assert_raise Test::Unit::AssertionFailedError do
+        assert_queued_in(300, MediumPriorityJob)
+      end
+    end
+
+    should "pass the assert_not_queued_in(300, job) assertion" do
+      assert_not_queued_in(300, MediumPriorityJob)
+    end
+
+    context "and then the job is removed with #remove_delayed" do
+      setup do
+        Resque.remove_delayed(MediumPriorityJob)
+      end
+      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do
+        assert_not_queued_at(300, MediumPriorityJob)
+      end
+
+      should "fail the assert_queued_at(@time, MediumPriorityJob) assertion" do
+        assert_raise Test::Unit::AssertionFailedError do
+          assert_queued_at(300, MediumPriorityJob)
+        end
+      end
+    end
+  end
+
+  context "A task that schedules a resque job in 5 minutes with arguments" do
+    setup { Resque.enqueue_in(600, JobWithArguments, 1, "test") }
+    should "pass the assert_queued_in(600, JobWithArguments) assertion" do
+      assert_queued_in(600, JobWithArguments)
+    end
+
+    should "pass the assert_queued_in(600, JobWithArguments, [1, 'test']) assertion" do
+      assert_queued_in(600, JobWithArguments, [1, 'test'])
+    end
+
+    should "fail the assert_queued_in(600, JobWithArguments, [2, 'test']) assertion" do
+      assert_raise Test::Unit::AssertionFailedError do
+        assert_queued_in(600, JobWithArguments, [2, 'test'])
+      end
+    end
+
+    context "and then the job is removed with #remove_delayed" do
+      setup do
+        Resque.remove_delayed(JobWithArguments, 1, 'test')
+      end
+      should "pass the assert_not_queued_at(@time, JobWithArguments, 1, 'test') assertion" do
+        assert_not_queued_at(600, JobWithArguments, 1, 'test')
+      end
+
+      should "fail the assert_queued_at(@time, JobWithArguments, 1, 'test') assertion" do
+        assert_raise Test::Unit::AssertionFailedError do
+          assert_queued_at(600, JobWithArguments, 1, 'test')
+        end
+      end
+    end
+
+    context "and a job of the same class but with different arguments is removed with #remove_delayed" do
+      setup do
+        Resque.remove_delayed(JobWithArguments, 2, 'test')
+      end
+      should "still pass the assert_queued_in(600, JobWithArguments) assertion" do
+        assert_queued_in(600, JobWithArguments)
+      end
+
+      should "still pass the assert_queued_in(600, JobWithArguments, [1, 'test']) assertion" do
+        assert_queued_in(600, JobWithArguments, [1, 'test'])
+      end
+
+      should "still fail the assert_queued_in(600, JobWithArguments, [2, 'test']) assertion" do
+        assert_raise Test::Unit::AssertionFailedError do
+          assert_queued_in(600, JobWithArguments, [2, 'test'])
+        end
+      end
+    end
+  end
+
+  context "A task that schedules a resque job on Sept. 6, 2016 at 6am" do
+    setup do
+      @time = Time.mktime(2016, 9, 6, 6)
+      Resque.enqueue_at(@time, MediumPriorityJob)
+    end
+
+    should "pass the assert_queued_at(@time, MediumPriorityJob) assertion" do
+      assert_queued_at(@time, MediumPriorityJob)
+    end
+
+    should "fail the assert_queued_at(@time - 100, MediumPriorityJob) assertion" do
+      assert_raise Test::Unit::AssertionFailedError do
+        assert_queued_at(@time - 100, MediumPriorityJob)
+      end
+    end
+
+    should "pass the assert_not_queued_at(@time - 100, MediumPriorityJob) assertion" do
+      assert_not_queued_at(@time - 100, MediumPriorityJob)
+    end
+
+    context "and then the job is removed with #remove_delayed" do
+      setup do
+        Resque.remove_delayed(MediumPriorityJob)
+      end
+      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do
+        assert_not_queued_at(@time, MediumPriorityJob)
+      end
+
+      should "fail the assert_queued_at(@time, MediumPriorityJob) assertion" do
+        assert_raise Test::Unit::AssertionFailedError do
+          assert_queued_at(@time, MediumPriorityJob)
+        end
+      end
+    end
+
+    context "and then the job is removed with #remove_delayed_job_with_timestamp" do
+      setup do
+        Resque.remove_delayed_job_from_timestamp(@time, MediumPriorityJob)
+      end
+
+      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do
+        assert_not_queued_at(@time, MediumPriorityJob)
+      end
+
+      should "fail the assert_queued_at(@time, MediumPriorityJob) assertion" do
+        assert_raise Test::Unit::AssertionFailedError do
+          assert_queued_at(@time, MediumPriorityJob)
+        end
+      end
+    end
+  end
+
+  context "A task that schedules a resque job with arguments on on Sept. 6, 2016 at 6am" do
+    setup do
+      @time = Time.mktime(2016, 9, 6, 6)
+      Resque.enqueue_at(@time, JobWithArguments, 1, "test")
+    end
+
+    should "pass the assert_queued_at(@time, JobWithArguments, *args) assertion" do
+      assert_queued_at(@time, JobWithArguments, [1, "test"])
+    end
+
+    should "fail the assert_queued_at(@time - 100, JobWithArguments, *args) assertion" do
+      assert_raise Test::Unit::AssertionFailedError do
+        assert_queued_at(@time - 100, JobWithArguments, [1, "test"])
+      end
+    end
+
+    should "pass the assert_not_queued_at(@time - 100, JobWithArguments, *args) assertion" do
+      assert_not_queued_at(@time - 100, JobWithArguments, [1, "test"])
+    end
+
+    context "and then the job is removed with #remove_delayed" do
+      setup do
+        Resque.remove_delayed(JobWithArguments, 1, "test")
+      end
+
+      should "pass the assert_not_queued_at(@time, JobWithArguments, *args) assertion" do
+        assert_not_queued_at(@time, JobWithArguments, [1, "test"])
+      end
+
+      should "fail the assert_queued_at(@time, JobWithArguments, *args) assertion" do
+        assert_raise Test::Unit::AssertionFailedError do
+          assert_queued_at(@time, JobWithArguments, [1, "test"])
+        end
+      end
+    end
+
+    context "and then the job is removed with #remove_delayed_job_from_timestamp" do
+      setup do
+        Resque.remove_delayed_job_from_timestamp(@time, JobWithArguments, 1, "test")
+      end
+
+      should "pass the assert_not_queued_at(@time, JobWithArguments, *args) assertion" do
+        assert_not_queued_at(@time, JobWithArguments, [1, "test"])
+      end
+
+      should "fail the assert_queued_at(@time, MediumPriorityJob, *args) assertion" do
+        assert_raise Test::Unit::AssertionFailedError do
+          assert_queued_at(@time, JobWithArguments, [1, "test"])
+        end
+      end
+    end
+  end
+end

data/test/resque_unit_test.rb

@@ -0,0 +1,460 @@
+require 'test_helper'
+
+class ResqueUnitTest < Test::Unit::TestCase
+
+  def setup
+    # should probably happen automatically, but I haven't thought of a
+    # good way to hook setup() yet.
+    Resque.reset!
+  end
+
+  context "A task that schedules a resque job implementing self.queue" do
+    setup { Resque.enqueue(MediumPriorityJob) }
+    should "pass the assert_queued(job) assertion" do
+      assert_queued(MediumPriorityJob)
+      assert_job_created(MediumPriorityJob.queue, MediumPriorityJob)
+      assert_equal 1, Resque.queue(MediumPriorityJob.queue).length
+    end
+  end
+
+  context "A task that explicitly is queued to a different queue" do
+    setup { Resque.enqueue_to(:a_non_class_determined_queue, MediumPriorityJob) }
+    should "not queue to the class-determined queue" do
+      assert_equal 0, Resque.queue(MediumPriorityJob.queue).length
+    end
+    should "queue to the explicly-stated queue" do
+      assert_equal 1, Resque.queue(:a_non_class_determined_queue).length
+    end
+  end
+  
+  context "A task that spawns multiple jobs on a single queue" do
+    setup do 
+      3.times {Resque.enqueue(HighPriorityJob)}
+    end
+
+    should "allow partial runs with explicit limit" do
+      assert_equal 3, Resque.queue(:high).length, 'failed setup'
+      Resque.run_for!( :high, 1 )
+      assert_equal 2, Resque.queue(:high).length, 'failed to run just single job'
+    end
+
+    should "allow full run with too-large explicit limit" do
+      assert_equal 3, Resque.queue(:high).length, 'failed setup'
+      Resque.run_for!( :high, 50 )
+      assert_equal 0, Resque.queue(:high).length, 'failed to run all jobs'
+    end
+
+    should "allow full run with implicit limit" do
+      assert_equal 3, Resque.queue(:high).length, 'failed setup'
+      Resque.run_for!( :high )
+      assert_equal 0, Resque.queue(:high).length, 'failed to run all jobs'
+    end
+  end
+
+  context "A task that schedules a resque job" do
+    setup do 
+      @returned = Resque.enqueue(LowPriorityJob)
+    end
+
+    should 'return a value that evaluates to true' do
+      assert @returned
+    end
+
+    should "pass the assert_queued(job) assertion" do 
+      assert_queued(LowPriorityJob)
+    end
+
+    should "fail the assert_not_queued(job) assertion" do 
+      assert_raise Test::Unit::AssertionFailedError do 
+        assert_not_queued(LowPriorityJob)
+      end
+    end
+
+    should "should be size 1" do
+      assert_equal 1, Resque.size(:low)
+    end
+
+    context ", when Resque.run! is called," do 
+      setup do 
+        assert !LowPriorityJob.run?, "The job should not have been run yet"
+        Resque.run!
+      end
+      
+      teardown do 
+        LowPriorityJob.run = false
+      end
+
+      should "run the job" do 
+        assert LowPriorityJob.run?, "The job should have run"
+      end
+
+      should "clear the job from the queue" do
+        assert_not_queued(LowPriorityJob)
+      end
+    end
+
+    # assert number of jobs?
+  end
+
+  context "A task that schedules a resque job with hooks" do
+    setup do 
+      Resque.enable_hooks!
+    end
+
+    teardown do
+      Resque.disable_hooks!
+    end
+
+    context "before, around, after, failure, after_enqueue" do
+      setup do 
+        JobWithHooks.clear_markers
+        Resque.enqueue(JobWithHooks)
+      end
+
+      should "have run the after_enqueue hook" do 
+        assert_queued(JobWithHooks)
+        assert(JobWithHooks.markers[:after_enqueue], 'no after_queue marker set')
+      end
+
+      should "have run the before_enqueue hook" do 
+        assert(JobWithHooks.markers[:before_enqueue], 'no before_queue marker set')
+        assert_queued(JobWithHooks)
+      end
+
+      should "run the before and after hooks during a run" do 
+        Resque.run!
+        assert(JobWithHooks.markers[:before], 'no before marker set')
+        assert(JobWithHooks.markers[:around], 'no around marker set')
+        assert(JobWithHooks.markers[:after], 'no after marker set')
+        assert(!JobWithHooks.markers[:failed], 'failed marker set, and it should not')
+      end
+
+      should "run the before and failed hooks during a run" do
+        JobWithHooks.make_it_fail do
+          assert_raise(RuntimeError) do
+            Resque.run!
+            assert(JobWithHooks.markers[:before], 'no before marker set')
+            assert(JobWithHooks.markers[:around], 'no around marker set')
+            assert(!JobWithHooks.markers[:after], 'after marker set, and it should not')
+            assert(JobWithHooks.markers[:failed], 'no failed marker set')
+          end
+        end
+      end
+
+      should "not call perform if the around hook raised Resque::Job::DontPerform" do
+        JobWithHooks.make_it_dont_perform do
+          Resque.run!
+          assert(JobWithHooks.markers[:before], 'no before marker set')
+          assert(JobWithHooks.markers[:around], 'no around marker set')
+          assert(!JobWithHooks.markers[:after], 'after marker set, and it should not')
+          assert(!JobWithHooks.markers[:failed], 'failed marker set, and it should not')
+        end
+      end
+    end
+
+    context "but without before" do
+      setup do
+        JobWithHooksWithoutBefore.clear_markers
+        Resque.enqueue(JobWithHooksWithoutBefore)
+      end
+
+      should "not run before hooks during a run" do
+        Resque.run!
+        assert(!JobWithHooksWithoutBefore.markers[:before], 'before marker set, and it should not')
+      end
+    end
+
+    context "when before_enqueue returns false" do
+      setup do
+        JobWithHooksBeforeBlocks.clear_markers
+      end
+
+      should "not queue" do
+        Resque.enqueue JobWithHooksBeforeBlocks
+        assert_not_queued JobWithHooksBeforeBlocks
+      end
+
+    end
+
+    context "but without around" do
+      setup do
+        JobWithHooksWithoutAround.clear_markers
+        Resque.enqueue(JobWithHooksWithoutAround)
+      end
+
+      should "not run around hooks during a run" do
+        Resque.run!
+        assert(!JobWithHooksWithoutAround.markers[:around], 'around marker set, and it should not')
+      end
+    end
+  end
+
+  context "Block assertions" do
+    should "pass the assert_queued(job) assertion when queued in block" do
+      assert_queues(HighPriorityJob) do
+        Resque.enqueue(HighPriorityJob)
+      end
+    end
+
+    should "pass the assert_queued(job) assertion when queued in block and outside" do
+      Resque.enqueue(HighPriorityJob)
+      assert_queues(HighPriorityJob) do
+        Resque.enqueue(HighPriorityJob)
+      end
+    end
+
+    should "fail the assert_queued(job) assertion when not queued in block but outside" do
+      Resque.enqueue(LowPriorityJob)
+      assert_raise Test::Unit::AssertionFailedError do
+        assert_queues(LowPriorityJob) do
+          # Nothing.
+        end
+      end
+    end
+
+    should "pass the assert_not_queued(job) assertion when not queued in block" do
+      Resque.enqueue(LowPriorityJob)
+      assert_not_queued(LowPriorityJob) do
+        # Nothing.
+      end
+    end
+
+    should "fail the assert_not_queued(job) assertion when not queued in block" do
+      assert_raise Test::Unit::AssertionFailedError do
+        assert_not_queued(LowPriorityJob) do
+          Resque.enqueue(LowPriorityJob)
+        end
+      end
+    end
+
+    should "fail the assert_not_queued(job) assertion when queued and not in block" do
+      assert_raise Test::Unit::AssertionFailedError do
+        Resque.enqueue(LowPriorityJob)
+        assert_not_queued(LowPriorityJob) do
+          Resque.enqueue(LowPriorityJob)
+        end
+      end
+    end
+
+    should "pass the assert_nothing_queued assertion when nothing queued in block" do
+      Resque.enqueue(LowPriorityJob)
+      assert_nothing_queued do
+        # Nothing.
+      end
+    end
+
+    should "fail the assert_nothing_queued assertion when queued in block" do
+      assert_raise Test::Unit::AssertionFailedError do
+        assert_nothing_queued do
+          Resque.enqueue(LowPriorityJob)
+        end
+      end
+    end
+  end
+
+  context "An empty queue" do
+    should "pass the assert_not_queued(job) assertion" do 
+      assert_not_queued(LowPriorityJob)
+    end
+
+    should "fail the assert_queued(job) assertion" do
+      assert_raise Test::Unit::AssertionFailedError do 
+        assert_queued(LowPriorityJob)
+      end
+    end
+
+    should "be size 0 when empty" do
+      assert_equal 0, Resque.size(:low)
+    end
+  end
+  
+  context "A task that schedules a resque job with arguments" do 
+    setup do 
+      Resque.enqueue(JobWithArguments, 1, :test, {:symbol => :symbol})
+    end
+    
+    should "pass the assert_queued(job, *args) assertion if the args match and sees enqueued symbols as strings" do
+      assert_queued(JobWithArguments, [1, "test", {"symbol"=>"symbol"}])
+    end
+    
+    should "pass the assert_queued(job, *args) assertion if the args match using symbols" do
+      assert_queued(JobWithArguments, [1, :test, {:symbol => :symbol}])
+    end
+
+    should "pass the assert_queued(job) assertion with no args passed" do
+      assert_queued(JobWithArguments)
+    end
+
+    should "fail the assert_queued(job) assertion if the args don't match" do 
+      assert_raise Test::Unit::AssertionFailedError do 
+        assert_queued(JobWithArguments, [2, "test"])
+      end
+    end
+
+    should "pass the assert_not_queued(job) assertion if the args don't match" do
+      assert_not_queued(JobWithArguments, [2, "test"])
+    end
+
+    should "fail the assert_not_queued(job) assertion if the args match" do
+      assert_raise Test::Unit::AssertionFailedError do 
+        assert_not_queued(JobWithArguments, [1, "test", {"symbol"=>"symbol"}])
+      end
+    end
+  end
+
+  context "A job that schedules a new resque job" do
+    setup do 
+      Resque.enqueue(JobThatCreatesANewJob)
+    end
+
+    should "pass the assert_queued(job) assertion" do 
+      assert_queued(JobThatCreatesANewJob)
+    end
+
+    should "fail the assert_not_queued(job) assertion" do 
+      assert_raise Test::Unit::AssertionFailedError do 
+        assert_not_queued(JobThatCreatesANewJob)
+      end
+    end
+
+    should "pass the assert_not_queued(LowPriorityJob) assertion" do
+      assert_not_queued(LowPriorityJob)
+    end
+
+    context ", when Resque.run! is called," do 
+      setup do 
+        Resque.run!
+      end
+
+      should "clear the job from the queue" do
+        assert_not_queued(JobThatCreatesANewJob)
+      end
+
+      should "add a LowPriorityJob" do
+        assert_queued(LowPriorityJob)
+      end
+    end
+
+    context ", when Resque.full_run!" do
+      setup do
+        assert !LowPriorityJob.run?, "The job should not have been run yet, did you call 'LowPriorityJob.run = false' in teardowns of other tests?"
+        Resque.full_run!
+      end
+
+      teardown do 
+        LowPriorityJob.run = false
+      end
+
+      should "clear the jobs from the queue" do
+        assert_not_queued(JobThatCreatesANewJob)
+        assert_not_queued(LowPriorityJob)
+      end
+
+      should "run the new resque jobs" do
+        assert LowPriorityJob.run?, "LowPriorityJob should have been run"
+      end
+    end
+  end
+
+  context "A task in a different queue" do
+    setup do
+      Resque.enqueue(LowPriorityJob)
+      Resque.enqueue(HighPriorityJob)
+    end
+
+    should "add a LowPriorityJob" do
+      assert_queued(LowPriorityJob)
+    end
+
+    should "add a HighPriorityJob" do
+      assert_queued(HighPriorityJob)
+    end
+
+    context ", when Resque.run_for! is called," do 
+      should "run only tasks in the high priority queue" do
+        Resque.run_for!(Resque.queue_for(HighPriorityJob))
+  
+        assert_queued(LowPriorityJob)
+        assert_not_queued(HighPriorityJob)
+      end
+    end
+  end
+
+  context "An assertion message" do
+    context "of assert_queued" do
+      should "include job class and queue content" do
+        begin
+          assert_not_queued(LowPriorityJob)
+        rescue Test::Unit::AssertionFailedError => error
+          assert_equal "LowPriorityJob should have been queued in low: [].", error.message
+        end
+      end
+      
+      should "include job arguments if provided" do
+        begin
+          assert_not_queued(JobWithArguments, [1, "test"])
+        rescue Test::Unit::AssertionFailedError => error
+          assert_equal "JobWithArguments with [1, \"test\"] should have been queued in medium: [].", error.message
+        end
+      end
+    end
+
+    context "of assert_not_queued" do
+      should "include job class and queue content" do
+        begin
+          Resque.enqueue(LowPriorityJob)
+          assert_not_queued(LowPriorityJob)
+        rescue Test::Unit::AssertionFailedError => error
+            assert_equal "LowPriorityJob should not have been queued in low.", error.message
+        end
+      end
+      
+      should "include job arguments if provided" do
+        begin
+          Resque.enqueue(JobWithArguments, 1, "test")
+          assert_not_queued(JobWithArguments, [1, "test"])
+        rescue Test::Unit::AssertionFailedError => error
+          assert_equal "JobWithArguments with [1, \"test\"] should not have been queued in medium.", error.message
+        end
+      end
+    end
+
+    context "of assert_nothing_queued" do
+      should "include diff" do
+        begin
+          Resque.reset!
+          assert_nothing_queued do
+            Resque.enqueue(LowPriorityJob)
+          end
+        rescue Test::Unit::AssertionFailedError => error
+          assert_equal "No jobs should have been queued.\n<0> expected but was\n<1>.", error.message
+        end
+      end
+    end
+  end
+
+  context "A job that does not specify a queue" do
+    should "receive Resque::NoQueueError" do
+      assert_raise(Resque::NoQueueError) do
+        Resque.enqueue(JobThatDoesNotSpecifyAQueue)
+      end
+    end
+  end
+
+  context "A job that is created using Resque::Job.create" do
+    should "be queued" do
+      assert_nothing_raised do
+        Resque::Job.create(:my_custom_queue, "LowPriorityJob", "arg1", "arg2")
+        assert_job_created(:my_custom_queue, LowPriorityJob, ["arg1", "arg2"])
+      end
+    end
+
+    should "queue a job with a dasherized name" do
+      assert_nothing_raised do
+        Resque::Job.create(:my_custom_queue, "low-priority-job", "arg1", "arg2")
+        assert_job_created(:my_custom_queue, LowPriorityJob, ["arg1", "arg2"])
+      end
+    end
+  end
+
+end