nogara-resque-loner 1.2.1

data/tasks/resque.rake

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'resque/tasks'

data/test/hoptoad_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+begin
+  require 'hoptoad_notifier'
+rescue LoadError
+  warn "Install hoptoad_notifier gem to run Hoptoad tests."
+end
+
+if defined? HoptoadNotifier
+  context "Hoptoad" do
+    test "should be notified of an error" do
+      exception = StandardError.new("BOOM")
+      worker = Resque::Worker.new(:test)
+      queue = "test"
+      payload = {'class' => Object, 'args' => 66}
+
+      HoptoadNotifier.expects(:notify_or_ignore).with(
+        exception,
+        :parameters => {:payload_class => 'Object', :payload_args => '66'})
+
+      backend = Resque::Failure::Hoptoad.new(exception, worker, queue, payload)
+      backend.save
+    end
+  end
+end

data/test/job_hooks_test.rb

@@ -0,0 +1,323 @@
+require 'test_helper'
+
+context "Resque::Job before_perform" do
+  include PerformJob
+
+  class ::BeforePerformJob
+    def self.before_perform_record_history(history)
+      history << :before_perform
+    end
+
+    def self.perform(history)
+      history << :perform
+    end
+  end
+
+  test "it runs before_perform before perform" do
+    result = perform_job(BeforePerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal history, [:before_perform, :perform]
+  end
+
+  class ::BeforePerformJobFails
+    def self.before_perform_fail_job(history)
+      history << :before_perform
+      raise StandardError
+    end
+    def self.perform(history)
+      history << :perform
+    end
+  end
+
+  test "raises an error and does not perform if before_perform fails" do
+    history = []
+    assert_raises StandardError do
+      perform_job(BeforePerformJobFails, history)
+    end
+    assert_equal history, [:before_perform], "Only before_perform was run"
+  end
+
+  class ::BeforePerformJobAborts
+    def self.before_perform_abort(history)
+      history << :before_perform
+      raise Resque::Job::DontPerform
+    end
+    def self.perform(history)
+      history << :perform
+    end
+  end
+
+  test "does not perform if before_perform raises Resque::Job::DontPerform" do
+    result = perform_job(BeforePerformJobAborts, history=[])
+    assert_equal false, result, "perform returned false"
+    assert_equal history, [:before_perform], "Only before_perform was run"
+  end
+end
+
+context "Resque::Job after_perform" do
+  include PerformJob
+
+  class ::AfterPerformJob
+    def self.perform(history)
+      history << :perform
+    end
+    def self.after_perform_record_history(history)
+      history << :after_perform
+    end
+  end
+
+  test "it runs after_perform after perform" do
+    result = perform_job(AfterPerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal history, [:perform, :after_perform]
+  end
+
+  class ::AfterPerformJobFails
+    def self.perform(history)
+      history << :perform
+    end
+    def self.after_perform_fail_job(history)
+      history << :after_perform
+      raise StandardError
+    end
+  end
+
+  test "raises an error but has already performed if after_perform fails" do
+    history = []
+    assert_raises StandardError do
+      perform_job(AfterPerformJobFails, history)
+    end
+    assert_equal history, [:perform, :after_perform], "Only after_perform was run"
+  end
+end
+
+context "Resque::Job around_perform" do
+  include PerformJob
+
+  class ::AroundPerformJob
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform_record_history(history)
+      history << :start_around_perform
+      yield
+      history << :finish_around_perform
+    end
+  end
+
+  test "it runs around_perform then yields in order to perform" do
+    result = perform_job(AroundPerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal history, [:start_around_perform, :perform, :finish_around_perform]
+  end
+
+  class ::AroundPerformJobFailsBeforePerforming
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform_fail(history)
+      history << :start_around_perform
+      raise StandardError
+      yield
+      history << :finish_around_perform
+    end
+  end
+
+  test "raises an error and does not perform if around_perform fails before yielding" do
+    history = []
+    assert_raises StandardError do
+      perform_job(AroundPerformJobFailsBeforePerforming, history)
+    end
+    assert_equal history, [:start_around_perform], "Only part of around_perform was run"
+  end
+
+  class ::AroundPerformJobFailsWhilePerforming
+    def self.perform(history)
+      history << :perform
+      raise StandardError
+    end
+    def self.around_perform_fail_in_yield(history)
+      history << :start_around_perform
+      begin
+        yield
+      ensure
+        history << :ensure_around_perform
+      end
+      history << :finish_around_perform
+    end
+  end
+
+  test "raises an error but may handle exceptions if perform fails" do
+    history = []
+    assert_raises StandardError do
+      perform_job(AroundPerformJobFailsWhilePerforming, history)
+    end
+    assert_equal history, [:start_around_perform, :perform, :ensure_around_perform], "Only part of around_perform was run"
+  end
+
+  class ::AroundPerformJobDoesNotHaveToYield
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform_dont_yield(history)
+      history << :start_around_perform
+      history << :finish_around_perform
+    end
+  end
+
+  test "around_perform is not required to yield" do
+    history = []
+    result = perform_job(AroundPerformJobDoesNotHaveToYield, history)
+    assert_equal false, result, "perform returns false"
+    assert_equal history, [:start_around_perform, :finish_around_perform], "perform was not run"
+  end
+end
+
+context "Resque::Job on_failure" do
+  include PerformJob
+
+  class ::FailureJobThatDoesNotFail
+    def self.perform(history)
+      history << :perform
+    end
+    def self.on_failure_record_failure(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "it does not call on_failure if no failures occur" do
+    result = perform_job(FailureJobThatDoesNotFail, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal history, [:perform]
+  end
+
+  class ::FailureJobThatFails
+    def self.perform(history)
+      history << :perform
+      raise StandardError, "oh no"
+    end
+    def self.on_failure_record_failure(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "it calls on_failure with the exception and then re-raises the exception" do
+    history = []
+    assert_raises StandardError do
+      perform_job(FailureJobThatFails, history)
+    end
+    assert_equal history, [:perform, "oh no"]
+  end
+
+  class ::FailureJobThatFailsBadly
+    def self.perform(history)
+      history << :perform
+      raise SyntaxError, "oh no"
+    end
+    def self.on_failure_record_failure(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "it calls on_failure even with bad exceptions" do
+    history = []
+    assert_raises SyntaxError do
+      perform_job(FailureJobThatFailsBadly, history)
+    end
+    assert_equal history, [:perform, "oh no"]
+  end
+end
+
+context "Resque::Job after_enqueue" do
+  include PerformJob
+
+  class ::AfterEnqueueJob
+    @queue = :jobs
+    def self.after_enqueue_record_history(history)
+      history << :after_enqueue
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  test "the after enqueue hook should run" do
+    history = []
+    @worker = Resque::Worker.new(:jobs)
+    Resque.enqueue(AfterEnqueueJob, history)
+    @worker.work(0)
+    assert_equal history, [:after_enqueue], "after_enqueue was not run"
+  end
+end
+
+context "Resque::Job all hooks" do
+  include PerformJob
+
+  class ::VeryHookyJob
+    def self.before_perform_record_history(history)
+      history << :before_perform
+    end
+    def self.around_perform_record_history(history)
+      history << :start_around_perform
+      yield
+      history << :finish_around_perform
+    end
+    def self.perform(history)
+      history << :perform
+    end
+    def self.after_perform_record_history(history)
+      history << :after_perform
+    end
+    def self.on_failure_record_history(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "the complete hook order" do
+    result = perform_job(VeryHookyJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal history, [
+      :before_perform,
+      :start_around_perform,
+      :perform,
+      :finish_around_perform,
+      :after_perform
+    ]
+  end
+
+  class ::VeryHookyJobThatFails
+    def self.before_perform_record_history(history)
+      history << :before_perform
+    end
+    def self.around_perform_record_history(history)
+      history << :start_around_perform
+      yield
+      history << :finish_around_perform
+    end
+    def self.perform(history)
+      history << :perform
+    end
+    def self.after_perform_record_history(history)
+      history << :after_perform
+      raise StandardError, "oh no"
+    end
+    def self.on_failure_record_history(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "the complete hook order with a failure at the last minute" do
+    history = []
+    assert_raises StandardError do
+      perform_job(VeryHookyJobThatFails, history)
+    end
+    assert_equal history, [
+      :before_perform,
+      :start_around_perform,
+      :perform,
+      :finish_around_perform,
+      :after_perform,
+      "oh no"
+    ]
+  end
+end

data/test/job_plugins_test.rb

@@ -0,0 +1,230 @@
+require 'test_helper'
+
+context "Multiple plugins with multiple hooks" do
+  include PerformJob
+
+  module Plugin1
+    def before_perform_record_history1(history)
+      history << :before1
+    end
+    def after_perform_record_history1(history)
+      history << :after1
+    end
+  end
+
+  module Plugin2
+    def before_perform_record_history2(history)
+      history << :before2
+    end
+    def after_perform_record_history2(history)
+      history << :after2
+    end
+  end
+
+  class ::ManyBeforesJob
+    extend Plugin1
+    extend Plugin2
+    def self.perform(history)
+      history << :perform
+    end
+  end
+
+  test "hooks of each type are executed in alphabetical order" do
+    result = perform_job(ManyBeforesJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:before1, :before2, :perform, :after1, :after2], history
+  end
+end
+
+context "Resque::Plugin ordering before_perform" do
+  include PerformJob
+
+  module BeforePerformPlugin
+    def before_perform1(history)
+      history << :before_perform1
+    end
+  end
+
+  class ::JobPluginsTestBeforePerformJob
+    extend BeforePerformPlugin
+    def self.perform(history)
+      history << :perform
+    end
+    def self.before_perform(history)
+      history << :before_perform
+    end
+  end
+
+  test "before_perform hooks are executed in order" do
+    result = perform_job(JobPluginsTestBeforePerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:before_perform, :before_perform1, :perform], history
+  end
+end
+
+context "Resque::Plugin ordering after_perform" do
+  include PerformJob
+
+  module AfterPerformPlugin
+    def after_perform_record_history(history)
+      history << :after_perform1
+    end
+  end
+
+  class ::JobPluginsTestAfterPerformJob
+    extend AfterPerformPlugin
+    def self.perform(history)
+      history << :perform
+    end
+    def self.after_perform(history)
+      history << :after_perform
+    end
+  end
+
+  test "after_perform hooks are executed in order" do
+    result = perform_job(JobPluginsTestAfterPerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:perform, :after_perform, :after_perform1], history
+  end
+end
+
+context "Resque::Plugin ordering around_perform" do
+  include PerformJob
+
+  module AroundPerformPlugin1
+    def around_perform1(history)
+      history << :around_perform_plugin1
+      yield
+    end
+  end
+
+  class ::AroundPerformJustPerformsJob
+    extend AroundPerformPlugin1
+    def self.perform(history)
+      history << :perform
+    end
+  end
+
+  test "around_perform hooks are executed before the job" do
+    result = perform_job(AroundPerformJustPerformsJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:around_perform_plugin1, :perform], history
+  end
+
+  class ::JobPluginsTestAroundPerformJob
+    extend AroundPerformPlugin1
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform(history)
+      history << :around_perform
+      yield
+    end
+  end
+
+  test "around_perform hooks are executed in order" do
+    result = perform_job(JobPluginsTestAroundPerformJob, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:around_perform, :around_perform_plugin1, :perform], history
+  end
+
+  module AroundPerformPlugin2
+    def around_perform2(history)
+      history << :around_perform_plugin2
+      yield
+    end
+  end
+
+  class ::AroundPerformJob2
+    extend AroundPerformPlugin1
+    extend AroundPerformPlugin2
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform(history)
+      history << :around_perform
+      yield
+    end
+  end
+
+  test "many around_perform are executed in order" do
+    result = perform_job(AroundPerformJob2, history=[])
+    assert_equal true, result, "perform returned true"
+    assert_equal [:around_perform, :around_perform_plugin1, :around_perform_plugin2, :perform], history
+  end
+
+  module AroundPerformDoesNotYield
+    def around_perform0(history)
+      history << :around_perform0
+    end
+  end
+
+  class ::AroundPerformJob3
+    extend AroundPerformPlugin1
+    extend AroundPerformPlugin2
+    extend AroundPerformDoesNotYield
+    def self.perform(history)
+      history << :perform
+    end
+    def self.around_perform(history)
+      history << :around_perform
+      yield
+    end
+  end
+
+  test "the job is aborted if an around_perform hook does not yield" do
+    result = perform_job(AroundPerformJob3, history=[])
+    assert_equal false, result, "perform returned false"
+    assert_equal [:around_perform, :around_perform0], history
+  end
+
+  module AroundPerformGetsJobResult
+    @@result = nil
+    def last_job_result
+      @@result
+    end
+
+    def around_perform_gets_job_result(*args)
+      @@result = yield
+    end
+  end
+
+  class ::AroundPerformJobWithReturnValue < GoodJob
+    extend AroundPerformGetsJobResult
+  end
+
+  test "the job is aborted if an around_perform hook does not yield" do
+    result = perform_job(AroundPerformJobWithReturnValue, 'Bob')
+    assert_equal true, result, "perform returned true"
+    assert_equal 'Good job, Bob', AroundPerformJobWithReturnValue.last_job_result
+  end
+end
+
+context "Resque::Plugin ordering on_failure" do
+  include PerformJob
+
+  module OnFailurePlugin
+    def on_failure1(exception, history)
+      history << "#{exception.message} plugin"
+    end
+  end
+
+  class ::FailureJob
+    extend OnFailurePlugin
+    def self.perform(history)
+      history << :perform
+      raise StandardError, "oh no"
+    end
+    def self.on_failure(exception, history)
+      history << exception.message
+    end
+  end
+
+  test "on_failure hooks are executed in order" do
+    history = []
+    assert_raises StandardError do
+      perform_job(FailureJob, history)
+    end
+    assert_equal [:perform, "oh no", "oh no plugin"], history
+  end
+end