resque_unit 0.3.6 → 0.4.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1aad0f765a2b78da6d5f17cdbf2f5646066d8b8d
+  data.tar.gz: c694a2f46b3ec5892f7a83ebfae9d734dd0371ec
+SHA512:
+  metadata.gz: 812552beeb3b8c3de00be72b6c13b8dfc4fd2808df1114f308c3eb5aaba2635108d58d9583c5a8c879248b91b716c0bf21c38fad6b2d1453a0405c272daa3f3b
+  data.tar.gz: 97110758541b5c3335906743fdd0dbfd2f1514106ec90ea98dbb9149bef0f86b0932974cc2ed2455d9ea119fffae551aaf9764302ab64101195f4ae3977dec8a

data/lib/resque_unit/assertions.rb

@@ -21,9 +21,9 @@ module ResqueUnit::Assertions
     queue = if block_given?
       snapshot = Resque.size(queue_name)
       yield
-      Resque.queue(queue_name)[snapshot..-1]
+      Resque.all(queue_name)[snapshot..-1]
     else
-      Resque.queue(queue_name)
+      Resque.all(queue_name)
     end
 
     assert_with_custom_message(!in_queue?(queue, klass, args),
@@ -43,9 +43,9 @@ module ResqueUnit::Assertions
     queue = if block_given?
       snapshot = Resque.size(queue_name)
       yield
-      Resque.queue(queue_name)[snapshot..-1]
+      Resque.all(queue_name)[snapshot..-1]
     else
-      Resque.queue(queue_name)
+      Resque.all(queue_name)
     end
 
     assert_with_custom_message(in_queue?(queue, klass, args),
@@ -74,13 +74,8 @@ module ResqueUnit::Assertions
   end
 
   def matching_jobs(queue, klass, args = nil)
-    queue = Resque.queue(queue) if queue.is_a? Symbol
-    if args # retrieve the elements that match klass and args in the queue
-      args = Resque.normalized_args(args)
-      queue.select {|e| e[:klass] == klass && e[:args] == args}
-    else # if no args were passed, retrieve all queued jobs that match klass
-      queue.select {|e| e[:klass] == klass}
-    end
+    normalized_args = Resque.decode(Resque.encode(args)) if args
+    queue.select {|e| e["class"] == klass.to_s && (!args || e["args"] == normalized_args )}
   end
 
 end

data/lib/resque_unit/helpers.rb

@@ -1,4 +1,4 @@
-module Resque
+module ResqueUnit
   module Helpers
     # Given a Ruby object, returns a string suitable for storage in a
     # queue.
@@ -13,7 +13,7 @@ module Resque
     # Given a string, returns a Ruby object.
     def decode(object)
       return unless object
-
+      
       if defined? Yajl
         begin
           Yajl::Parser.parse(object, :check_utf8 => false)

data/lib/resque_unit/plugin.rb

@@ -51,6 +51,11 @@ unless defined?(Resque::Plugin)
       def after_enqueue_hooks(job)
         job.methods.grep(/^after_enqueue/).sort
       end
+
+      # Given an object, returns a list `before_enqueue` hook names.
+      def before_enqueue_hooks(job)
+        job.methods.grep(/^before_enqueue/).sort
+      end
     end
   end
 
@@ -62,4 +67,4 @@ unless defined?(Resque::Job::DontPerform)
       DontPerform = Class.new(StandardError)
     end
   end
-end
+end

data/lib/resque_unit/resque.rb

@@ -1,7 +1,7 @@
 # The fake Resque class. This needs to be loaded after the real Resque
 # for the assertions in +ResqueUnit::Assertions+ to work.
 module Resque
-  include Helpers
+  include ResqueUnit::Helpers
   extend self
 
   # Resets all the queues to the empty state. This should be called in
@@ -24,13 +24,42 @@ module Resque
   end
 
   # Returns an array of all the jobs that have been queued. Each
-  # element is of the form +{:klass => klass, :args => args}+ where
+  # element is of the form +{"class" => klass, "args" => args}+ where
   # +klass+ is the job's class and +args+ is an array of the arguments
   # passed to the job.
   def queue(queue_name)
     queues[queue_name]
   end
 
+  # Return an array of all jobs' payloads for queue
+  # Elements are decoded
+  def all(queue_name)
+    result = list_range(queue_name, 0, size(queue_name))
+    result.is_a?(Array) ? result : [ result ]
+  end
+
+  # Returns an array of jobs' payloads for queue.
+  #
+  # start and count should be integer and can be used for pagination.
+  # start is the item to begin, count is how many items to return.
+  #
+  # To get the 3rd page of a 30 item, paginatied list one would use:
+  #   Resque.peek('my_list', 59, 30)
+  def peek(queue_name, start = 0, count = 1)
+    list_range(queue_name, start, count)
+  end
+
+  # Gets a range of jobs' payloads from queue.
+  # Returns single element if count equal 1
+  # Elements are decoded
+  def list_range(key, start = 0, count = 1)
+    data = if count == 1
+      decode(queues[key][start])
+    else
+      (queues[key][start...start + count] || []).map { |entry| decode(entry) }
+    end
+  end
+
   # Yes, all Resque hooks!
   def enable_hooks!
     @hooks_enabled = true
@@ -42,25 +71,25 @@ module Resque
 
   # Executes all jobs in all queues in an undefined order.
   def run!
-    old_queue = @queue.dup
-    self.reset!
-
-    old_queue.each do |k, v|
-      while job = v.shift
-        @hooks_enabled ? perform_with_hooks(job) : perform_without_hooks(job)
-      end
+    payloads = []
+    @queue.each do |queue_name, queue|
+      payloads.concat queue.slice!(0, queue.size)
     end
+    exec_payloads payloads.shuffle
   end
 
-  # Executes all jobs in the given queue in an undefined order.
-  def run_for!(queue_name)
-    jobs = self.queue(queue_name)
-    self.reset!(queue_name)
+  def run_for!(queue_name, limit=false)
+    queue = @queue[queue_name]
+    exec_payloads queue.slice!(0, ( limit ? limit : queue.size) ).shuffle
+  end
 
-    while job = jobs.shift
-      @hooks_enabled ? perform_with_hooks(job) : perform_without_hooks(job)
+  def exec_payloads(raw_payloads)
+    raw_payloads.each do |raw_payload|
+      job_payload = decode(raw_payload)
+      @hooks_enabled ? perform_with_hooks(job_payload) : perform_without_hooks(job_payload)
     end
   end
+  private :exec_payloads
 
   # 1. Execute all jobs in all queues in an undefined order,
   # 2. Check if new jobs were announced, and execute them.
@@ -80,20 +109,21 @@ module Resque
 
   # :nodoc: 
   def enqueue(klass, *args)
-    queue_name = queue_for(klass)
-    # Behaves like Resque, raise if no queue was specifed
-    raise NoQueueError.new("Jobs must be placed onto a queue.") unless queue_name
-    enqueue_unit(queue_name, {:klass => klass, :args => normalized_args(args) })
+    enqueue_to( queue_for(klass), klass, *args)
   end
 
-  def normalized_args(args)
-    decode(encode(args))
+  # :nodoc:
+  def enqueue_to( queue_name, klass, *args )
+    # Behaves like Resque, raise if no queue was specifed
+    raise NoQueueError.new("Jobs must be placed onto a queue.") unless queue_name
+    enqueue_unit(queue_name, {"class" => klass.to_s, "args" => args })
   end
 
   # :nodoc: 
   def queue_for(klass)
     klass.instance_variable_get(:@queue) || (klass.respond_to?(:queue) && klass.queue)
   end
+  alias :queue_from_class :queue_for
 
   # :nodoc:
   def empty_queues?
@@ -103,33 +133,41 @@ module Resque
   end
 
   def enqueue_unit(queue_name, hash)
-    queue(queue_name) << hash
+    klass = constantize(hash["class"])
+    if @hooks_enabled
+      before_hooks = Plugin.before_enqueue_hooks(klass).map do |hook|
+        klass.send(hook, *hash["args"])
+      end
+      return nil if before_hooks.any? { |result| result == false }
+    end
+    queue(queue_name) << encode(hash)
     if @hooks_enabled
-      Plugin.after_enqueue_hooks(hash[:klass]).each do |hook|
-        hash[:klass].send(hook, *hash[:args])
+      Plugin.after_enqueue_hooks(klass).each do |hook|
+        klass.send(hook, *hash["args"])
       end
     end
     queue(queue_name).size
   end
 
   # Call perform on the job class
-  def perform_without_hooks(job)
-    job[:klass].perform(*job[:args])
+  def perform_without_hooks(job_payload)
+    constantize(job_payload["class"]).perform(*job_payload["args"])
   end
 
   # Call perform on the job class, and adds support for Resque hooks.
-  def perform_with_hooks(job)
-    before_hooks  = Resque::Plugin.before_hooks(job[:klass])
-    around_hooks  = Resque::Plugin.around_hooks(job[:klass])
-    after_hooks   = Resque::Plugin.after_hooks(job[:klass])
-    failure_hooks = Resque::Plugin.failure_hooks(job[:klass])
+  def perform_with_hooks(job_payload)
+    job_class = constantize(job_payload["class"])
+    before_hooks  = Resque::Plugin.before_hooks(job_class)
+    around_hooks  = Resque::Plugin.around_hooks(job_class)
+    after_hooks   = Resque::Plugin.after_hooks(job_class)
+    failure_hooks = Resque::Plugin.failure_hooks(job_class)
     
     begin
       # Execute before_perform hook. Abort the job gracefully if
       # Resque::DontPerform is raised.
       begin
         before_hooks.each do |hook|
-          job[:klass].send(hook, *job[:args])
+          job_class.send(hook, *job_payload["args"])
         end
       rescue Resque::Job::DontPerform
         return false
@@ -137,7 +175,7 @@ module Resque
       
       # Execute the job. Do it in an around_perform hook if available.
       if around_hooks.empty?
-        perform_without_hooks(job)
+        perform_without_hooks(job_payload)
         job_was_performed = true
       else
         # We want to nest all around_perform plugins, with the last one
@@ -145,12 +183,12 @@ module Resque
         stack = around_hooks.reverse.inject(nil) do |last_hook, hook|
           if last_hook
             lambda do
-              job[:klass].send(hook, *job[:args]) { last_hook.call }
+              job_class.send(hook, *job_payload["args"]) { last_hook.call }
             end
           else
             lambda do
-              job[:klass].send(hook, *job[:args]) do
-                result = perform_without_hooks(job)
+              job_class.send(hook, *job_payload["args"]) do
+                result = perform_without_hooks(job_payload)
                 job_was_performed = true
                 result
               end
@@ -162,7 +200,7 @@ module Resque
       
       # Execute after_perform hook
       after_hooks.each do |hook|
-        job[:klass].send(hook, *job[:args])
+        job_class.send(hook, *job_payload["args"])
       end
       
       # Return true if the job was performed
@@ -170,16 +208,16 @@ module Resque
       
     # If an exception occurs during the job execution, look for an
     # on_failure hook then re-raise.
-    rescue => e
-      failure_hooks.each { |hook| job[:klass].send(hook, e, *job[:args]) }
+    rescue Object => e
+      failure_hooks.each { |hook| job_class.send(hook, e, *job_payload["args"]) }
       raise e
     end
   end
 
   class Job
-    extend Helpers
+    extend ResqueUnit::Helpers
     def self.create(queue, klass_name, *args)
-      Resque.enqueue_unit(queue, {:klass => constantize(klass_name), :args => decode(encode(args))})
+      Resque.enqueue_unit(queue, {"class" => constantize(klass_name).to_s, "args" => args})
     end
   end
 

data/lib/resque_unit/scheduler.rb

@@ -1,5 +1,5 @@
 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.
@@ -11,28 +11,30 @@ module ResqueUnit
     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), {:klass => klass, :args => decode(encode(args)), :timestamp => timestamp})
+      enqueue_unit(queue_for(klass), {"class" => klass.name, "args" => args, "timestamp" => timestamp})
     end
 
     def remove_delayed(klass, *args)
-      queue = Resque.queue(queue_for(klass))
-      if args # retrieve the elements that match klass and args in the queue
-        args = Resque.normalized_args(args)
-        queue.delete_if { |e| e[:klass] == klass && e[:args] == args }
-      else # if no args were passed, retrieve all queued jobs that match klass
-        queue.delete_if {|e| e[:klass] == klass}
-      end
+      # 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 && Time.parse(e["timestamp"]).to_i == Time.parse(timestamp.to_s).to_i && e["args"] == args }
     end
   end
 
   Resque.send(:extend, Scheduler)
 end
-

data/lib/resque_unit/scheduler_assertions.rb

@@ -1,5 +1,7 @@
 # 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
@@ -12,9 +14,8 @@ module ResqueUnit::SchedulerAssertions
   # 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
+    assert in_timestamped_queue?(queue, expected_timestamp, klass, args),
+      (message || "#{klass} should have been queued in #{queue} before #{expected_timestamp}: #{Resque.queue(queue).inspect}.")
   end
 
   # Similar to +assert_queued_at+, except it takes an expected time
@@ -26,9 +27,8 @@ module ResqueUnit::SchedulerAssertions
   # 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
+    assert !in_timestamped_queue?(queue, expected_timestamp, klass, args),
+      (message || "#{klass} should not have been queued in #{queue} before #{expected_timestamp}.")
   end
 
   # opposite of +assert_queued_in+
@@ -41,7 +41,7 @@ module ResqueUnit::SchedulerAssertions
   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.queue(queue_name), klass, args).select {|e| e[:timestamp] && e[:timestamp] <= expected_timestamp}.empty?
+    !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.rb

@@ -7,12 +7,20 @@ rescue LoadError
   require 'json'
 end
 
-require 'test/unit'
 require 'resque_unit/helpers'
 require 'resque_unit/resque'
 require 'resque_unit/errors'
 require 'resque_unit/assertions'
-require 'resque_unit/plugin' 
+require 'resque_unit/plugin'
 
-Test::Unit::TestCase.send(:include, ResqueUnit::Assertions)
+if defined?(Test::Unit)
+  Test::Unit::TestCase.send(:include, ResqueUnit::Assertions)
+end
+
+if defined?(MiniTest::Unit::TestCase)
+  MiniTest::Unit::TestCase.send(:include, ResqueUnit::Assertions)
+end
 
+if defined?(Minitest::Test)
+  Minitest::Test.send(:include, ResqueUnit::Assertions)
+end

data/lib/resque_unit_scheduler.rb

@@ -1,4 +1,14 @@
 require 'resque_unit/scheduler'
 require 'resque_unit/scheduler_assertions'
 
-Test::Unit::TestCase.send(:include, ResqueUnit::SchedulerAssertions)
+if defined?(Test::Unit)
+  Test::Unit::TestCase.send(:include, ResqueUnit::SchedulerAssertions)
+end
+
+if defined?(MiniTest::Unit::TestCase)
+  MiniTest::Unit::TestCase.send(:include, ResqueUnit::SchedulerAssertions)
+end
+
+if defined?(Minitest::Test)
+  Minitest::Test.send(:include, ResqueUnit::SchedulerAssertions)
+end

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

@@ -18,12 +18,12 @@ class ResqueUnitSchedulerTest < Test::Unit::TestCase
     end
 
     should "fail the assert_queued_in(300, job) assertion" do
-      assert_raise Test::Unit::AssertionFailedError 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 
+    should "pass the assert_not_queued_in(300, job) assertion" do
       assert_not_queued_in(300, MediumPriorityJob)
     end
 
@@ -31,7 +31,7 @@ class ResqueUnitSchedulerTest < Test::Unit::TestCase
       setup do
         Resque.remove_delayed(MediumPriorityJob)
       end
-      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do 
+      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do
         assert_not_queued_at(300, MediumPriorityJob)
       end
 
@@ -42,7 +42,7 @@ class ResqueUnitSchedulerTest < Test::Unit::TestCase
       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
@@ -53,8 +53,8 @@ class ResqueUnitSchedulerTest < Test::Unit::TestCase
       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 
+    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
@@ -63,7 +63,7 @@ class ResqueUnitSchedulerTest < Test::Unit::TestCase
       setup do
         Resque.remove_delayed(JobWithArguments, 1, 'test')
       end
-      should "pass the assert_not_queued_at(@time, JobWithArguments, 1, 'test') assertion" do 
+      should "pass the assert_not_queued_at(@time, JobWithArguments, 1, 'test') assertion" do
         assert_not_queued_at(600, JobWithArguments, 1, 'test')
       end
 
@@ -86,26 +86,26 @@ class ResqueUnitSchedulerTest < Test::Unit::TestCase
         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 
+      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 
+    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 
+    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
@@ -118,7 +118,39 @@ class ResqueUnitSchedulerTest < Test::Unit::TestCase
       setup do
         Resque.remove_delayed(MediumPriorityJob)
       end
-      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do 
+      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_from_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
+
+    context "and then the job is removed with #remove_delayed_job_from_timestamp with timestamp specified in another timezone" do
+      setup do
+        Resque.remove_delayed_job_from_timestamp(@time.utc, MediumPriorityJob)
+      end
+
+      should "pass the assert_not_queued_at(@time, MediumPriorityJob) assertion" do
         assert_not_queued_at(@time, MediumPriorityJob)
       end
 
@@ -129,4 +161,73 @@ class ResqueUnitSchedulerTest < Test::Unit::TestCase
       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
+
+    context "and then the job is removed with #remove_delayed_job_from_timestamp with timestamp in another timezone" do
+      setup 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
+        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

@@ -17,8 +17,42 @@ class ResqueUnitTest < Test::Unit::TestCase
     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 
+    setup do
       @returned = Resque.enqueue(LowPriorityJob)
     end
 
@@ -26,12 +60,12 @@ class ResqueUnitTest < Test::Unit::TestCase
       assert @returned
     end
 
-    should "pass the assert_queued(job) assertion" do 
+    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 
+    should "fail the assert_not_queued(job) assertion" do
+      assert_raise Test::Unit::AssertionFailedError do
         assert_not_queued(LowPriorityJob)
       end
     end
@@ -40,17 +74,17 @@ class ResqueUnitTest < Test::Unit::TestCase
       assert_equal 1, Resque.size(:low)
     end
 
-    context ", when Resque.run! is called," do 
-      setup do 
+    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 
+
+      teardown do
         LowPriorityJob.run = false
       end
 
-      should "run the job" do 
+      should "run the job" do
         assert LowPriorityJob.run?, "The job should have run"
       end
 
@@ -63,51 +97,96 @@ class ResqueUnitTest < Test::Unit::TestCase
   end
 
   context "A task that schedules a resque job with hooks" do
-    setup do 
+    setup do
       Resque.enable_hooks!
-      JobWithHooks.clear_markers
-      Resque.enqueue(JobWithHooks)
     end
 
     teardown do
       Resque.disable_hooks!
     end
 
-    should "have run the after_enqueue hook" do 
-      assert_queued(JobWithHooks)
-      assert(JobWithHooks.markers[:after_enqueue], 'no after_queue marker set')
-    end
+    context "before, around, after, failure, after_enqueue" do
+      setup do
+        JobWithHooks.clear_markers
+        Resque.enqueue(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 "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 "run the before and failed hooks during a run" do
-      JobWithHooks.make_it_fail do
-        assert_raise(RuntimeError) do
+      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], 'no failed marker set')
+          assert(!JobWithHooks.markers[:failed], 'failed marker set, and it should not')
         end
       end
     end
 
-    should "not call perform if the around hook raised Resque::Job::DontPerform" do
-      JobWithHooks.make_it_dont_perform do
+    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(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')
+        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
@@ -117,14 +196,14 @@ class ResqueUnitTest < Test::Unit::TestCase
       end
     end
 
-    should "pass the assert_queued(job) assertion when queued and not in block" do
+    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" do
+    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
@@ -174,12 +253,12 @@ class ResqueUnitTest < Test::Unit::TestCase
   end
 
   context "An empty queue" do
-    should "pass the assert_not_queued(job) assertion" 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_raise Test::Unit::AssertionFailedError do
         assert_queued(LowPriorityJob)
       end
     end
@@ -188,16 +267,16 @@ class ResqueUnitTest < Test::Unit::TestCase
       assert_equal 0, Resque.size(:low)
     end
   end
-  
-  context "A task that schedules a resque job with arguments" do 
-    setup do 
+
+  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
@@ -206,8 +285,8 @@ class ResqueUnitTest < Test::Unit::TestCase
       assert_queued(JobWithArguments)
     end
 
-    should "fail the assert_queued(job) assertion if the args don't match" do 
-      assert_raise Test::Unit::AssertionFailedError do 
+    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
@@ -217,23 +296,23 @@ class ResqueUnitTest < Test::Unit::TestCase
     end
 
     should "fail the assert_not_queued(job) assertion if the args match" do
-      assert_raise Test::Unit::AssertionFailedError 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 
+    setup do
       Resque.enqueue(JobThatCreatesANewJob)
     end
 
-    should "pass the assert_queued(job) assertion" do 
+    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 
+    should "fail the assert_not_queued(job) assertion" do
+      assert_raise Test::Unit::AssertionFailedError do
         assert_not_queued(JobThatCreatesANewJob)
       end
     end
@@ -242,8 +321,8 @@ class ResqueUnitTest < Test::Unit::TestCase
       assert_not_queued(LowPriorityJob)
     end
 
-    context ", when Resque.run! is called," do 
-      setup do 
+    context ", when Resque.run! is called," do
+      setup do
         Resque.run!
       end
 
@@ -262,7 +341,7 @@ class ResqueUnitTest < Test::Unit::TestCase
         Resque.full_run!
       end
 
-      teardown do 
+      teardown do
         LowPriorityJob.run = false
       end
 
@@ -291,10 +370,10 @@ class ResqueUnitTest < Test::Unit::TestCase
       assert_queued(HighPriorityJob)
     end
 
-    context ", when Resque.run_for! is called," do 
+    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
@@ -310,7 +389,7 @@ class ResqueUnitTest < Test::Unit::TestCase
           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"])
@@ -329,7 +408,7 @@ class ResqueUnitTest < Test::Unit::TestCase
             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")

data/test/sample_jobs.rb

@@ -49,10 +49,30 @@ class JobThatDoesNotSpecifyAQueue
   end
 end
 
+module HooksMethods
+  def after_enqueue_mark(*args)
+    markers[:after_enqueue] = true
+  end
+
+  def before_enqueue_mark(*args)
+    markers[:before_enqueue] = true
+  end
+  
+  def after_perform_mark(*args)
+    markers[:after] = true
+  end
+  
+  def failure_perform_mark(*args)
+    markers[:failure] = true
+  end
+end
+
 class JobWithHooks
+  extend HooksMethods
+
   @queue = :with_hooks
   @markers = {}
-  
+
   def self.perform
     raise 'FAIL!' if @will_fail
   end
@@ -65,10 +85,6 @@ class JobWithHooks
     @markers = {}
   end
   
-  def self.after_enqueue_mark(*args)
-    markers[:after_enqueue] = true
-  end
-  
   def self.before_perform_mark(*args)
     markers[:before] = true
   end
@@ -82,14 +98,6 @@ class JobWithHooks
     end
   end
   
-  def self.after_perform_mark(*args)
-    markers[:after] = true
-  end
-  
-  def self.failure_perform_mark(*args)
-    markers[:failure] = true
-  end
-  
   def self.make_it_fail(&block)
     @will_fail = true
     yield
@@ -102,5 +110,58 @@ class JobWithHooks
   ensure
     @dont_perform = false
   end
+end
+
+class JobWithHooksBeforeBlocks < JobWithHooks
+  @queue = :with_hooks
+  def self.before_enqueue_block_enqueueing
+    return false
+  end
+end
+
+class JobWithHooksWithoutBefore
+  extend HooksMethods
+
+  @queue = :with_hooks
+  @markers = {}
+
+  def self.markers
+    @markers
+  end
+  
+  def self.clear_markers
+    @markers = {}
+  end
+  
+  def self.perform; end
+
+  def self.around_perform_mark(*args)
+    markers[:around] = true
+    if @dont_perform
+      raise Resque::Job::DontPerform
+    else
+      yield
+    end
+  end
+end
+
+class JobWithHooksWithoutAround
+  extend HooksMethods
+
+  @queue = :with_hooks
+  @markers = {}
+
+  def self.markers
+    @markers
+  end
   
-end
+  def self.clear_markers
+    @markers = {}
+  end
+
+  def self.perform; end
+  
+  def self.before_perform_mark(*args)
+    markers[:before] = true
+  end
+end

metadata

@@ -1,72 +1,66 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: resque_unit
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 3
-  - 6
-  version: 0.3.6
+version: !ruby/object:Gem::Version
+  version: 0.4.8
 platform: ruby
-authors: 
+authors:
 - Justin Weiss
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-11 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: json
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 4
-        - 6
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
         version: 1.4.6
   type: :runtime
   prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.6
+- !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *id003
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: justin@uberweiss.org
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
+- README.md
+files:
 - README.md
-files: 
+- lib/resque_unit.rb
 - lib/resque_unit/assertions.rb
 - lib/resque_unit/errors.rb
 - lib/resque_unit/helpers.rb
@@ -74,47 +68,37 @@ files:
 - 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_test.rb
 - test/resque_unit_scheduler_test.rb
 - test/resque_unit_test.rb
 - test/sample_jobs.rb
 - test/test_helper.rb
-- README.md
-has_rdoc: true
 homepage: http://github.com/justinweiss/resque_unit
-licenses: []
-
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: -549847167591292216
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: -549847167591292216
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Test::Unit support for resque job queueing
-test_files: 
+test_files:
+- test/resque_test.rb
 - test/resque_unit_scheduler_test.rb
 - test/resque_unit_test.rb