resque_unit 0.4.8 → 1.0.0.beta.2

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
 

data/test/test_helper.rb

@@ -1,9 +1,7 @@
 require 'rubygems'
-require 'shoulda'
+require 'minitest/spec'
 require 'resque_unit'
+require 'resque_unit_scheduler'
 require 'sample_jobs'
-
-# Fix shoulda under 1.9.2. See https://github.com/thoughtbot/shoulda/issues/issue/117
-unless defined?(Test::Unit::AssertionFailedError)
-  Test::Unit::AssertionFailedError = MiniTest::Assertion
-end
+require 'minitest/autorun'
+require 'pry-byebug'