Merge pull request #22 from mateusdelbianco/master

Enhancements and bugfixes.

Gemfile

@@ -4,5 +4,16 @@ gemspec
 group :development do
   gem 'gemcutter'
   gem 'ruby-debug', :platform => :mri_18
-  gem 'ruby-debug19', :platform => :mri_19
+  gem 'debugger', :platform => :mri_19
+end
+
+group :test do
+  gem "rake"
+  gem "rack-test", "~> 0.5"
+  gem "mocha", "~> 0.9.7"
+  gem "yajl-ruby", "~>0.8.2", :platforms => :mri
+  gem "json", "~>1.5.3", :platforms => [:jruby, :rbx]
+  gem "hoptoad_notifier"
+  gem "airbrake"
+  gem "i18n"
 end

lib/resque-ext/job.rb

@@ -16,10 +16,12 @@ def self.create_with_loner(queue, klass, *args)
       item = { :class => klass.to_s, :args => args }
       return "EXISTED" if Resque::Plugins::Loner::Helpers.loner_queued?(queue, item)
       # multi block returns array of keys
+      create_return_value = false
       Resque.redis.multi do
-        create_without_loner(queue, klass, *args)
+        create_return_value = create_without_loner(queue, klass, *args)
         Resque::Plugins::Loner::Helpers.mark_loner_as_queued(queue, item)
       end.first
+      create_return_value
     end
 
     #

lib/resque-loner/unique_job.rb

@@ -36,8 +36,8 @@ def redis_key(payload)
 
         #
         # The default ttl of a locking key is -1, i.e. forever.  If for some reason you only
-        # want the lock to be in place after a certain amount of time, just set a ttl for
-        # for your job.  For example:
+        # want the lock to be in place after a certain amount of time, just set a ttl (in
+        # seconds) for your job.  For example:
         #
         # class FooJob
         #   include Resque::Plugins::UniqueJob

spec/loner_spec.rb

@@ -11,10 +11,8 @@ class SomeJob
   @queue = :some_queue
 end
 
-class SomeUniqueJob 
-
+class SomeUniqueJob
   include Resque::Plugins::UniqueJob
-
   @queue = :other_queue
   def self.perform(foo); end
 end
@@ -28,7 +26,6 @@ def self.perform(foo)
 end
 
 class DeprecatedUniqueJob < Resque::Plugins::Loner::UniqueJob
-
   @queue = :other_queue
   def self.perform(foo); end
 end
@@ -149,7 +146,7 @@ def self.perform(*args); end
       Resque.enqueue(SomeUniqueJob, "foo")
       Resque.size(:other_queue).should == 1
     end
-    
+
     it 'should not raise an error when deleting an already empty queue' do
       expect { Resque.remove_queue(:other_queue) }.to_not raise_error
     end

spec/spec_helper.rb

@@ -3,12 +3,26 @@
 require 'rspec'
 
 require 'ruby-debug'
-require 'mock_redis'
 require 'resque'
 require 'resque-loner'
 
 RSpec.configure do |config|
   config.before(:suite) do
-    Resque.redis = MockRedis.new
+    if !system("which redis-server")
+      puts '', "** can't find `redis-server` in your path"
+      puts "** try running `sudo rake install`"
+      abort ''
+    end
+    puts "Starting redis for testing at localhost:9736..."
+    `redis-server #{File.dirname(File.expand_path(__FILE__))}/redis-test.conf`
+    puts  "redis-server #{File.dirname(File.expand_path(__FILE__))}/redis-test.conf"
+    Resque.redis = 'localhost:9736'
+  end
+
+  config.after(:suite) do
+    pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
+    puts "Killing test redis server #{pid}..."
+    `rm -f #{File.dirname(File.expand_path(__FILE__))}/dump.rdb`
+    Process.kill("KILL", pid.to_i)
   end
 end

test/airbrake_test.rb

@@ -0,0 +1,27 @@
+
+require 'test_helper'
+
+begin
+  require 'airbrake'
+rescue LoadError
+  warn "Install airbrake gem to run Airbrake tests."
+end
+
+if defined? Airbrake
+  require 'resque/failure/airbrake'
+  context "Airbrake" 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}
+
+      Airbrake.expects(:notify_or_ignore).with(
+        exception,
+        :parameters => {:payload_class => 'Object', :payload_args => '66'})
+
+      backend = Resque::Failure::Airbrake.new(exception, worker, queue, payload)
+      backend.save
+    end
+  end
+end

test/hoptoad_test.rb

@@ -7,6 +7,7 @@
 end
 
 if defined? HoptoadNotifier
+  require 'resque/failure/hoptoad'
   context "Hoptoad" do
     test "should be notified of an error" do
       exception = StandardError.new("BOOM")

test/job_hooks_test.rb

@@ -250,6 +250,106 @@ def self.perform(history)
   end
 end
 
+
+context "Resque::Job before_enqueue" do
+  include PerformJob
+
+  class ::BeforeEnqueueJob
+    @queue = :jobs
+    def self.before_enqueue_record_history(history)
+      history << :before_enqueue
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  class ::BeforeEnqueueJobAbort
+    @queue = :jobs
+    def self.before_enqueue_abort(history)
+      false
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  test "the before enqueue hook should run" do
+    history = []
+    @worker = Resque::Worker.new(:jobs)
+    assert Resque.enqueue(BeforeEnqueueJob, history)
+    @worker.work(0)
+    assert_equal history, [:before_enqueue], "before_enqueue was not run"
+  end
+
+  test "a before enqueue hook that returns false should prevent the job from getting queued" do
+    history = []
+    @worker = Resque::Worker.new(:jobs)
+    assert_nil Resque.enqueue(BeforeEnqueueJobAbort, history)
+    assert_equal 0, Resque.size(:jobs)
+  end
+end
+
+context "Resque::Job after_dequeue" do
+  include PerformJob
+
+  class ::AfterDequeueJob
+    @queue = :jobs
+    def self.after_dequeue_record_history(history)
+      history << :after_dequeue
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  test "the after dequeue hook should run" do
+    history = []
+    @worker = Resque::Worker.new(:jobs)
+    Resque.dequeue(AfterDequeueJob, history)
+    @worker.work(0)
+    assert_equal history, [:after_dequeue], "after_dequeue was not run"
+  end
+end
+
+
+context "Resque::Job before_dequeue" do
+  include PerformJob
+
+  class ::BeforeDequeueJob
+    @queue = :jobs
+    def self.before_dequeue_record_history(history)
+      history << :before_dequeue
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  class ::BeforeDequeueJobAbort
+    @queue = :jobs
+    def self.before_dequeue_abort(history)
+      false
+    end
+
+    def self.perform(history)
+    end
+  end
+
+  test "the before dequeue hook should run" do
+    history = []
+    @worker = Resque::Worker.new(:jobs)
+    Resque.dequeue(BeforeDequeueJob, history)
+    @worker.work(0)
+    assert_equal history, [:before_dequeue], "before_dequeue was not run"
+  end
+
+  test "a before dequeue hook that returns false should prevent the job from getting dequeued" do
+    history = []
+    assert_equal nil, Resque.dequeue(BeforeDequeueJobAbort, history)
+  end
+end
+
 context "Resque::Job all hooks" do
   include PerformJob
 
@@ -320,4 +420,45 @@ def self.on_failure_record_history(exception, history)
       "oh no"
     ]
   end
+
+  class ::CallbacksInline
+    @queue = :callbacks_inline
+
+    def self.before_perform_record_history(history, count)
+      history << :before_perform
+      count['count'] += 1
+    end
+
+    def self.after_perform_record_history(history, count)
+      history << :after_perform
+      count['count'] += 1
+    end
+
+    def self.around_perform_record_history(history, count)
+      history << :start_around_perform
+      count['count'] += 1
+      yield
+      history << :finish_around_perform
+      count['count'] += 1
+    end
+
+    def self.perform(history, count)
+      history << :perform
+      $history = history
+      $count = count
+    end
+  end
+
+  test "it runs callbacks when inline is true" do
+    begin
+      Resque.inline = true
+      # Sending down two parameters that can be passed and updated by reference
+      result = Resque.enqueue(CallbacksInline, [], {'count' => 0})
+      assert_equal true, result, "perform returned true"
+      assert_equal $history, [:before_perform, :start_around_perform, :perform, :finish_around_perform, :after_perform]
+      assert_equal 4, $count['count']
+    ensure
+      Resque.inline = false
+    end
+  end
 end