backburner-allq 1.0.0

data/test/async_proxy_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class AsyncUser; end
+
+describe "Backburner::AsyncProxy class" do
+  before do
+    Backburner.default_queues.clear
+    clear_jobs!(Backburner.configuration.primary_queue)
+  end
+
+  describe "for method_missing enqueue" do
+    should "enqueue job onto worker with no args" do
+      @async = Backburner::AsyncProxy.new(AsyncUser, 10, :pri => 1000, :ttr => 100)
+      @async.foo
+      pop_one_job do |job, body|
+        assert_equal "AsyncUser", body["class"]
+        assert_equal [10, "foo"], body["args"]
+        assert_equal 100, job.ttr
+        assert_equal 1000, job.pri
+        job.delete
+      end
+    end
+
+    should "enqueue job onto worker with args" do
+      @async = Backburner::AsyncProxy.new(AsyncUser, 10, :pri => 1000, :ttr => 100)
+      @async.bar(1, 2, 3)
+      pop_one_job do |job, body|
+        assert_equal "AsyncUser", body["class"]
+        assert_equal [10, "bar", 1, 2, 3], body["args"]
+        assert_equal 100, job.ttr
+        assert_equal 1000, job.pri
+        job.delete
+      end
+    end
+  end # method_missing
+end # AsyncProxy

data/test/back_burner_test.rb

@@ -0,0 +1,88 @@
+require File.expand_path('../test_helper', __FILE__)
+
+$backburner_sum = 0
+$backburner_numbers = []
+
+class TestBackburnerJob
+  include Backburner::Queue
+  queue "test.jobber"
+
+  def self.perform(value, number)
+    $backburner_sum += value
+    $backburner_numbers << number
+  end
+end
+
+class TestWorker < Backburner::Worker; end
+
+describe "Backburner module" do
+  before { Backburner.default_queues.clear }
+
+  describe "for enqueue method" do
+    before do
+      Backburner.enqueue TestBackburnerJob, 5, 6
+      Backburner.enqueue TestBackburnerJob, 15, 10
+      silenced(2) do
+        worker = Backburner::Workers::Simple.new('test.jobber')
+        worker.prepare
+        2.times { worker.work_one_job }
+      end
+    end
+
+    it "can run jobs using #run method" do
+      assert_equal 20, $backburner_sum
+      assert_same_elements [6, 10], $backburner_numbers
+    end
+  end # enqueue
+
+  describe "for work method" do
+    it "invokes worker simple start" do
+      Backburner::Workers::Simple.expects(:start).with(["foo", "bar"])
+      Backburner.work("foo", "bar")
+    end
+
+    it "invokes other worker if specified in configuration" do
+      Backburner.configure { |config| config.default_worker = TestWorker }
+      TestWorker.expects(:start).with(["foo", "bar"])
+      Backburner.work("foo", "bar")
+    end
+
+    it "invokes other worker if specified in work method as options" do
+      TestWorker.expects(:start).with(["foo", "bar"])
+      Backburner.work("foo", "bar", :worker => TestWorker)
+    end
+
+    it "invokes worker start with no args" do
+      Backburner::Workers::Simple.expects(:start).with([])
+      Backburner.work
+    end
+  end # work!
+
+  describe "for configuration" do
+    it "remembers the tube_namespace" do
+      assert_equal "demo.test", Backburner.configuration.tube_namespace
+    end
+
+    it "remembers the namespace_separator" do
+      assert_equal ".", Backburner.configuration.namespace_separator
+    end
+
+    it "disallows a reserved separator" do
+      assert_raises RuntimeError do
+        Backburner.configuration.namespace_separator = ':'
+      end
+    end
+  end # configuration
+
+  describe "for default_queues" do
+    it "supports assignment" do
+      Backburner.default_queues << "foo"
+      Backburner.default_queues << "bar"
+      assert_same_elements ["foo", "bar"], Backburner.default_queues
+    end
+  end
+
+  after do
+    Backburner.configure { |config| config.default_worker = Backburner::Workers::Simple }
+  end
+end # Backburner

data/test/connection_test.rb

@@ -0,0 +1,179 @@
+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/hooked.rb

@@ -0,0 +1,122 @@
+$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

@@ -0,0 +1,72 @@
+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