resque_unit 0.3.3 → 0.3.4

data/README.md

@@ -27,7 +27,7 @@ example, if you have code that queues a resque job:
       @queue = :low  
     
       def self.perform(x)
-        // do stuff
+        # do stuff
       end
     end
     
@@ -65,11 +65,48 @@ You can also access the queues directly:
       assert_equal 1, Resque.queue(:low).length
     end
 
+Finally, you can enable hooks:
+
+    Resque.enable_hooks!
+
+    class MyJobWithHooks
+      @queue = :hooked
+
+      def self.perform(x)
+        # do stuff
+      end
+
+      def self.after_enqueue_mark(*args)
+        # called when the job is enqueued
+      end
+
+      def self.before_perform_mark(*args)
+        # called just before the +perform+ method
+      end
+
+      def self.after_perform_mark(*args)
+        # called just after the +perform+ method
+      end
+
+      def self.failure_perform_mark(*args)
+        # called if the +perform+ method raised
+      end
+
+    end
+
+    def queue_job
+      Resque.enqueue(MyJobWithHooks, 1)
+    end
+
 Caveats
 =======
 
 * You should make sure that you call `Resque.reset!` in your test's
   setup method to clear all of the test queues.
+* Hooks support is optional. Just because you probably don't want to call
+  them during unit tests if they play with a DB. Call `Resque.enable_hooks!`
+  in your tests's setup method to enable hooks. To disable hooks, call
+  `Resque.disable_hooks!`.
 
 Resque-Scheduler Support
 ========================

data/lib/resque_unit.rb

@@ -12,6 +12,7 @@ require 'resque_unit/helpers'
 require 'resque_unit/resque'
 require 'resque_unit/errors'
 require 'resque_unit/assertions'
+require 'resque_unit/plugin' 
 
 Test::Unit::TestCase.send(:include, ResqueUnit::Assertions)
 

data/lib/resque_unit/plugin.rb

@@ -0,0 +1,65 @@
+# A copy of the original Resque:Plugin class from the "resque" gem
+# No need to redefine this class if the resque gem was already loaded
+unless defined?(Resque::Plugin)
+
+  module Resque
+    module Plugin
+      extend self
+
+      LintError = Class.new(RuntimeError)
+
+      # Ensure that your plugin conforms to good hook naming conventions.
+      #
+      #   Resque::Plugin.lint(MyResquePlugin)
+      def lint(plugin)
+        hooks = before_hooks(plugin) + around_hooks(plugin) + after_hooks(plugin)
+
+        hooks.each do |hook|
+          if hook =~ /perform$/
+            raise LintError, "#{plugin}.#{hook} is not namespaced"
+          end
+        end
+
+        failure_hooks(plugin).each do |hook|
+          if hook =~ /failure$/
+            raise LintError, "#{plugin}.#{hook} is not namespaced"
+          end
+        end
+      end
+
+      # Given an object, returns a list `before_perform` hook names.
+      def before_hooks(job)
+        job.methods.grep(/^before_perform/).sort
+      end
+
+      # Given an object, returns a list `around_perform` hook names.
+      def around_hooks(job)
+        job.methods.grep(/^around_perform/).sort
+      end
+
+      # Given an object, returns a list `after_perform` hook names.
+      def after_hooks(job)
+        job.methods.grep(/^after_perform/).sort
+      end
+
+      # Given an object, returns a list `on_failure` hook names.
+      def failure_hooks(job)
+        job.methods.grep(/^on_failure/).sort
+      end
+
+      # Given an object, returns a list `after_enqueue` hook names.
+      def after_enqueue_hooks(job)
+        job.methods.grep(/^after_enqueue/).sort
+      end
+    end
+  end
+
+end
+
+unless defined?(Resque::Job::DontPerform)
+  module Resque
+    class Job
+      DontPerform = Class.new(StandardError)
+    end
+  end
+end

data/lib/resque_unit/resque.rb

@@ -31,6 +31,15 @@ module Resque
     queues[queue_name]
   end
 
+  # Yes, all Resque hooks!
+  def enable_hooks!
+    @hooks_enabled = true
+  end
+
+  def disable_hooks!
+    @hooks_enabled = nil
+  end
+
   # Executes all jobs in all queues in an undefined order.
   def run!
     old_queue = @queue.dup
@@ -38,7 +47,7 @@ module Resque
 
     old_queue.each do |k, v|
       while job = v.shift
-        job[:klass].perform(*job[:args])
+        @hooks_enabled ? perform_with_hooks(job) : perform_without_hooks(job)
       end
     end
   end
@@ -49,7 +58,7 @@ module Resque
     self.reset!(queue_name)
 
     while job = jobs.shift
-      job[:klass].perform(*job[:args])
+      @hooks_enabled ? perform_with_hooks(job) : perform_without_hooks(job)
     end
   end
 
@@ -74,7 +83,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
-    queue(queue_name) << {:klass => klass, :args => normalized_args(args) }
+    enqueue_unit(queue_name, {:klass => klass, :args => normalized_args(args) })
   end
 
   def normalized_args(args)
@@ -93,4 +102,77 @@ module Resque
     end
   end
 
+  def enqueue_unit(queue_name, hash)
+    queue(queue_name) << hash
+    if @hooks_enabled
+      Plugin.after_enqueue_hooks(hash[:klass]).each do |hook|
+        hash[:klass].send(hook, *hash[:args])
+      end
+    end
+  end
+
+  # Call perform on the job class
+  def perform_without_hooks(job)
+    job[:klass].perform(*job[: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])
+    
+    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])
+        end
+      rescue Resque::Job::DontPerform
+        return false
+      end
+      
+      # Execute the job. Do it in an around_perform hook if available.
+      if around_hooks.empty?
+        perform_without_hooks(job)
+        job_was_performed = true
+      else
+        # We want to nest all around_perform plugins, with the last one
+        # finally calling perform
+        stack = around_hooks.reverse.inject(nil) do |last_hook, hook|
+          if last_hook
+            lambda do
+              job[:klass].send(hook, *job[:args]) { last_hook.call }
+            end
+          else
+            lambda do
+              job[:klass].send(hook, *job[:args]) do
+                result = perform_without_hooks(job)
+                job_was_performed = true
+                result
+              end
+            end
+          end
+        end
+        stack.call
+      end
+      
+      # Execute after_perform hook
+      after_hooks.each do |hook|
+        job[:klass].send(hook, *job[:args])
+      end
+      
+      # Return true if the job was performed
+      return job_was_performed
+      
+    # 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]) }
+      raise e
+    end
+  end
+
 end

data/lib/resque_unit/scheduler.rb

@@ -19,7 +19,7 @@ module ResqueUnit
     end
     
     def enqueue_with_timestamp(timestamp, klass, *args)
-      queue(queue_for(klass)) << {:klass => klass, :args => decode(encode(args)), :timestamp => timestamp}
+      enqueue_unit(queue_for(klass), {:klass => klass, :args => decode(encode(args)), :timestamp => timestamp})
     end
 
   end

data/test/resque_unit_test.rb

@@ -57,6 +57,54 @@ 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!
+      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
+
+    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 "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], 'failed 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
       assert_queues(HighPriorityJob) do

data/test/sample_jobs.rb

@@ -47,4 +47,60 @@ class JobThatDoesNotSpecifyAQueue
   
   def self.perform
   end
+end
+
+class JobWithHooks
+  @queue = :with_hooks
+  @markers = {}
+  
+  def self.perform
+    raise 'FAIL!' if @will_fail
+  end
+  
+  def self.markers
+    @markers
+  end
+  
+  def self.clear_markers
+    @markers = {}
+  end
+  
+  def self.after_enqueue_mark(*args)
+    markers[:after_enqueue] = true
+  end
+  
+  def self.before_perform_mark(*args)
+    markers[:before] = true
+  end
+  
+  def self.around_perform_mark(*args)
+    markers[:around] = true
+    if @dont_perform
+      raise Resque::Job::DontPerform
+    else
+      yield
+    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
+  ensure
+    @will_fail = false
+  end
+  
+  def self.make_it_dont_perform(&block)
+    @dont_perform = true
+  ensure
+    @dont_perform = false
+  end
+  
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 3
-  version: 0.3.3
+  - 4
+  version: 0.3.4
 platform: ruby
 authors: 
 - Justin Weiss
@@ -14,12 +14,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-17 00:00:00 -08:00
+date: 2011-02-14 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -31,10 +30,10 @@ dependencies:
         - 6
         version: 1.4.6
   type: :runtime
+  prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: bundler
-  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -44,10 +43,10 @@ dependencies:
         - 0
         version: "0"
   type: :development
+  prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: shoulda
-  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -57,6 +56,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
+  prerelease: false
   version_requirements: *id003
 description: 
 email: justin@uberweiss.org
@@ -70,6 +70,7 @@ files:
 - lib/resque_unit/assertions.rb
 - lib/resque_unit/errors.rb
 - lib/resque_unit/helpers.rb
+- lib/resque_unit/plugin.rb
 - lib/resque_unit/resque.rb
 - lib/resque_unit/scheduler.rb
 - lib/resque_unit/scheduler_assertions.rb
@@ -94,6 +95,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 1471830878985269609
       segments: 
       - 0
       version: "0"
@@ -102,6 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 1471830878985269609
       segments: 
       - 0
       version: "0"