backburner 1.8.0 → 1.9.0

data/test/fixtures/test_fork_jobs.rb

@@ -1,77 +0,0 @@
-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
-
-class TestJobNoopFork
-  include Backburner::Queue
-  def self.perform; end
-end

data/test/fixtures/test_forking_jobs.rb

@@ -1,56 +0,0 @@
-class ResponseForkingJob
-  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 TestJobForking
-  include Backburner::Queue
-  queue_priority 1000
-  def self.perform(x, y)
-    Backburner::Workers::Forking.enqueue ResponseForkingJob, [{
-        :worker_test_count_set => x + y
-    }], :queue => 'response'
-  end
-end
-
-class TestFailJobForking
-  include Backburner::Queue
-  def self.perform(x, y)
-    Backburner::Workers::Forking.enqueue ResponseForkingJob, [{
-       :worker_raise => true
-    }], :queue => 'response'
-  end
-end
-
-class TestRetryJobForking
-  include Backburner::Queue
-  def self.perform(x, y)
-    if $worker_test_count <= 2
-      Backburner::Workers::Forking.enqueue ResponseForkingJob, [{
-          :worker_test_count => 1
-      }], :queue => 'response'
-
-      raise RuntimeError
-    else # succeeds
-      Backburner::Workers::Forking.enqueue ResponseForkingJob, [{
-          :worker_test_count => 1,
-          :worker_success => true
-      }], :queue => 'response'
-    end
-  end
-end
-
-class TestAsyncJobForking
-  include Backburner::Performable
-  def self.foo(x, y)
-    Backburner::Workers::Forking.enqueue ResponseForkingJob, [{
-        :worker_test_count_set => x * y
-    }], :queue => 'response'
-  end
-end

data/test/fixtures/test_jobs.rb

@@ -1,140 +0,0 @@
-$worker_test_count = 0
-$worker_success = false
-
-class TestPlainJob
-  def self.queue; "test-plain"; end
-  def self.perform(x, y); $worker_test_count += x + y + 1; end
-end
-
-class TestJob
-  include Backburner::Queue
-  queue_priority :medium
-  queue_respond_timeout 300
-  def self.perform(x, y); $worker_test_count += x + y; end
-end
-
-class TestParentQueueJob
-  include Backburner::Queue
-  queue "test-parent"
-  queue_priority :high
-  queue_respond_timeout 250
-  def self.perform(x, y); $worker_test_count += x + y; end
-end
-
-class TestChildQueueJob < TestParentQueueJob; end
-
-class TestNamedQueueJob
-  include Backburner::Queue
-  queue lambda { |klass| klass.name.downcase }
-  def self.perform; end
-end
-
-class TestSlowJob
-  include Backburner::Queue
-  queue_priority :medium
-  queue_respond_timeout 300
-  def self.perform(x, y); sleep 1; $worker_test_count += x + y; end
-end
-
-class TestStuckJob
-  include Backburner::Queue
-  queue_priority :medium
-  queue_respond_timeout 300
-  def self.perform(_x, _y)
-    loop do
-      sleep 0.5
-    end
-  end
-end
-
-class TestFailJob
-  include Backburner::Queue
-  def self.perform(x, y); raise RuntimeError; end
-end
-
-class TestRetryJob
-  include Backburner::Queue
-  def self.perform(x, y)
-    $worker_test_count += 1
-    raise RuntimeError unless $worker_test_count > 2
-    $worker_success = true
-  end
-end
-
-class TestFloatRetryDelayJob
-  include Backburner::Queue
-  queue_retry_delay 1.5
-  def self.perform(retry_count)
-    raise RuntimeError
-  end
-end
-
-class TestFloatRespondTimeoutJob
-  include Backburner::Queue
-  queue "test-plain"
-  queue_respond_timeout 1.5
-  def self.perform; end
-end
-
-class TestConfigurableRetryJob
-  include Backburner::Queue
-  def self.perform(retry_count)
-    $worker_test_count += 1
-    raise RuntimeError unless $worker_test_count > retry_count
-    $worker_success = true
-  end
-end
-
-class TestRetryWithQueueOverridesJob
-  include Backburner::Queue
-  def self.perform(retry_count)
-    $worker_test_count += 1
-    raise RuntimeError unless $worker_test_count > retry_count
-    $worker_success = true
-  end
-
-  def self.queue_max_job_retries
-    3
-  end
-
-  def self.queue_retry_delay
-    0
-  end
-
-  def self.queue_retry_delay_proc
-    lambda { |min_retry_delay, num_retries| min_retry_delay + (num_retries ** 2) }
-  end
-end
-
-class TestAsyncJob
-  include Backburner::Performable
-  def self.foo(x, y); $worker_test_count = x * y; end
-end
-
-class TestLambdaQueueJob
-  include Backburner::Queue
-  queue lambda { |klass| klass.calculated_queue_name }
-  def self.calculated_queue_name; 'lambda-queue' end
-end
-
-class TestOverTTRJob
-  include Backburner::Queue
-  queue_respond_timeout 2
-  # Outlives its TTR without Timeout being able to interrupt it (like a blocking C call)
-  def self.perform; Thread.handle_interrupt(Object => :never) { sleep 3 }; end
-end
-
-# Like an autoloader that doesn't find a file for the constant
-module AutoloadingDemo
-  def self.const_missing(name); raise LoadError, "cannot load such file -- autoloading_demo/#{name}"; end
-end
-
-# Job classes an app autoloads: whose files fail to load, and one whose file isn't there
-autoload :TestBrokenNameJob, File.expand_path('../autoload/test_broken_name_job', __FILE__)
-autoload :TestBrokenRequireJob, File.expand_path('../autoload/test_broken_require_job', __FILE__)
-autoload :TestBrokenNoMethodJob, File.expand_path('../autoload/test_broken_no_method_job', __FILE__)
-autoload :TestNoFileJob, File.expand_path('../autoload/test_no_such_job', __FILE__)
-autoload :TestBrokenRuntimeJob, File.expand_path('../autoload/test_broken_runtime_job', __FILE__)
-autoload :TestSameNameJob, File.expand_path('../autoload/test_same_name_job', __FILE__)
-autoload :TestBrokenSyntaxJob, File.expand_path('../autoload/test_broken_syntax_job', __FILE__)
-autoload :TestBrokenTimeoutJob, File.expand_path('../autoload/test_broken_timeout_job', __FILE__)

data/test/fixtures/test_queue_settings.rb

@@ -1,54 +0,0 @@
-class TestJobSettings
-  include Backburner::Queue
-  queue "job-settings:5:10:6"
-  def self.perform; end
-end
-
-class TestJobSettingsOverride
-  include Backburner::Queue
-  queue "job-settings-override:5:10:12"
-  queue_jobs_limit 10
-  queue_garbage_limit 1000
-  queue_retry_limit 2
-  def self.perform; end
-end
-class TestTubeLimitsJob
-  include Backburner::Queue
-  queue "tube-limits"
-  queue_jobs_limit 5
-  queue_garbage_limit 100
-  queue_retry_limit 3
-  def self.perform; end
-end
-
-# Shares its parent's tube, whose options stay the parent's
-class TestTubeLimitsChildJob < TestTubeLimitsJob
-  queue_jobs_limit 1
-  queue_garbage_limit 7
-end
-
-class TestTubeLimitsLambdaJob
-  include Backburner::Queue
-  queue lambda { |klass| "tube-limits-#{klass.name.downcase}" }
-  queue_jobs_limit 3
-  def self.perform; end
-end
-
-# Gets a tube of its own from the inherited lambda, so its options are its own
-class TestTubeLimitsLambdaChildJob < TestTubeLimitsLambdaJob
-  queue_jobs_limit 4
-end
-
-class TestTubeFewLimitsJob
-  include Backburner::Queue
-  queue "tube-few-limits"
-  queue_retry_limit 2
-  def self.perform; end
-end
-
-# Shares its parent's tube and fills in the limits the parent leaves unset
-class TestTubeFewLimitsChildJob < TestTubeFewLimitsJob
-  queue_jobs_limit 3
-  queue_garbage_limit 50
-  queue_retry_limit 9
-end

data/test/helpers/templogger.rb

@@ -1,22 +0,0 @@
-class Templogger
-  attr_reader :logger, :log_path
-
-  def initialize(root_path)
-    @file = Tempfile.new('foo', root_path)
-    @log_path = @file.path
-    @logger = Logger.new(@log_path)
-  end
-
-  # wait_for_match /Completed TestJobFork/m
-  def wait_for_match(match_pattern)
-    sleep 0.1 until self.body =~ match_pattern
-  end
-
-  def body
-    File.read(@log_path)
-  end
-
-  def close
-    @file.close! # unlink it now: a Tempfile finalizer left for GC calls Process.pid, which some tests mock
-  end
-end