resque-loner 1.2.1 → 1.3.0

data/spec/spec_helper.rb

@@ -1,14 +1,30 @@
 require 'rubygems'
 require 'bundler/setup'
+
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
+require 'English'
+require 'simplecov'
+
 require 'rspec'
 
-require 'ruby-debug'
-require 'mock_redis'
 require 'resque'
 require 'resque-loner'
 
+module Support
+  class << self
+    attr_accessor :redis_pid
+  end
+end
+
 RSpec.configure do |config|
   config.before(:suite) do
-    Resque.redis = MockRedis.new
+    unless ENV['RESQUE_LONER_DISABLE_TEST_REDIS_SERVER']
+      # Start our own Redis when the tests start. RedisInstance will take care of
+      # starting and stopping.
+      require File.expand_path('../support/redis_instance', __FILE__)
+      RedisInstance.run!
+    end
   end
 end

data/spec/support/redis_instance.rb

@@ -0,0 +1,133 @@
+# vim:fileencoding=utf-8
+require 'socket'
+require 'timeout'
+require 'fileutils'
+
+class RedisInstance # rubocop:disable ClassLength
+  class << self
+    @running = false
+    @port = nil
+    @pid = nil
+    @waiting = false
+
+    def run_if_needed!
+      run! unless @running
+    end
+
+    def run!
+      ensure_redis_server_present!
+      ensure_pid_directory
+      reassign_redis_clients
+      start_redis_server
+      post_boot_waiting_and_such
+
+      @running = true
+    end
+
+    def stop!
+      $stdout.puts "Sending TERM to Redis (#{pid})..."
+      Process.kill('TERM', pid)
+
+      @port = nil
+      @running = false
+      @pid = nil
+    end
+
+    private
+
+    def post_boot_waiting_and_such
+      wait_for_pid
+      puts "Booted isolated Redis on #{port} with PID #{pid}."
+
+      wait_for_redis_boot
+
+      # Ensure we tear down Redis on Ctrl+C / test failure.
+      at_exit { stop! }
+    end
+
+    def ensure_redis_server_present!
+      unless system('redis-server -v')
+        fail "** can't find `redis-server` in your path"
+      end
+    end
+
+    def wait_for_redis_boot
+      Timeout.timeout(10) do
+        loop do
+          begin
+            break if Resque.redis.ping == 'PONG'
+          rescue Redis::CannotConnectError
+            @waiting = true
+          end
+        end
+        @waiting = false
+      end
+    end
+
+    def ensure_pid_directory
+      FileUtils.mkdir_p(File.dirname(pid_file))
+    end
+
+    def reassign_redis_clients
+      Resque.redis = Redis.new(
+        hostname: '127.0.0.1', port: port, thread_safe: true
+      )
+    end
+
+    def start_redis_server
+      IO.popen('redis-server -', 'w+') do |server|
+        server.write(config)
+        server.close_write
+      end
+    end
+
+    def pid
+      @pid ||= File.read(pid_file).to_i
+    end
+
+    def wait_for_pid
+      Timeout.timeout(10) do
+        loop { break if File.exist?(pid_file) }
+      end
+    end
+
+    def port
+      @port ||= random_port
+    end
+
+    def pid_file
+      '/tmp/redis-loner-test.pid'
+    end
+
+    def config
+      <<-EOF
+        daemonize yes
+        pidfile #{pid_file}
+        port #{port}
+      EOF
+    end
+
+    # Returns a random port in the upper (10000-65535) range.
+    def random_port
+      ports = (10_000..65_535).to_a
+
+      loop do
+        port = ports[rand(ports.size)]
+        return port if port_available?('127.0.0.1', port)
+      end
+    end
+
+    def port_available?(ip, port, seconds = 1)
+      Timeout.timeout(seconds) do
+        begin
+          TCPSocket.new(ip, port).close
+          false
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+          true
+        end
+      end
+    rescue Timeout::Error
+      true
+    end
+  end
+end

data/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

data/test/job_hooks_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-context "Resque::Job before_perform" do
+context 'Resque::Job before_perform' do
   include PerformJob
 
   class ::BeforePerformJob
@@ -13,48 +13,48 @@ context "Resque::Job before_perform" do
     end
   end
 
-  test "it runs before_perform before perform" do
-    result = perform_job(BeforePerformJob, history=[])
-    assert_equal true, result, "perform returned true"
+  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
+      fail StandardError
     end
     def self.perform(history)
       history << :perform
     end
   end
 
-  test "raises an error and does not perform if before_perform fails" do
+  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"
+    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
+      fail 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"
+  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
+context 'Resque::Job after_perform' do
   include PerformJob
 
   class ::AfterPerformJob
@@ -66,9 +66,9 @@ context "Resque::Job after_perform" do
     end
   end
 
-  test "it runs after_perform after perform" do
-    result = perform_job(AfterPerformJob, history=[])
-    assert_equal true, result, "perform returned true"
+  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
 
@@ -78,20 +78,20 @@ context "Resque::Job after_perform" do
     end
     def self.after_perform_fail_job(history)
       history << :after_perform
-      raise StandardError
+      fail StandardError
     end
   end
 
-  test "raises an error but has already performed if after_perform fails" do
+  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"
+    assert_equal history, [:perform, :after_perform], 'Only after_perform was run'
   end
 end
 
-context "Resque::Job around_perform" do
+context 'Resque::Job around_perform' do
   include PerformJob
 
   class ::AroundPerformJob
@@ -105,9 +105,9 @@ context "Resque::Job around_perform" do
     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"
+  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
 
@@ -117,24 +117,24 @@ context "Resque::Job around_perform" do
     end
     def self.around_perform_fail(history)
       history << :start_around_perform
-      raise StandardError
+      fail StandardError
       yield
       history << :finish_around_perform
     end
   end
 
-  test "raises an error and does not perform if around_perform fails before yielding" do
+  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"
+    assert_equal history, [:start_around_perform], 'Only part of around_perform was run'
   end
 
   class ::AroundPerformJobFailsWhilePerforming
     def self.perform(history)
       history << :perform
-      raise StandardError
+      fail StandardError
     end
     def self.around_perform_fail_in_yield(history)
       history << :start_around_perform
@@ -147,12 +147,12 @@ context "Resque::Job around_perform" do
     end
   end
 
-  test "raises an error but may handle exceptions if perform fails" do
+  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"
+    assert_equal history, [:start_around_perform, :perform, :ensure_around_perform], 'Only part of around_perform was run'
   end
 
   class ::AroundPerformJobDoesNotHaveToYield
@@ -165,15 +165,15 @@ context "Resque::Job around_perform" do
     end
   end
 
-  test "around_perform is not required to yield" do
+  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"
+    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
+context 'Resque::Job on_failure' do
   include PerformJob
 
   class ::FailureJobThatDoesNotFail
@@ -185,50 +185,50 @@ context "Resque::Job on_failure" do
     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"
+  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"
+      fail 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
+  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"]
+    assert_equal history, [:perform, 'oh no']
   end
 
   class ::FailureJobThatFailsBadly
     def self.perform(history)
       history << :perform
-      raise SyntaxError, "oh no"
+      fail 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
+  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"]
+    assert_equal history, [:perform, 'oh no']
   end
 end
 
-context "Resque::Job after_enqueue" do
+context 'Resque::Job after_enqueue' do
   include PerformJob
 
   class ::AfterEnqueueJob
@@ -241,16 +241,114 @@ context "Resque::Job after_enqueue" do
     end
   end
 
-  test "the after enqueue hook should run" do
+  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"
+    assert_equal history, [:after_enqueue], 'after_enqueue was not run'
   end
 end
 
-context "Resque::Job all hooks" do
+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
 
   class ::VeryHookyJob
@@ -273,9 +371,9 @@ context "Resque::Job all hooks" do
     end
   end
 
-  test "the complete hook order" do
-    result = perform_job(VeryHookyJob, history=[])
-    assert_equal true, result, "perform returned true"
+  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,
@@ -299,14 +397,14 @@ context "Resque::Job all hooks" do
     end
     def self.after_perform_record_history(history)
       history << :after_perform
-      raise StandardError, "oh no"
+      fail 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
+  test 'the complete hook order with a failure at the last minute' do
     history = []
     assert_raises StandardError do
       perform_job(VeryHookyJobThatFails, history)
@@ -317,7 +415,48 @@ context "Resque::Job all hooks" do
       :perform,
       :finish_around_perform,
       :after_perform,
-      "oh no"
+      '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