backburner 1.8.0 → 1.9.0

data/test/job_test.rb

@@ -1,207 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-require File.expand_path('../fixtures/test_jobs', __FILE__)
-
-module NestedDemo
-  class TestJobC
-    def self.perform(x); puts "Performed #{x} in #{self}"; end
-  end
-
-  class TestJobD
-    include Backburner::Queue
-    def self.perform(x); raise RuntimeError; end
-  end
-end
-
-describe "Backburner::Job module" do
-  describe "for initialize" do
-    describe "with hash" do
-      before do
-        @task = stub(:body => task_body, :ttr => 120, :delete => true, :bury => true)
-      end
-
-      describe "with string keys" do
-        let(:task_body) { { "class" => "NewsletterSender", "args" => ["foo@bar.com", "bar@foo.com"] } }
-        it "should create job with correct task data" do
-          @job = Backburner::Job.new(@task)
-          assert_equal @task, @job.task
-          assert_equal ["class", "args"], @job.body.keys
-          assert_equal task_body["class"], @job.name
-          assert_equal task_body["args"], @job.args
-        end
-      end
-
-      describe "with symbol keys" do
-        let(:task_body) { { :class => "NewsletterSender", :args => ["foo@bar.com", "bar@foo.com"] } }
-        it "should create job with correct task data" do
-          @job = Backburner::Job.new(@task)
-          assert_equal @task, @job.task
-          assert_equal [:class, :args], @job.body.keys
-          assert_equal task_body[:class], @job.name
-          assert_equal task_body[:args], @job.args
-        end
-      end
-    end # with hash
-
-    describe "with json string" do
-      before do
-        @task_body =  { "class" => "NewsletterSender", "args" => ["foo@bar.com", "bar@foo.com"] }
-        @task = stub(:body => @task_body.to_json, :ttr => 120, :delete => true, :bury => true)
-      end
-
-      it "should create job with correct task data" do
-        @job = Backburner::Job.new(@task)
-        assert_equal @task, @job.task
-        assert_equal ["class", "args"], @job.body.keys
-        assert_equal @task_body["class"], @job.name
-        assert_equal @task_body["args"], @job.args
-      end
-    end # with json
-
-    describe "with invalid string" do
-      before do
-        @task_body =  "^%$*&^*"
-        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
-      end
-
-      it "should raise a job format exception" do
-        assert_raises(Backburner::Job::JobFormatInvalid) {
-          @job = Backburner::Job.new(@task)
-        }
-      end
-    end # invalid
-  end # initialize
-
-  describe "for process method" do
-    describe "with valid task" do
-      before do
-        @task_body =  { "class" => "NestedDemo::TestJobC", "args" => [56] }
-        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
-        @task.expects(:delete).once
-      end
-
-      it "should process task" do
-        @job = Backburner::Job.new(@task)
-        out = silenced(1) { @job.process }
-        assert_match(/Performed 56 in NestedDemo::TestJobC/, out)
-      end # process
-    end # valid
-
-    describe "with invalid task" do
-      before do
-        @task_body =  { "class" => "NestedDemo::TestJobD", "args" => [56] }
-        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
-        @task.expects(:delete).never
-      end
-
-      it "should raise an exception" do
-        @job = Backburner::Job.new(@task)
-        assert_raises(RuntimeError) { @job.process }
-      end # error invalid
-    end # invalid
-
-    describe "with invalid class" do
-      before do
-        @task_body =  { "class" => "NestedDemo::TestJobY", "args" => [56] }
-        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
-        @task.expects(:delete).never
-      end
-
-      it "should raise an exception" do
-        @job = Backburner::Job.new(@task)
-        assert_raises(Backburner::Job::JobNotFound) { @job.process }
-      end # error class
-    end # invalid
-
-    describe "with a class an autoloader can't load" do
-      before do
-        @task_body = { "class" => "AutoloadingDemo::TestJobGone", "args" => [56] }
-        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
-        @task.expects(:delete).never
-      end
-
-      it "should raise JobNotFound" do
-        @job = Backburner::Job.new(@task)
-        assert_raises(Backburner::Job::JobNotFound) { @job.process }
-      end
-    end # autoloader
-
-    describe "with a class whose file fails to load" do
-      it "should raise JobNotFound naming the cause on one line" do
-        task = stub(:body => { "class" => "TestBrokenNameJob", "args" => [56] }, :ttr => 120, :delete => true, :bury => true)
-        error = assert_raises(Backburner::Job::JobNotFound) { Backburner::Job.new(task).process }
-        assert_match(/\ATestBrokenNameJob \(NameError: uninitialized constant (TestBrokenNameJob::)?TestMissingConcern\)\z/, error.message)
-      end
-    end # broken class file
-  end # process
-
-  describe "for simple delegation method" do
-    describe "with valid class" do
-      before do
-        @task_body =  { "class" => "NestedDemo::TestJobC", "args" => [56] }
-        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
-        @task.expects(:bury).once
-      end
-
-      it "should call bury for task" do
-        @job = Backburner::Job.new(@task)
-        @job.bury
-      end # bury
-    end
-
-    describe "with invalid class" do
-      before do
-        @task_body = { "class" => "AnUnknownClass", "args" => [] }
-        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true, :release => true)
-      end
-
-      it "should call bury for task" do
-        @task.expects(:bury).once
-        @job = Backburner::Job.new(@task)
-        Backburner::Hooks.expects(:invoke_hook_events)
-          .with("AnUnknownClass", :on_bury, anything)
-        @job.bury
-      end
-
-      it "should call retry for task" do
-        @task.expects(:release).once
-        @job = Backburner::Job.new(@task)
-        Backburner::Hooks.expects(:invoke_hook_events)
-          .with("AnUnknownClass", :on_retry, 0, is_a(Integer), anything)
-        @job.retry(0, 0)
-      end
-    end
-  end # simple delegation
-
-  describe "timing out for various values of ttr" do
-    before do
-      @task_body = { "class" => "NestedDemo::TestJobC", "args" => [56] }
-    end
-
-    describe "when ttr == 0" do
-      it "should use 0 for the timeout" do
-        @task = stub(:body => @task_body, :delete => true, :ttr => 0)
-        @job = Backburner::Job.new(@task)
-        Timeout.expects(:timeout).with(0)
-        @job.process
-      end
-    end
-
-    describe "when ttr == 1" do
-      it "should use 1 for the timeout" do
-        @task = stub(:body => @task_body, :delete => true, :ttr => 1)
-        @job = Backburner::Job.new(@task)
-        Timeout.expects(:timeout).with(1)
-        @job.process
-      end
-    end
-
-    describe "when ttr > 1" do
-      it "should use ttr-1 for the timeout" do
-        @task = stub(:body => @task_body, :delete => true, :ttr => 2)
-        @job = Backburner::Job.new(@task)
-        Timeout.expects(:timeout).with(1)
-        @job.process
-      end
-    end
-  end
-end

data/test/logger_test.rb

@@ -1,71 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-describe "Backburner::Logger module" do
-  include Backburner::Logger
-
-  before do
-    @strio = StringIO.new
-    @logger = Logger.new(@strio)
-  end
-
-  describe "for log_info method" do
-    it "prints out to std out" do
-      output = capture_stdout { log_info("foo") }
-      assert_equal "foo\n", output
-    end
-
-    it "can be configured to log to logger" do
-      Backburner.configure { |config| config.logger = @logger }
-      log_info("foo")
-      assert_match(/I,.*?foo/, @strio.string)
-    end
-
-    after do
-      Backburner.configure { |config| config.logger = nil }
-    end
-  end # log_info
-
-  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
-
-    it "can be configured to log to logger" do
-      Backburner.configure { |config| config.logger = @logger }
-      log_error("bar")
-      assert_match(/E,.*?bar/, @strio.string)
-    end
-
-    after do
-      Backburner.configure { |config| config.logger = nil }
-    end
-  end # log_error
-
-  describe "for log_warn method" do
-    it "prints out to std err" do
-      output = capture_stdout { log_warn("baz") }
-      assert_equal "baz\n", output
-    end
-
-    it "can be configured to log to logger" do
-      Backburner.configure { |config| config.logger = @logger }
-      log_warn("baz")
-      assert_match(/W,.*?baz/, @strio.string)
-    end
-
-    it "logs as an error to a logger without a public warn method" do
-      logged = []
-      logger = Object.new # the README asks a logger for info and error only
-      logger.define_singleton_method(:info) { |msg| logged << [:info, msg] }
-      logger.define_singleton_method(:error) { |msg| logged << [:error, msg] }
-      Backburner.configure { |config| config.logger = logger }
-      log_warn("baz")
-      assert_equal [[:error, "baz"]], logged
-    end
-
-    after do
-      Backburner.configure { |config| config.logger = nil }
-    end
-  end # log_warn
-end

data/test/performable_test.rb

@@ -1,138 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class TestObj
-  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
-
-class PerformableTestObj < TestObj
-  include Backburner::Performable
-end
-
-class AutomagicTestObj < TestObj
-  # Don't include Backburner::Performable because it should be automagically included
-  def qux(state, state2); "garply #{state} #{state2}" end
-  def self.garply(state, state2); "thud #{state} #{state2}" end
-  def qux?; "garply!" end
-end
-
-class AsyncInstanceMethodsTestObj < PerformableTestObj; end
-class AsyncStaticMethodsTestObj < PerformableTestObj; end
-
-class AsyncSettingsTestObj < TestObj
-  include Backburner::Performable
-  queue "performable-settings"
-  queue_priority 10
-  queue_respond_timeout 300
-  queue_max_job_retries 3
-  handle_asynchronously :foo
-  handle_static_asynchronously :bar
-end
-
-class QueueThenPerformableTestObj < TestObj
-  include Backburner::Queue
-  queue "queue-then-performable"
-  queue_priority 20
-  queue_respond_timeout 200
-  include Backburner::Performable
-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(PerformableTestObj, [56, :foo, true, false], has_entries(:pri => 5000, :queue => "foo"))
-      PerformableTestObj.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(PerformableTestObj, [nil, :bar, true, false], has_entries(:pri => 5000, :queue => "foo"))
-      PerformableTestObj.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", PerformableTestObj.perform(PerformableTestObj::ID, :foo, true, false)
-    end # instance
-
-    it "should work for class level" do
-      assert_equal "baz false true", PerformableTestObj.perform(nil, :bar, false, true)
-    end # class
-  end # perform
-
-  describe "for handle_asynchronously class method" do
-    it "should automagically asynchronously proxy calls to the method" do
-      Backburner::Performable.handle_asynchronously(AutomagicTestObj, :qux, :pri => 5000, :queue => "qux")
-
-      Backburner::Worker.expects(:enqueue).with(AutomagicTestObj, [56, :qux_without_async, true, false], has_entries(:pri => 5000, :queue => "qux"))
-      AutomagicTestObj.new.qux(true, false)
-    end
-
-    it "should work for class methods, too" do
-      Backburner::Performable.handle_static_asynchronously(AutomagicTestObj, :garply, :pri => 5000, :queue => "garply")
-
-      Backburner::Worker.expects(:enqueue).with(AutomagicTestObj, [nil, :garply_without_async, true, false], has_entries(:pri => 5000, :queue => "garply"))
-      AutomagicTestObj.garply(true, false)
-    end
-
-    it "should correctly handle punctuation" do
-      Backburner::Performable.handle_asynchronously(AutomagicTestObj, :qux?)
-
-      Backburner::Worker.expects(:enqueue).with(AutomagicTestObj, [56, :qux_without_async?], {})
-      AutomagicTestObj.new.qux?
-    end
-
-    it "should be available for instance methods on any class that includes the Performable module" do
-      AsyncInstanceMethodsTestObj.handle_asynchronously :foo, pri: 5000, queue: 'qux'
-      Backburner::Worker.expects(:enqueue).with(AsyncInstanceMethodsTestObj, [56, :foo_without_async, true, false], has_entries(:pri => 5000, :queue => "qux"))
-      AsyncInstanceMethodsTestObj.new.foo(true, false)
-    end
-
-    it "should be available for class methods on any class that includes the Performable module" do
-      AsyncStaticMethodsTestObj.handle_static_asynchronously :bar, pri: 5000, queue: 'garply'
-      Backburner::Worker.expects(:enqueue).with(AsyncStaticMethodsTestObj, [nil, :bar_without_async, true, false], has_entries(:pri => 5000, :queue => "garply"))
-      AsyncStaticMethodsTestObj.bar(true, false)
-    end
-
-    describe "on a class with queue settings" do
-      before { clear_jobs!("performable-settings") }
-      after { clear_jobs!("performable-settings") }
-
-      it "keeps the class's queue settings" do
-        assert_equal "performable-settings", AsyncSettingsTestObj.queue
-        assert_equal 10, AsyncSettingsTestObj.queue_priority
-        assert_equal 300, AsyncSettingsTestObj.queue_respond_timeout
-        assert_equal 3, AsyncSettingsTestObj.queue_max_job_retries
-      end
-
-      it "enqueues instance and class method calls with the class's queue settings" do
-        AsyncSettingsTestObj.new.foo(true, false)
-        AsyncSettingsTestObj.bar(false, true)
-        [[56, "foo_without_async", true, false], [nil, "bar_without_async", false, true]].each do |args|
-          pop_one_job("performable-settings") do |job, body|
-            assert_equal ["AsyncSettingsTestObj", args], [body["class"], body["args"]]
-            assert_equal [10, 300], [job.pri, job.ttr]
-            job.delete
-          end
-        end
-      end
-    end
-  end # handle_asynchronously
-
-  describe "when included after Backburner::Queue" do
-    it "keeps the queue settings the class already set" do
-      assert_equal "queue-then-performable", QueueThenPerformableTestObj.queue
-      assert_equal 20, QueueThenPerformableTestObj.queue_priority
-      assert_equal 200, QueueThenPerformableTestObj.queue_respond_timeout
-    end
-  end
-end

data/test/queue_test.rb

@@ -1,132 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-module NestedDemo
-  class TestJobA; include Backburner::Queue; end
-  class TestJobB; include Backburner::Queue; end
-end
-
-module InheritDemo
-  class ParentJob
-    include Backburner::Queue
-    queue "inherit-parent"
-    queue_priority 10
-    queue_respond_timeout 77
-    queue_max_job_retries 4
-    queue_retry_delay 9
-    queue_retry_delay_proc lambda { |min_retry_delay, num_retries| 42 }
-    queue_jobs_limit 3
-    queue_garbage_limit 50
-    queue_retry_limit 6
-  end
-  class ChildJob < ParentJob; end
-  class GrandchildJob < ChildJob; end
-  class OverrideJob < ParentJob
-    queue "inherit-override"
-    queue_priority 20
-  end
-  class ReincludedJob < ParentJob; include Backburner::Queue; end
-  class LambdaParentJob
-    include Backburner::Queue
-    queue lambda { |klass| klass.name }
-  end
-  class LambdaChildJob < LambdaParentJob; 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 Backburner.configuration.primary_queue, 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
-
-    it "should allow lambdas" do
-      NestedDemo::TestJobB.queue(lambda { |klass| klass.name })
-      assert_equal "NestedDemo::TestJobB", NestedDemo::TestJobB.queue
-    end
-  end # queue
-
-  describe "for queue_priority assignment method" do
-    it "should allow queue priority to be assigned" do
-      NestedDemo::TestJobB.queue_priority(1000)
-      assert_equal 1000, NestedDemo::TestJobB.queue_priority
-    end
-  end # queue_priority
-
-  describe "for queue_respond_timeout assignment method" do
-    it "should allow queue respond_timeout to be assigned" do
-      NestedDemo::TestJobB.queue_respond_timeout(300)
-      assert_equal 300, NestedDemo::TestJobB.queue_respond_timeout
-    end
-  end # queue_respond_timeout
-
-  describe "for queue_max_job_retries assignment method" do
-    it "should allow queue max_job_retries to be assigned" do
-      NestedDemo::TestJobB.queue_max_job_retries(5)
-      assert_equal 5, NestedDemo::TestJobB.queue_max_job_retries
-    end
-  end # queue_max_job_retries
-
-  describe "for queue_retry_delay assignment method" do
-    it "should allow queue retry_delay to be assigned" do
-      NestedDemo::TestJobB.queue_retry_delay(300)
-      assert_equal 300, NestedDemo::TestJobB.queue_retry_delay
-    end
-  end # queue_retry_delay
-
-  describe "for queue_retry_delay_proc assignment method" do
-    it "should allow queue retry_delay_proc to be assigned" do
-      retry_delay_proc = lambda { |x, y| x - y }
-      NestedDemo::TestJobB.queue_retry_delay_proc(retry_delay_proc)
-      assert_equal retry_delay_proc.call(2, 1), NestedDemo::TestJobB.queue_retry_delay_proc.call(2, 1)
-    end
-  end # queue_retry_delay_proc
-
-  describe "for subclasses" do
-    settings = [:queue, :queue_priority, :queue_respond_timeout, :queue_max_job_retries, :queue_retry_delay,
-                :queue_retry_delay_proc, :queue_jobs_limit, :queue_garbage_limit, :queue_retry_limit]
-
-    it "inherits every queue setting from the superclass" do
-      settings.each do |setting|
-        refute_nil InheritDemo::ParentJob.send(setting), setting
-        assert_equal InheritDemo::ParentJob.send(setting), InheritDemo::ChildJob.send(setting), setting
-        assert_equal InheritDemo::ParentJob.send(setting), InheritDemo::GrandchildJob.send(setting), setting
-      end
-    end
-
-    it "uses its own settings over inherited ones without changing the superclass" do
-      assert_equal "inherit-override", InheritDemo::OverrideJob.queue
-      assert_equal 20, InheritDemo::OverrideJob.queue_priority
-      assert_equal 77, InheritDemo::OverrideJob.queue_respond_timeout
-      assert_equal "inherit-parent", InheritDemo::ParentJob.queue
-      assert_equal 10, InheritDemo::ParentJob.queue_priority
-    end
-
-    it "inherits the superclass settings when it includes Backburner::Queue again" do
-      assert_equal "inherit-parent", InheritDemo::ReincludedJob.queue
-      assert_equal 10, InheritDemo::ReincludedJob.queue_priority
-    end
-
-    it "calls an inherited queue lambda with the subclass" do
-      assert_equal "InheritDemo::LambdaChildJob", InheritDemo::LambdaChildJob.queue
-    end
-
-    it "registers subclasses as known queue classes, once each" do
-      [InheritDemo::ChildJob, InheritDemo::GrandchildJob, InheritDemo::OverrideJob, InheritDemo::ReincludedJob].each do |klass|
-        assert_equal 1, Backburner::Worker.known_queue_classes.count(klass), klass.name
-      end
-    end
-  end # subclasses
-end # Backburner::Queue