run all hooks plugin style

Author: rcarver

lib/resque/job.rb

@@ -108,6 +108,8 @@ def perform
       job_args = args || []
       job_was_performed = false
 
+      # Plugins may come via modules extended which implement Resque::Plugin.
+      # We also treat the payload_class itself like the last plugin.
       plugins = payload_class.instance_variable_get(:@plugins) || []
       plugins << payload_class
 
@@ -121,30 +123,41 @@ def perform
         end
 
         # Execute the job. Do it in an around_perform hook if available.
-        if payload_class.respond_to?(:around_perform)
-          payload_class.around_perform(*job_args) do
-            payload_class.perform(*job_args)
-            job_was_performed = true
-          end
-        else
+        around_plugins = plugins.select { |p| p.respond_to?(:around_perform) }.reverse
+
+        if around_plugins.empty?
           payload_class.perform(*job_args)
           job_was_performed = true
+        else
+          # We want to nest all around_perform plugins, with the last one
+          # finally calling perform
+          stack = around_plugins.inject(nil) do |last_plugin, plugin|
+            if last_plugin
+              lambda do
+                plugin.around_perform(*job_args) { last_plugin.call }
+              end
+            else
+              lambda do
+                plugin.around_perform(*job_args) do
+                  payload_class.perform(*job_args)
+                  job_was_performed = true
+                end
+              end
+            end
+          end
+          stack.call
         end
 
         # Execute after_perform hook
-        if payload_class.respond_to?(:after_perform)
-          payload_class.after_perform(*job_args)
-        end
+        plugins.each { |p| p.after_perform(*job_args) if p.respond_to?(:after_perform) }
 
         # 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 Object => e
-        if payload_class.respond_to?(:on_failure)
-          payload_class.on_failure(e, *job_args)
-        end
+        plugins.each { |p| p.on_failure(e, *job_args) if p.respond_to?(:on_failure) }
         raise
       end
     end

test/plugin_test.rb

@@ -0,0 +1,217 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Multiple plugins with multiple callbacks" do
+  include PerformJob
+
+  module Plugin1
+    extend Resque::Plugin
+    def before_perform(history)
+      history << :before_one
+    end
+    def after_perform(history)
+      history << :after_one
+    end
+  end
+
+  module Plugin2
+    extend Resque::Plugin
+    def before_perform(history)
+      history << :before_two
+    end
+    def after_perform(history)
+      history << :after_two
+    end
+  end
+
+  class ManyBeforesJob
+    extend Plugin1
+    extend Plugin2
+    def self.perform(history)
+      history << :perform
+    end
+  end
+
+  test "all plugins are executed in order" do
+    result = perform_job(ManyBeforesJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:before_one, :before_two, :perform, :after_one, :after_two], history
+  end
+end
+
+context "Resque::Plugin before_perform" do
+  include PerformJob
+
+  module BeforePerform
+    extend Resque::Plugin
+    def before_perform(history)
+      history << :before_perform_plugin
+    end
+  end
+
+  class BeforePerformJob
+    extend BeforePerform
+    def self.perform(history)
+      history << :perform
+    end
+    def self.before_perform(history)
+      history << :before_perform
+    end
+  end
+
+  test "before_perform is executed in plugins first, then the job" do
+    result = perform_job(BeforePerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:before_perform_plugin, :before_perform, :perform], history
+  end
+end
+
+context "Resque::Plugin after_perform" do
+  include PerformJob
+
+  module AfterPerform
+    extend Resque::Plugin
+    def after_perform(history)
+      history << :after_perform_plugin
+    end
+  end
+
+  class AfterPerformJob
+    extend AfterPerform
+    def self.perform(history)
+      history << :perform
+    end
+    def self.after_perform(history)
+      history << :after_perform
+    end
+  end
+
+  test "after_perform is executed in plugins first, then the job" do
+    result = perform_job(AfterPerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:perform, :after_perform_plugin, :after_perform], history
+  end
+end
+
+context "Resque::Plugin around_perform" do
+  include PerformJob
+
+  module AroundPerform
+    extend Resque::Plugin
+    def around_perform(history)
+      history << :around_perform_plugin
+      yield
+    end
+  end
+
+  class AroundPerformJustPerformsJob
+    extend AroundPerform
+    def self.perform(history)
+      history << :perform
+    end
+  end
+
+  test "around_perform is executed in plugins first, then the job is executed" do
+    result = perform_job(AroundPerformJustPerformsJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:around_perform_plugin, :perform], history
+  end
+
+  class AroundPerformJob
+    extend AroundPerform
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform(history)
+      history << :around_perform
+      yield
+    end
+  end
+
+  test "around_perform is executed in plugins first, then the job" do
+    result = perform_job(AroundPerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:around_perform_plugin, :around_perform, :perform], history
+  end
+
+  module AroundPerform2
+    extend Resque::Plugin
+    def around_perform(history)
+      history << :around_perform_plugin2
+      yield
+    end
+  end
+
+  class AroundPerformJob2
+    extend AroundPerform
+    extend AroundPerform2
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform(history)
+      history << :around_perform
+      yield
+    end
+  end
+
+  test "around_perform is executed in multiple plugins first, then the job" do
+    result = perform_job(AroundPerformJob2, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:around_perform_plugin, :around_perform_plugin2, :around_perform, :perform], history
+  end
+
+  module AroundPerformDoesNotYield
+    extend Resque::Plugin
+    def around_perform(history)
+      history << :around_perform_plugin_no_yield
+    end
+  end
+
+  class AroundPerformJob3
+    extend AroundPerform
+    extend AroundPerformDoesNotYield
+    extend AroundPerform2
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform(history)
+      history << :around_perform
+      yield
+    end
+  end
+
+  test "around_perform is executed in multiple plugins but the job aborts if all plugins do not yield" do
+    result = perform_job(AroundPerformJob3, history=[])
+    assert_equal false, result, "perform returned false"
+    assert_equal [:around_perform_plugin, :around_perform_plugin_no_yield], history
+  end
+end
+
+context "Resque::Plugin on_failure" do
+  include PerformJob
+
+  module OnFailure
+    extend Resque::Plugin
+    def on_failure(exception, history)
+      history << "#{exception.message} plugin"
+    end
+  end
+
+  class FailureJob
+    extend OnFailure
+    def self.perform(history)
+      history << :perform
+      raise StandardError, "oh no"
+    end
+    def self.on_failure(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "after_perform is executed in plugins first, then the job" do
+    history = []
+    assert_raises StandardError do
+      perform_job(FailureJob, history)
+    end
+    assert_equal [:perform, "oh no plugin", "oh no"], history
+  end
+end