resque_unit 0.1.1 → 0.2.0

data/README.md

@@ -71,4 +71,22 @@ Caveats
 * You should make sure that you call `Resque.reset!` in your test's
   setup method to clear all of the test queues.
 
+Resque-Scheduler Support
+========================
+
+By calling `require 'resque_unit_scheduler'`, ResqueUnit will provide
+mocks for resque-scheduler's `enqueue_at` and `enqueue_in` methods,
+along with a few extra assertions. These are used like this:
+
+    Resque.enqueue_in(600, MediumPriorityJob) # enqueues MediumPriorityJob in 600 seconds
+    assert_queued_in(600, MediumPriorityJob) # will pass
+    assert_not_queued_in(300, MediumPriorityJob) # will also pass
+
+    Resque.enqueue_at(Time.now + 10, MediumPriorityJob) # enqueues MediumPriorityJob at 10 seconds from now
+    assert_queued_at(Time.now + 10, MediumPriorityJob) # will pass
+    assert_not_queued_at(Time.now + 1, MediumPriorityJob) # will also pass
+
+For now, `assert_queued` and `assert_not_queued` will pass for any
+scheduled job. `Resque.run!` will run all scheduled jobs as well.
+
 Copyright (c) 2010 Justin Weiss, released under the MIT license

data/lib/resque_unit/assertions.rb

@@ -17,7 +17,7 @@ module ResqueUnit::Assertions
   # The opposite of +assert_queued+.
   def assert_not_queued(klass, args = nil, message = nil)
     queue = Resque.queue_for(klass)
-    assert_block (message || "#{klass} should have been queued in #{queue}.") do 
+    assert_block (message || "#{klass} should not have been queued in #{queue}.") do 
       !in_queue?(queue, klass, args)
     end
   end
@@ -25,11 +25,15 @@ module ResqueUnit::Assertions
   private
 
   def in_queue?(queue, klass, args = nil)
-    if args # verify the klass and args match some element in the queue
-      !Resque.queue(queue).select {|e| e[:klass] == klass && e[:args] == args}.empty?
-    else # if no args were passed, just verify the job is in the queue
-      !Resque.queue(queue).select {|e| e[:klass] == klass}.empty?
+    !matching_jobs(queue, klass, args).empty?
+  end
+
+  def matching_jobs(queue, klass, args = nil)
+    if args # retrieve the elements that match klass and args in the queue
+      Resque.queue(queue).select {|e| e[:klass] == klass && e[:args] == args}
+    else # if no args were passed, retrieve all queued jobs that match klass
+      Resque.queue(queue).select {|e| e[:klass] == klass}
     end
   end
-  
+
 end

data/lib/resque_unit/scheduler.rb

@@ -0,0 +1,29 @@
+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)
+      queue(queue_for(klass)) << {:klass => klass, :args => args, :timestamp => timestamp}
+    end
+
+  end
+
+  Resque.send(:extend, Scheduler)
+end
+

data/lib/resque_unit/scheduler_assertions.rb

@@ -0,0 +1,47 @@
+# These are a group of assertions you can use in your unit tests to
+# verify that your code is using resque-scheduler correctly.
+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, expected_timestamp, klass, args = nil)
+    # check if we have any matching jobs with a timestamp less than
+    # expected_timestamp
+    !matching_jobs(queue, klass, args).select {|e| e[:timestamp] && 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_unit_scheduler_test.rb

@@ -0,0 +1,70 @@
+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
+
+  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
+  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
+  end
+
+end

data/test/resque_unit_test.rb

@@ -1,8 +1,8 @@
 require 'test_helper'
 
-class ResqueUnitTest < ActiveSupport::TestCase
+class ResqueUnitTest < Test::Unit::TestCase
 
-  setup do
+  def setup
     # should probably happen automatically, but I haven't thought of a
     # good way to hook setup() yet.
     Resque.reset!

data/test/test_helper.rb

@@ -1,6 +1,4 @@
 require 'rubygems'
-require 'active_support'
-require 'active_support/test_case'
 require 'shoulda'
 require 'resque_unit'
 require 'sample_jobs'

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Justin Weiss
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-06 00:00:00 -07:00
+date: 2010-05-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,7 +40,11 @@ extra_rdoc_files:
 files: 
 - lib/resque_unit/assertions.rb
 - lib/resque_unit/resque.rb
+- lib/resque_unit/scheduler.rb
+- lib/resque_unit/scheduler_assertions.rb
 - lib/resque_unit.rb
+- lib/resque_unit_scheduler.rb
+- test/resque_unit_scheduler_test.rb
 - test/resque_unit_test.rb
 - test/sample_jobs.rb
 - test/test_helper.rb
@@ -76,4 +80,5 @@ signing_key:
 specification_version: 3
 summary: Test::Unit support for resque job queueing
 test_files: 
+- test/resque_unit_scheduler_test.rb
 - test/resque_unit_test.rb