resque_unit 0.4.8 → 1.0.0.beta.1

data/lib/resque_unit_scheduler.rb

@@ -1,7 +1,8 @@
-require 'resque_unit/scheduler'
+require 'resque_unit'
+require 'resque-scheduler'
 require 'resque_unit/scheduler_assertions'
 
-if defined?(Test::Unit)
+if defined?(Test::Unit::TestCase)
   Test::Unit::TestCase.send(:include, ResqueUnit::SchedulerAssertions)
 end
 

data/test/redis_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+describe Redis do
+  it "uses a real Redis connection by default" do
+    redis = Redis.current
+    refute_equal Redis::Connection::Memory, redis.client.driver
+
+    redis = Redis.new
+    refute_equal Redis::Connection::Memory, redis.client.driver
+  end
+end

data/test/resque_test.rb

@@ -1,60 +1,60 @@
 require 'test_helper'
+describe Resque do
 
-class ResqueTest < Test::Unit::TestCase
-
-  def setup
+  before do
     Resque.reset!
   end
 
-  context "with one queued job" do
-    setup do
+  describe "with one queued job" do
+    before 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
+    it "returns the 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
+    it "returns an 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
+  describe "with few queued jobs" do
+    before 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
+    it "returns 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
+    it "returns an 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)
+    it "returns all jobs' payloads when peek method called with count equal 0" do
+      # This is the way Resque.peek works, so it's now the way resque-unit works!
+      assert_equal Resque.all(MediumPriorityJob.queue), Resque.peek(MediumPriorityJob.queue, 0, 0)
     end
 
-    should "return all jobs' payloads when all method called" do
+    it "returns 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
+  describe "without queued jobs" do
+    it "returns 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
+    it "returns an 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
+    it "returns an empty array when `all` is called" do
       assert_equal [], Resque.all(MediumPriorityJob.queue)
     end
   end

data/test/resque_unit_scheduler_test.rb

@@ -1,230 +1,232 @@
 require 'test_helper'
 require 'resque_unit_scheduler'
 
-class ResqueUnitSchedulerTest < Test::Unit::TestCase
-
-  def setup
+describe Resque do
+  include ResqueUnit::Assertions
+  include ResqueUnit::SchedulerAssertions
+  
+  before do
     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
+  describe "A task that schedules a resque job in 5 minutes" do
+    before { Resque.enqueue_in(600, MediumPriorityJob) }
+    it "passes the assert_queued(job) assertion" do
       assert_queued(MediumPriorityJob)
     end
 
-    should "pass the assert_queued_in(600, job) assertion" do
+    it "passes 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
+    it "fails the assert_queued_in(300, job) assertion" do
+      assert_raises Minitest::Assertion do
         assert_queued_in(300, MediumPriorityJob)
       end
     end
 
-    should "pass the assert_not_queued_in(300, job) assertion" do
+    it "passes 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
+    describe "and then the job is removed with #remove_delayed" do
+      before do
         Resque.remove_delayed(MediumPriorityJob)
       end
-      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do
+      it "passes 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
+      it "fails the assert_queued_at(@time, MediumPriorityJob) assertion" do
+        assert_raises Minitest::Assertion 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
+  describe "A task that schedules a resque job in 5 minutes with arguments" do
+    before { Resque.enqueue_in(600, JobWithArguments, 1, "test") }
+    it "passes 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
+    it "passes 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
+    it "fails the assert_queued_in(600, JobWithArguments, [2, 'test']) assertion" do
+      assert_raises Minitest::Assertion do
         assert_queued_in(600, JobWithArguments, [2, 'test'])
       end
     end
 
-    context "and then the job is removed with #remove_delayed" do
-      setup do
+    describe "and then the job is removed with #remove_delayed" do
+      before do
         Resque.remove_delayed(JobWithArguments, 1, 'test')
       end
-      should "pass the assert_not_queued_at(@time, JobWithArguments, 1, 'test') assertion" do
+      it "passes 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
+      it "fails the assert_queued_at(@time, JobWithArguments, 1, 'test') assertion" do
+        assert_raises Minitest::Assertion 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
+    describe "and a job of the same class but with different arguments is removed with #remove_delayed" do
+      before do
         Resque.remove_delayed(JobWithArguments, 2, 'test')
       end
-      should "still pass the assert_queued_in(600, JobWithArguments) assertion" do
+      it "still passes 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
+      it "still passes 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
+      it "still fails the assert_queued_in(600, JobWithArguments, [2, 'test']) assertion" do
+        assert_raises Minitest::Assertion 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
+  describe "A task that schedules a resque job on Sept. 6, 2016 at 6am" do
+    before do
       @time = Time.mktime(2016, 9, 6, 6)
       Resque.enqueue_at(@time, MediumPriorityJob)
     end
 
-    should "pass the assert_queued_at(@time, MediumPriorityJob) assertion" do
+    it "passes 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
+    it "fails the assert_queued_at(@time - 100, MediumPriorityJob) assertion" do
+      assert_raises Minitest::Assertion do
         assert_queued_at(@time - 100, MediumPriorityJob)
       end
     end
 
-    should "pass the assert_not_queued_at(@time - 100, MediumPriorityJob) assertion" do
+    it "passes 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
+    describe "and then the job is removed with #remove_delayed" do
+      before do
         Resque.remove_delayed(MediumPriorityJob)
       end
-      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do
+      it "passes 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
+      it "fails the assert_queued_at(@time, MediumPriorityJob) assertion" do
+        assert_raises Minitest::Assertion do
           assert_queued_at(@time, MediumPriorityJob)
         end
       end
     end
 
-    context "and then the job is removed with #remove_delayed_job_from_timestamp" do
-      setup do
+    describe "and then the job is removed with #remove_delayed_job_from_timestamp" do
+      before do
         Resque.remove_delayed_job_from_timestamp(@time, MediumPriorityJob)
       end
 
-      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do
+      it "passes 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
+      it "fails the assert_queued_at(@time, MediumPriorityJob) assertion" do
+        assert_raises Minitest::Assertion do
           assert_queued_at(@time, MediumPriorityJob)
         end
       end
     end
 
-    context "and then the job is removed with #remove_delayed_job_from_timestamp with timestamp specified in another timezone" do
-      setup do
+    describe "and then the job is removed with #remove_delayed_job_from_timestamp with timestamp specified in another timezone" do
+      before do
         Resque.remove_delayed_job_from_timestamp(@time.utc, MediumPriorityJob)
       end
 
-      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do
+      it "passes 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
+      it "fails the assert_queued_at(@time, MediumPriorityJob) assertion" do
+        assert_raises Minitest::Assertion 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
+  describe "A task that schedules a resque job with arguments on on Sept. 6, 2016 at 6am" do
+    before 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
+    it "passes 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
+    it "fails the assert_queued_at(@time - 100, JobWithArguments, *args) assertion" do
+      assert_raises Minitest::Assertion do
         assert_queued_at(@time - 100, JobWithArguments, [1, "test"])
       end
     end
 
-    should "pass the assert_not_queued_at(@time - 100, JobWithArguments, *args) assertion" do
+    it "passes 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
+    describe "and then the job is removed with #remove_delayed" do
+      before do
         Resque.remove_delayed(JobWithArguments, 1, "test")
       end
 
-      should "pass the assert_not_queued_at(@time, JobWithArguments, *args) assertion" do
+      it "passes 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
+      it "fails the assert_queued_at(@time, JobWithArguments, *args) assertion" do
+        assert_raises Minitest::Assertion 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
+    describe "and then the job is removed with #remove_delayed_job_from_timestamp" do
+      before do
         Resque.remove_delayed_job_from_timestamp(@time, JobWithArguments, 1, "test")
       end
 
-      should "pass the assert_not_queued_at(@time, JobWithArguments, *args) assertion" do
+      it "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
+      it "fail the assert_queued_at(@time, MediumPriorityJob, *args) assertion" do
+        assert_raises Minitest::Assertion do
           assert_queued_at(@time, JobWithArguments, [1, "test"])
         end
       end
     end
 
-    context "and then the job is removed with #remove_delayed_job_from_timestamp with timestamp in another timezone" do
-      setup do
+    describe "and then the job is removed with #remove_delayed_job_from_timestamp with timestamp in another timezone" do
+      before do
         Resque.remove_delayed_job_from_timestamp(@time.utc, JobWithArguments, 1, "test")
       end
 
-      should "pass the assert_not_queued_at(@time, JobWithArguments, *args) assertion" do
+      it "passes 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
+      it "fails the assert_queued_at(@time, MediumPriorityJob, *args) assertion" do
+        assert_raises Minitest::Assertion do
           assert_queued_at(@time, JobWithArguments, [1, "test"])
         end
       end

data/test/resque_unit_test.rb

@@ -1,94 +1,94 @@
 require 'test_helper'
 
-class ResqueUnitTest < Test::Unit::TestCase
+describe ResqueUnit do
 
-  def setup
+  before do
     # 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
+  describe "A task that schedules a resque job implementing self.queue" do
+    before { Resque.enqueue(MediumPriorityJob) }
+    it "passes 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
+  describe "A task that explicitly is queued to a different queue" do
+    before { Resque.enqueue_to(:a_non_class_determined_queue, MediumPriorityJob) }
+    it "does 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
+    it "queues 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
+  describe "A task that spawns multiple jobs on a single queue" do
+    before do
       3.times {Resque.enqueue(HighPriorityJob)}
     end
 
-    should "allow partial runs with explicit limit" do
+    it "allows partial runs with explicit limit" do
       assert_equal 3, Resque.queue(:high).length, 'failed setup'
-      Resque.run_for!( :high, 1 )
+      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
+    it "allows full run with too-large explicit limit" do
       assert_equal 3, Resque.queue(:high).length, 'failed setup'
-      Resque.run_for!( :high, 50 )
+      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
+    it "allows full run with implicit limit" do
       assert_equal 3, Resque.queue(:high).length, 'failed setup'
-      Resque.run_for!( :high )
+      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
+  describe "A task that schedules a resque job" do
+    before do
       @returned = Resque.enqueue(LowPriorityJob)
     end
 
-    should 'return a value that evaluates to true' do
+    it 'returns a value that evaluates to true' do
       assert @returned
     end
 
-    should "pass the assert_queued(job) assertion" do
+    it "passes 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
+    it "fails the assert_not_queued(job) assertion" do
+      assert_raises Minitest::Assertion do
         assert_not_queued(LowPriorityJob)
       end
     end
 
-    should "should be size 1" do
+    it "has 1 job in the queue" do
       assert_equal 1, Resque.size(:low)
     end
 
-    context ", when Resque.run! is called," do
-      setup do
+    describe ", when Resque.run! is called," do
+      before do
         assert !LowPriorityJob.run?, "The job should not have been run yet"
         Resque.run!
       end
 
-      teardown do
+      after do
         LowPriorityJob.run = false
       end
 
-      should "run the job" do
+      it "runs the job" do
         assert LowPriorityJob.run?, "The job should have run"
       end
 
-      should "clear the job from the queue" do
+      it "clears the job from the queue" do
         assert_not_queued(LowPriorityJob)
       end
     end
@@ -96,32 +96,24 @@ class ResqueUnitTest < Test::Unit::TestCase
     # 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
+  describe "A task that schedules a resque job with hooks" do
+    describe "before, around, after, failure, after_enqueue" do
+      before do
         JobWithHooks.clear_markers
         Resque.enqueue(JobWithHooks)
       end
 
-      should "have run the after_enqueue hook" do
+      it "ran 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
+      it "ran 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
+      it "ran 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')
@@ -129,9 +121,9 @@ class ResqueUnitTest < Test::Unit::TestCase
         assert(!JobWithHooks.markers[:failed], 'failed marker set, and it should not')
       end
 
-      should "run the before and failed hooks during a run" do
+      it "ran the before and failed hooks during a run" do
         JobWithHooks.make_it_fail do
-          assert_raise(RuntimeError) do
+          assert_raises(RuntimeError) do
             Resque.run!
             assert(JobWithHooks.markers[:before], 'no before marker set')
             assert(JobWithHooks.markers[:around], 'no around marker set')
@@ -141,7 +133,7 @@ class ResqueUnitTest < Test::Unit::TestCase
         end
       end
 
-      should "not call perform if the around hook raised Resque::Job::DontPerform" do
+      it "does 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')
@@ -152,83 +144,83 @@ class ResqueUnitTest < Test::Unit::TestCase
       end
     end
 
-    context "but without before" do
-      setup do
+    describe "but without before" do
+      before do
         JobWithHooksWithoutBefore.clear_markers
         Resque.enqueue(JobWithHooksWithoutBefore)
       end
 
-      should "not run before hooks during a run" do
+      it "does 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
+    describe "when before_enqueue returns false" do
+      before do
         JobWithHooksBeforeBlocks.clear_markers
       end
 
-      should "not queue" do
+      it "does not queue" do
         Resque.enqueue JobWithHooksBeforeBlocks
         assert_not_queued JobWithHooksBeforeBlocks
       end
 
     end
 
-    context "but without around" do
-      setup do
+    describe "but without around" do
+      before do
         JobWithHooksWithoutAround.clear_markers
         Resque.enqueue(JobWithHooksWithoutAround)
       end
 
-      should "not run around hooks during a run" do
+      it "does 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
+  describe "Block assertions" do
+    it "passes 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
+    it "passes 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
+    it "fails the assert_queued(job) assertion when not queued in block but outside" do
       Resque.enqueue(LowPriorityJob)
-      assert_raise Test::Unit::AssertionFailedError do
+      assert_raises Minitest::Assertion do
         assert_queues(LowPriorityJob) do
           # Nothing.
         end
       end
     end
 
-    should "pass the assert_not_queued(job) assertion when not queued in block" do
+    it "passes 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
+    it "fails the assert_not_queued(job) assertion when not queued in block" do
+      assert_raises Minitest::Assertion 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
+    it "fails the assert_not_queued(job) assertion when queued and not in block" do
+      assert_raises Minitest::Assertion do
         Resque.enqueue(LowPriorityJob)
         assert_not_queued(LowPriorityJob) do
           Resque.enqueue(LowPriorityJob)
@@ -236,15 +228,15 @@ class ResqueUnitTest < Test::Unit::TestCase
       end
     end
 
-    should "pass the assert_nothing_queued assertion when nothing queued in block" do
+    it "passes 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
+    it "fails the assert_nothing_queued assertion when queued in block" do
+      assert_raises Minitest::Assertion do
         assert_nothing_queued do
           Resque.enqueue(LowPriorityJob)
         end
@@ -252,127 +244,127 @@ class ResqueUnitTest < Test::Unit::TestCase
     end
   end
 
-  context "An empty queue" do
-    should "pass the assert_not_queued(job) assertion" do
+  describe "An empty queue" do
+    it "passes 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
+    it "fails the assert_queued(job) assertion" do
+      assert_raises Minitest::Assertion do
         assert_queued(LowPriorityJob)
       end
     end
 
-    should "be size 0 when empty" do
+    it "is 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
+  describe "A task that schedules a resque job with arguments" do
+    before 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
+    it "passes 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
+    it "passes 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
+    it "passes 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
+    it "fails the assert_queued(job) assertion if the args don't match" do
+      assert_raises Minitest::Assertion do
         assert_queued(JobWithArguments, [2, "test"])
       end
     end
 
-    should "pass the assert_not_queued(job) assertion if the args don't match" do
+    it "passes 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
+    it "fails the assert_not_queued(job) assertion if the args match" do
+      assert_raises Minitest::Assertion do
         assert_not_queued(JobWithArguments, [1, "test", {"symbol"=>"symbol"}])
       end
     end
   end
 
-  context "A job that schedules a new resque job" do
-    setup do
+  describe "A job that schedules a new resque job" do
+    before do
       Resque.enqueue(JobThatCreatesANewJob)
     end
 
-    should "pass the assert_queued(job) assertion" do
+    it "passes 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
+    it "fails the assert_not_queued(job) assertion" do
+      assert_raises Minitest::Assertion do
         assert_not_queued(JobThatCreatesANewJob)
       end
     end
 
-    should "pass the assert_not_queued(LowPriorityJob) assertion" do
+    it "passes the assert_not_queued(LowPriorityJob) assertion" do
       assert_not_queued(LowPriorityJob)
     end
 
-    context ", when Resque.run! is called," do
-      setup do
+    describe ", when Resque.run! is called," do
+      before do
         Resque.run!
       end
 
-      should "clear the job from the queue" do
+      it "clears the job from the queue" do
         assert_not_queued(JobThatCreatesANewJob)
       end
 
-      should "add a LowPriorityJob" do
+      it "adds 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?"
+    describe ", when Resque.full_run!" do
+      before do
+        assert !LowPriorityJob.run?, "The job should not have run yet, did you call 'LowPriorityJob.run = false' in teardowns of other tests?"
         Resque.full_run!
       end
 
-      teardown do
+      after do
         LowPriorityJob.run = false
       end
 
-      should "clear the jobs from the queue" do
+      it "clears the jobs from the queue" do
         assert_not_queued(JobThatCreatesANewJob)
         assert_not_queued(LowPriorityJob)
       end
 
-      should "run the new resque jobs" do
+      it "runs 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
+  describe "A task in a different queue" do
+    before do
       Resque.enqueue(LowPriorityJob)
       Resque.enqueue(HighPriorityJob)
     end
 
-    should "add a LowPriorityJob" do
+    it "adds a LowPriorityJob" do
       assert_queued(LowPriorityJob)
     end
 
-    should "add a HighPriorityJob" do
+    it "adds 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))
+    describe ", when Resque.run_for! is called," do
+      it "runs only tasks in the high priority queue" do
+        Resque.run_for!(Resque.queue_from_class(HighPriorityJob))
 
         assert_queued(LowPriorityJob)
         assert_not_queued(HighPriorityJob)
@@ -380,80 +372,71 @@ class ResqueUnitTest < Test::Unit::TestCase
     end
   end
 
-  context "An assertion message" do
-    context "of assert_queued" do
-      should "include job class and queue content" do
+  describe "An assertion message" do
+    describe "of assert_queued" do
+      it "includes job class and queue content" do
         begin
           assert_not_queued(LowPriorityJob)
-        rescue Test::Unit::AssertionFailedError => error
+        rescue Minitest::Assertion => error
           assert_equal "LowPriorityJob should have been queued in low: [].", error.message
         end
       end
 
-      should "include job arguments if provided" do
+      it "includes job arguments if provided" do
         begin
           assert_not_queued(JobWithArguments, [1, "test"])
-        rescue Test::Unit::AssertionFailedError => error
+        rescue Minitest::Assertion => 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
+    describe "of assert_not_queued" do
+      it "includes 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
+        rescue Minitest::Assertion => error
+          assert_equal "LowPriorityJob should not have been queued in low.", error.message
         end
       end
 
-      should "include job arguments if provided" do
+      it "includes job arguments if provided" do
         begin
           Resque.enqueue(JobWithArguments, 1, "test")
           assert_not_queued(JobWithArguments, [1, "test"])
-        rescue Test::Unit::AssertionFailedError => error
+        rescue Minitest::Assertion => 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
+    describe "of assert_nothing_queued" do
+      it "includes 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
+        rescue Minitest::Assertion => error
+          assert_equal "No jobs should have been queued.\nExpected: 0\n  Actual: 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
+  describe "A job that does not specify a queue" do
+    it "receives Resque::NoQueueError" do
+      assert_raises(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
+  describe "A job that is created using Resque::Job.create" do
+    it "is queued" do
+      Resque::Job.create(:my_custom_queue, "LowPriorityJob", "arg1", "arg2")
+      assert_job_created(:my_custom_queue, LowPriorityJob, ["arg1", "arg2"])
     end
   end