resque_unit 0.3.7 → 0.4.0

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

@@ -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/resque.rb

@@ -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
@@ -45,20 +74,23 @@ module Resque
     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)
+
+    old_queue.each do |queue_name, queue|
+      queue.each do |job_payload|
+        job_payload = decode(job_payload)
+        @hooks_enabled ? perform_with_hooks(job_payload) : perform_without_hooks(job_payload)
       end
     end
   end
 
   # Executes all jobs in the given queue in an undefined order.
   def run_for!(queue_name)
-    jobs = self.queue(queue_name)
+    jobs_payloads = all(queue_name)
+
     self.reset!(queue_name)
 
-    while job = jobs.shift
-      @hooks_enabled ? perform_with_hooks(job) : perform_without_hooks(job)
+    jobs_payloads.each do |job_payload|
+      @hooks_enabled ? perform_with_hooks(job_payload) : perform_without_hooks(job_payload)
     end
   end
 
@@ -83,11 +115,7 @@ module Resque
     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) })
-  end
-
-  def normalized_args(args)
-    decode(encode(args))
+    enqueue_unit(queue_name, {"class" => klass.name, "args" => args })
   end
 
   # :nodoc: 
@@ -103,33 +131,35 @@ module Resque
   end
 
   def enqueue_unit(queue_name, hash)
-    queue(queue_name) << hash
+    klass = constantize(hash["class"])
+    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 +167,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 +175,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 +192,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
@@ -171,7 +201,7 @@ 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]) }
+      failure_hooks.each { |hook| job_class.send(hook, e, *job_payload["args"]) }
       raise e
     end
   end
@@ -179,7 +209,7 @@ module Resque
   class Job
     extend 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), "args" => args})
     end
   end
 

data/lib/resque_unit/scheduler.rb

@@ -19,17 +19,14 @@ module ResqueUnit
     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, "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
   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
@@ -41,7 +43,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/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_test.rb

@@ -65,49 +65,77 @@ class ResqueUnitTest < Test::Unit::TestCase
   context "A task that schedules a resque job with hooks" 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 "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
+      should "run the before and failed hooks during a run" do
+        JobWithHooks.make_it_fail do
+          assert_raise(RuntimeError) do
+            Resque.run!
+            assert(JobWithHooks.markers[:before], 'no before marker set')
+            assert(JobWithHooks.markers[:around], 'no around marker set')
+            assert(!JobWithHooks.markers[:after], 'after marker set, and it should not')
+            assert(JobWithHooks.markers[:failed], 'no failed marker set')
+          end
+        end
+      end
+
+      should "not call perform if the around hook raised Resque::Job::DontPerform" do
+        JobWithHooks.make_it_dont_perform do
           Resque.run!
           assert(JobWithHooks.markers[:before], 'no before marker set')
           assert(JobWithHooks.markers[:around], 'no around marker set')
           assert(!JobWithHooks.markers[:after], 'after marker set, and it should not')
-          assert(JobWithHooks.markers[:failed], '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 "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 +145,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

data/test/sample_jobs.rb

@@ -49,10 +49,26 @@ class JobThatDoesNotSpecifyAQueue
   end
 end
 
+module HooksMethods
+  def after_enqueue_mark(*args)
+    markers[:after_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 +81,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 +94,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 +106,51 @@ class JobWithHooks
   ensure
     @dont_perform = false
   end
+end
+
+class JobWithHooksWithoutBefore
+  extend HooksMethods
+
+  @queue = :with_hooks
+  @markers = {}
+
+  def self.markers
+    @markers
+  end
   
-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
+  
+  def self.clear_markers
+    @markers = {}
+  end
+
+  def self.perform; end
+  
+  def self.before_perform_mark(*args)
+    markers[:before] = true
+  end
+end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: resque_unit
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 3
-  - 7
-  version: 0.3.7
+  prerelease: 
+  version: 0.4.0
 platform: ruby
 authors: 
 - Justin Weiss
@@ -14,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-26 00:00:00 -07:00
+date: 2011-06-28 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -24,10 +20,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 4
-        - 6
         version: 1.4.6
   type: :runtime
   prerelease: false
@@ -39,8 +31,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   prerelease: false
@@ -52,8 +42,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   prerelease: false
@@ -76,6 +64,7 @@ files:
 - 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
@@ -95,7 +84,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -4275170874944831438
+      hash: -1898540308835741897
       segments: 
       - 0
       version: "0"
@@ -104,17 +93,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -4275170874944831438
+      hash: -1898540308835741897
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
 summary: Test::Unit support for resque job queueing
 test_files: 
+- test/resque_test.rb
 - test/resque_unit_scheduler_test.rb
 - test/resque_unit_test.rb