backburner 1.7.0 → 1.9.0

data/test/connection_test.rb

@@ -1,179 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-describe "Backburner::Connection class" do
-  describe "for initialize with single url" do
-    before do
-      @connection = Backburner::Connection.new("beanstalk://127.0.0.1")
-    end
-
-    it "should store url in accessor" do
-      assert_equal "beanstalk://127.0.0.1", @connection.url
-    end
-
-    it "should setup beanstalk connection" do
-      assert_kind_of Beaneater, @connection.beanstalk
-    end
-  end # initialize single connection
-
-  describe "for initialize with url" do
-    it "should delegate the address url correctly" do
-      @connection = Backburner::Connection.new("beanstalk://127.0.0.1")
-      connection = @connection.beanstalk.connection
-      assert_equal '127.0.0.1:11300', connection.address
-    end
-  end # initialize
-
-  describe "for bad uri" do
-    it "should raise a BadUrl" do
-      assert_raises(Backburner::Connection::BadURL) {
-        @connection = Backburner::Connection.new("fake://foo")
-      }
-    end
-  end
-
-  describe "for initialize with on_reconnect block" do
-    it "should store the block for use upon reconnect" do
-      callback = proc {}
-      connection = Backburner::Connection.new('beanstalk://127.0.0.1', &callback)
-      assert_equal callback, connection.on_reconnect
-    end
-  end
-
-  describe "dealing with connecting and reconnecting" do
-    before do
-      @connection = Backburner::Connection.new('beanstalk://127.0.0.1')
-    end
-
-    it "should know if its connection is open" do
-      assert_equal true, @connection.connected?
-      @connection.close
-      assert_equal false, @connection.connected?
-    end
-
-    it "should be able to attempt reconnecting to beanstalk" do
-      @connection.close
-      assert_equal false, @connection.connected?
-      @connection.reconnect!
-      assert_equal true, @connection.connected?
-    end
-
-    it "should allow for retryable commands" do
-      @result = false
-      @connection.close
-      @connection.retryable { @result = true }
-      assert_equal true, @result
-    end
-
-    it "should provide a hook when a retryable command successfully retries" do
-      @result = false
-      @retried = false
-      @connection.close
-      callback = proc { @result = true }
-      @connection.retryable(:on_retry => callback) do
-        unless @retried
-          @retried = true
-          raise Beaneater::NotConnected.new
-        end
-      end
-      assert_equal true, @result
-    end
-
-    it "should provide a hook when the connection successfully reconnects" do
-      reconnected = false
-      retried = false
-      @connection.close
-      @connection.on_reconnect = proc { reconnected = true }
-      @connection.retryable do
-        unless retried
-          retried = true
-          raise Beaneater::NotConnected.new
-        end
-      end
-      assert_equal true, reconnected
-    end
-
-    it "should call the on_reconnect hook before the on_retry hook" do
-      @result = []
-      @retried = false
-      @connection.close
-      @connection.on_reconnect = proc { @result << "reconnect" }
-      on_retry = proc { @result << "retry" }
-      @connection.retryable(:on_retry => on_retry) do
-        unless @retried
-          @retried = true
-          raise Beaneater::NotConnected.new
-        end
-      end
-      assert_equal %w(reconnect retry), @result
-    end
-
-    describe "ensuring the connection is open" do
-      it "should reattempt the connection to beanstalk several times" do
-        stats = @connection.stats
-        simulate_disconnect(@connection)
-        new_connection = Beaneater.new('127.0.0.1:11300')
-        Beaneater.expects(:new).twice.raises(Beaneater::NotConnected).then.returns(new_connection)
-        @connection.tubes
-        assert_equal true, @connection.connected?
-      end
-
-      it "should not attempt reconnecting if the current connection is open" do
-        assert_equal true, @connection.connected?
-        Beaneater.expects(:new).never
-        @connection.tubes
-      end
-
-      describe "when reconnecting is successful" do
-        it "should allow for a callback" do
-          @result = false
-          simulate_disconnect(@connection)
-          @connection.on_reconnect = proc { @result = true }
-          @connection.tubes
-          assert_equal true, @result
-        end
-
-        it "should pass self to the callback" do
-          result = nil
-          simulate_disconnect(@connection)
-          @connection.on_reconnect = lambda { |conn| result = conn }
-          @connection.tubes
-          assert_equal result, @connection
-        end
-      end
-    end
-
-    describe "when unable to ensure its connected" do
-      it "should raise Beaneater::NotConnected" do
-        Beaneater.stubs(:new).raises(Beaneater::NotConnected)
-        simulate_disconnect(@connection, 1) # since we're stubbing Beaneater.new above we only to simlulate the disconnect of our current connection
-        assert_raises Beaneater::NotConnected do
-          @connection.tubes
-        end
-      end
-    end
-
-    describe "when using the retryable method" do
-      it "should yield to the block multiple times" do
-        expected    = 2
-        retry_count = 0
-        @connection.retryable(max_retries: expected) do
-          if retry_count < 2
-            retry_count += 1
-            raise Beaneater::NotConnected
-          end
-        end
-        assert_equal expected, retry_count
-      end
-    end
-  end
-
-  describe "for delegated methods" do
-    before do
-      @connection = Backburner::Connection.new("beanstalk://127.0.0.1")
-    end
-
-    it "delegate methods to beanstalk connection" do
-      assert_equal "127.0.0.1", @connection.connection.host
-    end
-  end # delegator
-end # Connection

data/test/fixtures/active_jobs.rb

@@ -1,11 +0,0 @@
-require 'active_job'
-require 'active_job/queue_adapters/backburner_adapter'
-
-ActiveJob::Base.queue_adapter = :backburner
-ActiveJob::Base.logger = nil
-
-class TestJob < ActiveJob::Base
-  def perform(arg)
-    true
-  end
-end

data/test/fixtures/hooked.rb

@@ -1,122 +0,0 @@
-$hooked_fail_count = 0
-class HookFailError < RuntimeError; end
-
-class HookedObjectBeforeEnqueueFail
-  include Backburner::Performable
-
-  def self.before_enqueue_abe(*args)
-    puts "!!before_enqueue_foo!! #{args.inspect}"
-  end
-
-  def self.before_enqueue_bar(*args)
-    return false
-  end
-end
-
-
-class HookedObjectAfterEnqueueFail
-  def self.after_enqueue_abe(*args)
-    puts "!!after_enqueue_foo!! #{args.inspect}"
-  end
-
-  def self.after_enqueue_bar(*args)
-    raise HookFailError, "Fail HookedObjectAfterEnqueueFail"
-  end
-end
-
-class HookedObjectBeforePerformFail
-  include Backburner::Performable
-
-  def self.before_perform_abe(*args)
-    puts "!!before_perform_foo!! #{args.inspect}"
-  end
-
-  def self.before_perform_foo(*args)
-    return false
-  end
-
-  def self.foo(x)
-    puts "Fail ran!!"
-    raise HookFailError, "HookedObjectJobFailure on foo!"
-  end
-end
-
-class HookedObjectAfterPerformFail
-  def self.after_perform_abe(*args)
-    puts "!!after_perform_foo!! #{args.inspect}"
-  end
-
-  def self.after_perform_bar(*args)
-    raise HookFailError, "Fail HookedObjectAfterEnqueueFail"
-  end
-end
-
-class HookedObjectJobFailure
-  def self.foo(x)
-    raise HookFailError, "HookedObjectJobFailure on foo!"
-  end
-end
-
-class HookedObjectSuccess
-  include Backburner::Performable
-
-  def self.before_enqueue_foo(*args)
-    puts "!!before_enqueue_foo!! #{args.inspect}"
-  end
-
-  def self.before_enqueue_bar(*args)
-    puts "!!before_enqueue_bar!! #{args.inspect}"
-  end
-
-  def self.after_enqueue_foo(*args)
-    puts "!!after_enqueue_foo!! #{args.inspect}"
-  end
-
-  def self.after_enqueue_bar(*args)
-    puts "!!after_enqueue_bar!! #{args.inspect}"
-  end
-
-  def self.before_perform_foo(*args)
-    puts "!!before_perform_foo!! #{args.inspect}"
-  end
-
-  def self.after_perform_foo(*args)
-    puts "!!after_perform_foo!! #{args.inspect}"
-  end
-
-  def self.around_perform_bar(*args)
-    puts "!!BEGIN around_perform_bar!! #{args.inspect}"
-    yield
-    puts "!!END around_perform_bar!! #{args.inspect}"
-  end
-
-  def self.around_perform_cat(*args)
-    puts "!!BEGIN around_perform_cat!! #{args.inspect}"
-    yield
-    puts "!!END around_perform_cat!! #{args.inspect}"
-  end
-
-  def self.on_failure_foo(ex, *args)
-    puts "!!on_failure_foo!! #{ex.inspect} #{args.inspect}"
-  end
-
-  def self.on_bury_foo(*args)
-    puts "!!on_bury_foo!! #{args.inspect}"
-  end
-
-  def self.on_retry_foo(retry_count, delay, *args)
-    puts "!!on_retry_foo!! #{retry_count} #{delay} #{args.inspect}"
-  end
-
-  def self.foo(x)
-    $hooked_fail_count += 1
-    raise HookFailError, "Fail!" if $hooked_fail_count == 1
-    puts "This is the job running successfully!! #{x.inspect}"
-  end
-end # HookedObjectSuccess
-
-class HookedWorker < Backburner::Worker
-  def on_reconnect
-    puts "!!on_reconnect!!"
-  end
-end

data/test/fixtures/test_fork_jobs.rb

@@ -1,72 +0,0 @@
-class ResponseJob
-  include Backburner::Queue
-  queue_priority 1000
-  def self.perform(data)
-    $worker_test_count += data['worker_test_count'].to_i if data['worker_test_count']
-    $worker_success = data['worker_success'] if data['worker_success']
-    $worker_test_count = data['worker_test_count_set'].to_i if data['worker_test_count_set']
-    $worker_raise = data['worker_raise'] if data['worker_raise']
-  end
-end
-
-class TestJobFork
-  include Backburner::Queue
-  queue "test-job-fork"
-  queue_priority 1000
-  def self.perform(x, y)
-    Backburner::Workers::ThreadsOnFork.enqueue ResponseJob, [{
-        :worker_test_count_set => x + y
-    }], :queue => 'response'
-  end
-end
-
-class TestFailJobFork
-  include Backburner::Queue
-  queue "test-fail-job-fork"
-  def self.perform(x, y)
-    Backburner::Workers::ThreadsOnFork.enqueue ResponseJob, [{
-       :worker_raise => true
-    }], :queue => 'response'
-  end
-end
-
-class TestRetryJobFork
-  include Backburner::Queue
-  def self.perform(x, y)
-    $worker_test_count += 1
-
-    if $worker_test_count <= 2
-      Backburner::Workers::ThreadsOnFork.enqueue ResponseJob, [{
-          :worker_test_count => 1
-      }], :queue => 'response'
-
-      raise RuntimeError
-    else # succeeds
-      Backburner::Workers::ThreadsOnFork.enqueue ResponseJob, [{
-          :worker_test_count => 1,
-          :worker_success => true
-      }], :queue => 'response'
-    end
-  end
-end
-
-class TestAsyncJobFork
-  include Backburner::Performable
-  def self.foo(x, y)
-    Backburner::Workers::ThreadsOnFork.enqueue ResponseJob, [{
-        :worker_test_count_set => x * y
-    }], :queue => 'response'
-  end
-end
-
-class TestJobMultithreadFork
-  include Backburner::Queue
-  queue "test-job-multithread-fork"
-  queue_priority 1000
-  def self.perform(x, y)
-    sleep 1 # simluate work
-    Backburner::Workers::ThreadsOnFork.enqueue ResponseJob, [{
-        :worker_test_count_set => x + y
-    }], :queue => 'response'
-  end
-end

data/test/fixtures/test_forking_jobs.rb

@@ -1,56 +0,0 @@
-class ResponseForkingJob
-  include Backburner::Queue
-  queue_priority 1000
-  def self.perform(data)
-    $worker_test_count += data['worker_test_count'].to_i if data['worker_test_count']
-    $worker_success = data['worker_success'] if data['worker_success']
-    $worker_test_count = data['worker_test_count_set'].to_i if data['worker_test_count_set']
-    $worker_raise = data['worker_raise'] if data['worker_raise']
-  end
-end
-
-class TestJobForking
-  include Backburner::Queue
-  queue_priority 1000
-  def self.perform(x, y)
-    Backburner::Workers::Forking.enqueue ResponseForkingJob, [{
-        :worker_test_count_set => x + y
-    }], :queue => 'response'
-  end
-end
-
-class TestFailJobForking
-  include Backburner::Queue
-  def self.perform(x, y)
-    Backburner::Workers::Forking.enqueue ResponseForkingJob, [{
-       :worker_raise => true
-    }], :queue => 'response'
-  end
-end
-
-class TestRetryJobForking
-  include Backburner::Queue
-  def self.perform(x, y)
-    if $worker_test_count <= 2
-      Backburner::Workers::Forking.enqueue ResponseForkingJob, [{
-          :worker_test_count => 1
-      }], :queue => 'response'
-
-      raise RuntimeError
-    else # succeeds
-      Backburner::Workers::Forking.enqueue ResponseForkingJob, [{
-          :worker_test_count => 1,
-          :worker_success => true
-      }], :queue => 'response'
-    end
-  end
-end
-
-class TestAsyncJobForking
-  include Backburner::Performable
-  def self.foo(x, y)
-    Backburner::Workers::Forking.enqueue ResponseForkingJob, [{
-        :worker_test_count_set => x * y
-    }], :queue => 'response'
-  end
-end

data/test/fixtures/test_jobs.rb

@@ -1,87 +0,0 @@
-$worker_test_count = 0
-$worker_success = false
-
-class TestPlainJob
-  def self.queue; "test-plain"; end
-  def self.perform(x, y); $worker_test_count += x + y + 1; end
-end
-
-class TestJob
-  include Backburner::Queue
-  queue_priority :medium
-  queue_respond_timeout 300
-  def self.perform(x, y); $worker_test_count += x + y; end
-end
-
-class TestSlowJob
-  include Backburner::Queue
-  queue_priority :medium
-  queue_respond_timeout 300
-  def self.perform(x, y); sleep 1; $worker_test_count += x + y; end
-end
-
-class TestStuckJob
-  include Backburner::Queue
-  queue_priority :medium
-  queue_respond_timeout 300
-  def self.perform(_x, _y)
-    loop do
-      sleep 0.5
-    end
-  end
-end
-
-class TestFailJob
-  include Backburner::Queue
-  def self.perform(x, y); raise RuntimeError; end
-end
-
-class TestRetryJob
-  include Backburner::Queue
-  def self.perform(x, y)
-    $worker_test_count += 1
-    raise RuntimeError unless $worker_test_count > 2
-    $worker_success = true
-  end
-end
-
-class TestConfigurableRetryJob
-  include Backburner::Queue
-  def self.perform(retry_count)
-    $worker_test_count += 1
-    raise RuntimeError unless $worker_test_count > retry_count
-    $worker_success = true
-  end
-end
-
-class TestRetryWithQueueOverridesJob
-  include Backburner::Queue
-  def self.perform(retry_count)
-    $worker_test_count += 1
-    raise RuntimeError unless $worker_test_count > retry_count
-    $worker_success = true
-  end
-
-  def self.queue_max_job_retries
-    3
-  end
-
-  def self.queue_retry_delay
-    0
-  end
-
-  def self.queue_retry_delay_proc
-    lambda { |min_retry_delay, num_retries| min_retry_delay + (num_retries ** 2) }
-  end
-end
-
-class TestAsyncJob
-  include Backburner::Performable
-  def self.foo(x, y); $worker_test_count = x * y; end
-end
-
-class TestLambdaQueueJob
-  include Backburner::Queue
-  queue lambda { |klass| klass.calculated_queue_name }
-  def self.calculated_queue_name; 'lambda-queue' end
-end

data/test/fixtures/test_queue_settings.rb

@@ -1,14 +0,0 @@
-class TestJobSettings
-  include Backburner::Queue
-  queue "job-settings:5:10:6"
-  def self.perform; end
-end
-
-class TestJobSettingsOverride
-  include Backburner::Queue
-  queue "job-settings-override:5:10:12"
-  queue_jobs_limit 10
-  queue_garbage_limit 1000
-  queue_retry_limit 2
-  def self.perform; end
-end

data/test/helpers/templogger.rb

@@ -1,22 +0,0 @@
-class Templogger
-  attr_reader :logger, :log_path
-
-  def initialize(root_path)
-    @file = Tempfile.new('foo', root_path)
-    @log_path = @file.path
-    @logger = Logger.new(@log_path)
-  end
-
-  # wait_for_match /Completed TestJobFork/m
-  def wait_for_match(match_pattern)
-    sleep 0.1 until self.body =~ match_pattern
-  end
-
-  def body
-    File.read(@log_path)
-  end
-
-  def close
-    @file.close
-  end
-end