backburner 1.1.0 → 1.2.0.pre

data/test/worker_test.rb

@@ -11,65 +11,72 @@ describe "Backburner::Worker module" do
   describe "for enqueue class method" do
     it "should support enqueuing plain job" do
       Backburner::Worker.enqueue TestPlainJob, [7, 9], :ttr => 100, :pri => 2000
-      job, body = pop_one_job("test-plain")
-      assert_equal "TestPlainJob", body["class"]
-      assert_equal [7, 9], body["args"]
-      assert_equal 100, job.ttr
-      assert_equal 2000, job.pri
+      pop_one_job("test-plain") do |job, body|
+        assert_equal "TestPlainJob", body["class"]
+        assert_equal [7, 9], body["args"]
+        assert_equal 100, job.ttr
+        assert_equal 2000, job.pri
+      end
     end # plain
 
     it "should support enqueuing job with class queue priority" do
       Backburner::Worker.enqueue TestJob, [3, 4], :ttr => 100
-      job, body = pop_one_job
-      assert_equal "TestJob", body["class"]
-      assert_equal [3, 4], body["args"]
-      assert_equal 100, job.ttr
-      assert_equal 100, job.pri
+      pop_one_job do |job, body|
+        assert_equal "TestJob", body["class"]
+        assert_equal [3, 4], body["args"]
+        assert_equal 100, job.ttr
+        assert_equal 100, job.pri
+      end
     end # queue priority
 
     it "should support enqueuing job with specified named priority" do
       Backburner::Worker.enqueue TestJob, [3, 4], :ttr => 100, :pri => 'high'
-      job, body = pop_one_job
-      assert_equal "TestJob", body["class"]
-      assert_equal [3, 4], body["args"]
-      assert_equal 100, job.ttr
-      assert_equal 0, job.pri
+      pop_one_job do |job, body|
+        assert_equal "TestJob", body["class"]
+        assert_equal [3, 4], body["args"]
+        assert_equal 100, job.ttr
+        assert_equal 0, job.pri
+      end
     end # queue named priority
 
     it "should support enqueuing job with class queue respond_timeout" do
       Backburner::Worker.enqueue TestJob, [3, 4]
-      job, body = pop_one_job
-      assert_equal "TestJob", body["class"]
-      assert_equal [3, 4], body["args"]
-      assert_equal 300, job.ttr
-      assert_equal 100, job.pri
+      pop_one_job do |job, body|
+        assert_equal "TestJob", body["class"]
+        assert_equal [3, 4], body["args"]
+        assert_equal 300, job.ttr
+        assert_equal 100, job.pri
+      end
     end # queue respond_timeout
 
     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 300, job.ttr
+      pop_one_job("test.bar") do |job, body|
+        assert_equal "TestJob", body["class"]
+        assert_equal [6, 7], body["args"]
+        assert_equal 0, job.delay
+        assert_equal 5000, job.pri
+        assert_equal 300, job.ttr
+      end
     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
+      pop_one_job("bar.baz.foo") do |job, body|
+        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
     end # async
 
     it "should support enqueueing job with lambda queue" do
       expected_queue_name = TestLambdaQueueJob.calculated_queue_name
       Backburner::Worker.enqueue TestLambdaQueueJob, [6, 7], :queue => lambda { |klass| klass.calculated_queue_name }
-      job, body = pop_one_job(expected_queue_name)
-      assert_equal "TestLambdaQueueJob", body["class"]
-      assert_equal [6, 7], body["args"]
+      pop_one_job(expected_queue_name) do |job, body|
+        assert_equal "TestLambdaQueueJob", body["class"]
+        assert_equal [6, 7], body["args"]
+      end
     end
   end # enqueue
 
@@ -82,13 +89,6 @@ describe "Backburner::Worker module" do
     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 Beaneater, Backburner::Worker.connection.beanstalk
-    end
-  end # connection
-
   describe "for tube_names accessor" do
     before do
       Backburner.default_queues << "baz"

data/test/workers/forking_worker_test.rb

@@ -19,7 +19,7 @@ describe "Backburner::Workers::Forking module" do
       worker = @worker_class.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"], @worker_class.connection.tubes.watched.map(&:name)
+      assert_same_elements ["demo.test.foo", "demo.test.bar"], worker.connection.tubes.watched.map(&:name)
       assert_match(/demo\.test\.foo/, out)
     end # multiple
 
@@ -27,7 +27,7 @@ describe "Backburner::Workers::Forking module" do
       worker = @worker_class.new("foo")
       out = capture_stdout { worker.prepare }
       assert_equal ["demo.test.foo"], worker.tube_names
-      assert_same_elements ["demo.test.foo"], @worker_class.connection.tubes.watched.map(&:name)
+      assert_same_elements ["demo.test.foo"], worker.connection.tubes.watched.map(&:name)
       assert_match(/demo\.test\.foo/, out)
     end # single
 
@@ -36,7 +36,7 @@ describe "Backburner::Workers::Forking module" do
       worker = @worker_class.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"], @worker_class.connection.tubes.watched.map(&:name)
+      assert_same_elements ["demo.test.foo", "demo.test.bar"], worker.connection.tubes.watched.map(&:name)
       assert_match(/demo\.test\.foo/, out)
     end
 
@@ -45,7 +45,7 @@ describe "Backburner::Workers::Forking module" do
       worker = @worker_class.new
       out = capture_stdout { worker.prepare }
       assert_equal ["demo.test.bar"], worker.tube_names
-      assert_same_elements ["demo.test.bar"], @worker_class.connection.tubes.watched.map(&:name)
+      assert_same_elements ["demo.test.bar"], worker.connection.tubes.watched.map(&:name)
       assert_match(/demo\.test\.bar/, out)
     end # all assign
 
@@ -53,24 +53,21 @@ describe "Backburner::Workers::Forking module" do
       worker = @worker_class.new
       out = capture_stdout { worker.prepare }
       assert_contains worker.tube_names, "demo.test.backburner-jobs"
-      assert_contains @worker_class.connection.tubes.watched.map(&:name), "demo.test.backburner-jobs"
-      assert_match(/demo\.test\.test-job/, out)
+      assert_contains worker.connection.tubes.watched.map(&:name), "demo.test.backburner-jobs"
+      assert_match(/demo\.test\.backburner-jobs/, out)
     end # all read
   end # prepare
 
   describe "for fork_one_job method" do
 
-    it "should fork, reconnect, work job, and exit" do
+    it "should fork, work job, and exit" do
       clear_jobs!("bar.foo")
       @worker_class.enqueue TestJobForking, [1, 2], :queue => "bar.foo"
 
       fake_pid = 45
-      Process.expects(:fork).returns(fake_pid) do |&block|
-        Connection.expects(:new).with(Backburner.configuration.beanstalk_url)
-        @worker_class.any_instance.expects(:work_one_job)
-        @worker_class.any_instance.expects(:coolest_exit)
-        block.call
-      end
+      Process.expects(:fork).returns(fake_pid).yields
+      @worker_class.any_instance.expects(:work_one_job)
+      @worker_class.any_instance.expects(:coolest_exit)
       Process.expects(:wait).with(fake_pid)
 
       silenced(2) do

data/test/workers/simple_worker_test.rb

@@ -19,7 +19,7 @@ describe "Backburner::Workers::Basic module" do
       worker = @worker_class.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"], @worker_class.connection.tubes.watched.map(&:name)
+      assert_same_elements ["demo.test.foo", "demo.test.bar"], worker.connection.tubes.watched.map(&:name)
       assert_match(/demo\.test\.foo/, out)
     end # multiple
 
@@ -27,7 +27,7 @@ describe "Backburner::Workers::Basic module" do
       worker = @worker_class.new("foo")
       out = capture_stdout { worker.prepare }
       assert_equal ["demo.test.foo"], worker.tube_names
-      assert_same_elements ["demo.test.foo"], @worker_class.connection.tubes.watched.map(&:name)
+      assert_same_elements ["demo.test.foo"], worker.connection.tubes.watched.map(&:name)
       assert_match(/demo\.test\.foo/, out)
     end # single
 
@@ -36,7 +36,7 @@ describe "Backburner::Workers::Basic module" do
       worker = @worker_class.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"], @worker_class.connection.tubes.watched.map(&:name)
+      assert_same_elements ["demo.test.foo", "demo.test.bar"], worker.connection.tubes.watched.map(&:name)
       assert_match(/demo\.test\.foo/, out)
     end
 
@@ -45,7 +45,7 @@ describe "Backburner::Workers::Basic module" do
       worker = @worker_class.new
       out = capture_stdout { worker.prepare }
       assert_equal ["demo.test.bar"], worker.tube_names
-      assert_same_elements ["demo.test.bar"], @worker_class.connection.tubes.watched.map(&:name)
+      assert_same_elements ["demo.test.bar"], worker.connection.tubes.watched.map(&:name)
       assert_match(/demo\.test\.bar/, out)
     end # all assign
 
@@ -53,7 +53,7 @@ describe "Backburner::Workers::Basic module" do
       worker = @worker_class.new
       out = capture_stdout { worker.prepare }
       assert_contains worker.tube_names, "demo.test.backburner-jobs"
-      assert_contains @worker_class.connection.tubes.watched.map(&:name), "demo.test.backburner-jobs"
+      assert_contains worker.connection.tubes.watched.map(&:name), "demo.test.backburner-jobs"
       assert_match(/demo\.test\.backburner-jobs/, out)
     end # all read
   end # prepare
@@ -99,11 +99,16 @@ describe "Backburner::Workers::Basic module" do
     end # fail, argument
 
     it "should work an enqueued failing job" do
-      clear_jobs!("foo.bar")
-      @worker_class.enqueue TestFailJob, [1, 2], :queue => "foo.bar"
+      # NB: The #bury expectation below leaves the job in the queue (as reserved!)
+      # since bury is never actually called on the task. Therefore, clear_jobs!()
+      # can't remove it which can break a lot of things depending on the order the
+      # tests are run. So we ensure that it's using a unique queue name. Mocha
+      # lacks expectations with proxies (where we could actually call bury)
+      clear_jobs!('foo.bar.failed')
+      @worker_class.enqueue TestFailJob, [1, 2], :queue => 'foo.bar.failed'
       Backburner::Job.any_instance.expects(:bury).once
       out = silenced(2) do
-        worker = @worker_class.new('foo.bar')
+        worker = @worker_class.new('foo.bar.failed')
         worker.prepare
         worker.work_one_job
       end
@@ -275,12 +280,13 @@ describe "Backburner::Workers::Basic module" do
 
     it "should support event hooks with stopping enqueue" do
       $hooked_fail_count = 0
+      worker = @worker_class.new('foo.bar.events.retry2')
       clear_jobs!('foo.bar.events.retry2')
       silenced(2) do
         HookedObjectBeforeEnqueueFail.async(:queue => 'foo.bar.events.retry2').foo(5)
       end
       expanded_tube = [Backburner.configuration.tube_namespace, 'foo.bar.events.retry2'].join(".")
-      assert_nil @worker_class.connection.tubes[expanded_tube].peek(:ready)
+      assert_nil worker.connection.tubes[expanded_tube].peek(:ready)
     end # stopping enqueue
 
     it "should support event hooks with stopping perform" do
@@ -299,11 +305,18 @@ describe "Backburner::Workers::Basic module" do
       refute_match(/HookFailError/, out)
     end # stopping perform
 
+    it "should use the connection given as an argument" do
+      worker = @worker_class.new('foo.bar')
+      connection = mock('connection')
+      worker.expects(:reserve_job).with(connection).returns(stub_everything('job'))
+      worker.work_one_job(connection)
+    end
+
     after do
       Backburner.configure do |config|
         config.max_job_retries = 0
         config.retry_delay = 5
-        config.retry_delay_proc = lambda { |min_retry_delay, num_retries| min_retry_delay + (num_retries ** 3) } 
+        config.retry_delay_proc = lambda { |min_retry_delay, num_retries| min_retry_delay + (num_retries ** 3) }
       end
     end
   end # work_one_job

data/test/workers/threads_on_fork_worker_test.rb

@@ -176,7 +176,7 @@ describe "Backburner::Workers::ThreadsOnFork module" do
           worker.prepare
           worker.fork_inner('demo.test.bar')
         end
-        assert_same_elements %W(demo.test.bar), @worker_class.connection.tubes.watched.map(&:name)
+        assert_same_elements %W(demo.test.bar), worker.connection.tubes.watched.map(&:name)
       end
 
       it "should not create threads if the number of threads is 1" do
@@ -204,7 +204,6 @@ describe "Backburner::Workers::ThreadsOnFork module" do
         worker = @worker_class.new(%(foo))
         @worker_class.expects(:threads_number).returns(5)
         worker.expects(:run_while_can).times(5)
-        # TODO
         def worker.create_thread(*args, &block); block.call(*args) end
         silenced do
           worker.prepare
@@ -218,17 +217,19 @@ describe "Backburner::Workers::ThreadsOnFork module" do
 
         worker = @worker_class.new(%(foo))
         @worker_class.expects(:threads_number).returns(num_threads)
-        invocations = Array(1..num_threads).map { |i|
+
+        invocations = Array(1..num_threads).map do |i|
           conn = OpenStruct.new(:num => i)
           conn.expects(:close)
           conn
-        }
+        end
         Backburner::Connection.expects(:new).times(num_threads).returns(*invocations)
 
         # ensure each invocation of run_while_can is with a different connection
         num_conns = states('num_conns').starts_as(0)
         invocations.each do |conn|
-          worker.expects(:run_while_can).with(name, conn).when(num_conns.is(conn.num-1)).then(num_conns.is(conn.num))
+          worker.expects(:watch_tube).with(name, conn)
+          worker.expects(:run_while_can).with(conn).when(num_conns.is(conn.num-1)).then(num_conns.is(conn.num))
         end
 
         def worker.create_thread(*args, &block); block.call(*args) end
@@ -236,6 +237,7 @@ describe "Backburner::Workers::ThreadsOnFork module" do
           worker.prepare
           worker.fork_inner(name)
         end
+
         assert_equal(num_threads, num_conns.current_state)
       end
 
@@ -374,20 +376,22 @@ describe "Backburner::Workers::ThreadsOnFork module" do
         $worker_success = false
         $worker_raise   = false
         clear_jobs!('response')
-        clear_jobs!('foo.bar.1', 'foo.bar.2', 'foo.bar.3', 'foo.bar.4', 'foo.bar.5', 'foo.bar.6')
+        clear_jobs!('foo.bar.1', 'foo.bar.2', 'foo.bar.3', 'foo.bar.4', 'foo.bar.5', 'foo.bar.6', 'foo.bar.7')
         @worker_class.threads_number = 1
         @worker_class.garbage_after  = 10
+
         silenced do
           @response_worker = @worker_class.new('response')
           @response_worker.watch_tube('demo.test.response')
         end
+
         @ignore_forks = true
       end
 
       after do
         @templogger.close
         clear_jobs!('response')
-        clear_jobs!('foo.bar.1', 'foo.bar.2', 'foo.bar.3', 'foo.bar.4', 'foo.bar.5', 'foo.bar.6')
+        clear_jobs!('foo.bar.1', 'foo.bar.2', 'foo.bar.3', 'foo.bar.4', 'foo.bar.5', 'foo.bar.6', 'foo.bar.7')
         @worker_class.threads_number = 1
         @worker_class.shutdown = true
         silenced do
@@ -402,7 +406,8 @@ describe "Backburner::Workers::ThreadsOnFork module" do
         @worker = @worker_class.new('foo.bar.1')
         @worker.start(false)
         @worker_class.enqueue TestJobFork, [1, 2], :queue => "foo.bar.1"
-        silenced(2) do
+
+        silenced do
           @templogger.wait_for_match(/Completed TestJobFork/m)
           @response_worker.work_one_job
         end
@@ -458,23 +463,22 @@ describe "Backburner::Workers::ThreadsOnFork module" do
       end # retrying, succeeds
 
       it "should support a multithreaded worker without deadlocks" do
-        num_threads = 5
+        num_threads = 15
         num_jobs = 8
-        num_jobs.times do
-          @worker_class.enqueue TestJobFork, [6,2], :queue => 'foo.bar.6'
+        num_jobs.times do |i|
+          @worker_class.enqueue TestJobMultithreadFork, [6,2], :queue => 'foo.bar.6'
         end
+
         @worker_class.threads_number = num_threads
         @worker = @worker_class.new('foo.bar.6')
         @worker.start(false)
-        silenced(2) do
-          @templogger.wait_for_match(/Completed TestJobFork/m)
+
+        silenced do
+          @templogger.wait_for_match(/Completed TestJobMultithreadFork/m)
           num_jobs.times { @response_worker.work_one_job }
         end
         assert_equal num_jobs, $worker_test_count
       end # multithreaded
-
     end # practical tests
-
   end # forking and threading
-
 end # Backburner::Workers::ThreadsOnFork module

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: backburner
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0.pre
 platform: ruby
 authors:
 - Nathan Esquenazi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-14 00:00:00.000000000 Z
+date: 2015-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: beaneater
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: dante
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - '>'
       - !ruby/object:Gem::Version
         version: 0.1.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - '>'
       - !ruby/object:Gem::Version
         version: 0.1.5
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -70,14 +70,14 @@ dependencies:
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Beanstalk background job processing made easy
@@ -88,9 +88,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".DS_Store"
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
+- .travis.yml
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
@@ -156,17 +155,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Reliable beanstalk background job processing made easy for Ruby and Sinatra