backburner-allq 1.0.36 → 1.0.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ac9dbeeb771c9821488a74064bc6bbe1e059cb9e4dc7faf4f25caf08054b4e6
-  data.tar.gz: 298634152be89db02b2b2898b57c9d2fbd9b27354c7b49068af6aadd5613dbe5
+  metadata.gz: a737b01e7869afbe98e32059d9f28bd7b9ad4ccb9b763054dccb90f9062544dd
+  data.tar.gz: '00858748b53b6aab0bed26afef647ab3611e90df5a27b41d261c63943a711e60'
 SHA512:
-  metadata.gz: 34ee7a51b82f0362485e2346939f70d2bcb3db8412b72ccc237ebf63564b9bd9e9e26613e75fc0c2bdf3f9965ca0b96707db1130f35edfd93e475b7825bf7b9b
-  data.tar.gz: 27df1992ff07455872730e2d7d65638b4b63ee1670d4cddfe940de8f17ee27df002db0fba0b0086ea0da6bafedfdbfaea11f6c4acbc7671b9d95a9999600a057
+  metadata.gz: 3eec6cbbac812b151e230e2f4aedcf6106651225aac47ba0b928a4c38eec4e59bc5f7a186a496e2ce7fb36381b8d369f121b72ee88341b742b9edc0f94570f5e
+  data.tar.gz: 73272508ddf5fa6a6f34685380d03d5b4d17a16d2e3889e60f1bb43d9e3afa492a715f231359404c36ba07bf328868b77ee392b16264c7940968bd0eecef470b

data/.gitlab-ci.yml

@@ -0,0 +1,21 @@
+default:
+  image: ruby:3.0
+    
+stages:          # List of stages for jobs, and their order of execution
+  - test
+
+unit-test:  
+  tags: 
+    - allq
+  stage: test
+  script:
+    - docker-compose down || true
+    - docker-compose up -d || true
+    - sleep 10
+    - ruby -v
+    - bundle install
+    - bundle exec rake test TEST=test/allq/back_burner_test.rb DEBUG=true
+    - bundle exec rake test TEST=test/allq/worker_test.rb DEBUG=true
+  after_script:
+    - docker-compose down || true
+    

data/deploy.sh

@@ -1,3 +1,3 @@
 echo "Did you update the version?"
 gem build backburner-allq.gemspec
-gem push backburner-allq-1.0.36.gem
+gem push backburner-allq-1.0.39.gem

data/docker-compose.yml

@@ -0,0 +1,26 @@
+version: '3'
+services:
+  allq-client:
+    networks:
+      - local-net
+    image: "blitline/allq_client"
+    environment:
+      - SERVER_STRING=allq-server:5555
+    depends_on:
+      - allq-server
+    ports:
+      - 8090:8090
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "echo '{\"action\":\"peek\",\"params\":{\"tube\":\"default\", \"buried\":true}}' | socat - tcp4-connect:127.0.0.1:7768"]
+      interval: 1m
+      timeout: 10s
+      retries: 3
+  allq-server:
+    networks:
+      - local-net
+    image: "blitline/allq_server"
+    restart: unless-stopped
+networks:
+  local-net:
+

data/lib/backburner/allq_wrapper.rb

@@ -42,13 +42,17 @@ module Backburner
     # Release count
     attr_accessor :releases
 
-    def initialize(wrapper, job_resposne)
+    # Release count
+    attr_accessor :special
+
+    def initialize(wrapper, job_response)
       @client = wrapper
-      @id = job_resposne.id
-      @body = job_resposne.body
-      @expireds = job_resposne.expireds
-      @releases = job_resposne.releases
-      @tube = job_resposne.tube.to_s
+      @id = job_response.id
+      @body = job_response.body
+      @expireds = job_response.expireds
+      @releases = job_response.releases
+      @tube = job_response.tube.to_s
+      @special = job_response.special.to_s if job_response.special
     end
 
     def done
@@ -78,6 +82,10 @@ module Backburner
     def stats
       { 'expireds' => expireds, 'releases' => releases }
     end
+
+    def clear(tube)
+      @client.clear(tube)
+    end
   end
 
   class AllQWrapper
@@ -93,10 +101,8 @@ module Backburner
       @recent_times = []
     end
 
-    def speed
-      return @recent_times.sum(0.0) / @recent_times.size if @recent_times.size > 0
-
-      0
+    def clear(tube)
+       @client.tube_delete(tube)
     end
 
     def touch(job)
@@ -167,12 +173,6 @@ module Backburner
       app_priority > 10 ? 5 : app_priority
     end
 
-    def log_result(job_result)
-      puts("ALLQ-HTTP-JOB-ID=#{job_result.job_id}")
-    rescue StandardError => e
-      puts(e)
-    end
-
     def build_new_job(body, options)
       adjusted_priority = map_priority(options[:pri] || 5)
 
@@ -195,7 +195,6 @@ module Backburner
       ttl = options[:ttl] || options[:ttr] || DEFAULT_TIMEOUT
       tube_name = options[:tube_name] || 'default'
       delay = options[:delay] || 0
-      parent_id = options[:parent_id]
       limit = options[:limit]
       timeout = options[:timeout] || 3_600
       run_on_timeout = options[:run_on_timeout] || false
@@ -254,15 +253,21 @@ module Backburner
       raw_stats = @admin.stats_get
       final_stats = {}
 
-      raw_stats.each do |agg|
+      raw_stats.each_with_index do |agg, i|
         agg.stats.each do |tube_ref|
           name = tube_ref.tube
-          final_stats[name] = {} unless final_stats[name]
+          final_stats[name] = {'avg' => 0, 'tps' => 0} unless final_stats[name]
           final_stats[name]['ready'] = final_stats[name]['ready'].to_i + tube_ref.ready.to_i
           final_stats[name]['reserved'] = final_stats[name]['reserved'].to_i + tube_ref.reserved.to_i
           final_stats[name]['delayed'] = final_stats[name]['delayed'].to_i + tube_ref.delayed.to_i
           final_stats[name]['buried'] = final_stats[name]['buried'].to_i + tube_ref.buried.to_i
           final_stats[name]['parents'] = final_stats[name]['parents'].to_i + tube_ref.parents.to_i
+
+
+          # Fancy math to calculate averages on the fly
+          # https://math.stackexchange.com/questions/106313/regular-average-calculated-accumulatively
+          final_stats[name]['avg'] += (tube_ref.avg.to_f - final_stats[name]['avg'].to_f)/(i+1).to_f
+          final_stats[name]['tps'] += (tube_ref.tps.to_f - final_stats[name]['tps'].to_f)/(i+1).to_f
         end
       end
       final_stats

data/lib/backburner/configuration.rb

@@ -21,7 +21,7 @@ module Backburner
     attr_accessor :job_parser_proc     # proc to parse a job body from a string
 
     def initialize
-      @allq_url       = "allq://127.0.0.1:8091"
+      @allq_url       = "allq://127.0.0.1:8090"
       @tube_namespace      = "backburner"
       @namespace_separator = "."
       @default_priority    = 5

data/lib/backburner/connection.rb

@@ -23,6 +23,10 @@ module Backburner
       connect!
     end
 
+    def clear(tube)
+      @allq_wrapper.clear(tube)
+    end
+
     # Close the connection, if it exists
     def close
       @allq_wrapper.close if @allq_wrapper
@@ -110,6 +114,11 @@ module Backburner
       }
 
       options[:shard_key] = opt[:shard_key] if opt[:shard_key]
+      options[:parent_id] = opt[:parent_id] if opt[:parent_id]
+      options[:timeout] = opt[:timeout] if opt[:timeout]
+      options[:run_on_timeout] = opt[:run_on_timeout] if opt[:run_on_timeout]
+      options[:limit] = opt[:limit] if opt[:limit]
+      options[:is_parent] = opt[:is_parent] if opt[:is_parent]
 
       # Overwrite originals
       opt.merge!(options)

data/lib/backburner/job.rb

@@ -49,7 +49,15 @@ module Backburner
       return false unless res
       # Execute the job
       @hooks.around_hook_events(job_name, :around_perform, *args) do
-        timeout_job_after(@ttr > 1 ? @ttr - 1 : @ttr) { job_class.perform(*args) }
+
+        timeout_job_after(@ttr > 1 ? @ttr - 1 : @ttr) do
+          # Decide if we want access to the root task
+          if job_class.methods.include?(:perform_with_task)
+            job_class.perform_with_task(@task, *args)
+          else
+           job_class.perform(*args)
+          end
+        end
       end
       task.delete
       # Invoke after perform hook

data/lib/backburner/version.rb

@@ -1,3 +1,3 @@
 module Backburner
-  VERSION = "1.0.36"
+  VERSION = "1.0.39"
 end

data/lib/backburner/worker.rb

@@ -13,7 +13,10 @@ module Backburner
     # List of known_queue_classes
     class << self
       attr_writer :known_queue_classes
-      def known_queue_classes; @known_queue_classes ||= []; end
+
+      def known_queue_classes
+        @known_queue_classes ||= []
+      end
     end
 
     # Enqueues a job to be processed later by a worker.
@@ -37,8 +40,8 @@ module Backburner
 
       return nil unless res # stop if hook is false
 
-      data = { :class => job_class.name, :args => args, :ttr => ttr }
-      queue = opts[:queue] && (Proc === opts[:queue] ? opts[:queue].call(job_class) : opts[:queue])
+      data = { class: job_class.name, args: args, ttr: ttr }
+      queue = opts[:queue] && (opts[:queue].is_a?(Proc) ? opts[:queue].call(job_class) : opts[:queue])
 
       begin
         response = nil
@@ -67,12 +70,10 @@ module Backburner
     # @example
     #   Backburner::Worker.start(["foo.tube.name"])
     #
-    def self.start(tube_names=nil)
-      begin
-        self.new(tube_names).start
-      rescue SystemExit
-        # do nothing
-      end
+    def self.start(tube_names = nil)
+      new(tube_names).start
+    rescue SystemExit
+      # do nothing
     end
 
     # List of tube names to be watched and processed
@@ -84,7 +85,7 @@ module Backburner
     #   Worker.new(['test.job'])
     def initialize(tube_names = nil)
       @connection = new_connection
-      @tube_names = self.process_tube_names(tube_names)
+      @tube_names = process_tube_names(tube_names)
       register_signal_handlers!
     end
 
@@ -140,31 +141,30 @@ module Backburner
     # @raise [Beaneater::NotConnected] If beanstalk fails to connect multiple times.
     def work_one_job(conn = connection, tube_name = nil)
       if tube_name.nil?
-        self.log_error "Sampling tube, this is bad practice for Allq"
-        tube_name = @tube_names.sample 
+        log_error 'Sampling tube, this is bad practice for Allq'
+        tube_name = @tube_names.sample
       end
-      
+
       begin
         job = reserve_job(conn, tube_name)
       rescue Exception => e
-        self.log_error "Sleeping"
-        self.log_error "Exception: #{e.full_message}"
-        sleep(rand*3)
+        log_error "Exception: #{e.full_message}"
+        sleep(rand * 3)
         return
       end
 
       if job && job.body
         begin
-          self.log_job_begin(job.name, job.args)
+          log_job_begin(job.name, job.args)
           job.process
-          self.log_job_end(job.name)
+          log_job_end(job.name)
         rescue Backburner::Job::JobFormatInvalid => e
-          self.log_error self.exception_message(e)
-        rescue => e # Error occurred processing job
-          self.log_error self.exception_message(e) unless e.is_a?(Backburner::Job::RetryJob)
+          log_error exception_message(e)
+        rescue StandardError => e # Error occurred processing job
+          log_error exception_message(e) unless e.is_a?(Backburner::Job::RetryJob)
 
           unless job
-            self.log_error "Error occurred before we were able to assign a job. Giving up without retrying!"
+            log_error 'Error occurred before we were able to assign a job. Giving up without retrying!'
             return
           end
 
@@ -172,26 +172,29 @@ module Backburner
           # gone down between the time we reserved / processed the job and here.
           num_retries = job.releases
           max_job_retries = resolve_max_job_retries(job.job_class)
-          retry_status = "failed: attempt #{num_retries+1} of #{max_job_retries+1}"
+          retry_status = "failed: attempt #{num_retries + 1} of #{max_job_retries + 1}"
           retry_delay = resolve_retry_delay(job.job_class)
-          delay = resolve_retry_delay_proc(job.job_class).call(retry_delay, num_retries) rescue retry_delay
-          
+          delay = begin
+            resolve_retry_delay_proc(job.job_class).call(retry_delay, num_retries)
+          rescue StandardError
+            retry_delay
+          end
+
           if num_retries + 1 > max_job_retries
             job.bury
           else
             job.release(delay)
           end
-          self.log_job_end(job.name, "#{retry_status}, retrying in #{delay}s") if job_started_at
+          log_job_end(job.name, "#{retry_status}, retrying in #{delay}s") if job_started_at
 
           handle_error(e, job.name, job.args, job)
         end
       else
-        sleep(rand*3)
+        sleep(rand * 3)
       end
       job
     end
 
-
     protected
 
     # Return a new connection instance
@@ -200,9 +203,10 @@ module Backburner
     end
 
     # Reserve a job from the watched queues
-    def reserve_job(conn, tube_name, reserve_timeout = Backburner.configuration.reserve_timeout)
+    def reserve_job(conn, tube_name, _reserve_timeout = Backburner.configuration.reserve_timeout)
       job = conn.get(tube_name)
       return nil if job.nil? || job.body == nil?
+
       Backburner::Job.new(job)
     end
 
@@ -210,11 +214,10 @@ module Backburner
     # Filtered for tubes that match the known prefix
     def all_existing_queues
       known_queues    = Backburner::Worker.known_queue_classes.map(&:queue)
-      existing_tubes  = self.connection.tubes.all.map(&:name).select { |tube| tube =~ /^#{queue_config.tube_namespace}/ }
+      existing_tubes  = connection.tubes.all.map(&:name).select { |tube| tube =~ /^#{queue_config.tube_namespace}/ }
       existing_tubes + known_queues + [queue_config.primary_queue]
     end
 
-
     # Handles an error according to custom definition
     # Used when processing a job that errors out
     def handle_error(e, name, args, job)

data/test/allq/back_burner_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path('test_helper', __dir__)
+
+$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 do
+    Backburner.default_queues.clear
+    clear_jobs!(Backburner.configuration.primary_queue, 'test-plain', 'parent-plain', 'bar.baz.foo')
+  end
+
+  describe 'for work method' do
+    it 'invokes worker simple start' do
+      Backburner::Workers::Simple.expects(:start).with(%w[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(%w[foo bar])
+      Backburner.work('foo', 'bar')
+    end
+
+    it 'invokes other worker if specified in work method as options' do
+      TestWorker.expects(:start).with(%w[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 %w[foo bar], Backburner.default_queues
+    end
+  end
+
+  after do
+    Backburner.configure { |config| config.default_worker = Backburner::Workers::Simple }
+  end
+end # Backburner

data/test/allq/test_helper.rb

@@ -0,0 +1,108 @@
+$LOAD_PATH.unshift File.expand_path("lib")
+require 'backburner'
+require 'tempfile'
+require 'minitest/autorun'
+require_relative '../fixtures/test_jobs'
+
+begin
+  require 'mocha/setup'
+rescue LoadError
+  require 'mocha'
+end
+
+# Configure Backburner
+Backburner.configure do |config|
+  config.allq_url = "allq://127.0.0.1:8090"
+  config.tube_namespace = "demo.test"
+  config.on_error            = lambda { |e| puts e }
+end
+
+def clear_jobs!(*tube_names)
+  connection = allq_connection
+  tube_names.each do |tube_name|
+    expanded_name = [Backburner.configuration.tube_namespace, tube_name].join(".")
+    connection.clear(expanded_name)
+  end
+ensure
+  connection.close if connection
+end
+
+def allq_connection
+  Backburner::Connection.new(Backburner.configuration.allq_url)
+end
+
+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
+    if ENV['DEBUG'] # Skip if debug mode
+      yield
+      return ""
+    end
+
+    out = StringIO.new
+    $stdout = out
+    $stderr = out
+    yield
+    return out.string
+  ensure
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+end
+
+def sleeper(duration_in_seconds)
+  1.upto(duration_in_seconds) do |i|
+    sleep(1)
+    print '.'
+  end
+end
+
+# pop_one_job(tube_name)
+def pop_one_job(tube_name=Backburner.configuration.primary_queue)
+  tube_name  = [Backburner.configuration.tube_namespace, tube_name].join(".")
+  connection = allq_connection
+  silenced(3) { @res = connection.get(tube_name)}
+  data = nil
+  data = Backburner.configuration.job_parser_proc.call(@res.body) if @res && @res.body
+  yield @res, data
+ensure
+  connection.close if connection
+end
+
+# def work_one_job(tube_name=Backburner.configuration.primary_queue)
+#   tube_name  = [Backburner.configuration.tube_namespace, tube_name].join(".")
+#   connection = allq_connection
+#   job = Backburner::Worker.work_one_job(connection, tube_name)
+#   job.delete
+# end
+
+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

data/test/allq/worker_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path('test_helper', __dir__)
+
+describe 'Backburner::Worker module' do
+  before do
+    Backburner.default_queues.clear
+    clear_jobs!(Backburner.configuration.primary_queue, 'test-plain', 'parent-plain', 'bar.baz.foo')
+  end
+
+  it 'should support enqueuing plain job' do
+    Backburner::Worker.enqueue TestPlainJob, [7, 9], { ttr: 144 }
+    pop_one_job('test-plain') do |_job, body|
+      assert_equal 'TestPlainJob', body['class']
+      assert_equal [7, 9], body['args']
+      assert_equal 144, body['ttr'].to_i
+    end
+  end # plain
+
+  it 'should support enqueuing parent job' do
+    options = {
+      is_parent: true,
+      limit: 1,
+      timeout: 3,
+      run_on_timeout: true
+    }
+    # Enqueue parent job
+    response = Backburner::Worker.enqueue TestParentJob, [17, 9], options
+
+    options = {
+      parent_id: response.job_id
+    }
+    # Enqueue child job
+    Backburner::Worker.enqueue TestPlainJob, [7, 9], options
+    pop_one_job('test-plain') do |job, body|
+      assert_equal 'TestPlainJob', body['class']
+      assert_equal [7, 9], body['args']
+      job.delete
+    end
+
+    pop_one_job('parent-plain') do |_job, body|
+      assert_equal [17, 9], body['args']
+    end
+  end
+
+  it 'should support enqueuing parent job with timeout' do
+    options = {
+      is_parent: true,
+      limit: 1,
+      timeout: 3,
+      run_on_timeout: true
+    }
+    # Enqueue parent job
+    response = Backburner::Worker.enqueue TestParentJob, [17, 9], options
+
+    options = {
+      parent_id: response.job_id
+    }
+    # Enqueue child job
+    Backburner::Worker.enqueue TestPlainJob, [7, 9], options
+
+    pop_one_job('parent-plain') do |_job, body|
+      assert_equal body, nil
+      sleeper(10)
+    end
+
+    worker = Backburner::Workers::Simple.new('demo.test.parent-plain')
+    worker.prepare
+
+    TestParentJob.expects(:perform_with_task)
+    job = worker.work_one_job(allq_connection, 'demo.test.parent-plain')
+    assert_equal job.special, "true"
+  end 
+
+
+
+end
+
+
+      # options[:parent_id] = opt[:parent_id] if opt[:parent_id]
+      # options[:timeout] = opt[:timeout] if opt[:timeout]
+      # options[:run_on_timeout] = opt[:run_on_timeout] if opt[:run_on_timeout]
+      # options[:limit] = opt[:limit] if opt[:limit]
+      # options[:is_parent] = opt[:is_parent] if opt[:is_parent]

data/test/fixtures/test_jobs.rb

@@ -6,6 +6,18 @@ class TestPlainJob
   def self.perform(x, y); $worker_test_count += x + y + 1; end
 end
 
+
+class TestParentJob
+  def self.queue; "parent-plain"; end
+  def self.perform(args)
+    puts "plain perform #{args}"
+  end
+  def self.perform_with_task(task, *args)
+    puts "perform_with_task"
+    puts task.inspect
+  end
+end
+
 class TestJob
   include Backburner::Queue
   queue_priority :medium

data/test/worker_test.rb

@@ -1,6 +1,4 @@
 require File.expand_path('../test_helper', __FILE__)
-require File.expand_path('../fixtures/test_jobs', __FILE__)
-require File.expand_path('../fixtures/hooked', __FILE__)
 
 describe "Backburner::Worker module" do
   before do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: backburner-allq
 version: !ruby/object:Gem::Version
-  version: 1.0.36
+  version: 1.0.39
 platform: ruby
 authors:
 - Jason Malcolm
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-26 00:00:00.000000000 Z
+date: 2022-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: allq_rest
@@ -109,6 +109,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".gitlab-ci.yml"
 - ".travis.yml"
 - CHANGELOG.md
 - CONTRIBUTING.md
@@ -122,6 +123,7 @@ files:
 - bin/backburner
 - circle.yml
 - deploy.sh
+- docker-compose.yml
 - examples/custom.rb
 - examples/demo.rb
 - examples/god.rb
@@ -148,6 +150,9 @@ files:
 - lib/backburner/workers/simple.rb
 - lib/backburner/workers/threading.rb
 - lib/backburner/workers/threads_on_fork.rb
+- test/allq/back_burner_test.rb
+- test/allq/test_helper.rb
+- test/allq/worker_test.rb
 - test/async_proxy_test.rb
 - test/back_burner_test.rb
 - test/connection_test.rb
@@ -193,6 +198,9 @@ signing_key:
 specification_version: 4
 summary: Reliable allq background job processing made easy for Ruby and Sinatra
 test_files:
+- test/allq/back_burner_test.rb
+- test/allq/test_helper.rb
+- test/allq/worker_test.rb
 - test/async_proxy_test.rb
 - test/back_burner_test.rb
 - test/connection_test.rb