backburner 0.0.1

data/test/back_burner_test.rb

@@ -0,0 +1,61 @@
+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
+
+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::Worker.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 start" do
+      Backburner::Worker.expects(:start).with(["foo", "bar"])
+      Backburner.work("foo", "bar")
+    end
+
+    it "invokes worker start with no args" do
+      Backburner::Worker.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
+  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
+end # Backburner

data/test/connection_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Backburner::Connection class" do
+  describe "for initialize" do
+    before do
+      @connection = Backburner::Connection.new("beanstalk://localhost")
+    end
+
+    it "should store url in accessor" do
+      assert_equal "beanstalk://localhost", @connection.url
+    end
+
+    it "should setup beanstalk connection" do
+      assert_kind_of Beanstalk::Pool, @connection.beanstalk
+    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 delegated methods" do
+    before do
+      @connection = Backburner::Connection.new("beanstalk://localhost")
+    end
+
+    it "delegate methods to beanstalk connection" do
+      assert_equal "localhost:11300", @connection.list_tubes.keys.first
+    end
+  end # delegator
+end # Connection

data/test/helpers_test.rb

@@ -0,0 +1,79 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Backburner::Helpers module" do
+  include Backburner::Helpers
+
+  describe "for classify method" do
+    it "should support simple classify" do
+      assert_equal "FooBarBaz", classify("foo-bar-baz")
+    end
+
+    it "should not affect existing classified strings" do
+      assert_equal "Foo::BarBaz", classify("Foo::BarBaz")
+    end
+  end # classify
+
+  describe "for constantize method" do
+    it "should constantize known constant" do
+      assert_equal Backburner, constantize("Backburner")
+    end
+
+    it "should properly report when constant is undefined" do
+      assert_raises(NameError) { constantize("FakeObject") }
+    end
+  end # constantize
+
+  describe "for dasherize method" do
+    it "should not harm existing dashed names" do
+      assert_equal "foo/bar-baz", dasherize("foo/bar-baz")
+    end
+
+    it "should properly convert simple names to dashes" do
+      assert_equal "foo-bar", dasherize("FooBar")
+    end
+
+    it "should properly convert class to dash with namespace" do
+      assert_equal "foo/bar-baz", dasherize("Foo::BarBaz")
+    end
+  end # dasherize
+
+  describe "for exception_message method" do
+    it "prints out message about failure" do
+      output = exception_message(RuntimeError.new("test"))
+      assert_match /Exception RuntimeError/, output
+    end
+  end # exception_message
+
+  describe "for tube_namespace" do
+    before { Backburner.expects(:configuration).returns(stub(:tube_namespace => "test.foo.job")) }
+
+    it "accesses correct value" do
+      assert_equal "test.foo.job", tube_namespace
+    end
+  end # tube_namespace
+
+  describe "for expand_tube_name method" do
+    before { Backburner.expects(:configuration).returns(stub(:tube_namespace => "test.foo.job.")) }
+
+    it "supports base strings" do
+      assert_equal "test.foo.job.email/send-news", expand_tube_name("email/send_news")
+    end # simple string
+
+    it "supports qualified strings" do
+      assert_equal "test.foo.job.email/send-news", expand_tube_name("test.foo.job.email/send_news")
+    end # qualified string
+
+    it "supports base symbols" do
+      assert_equal "test.foo.job.email/send-news", expand_tube_name(:"email/send_news")
+    end # symbols
+
+    it "supports queue names" do
+      test = stub(:queue => "email/send_news")
+      assert_equal "test.foo.job.email/send-news", expand_tube_name(test)
+    end # queue names
+
+    it "supports class names" do
+      assert_equal "test.foo.job.runtime-error", expand_tube_name(RuntimeError)
+    end # class names
+  end # expand_tube_name
+end

data/test/logger_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Backburner::Logger module" do
+  include Backburner::Logger
+
+  describe "for log method" do
+    it "prints out to std out" do
+      output = capture_stdout { log("foo") }
+      assert_equal "foo\n", output
+    end
+  end # log
+
+  describe "for log_error method" do
+    it "prints out to std err" do
+      output = capture_stdout { log_error("bar") }
+      assert_equal "bar\n", output
+    end
+  end # log_error
+end

data/test/performable_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class TestObj
+  include Backburner::Performable
+  ID = 56
+  def id; ID; end
+  def self.find(id); TestObj.new if id == ID; end
+  def foo(state, state2); "bar #{state} #{state2}"; end
+  def self.bar(state, state2); "baz #{state} #{state2}"; end
+end
+
+describe "Backburner::Performable module" do
+  after { ENV["TEST"] = nil }
+
+  describe "for async instance method" do
+    it "should invoke worker enqueue" do
+      Backburner::Worker.expects(:enqueue).with(TestObj, [56, :foo, true, false], has_entries(:pri => 5000, :queue => "foo"))
+      TestObj.new.async(:pri => 5000, :queue => "foo").foo(true, false)
+    end
+  end # async instance
+
+  describe "for async class method" do
+    it "should invoke worker enqueue" do
+      Backburner::Worker.expects(:enqueue).with(TestObj, [nil, :bar, true, false], has_entries(:pri => 5000, :queue => "foo"))
+      TestObj.async(:pri => 5000, :queue => "foo").bar(true, false)
+    end
+  end # async class
+
+  describe "for perform class method" do
+    it "should work for instance" do
+      assert_equal "bar true false", TestObj.perform(TestObj::ID, :foo, true, false)
+    end # instance
+
+    it "should work for class level" do
+      assert_equal "baz false true", TestObj.perform(nil, :bar, false, true)
+    end # class
+  end # perform
+end

data/test/queue_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../test_helper', __FILE__)
+
+module NestedDemo
+  class TestJobA; include Backburner::Queue; end
+  class TestJobB; include Backburner::Queue; end
+end
+
+describe "Backburner::Queue module" do
+  describe "contains known_queue_classes" do
+    it "has all defined known queues" do
+      assert_contains Backburner::Worker.known_queue_classes, NestedDemo::TestJobA
+      assert_contains Backburner::Worker.known_queue_classes, NestedDemo::TestJobB
+    end
+  end
+
+  describe "for queue method accessor" do
+    it "should return the queue name" do
+      assert_equal "nested-demo/test-job-a", NestedDemo::TestJobA.queue
+    end
+  end # queue_name
+
+  describe "for queue assignment method" do
+    it "should allow queue name to be assigned" do
+      NestedDemo::TestJobB.queue("nested/job")
+      assert_equal "nested/job", NestedDemo::TestJobB.queue
+    end
+  end # queue
+end # Backburner::Queue

data/test/test_helper.rb

@@ -0,0 +1,93 @@
+require 'rubygems'
+require 'tempfile'
+require 'minitest/autorun'
+require 'mocha'
+$:.unshift File.expand_path("../../lib")
+require 'backburner'
+
+# Configure Backburner
+Backburner.configure do |config|
+  config.beanstalk_url = "beanstalk://localhost"
+  config.tube_namespace = "demo.test"
+end
+
+## Kernel Extensions
+require 'stringio'
+
+module Kernel
+  # Redirect standard out, standard error and the buffered logger for sprinkle to StringIO
+  # capture_stdout { any_commands; you_want } => "all output from the commands"
+  def capture_stdout
+    return yield if ENV['DEBUG'] # Skip if debug mode
+
+    out = StringIO.new
+    $stdout = out
+    $stderr = out
+    yield
+    return out.string
+  ensure
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+end
+
+class User
+  attr_accessor :id, :name
+
+  def initialize(id, name)
+    @id, @name = id, name
+  end
+end
+
+class MiniTest::Spec
+  class << self
+    alias :should :it
+    alias :context :describe
+  end
+  alias :assert_no_match  :refute_match
+  alias :assert_not_nil   :refute_nil
+  alias :assert_not_equal :refute_equal
+
+  # assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
+  def assert_same_elements(a1, a2, msg = nil)
+    [:select, :inject, :size].each do |m|
+      [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
+    end
+
+    assert a1h = a1.inject({}) { |h,e| h[e] ||= a1.select { |i| i == e }.size; h }
+    assert a2h = a2.inject({}) { |h,e| h[e] ||= a2.select { |i| i == e }.size; h }
+
+    assert_equal(a1h, a2h, msg)
+  end
+
+  #   assert_contains(['a', '1'], /\d/) => passes
+  #   assert_contains(['a', '1'], 'a') => passes
+  #   assert_contains(['a', '1'], /not there/) => fails
+  def assert_contains(collection, x, extra_msg = "")
+    collection = [collection] unless collection.is_a?(Array)
+    msg = "#{x.inspect} not found in #{collection.to_a.inspect} #{extra_msg}"
+    case x
+    when Regexp
+      assert(collection.detect { |e| e =~ x }, msg)
+    else
+      assert(collection.include?(x), msg)
+    end
+  end
+
+  # silenced(5) { ... }
+  def silenced(time=3, &block)
+    Timeout::timeout(time) { capture_stdout(&block) }
+  end
+
+  # pop_one_job(tube_name)
+  def pop_one_job(tube_name)
+    connection = Backburner::Worker.connection
+    tube_name = [Backburner.configuration.tube_namespace, tube_name].join(".")
+    connection.watch(tube_name)
+    connection.list_tubes_watched.each do |server, tubes|
+      tubes.each { |tube| connection.ignore(tube) unless tube == tube_name }
+    end
+    silenced(3) { @res = connection.reserve }
+    return @res, JSON.parse(@res.body)
+  end
+end # MiniTest::Spec

data/test/worker_test.rb

@@ -0,0 +1,163 @@
+require File.expand_path('../test_helper', __FILE__)
+
+$worker_test_count = 0
+
+class TestJob
+  include Backburner::Queue
+  def self.perform(x, y); $worker_test_count += x + y; end
+end
+
+class TestAsyncJob
+  include Backburner::Performable
+  def self.foo(x, y); $worker_test_count = x * y; end
+end
+
+describe "Backburner::Worker module" do
+  before { Backburner.default_queues.clear }
+
+  describe "for enqueue class method" do
+    it "should support enqueuing job" do
+      Backburner::Worker.enqueue TestJob, [3, 4], :ttr => 100
+      job, body = pop_one_job("test-job")
+      assert_equal "TestJob", body["class"]
+      assert_equal [3, 4], body["args"]
+      assert_equal 100, job.ttr
+      assert_equal Backburner.configuration.default_priority, job.pri
+    end # simple
+
+    it "should support enqueuing job with custom queue" do
+      Backburner::Worker.enqueue TestJob, [6, 7], :queue => "test.bar", :pri => 5000
+      job, body = pop_one_job("test.bar")
+      assert_equal "TestJob", body["class"]
+      assert_equal [6, 7], body["args"]
+      assert_equal 0, job.delay
+      assert_equal 5000, job.pri
+      assert_equal Backburner.configuration.respond_timeout, job.ttr
+    end # custom
+
+    it "should support async job" do
+      TestAsyncJob.async(:ttr => 100, :queue => "bar.baz.foo").foo(10, 5)
+      job, body = pop_one_job("bar.baz.foo")
+      assert_equal "TestAsyncJob", body["class"]
+      assert_equal [nil, "foo", 10, 5], body["args"]
+      assert_equal 100, job.ttr
+      assert_equal Backburner.configuration.default_priority, job.pri
+    end # async
+  end # enqueue
+
+  describe "for start class method" do
+    it "should initialize and start the worker instance" do
+      ech = stub
+      Backburner::Worker.expects(:new).with("foo").returns(ech)
+      ech.expects(:start)
+      Backburner::Worker.start("foo")
+    end
+  end # start
+
+  describe "for connection class method" do
+    it "should return the beanstalk connection" do
+      assert_equal "beanstalk://localhost", Backburner::Worker.connection.url
+      assert_kind_of Beanstalk::Pool, Backburner::Worker.connection.beanstalk
+    end
+  end # connection
+
+  describe "for tube_names accessor" do
+    it "supports retrieving tubes" do
+      worker = Backburner::Worker.new(["foo", "bar"])
+      assert_equal ["foo", "bar"], worker.tube_names
+    end
+
+    it "supports single tube array arg" do
+      worker = Backburner::Worker.new([["foo", "bar"]])
+      assert_equal ["foo", "bar"], worker.tube_names
+    end
+
+    it "supports empty nil array arg" do
+      worker = Backburner::Worker.new([nil])
+      assert_equal nil, worker.tube_names
+    end
+
+    it "supports single tube arg" do
+      worker = Backburner::Worker.new("foo")
+      assert_equal ["foo"], worker.tube_names
+    end
+
+    it "supports empty array arg" do
+      worker = Backburner::Worker.new([])
+      assert_equal nil, worker.tube_names
+    end
+
+    it "supports nil arg" do
+      worker = Backburner::Worker.new(nil)
+      assert_equal nil, worker.tube_names
+    end
+  end # tube_names
+
+  describe "for prepare method" do
+    it "should watch specified tubes" do
+      worker = Backburner::Worker.new(["foo", "bar"])
+      out = capture_stdout { worker.prepare }
+      assert_equal ["demo.test.foo", "demo.test.bar"], worker.tube_names
+      assert_same_elements ["demo.test.foo", "demo.test.bar"], Backburner::Worker.connection.list_tubes_watched.values.first
+      assert_match /demo\.test\.foo/, out
+    end # multiple
+
+    it "should watch single tube" do
+      worker = Backburner::Worker.new("foo")
+      out = capture_stdout { worker.prepare }
+      assert_equal ["demo.test.foo"], worker.tube_names
+      assert_same_elements ["demo.test.foo"], Backburner::Worker.connection.list_tubes_watched.values.first
+      assert_match /demo\.test\.foo/, out
+    end # single
+
+    it "should respect default_queues settings" do
+      Backburner.default_queues.concat(["foo", "bar"])
+      worker = Backburner::Worker.new
+      out = capture_stdout { worker.prepare }
+      assert_equal ["demo.test.foo", "demo.test.bar"], worker.tube_names
+      assert_same_elements ["demo.test.foo", "demo.test.bar"], Backburner::Worker.connection.list_tubes_watched.values.first
+      assert_match /demo\.test\.foo/, out
+    end
+
+    it "should assign based on all tubes" do
+      Backburner::Worker.any_instance.expects(:all_existing_queues).once.returns("bar")
+      worker = Backburner::Worker.new
+      out = capture_stdout { worker.prepare }
+      assert_equal ["demo.test.bar"], worker.tube_names
+      assert_same_elements ["demo.test.bar"], Backburner::Worker.connection.list_tubes_watched.values.first
+      assert_match /demo\.test\.bar/, out
+    end # all assign
+
+    it "should properly retrieve all tubes" do
+      worker = Backburner::Worker.new
+      out = capture_stdout { worker.prepare }
+      assert_contains worker.tube_names, "demo.test.test-job"
+      assert_contains Backburner::Worker.connection.list_tubes_watched.values.first, "demo.test.test-job"
+      assert_match /demo\.test\.test-job/, out
+    end # all read
+  end # prepare
+
+  describe "for work_one_job method" do
+    it "should work an enqueued job" do
+      $worker_test_count = 0
+      Backburner::Worker.enqueue TestJob, [1, 2], :queue => "foo.bar"
+      silenced(2) do
+        worker = Backburner::Worker.new('foo.bar')
+        worker.prepare
+        worker.work_one_job
+      end
+      assert_equal 3, $worker_test_count
+    end
+
+    it "should work for an async job" do
+      $worker_test_count = 0
+      TestAsyncJob.async(:queue => "bar.baz").foo(3, 5)
+      silenced(2) do
+        worker = Backburner::Worker.new('bar.baz')
+        worker.prepare
+        worker.work_one_job
+      end
+      assert_equal 15, $worker_test_count
+    end
+  end # work_one_job
+end # Backburner::Worker