inst-jobs 2.0.0 → 3.1.0

data/spec/delayed/worker/health_check_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Delayed::Worker::HealthCheck do
   let(:klass) { Class.new(Delayed::Worker::HealthCheck) { self.type_name = :test } }
@@ -10,116 +10,124 @@ RSpec.describe Delayed::Worker::HealthCheck do
   end
 
   after do
-    Delayed::Worker::HealthCheck.subclasses.delete(klass)
+    described_class.subclasses.delete(klass)
   end
 
   it "must maintain a list of its subclasses" do
     klass
-    expect(Delayed::Worker::HealthCheck.subclasses).to include klass
+    expect(described_class.subclasses).to include klass
   end
 
-  describe '.build(type:, config: {})' do
-    it 'must select the concrete class to use by the type_name in the subclass' do
-      check = Delayed::Worker::HealthCheck.build(type: 'test', worker_name: 'foobar')
+  describe ".build(type:, config: {})" do
+    it "must select the concrete class to use by the type_name in the subclass" do
+      check = described_class.build(type: "test", worker_name: "foobar")
       expect(check).to be_a(klass)
     end
 
     it "must raise ArgumentError when the specified type doesn't exist" do
-      expect {
-        Delayed::Worker::HealthCheck.build(type: 'nope', config: {worker_name: 'foobar'})
-      }.to raise_error ArgumentError
+      expect do
+        described_class.build(type: "nope", config: { worker_name: "foobar" })
+      end.to raise_error ArgumentError
     end
 
-    it 'must initiaize the specified class using the supplied config' do
-      config = {foo: 'bar'}.with_indifferent_access
-      check = Delayed::Worker::HealthCheck.build(type: 'test', worker_name: 'foobar', config: config)
+    it "must initiaize the specified class using the supplied config" do
+      config = { foo: "bar" }.with_indifferent_access
+      check = described_class.build(type: "test", worker_name: "foobar", config: config)
       expect(check.config).to eq config
     end
   end
 
-  describe '.reschedule_abandoned_jobs' do
-    let(:klass) { Class.new(Delayed::Worker::HealthCheck) {
-      self.type_name = :fake
-      class << self
-        attr_accessor :live_workers
+  describe ".reschedule_abandoned_jobs" do
+    let(:klass) do
+      Class.new(Delayed::Worker::HealthCheck) do
+        self.type_name = :fake
+        class << self
+          attr_accessor :live_workers
+        end
+
+        def live_workers
+          self.class.live_workers
+        end
       end
+    end
 
-      def live_workers
-        self.class.live_workers
-      end
-    } }
-
-    let(:initial_run_at) { Time.zone.now }
+    let(:initial_run_at) { 10.minutes.ago }
 
     before do
-      klass.live_workers = %w{alive}
+      klass.live_workers = %w[alive]
       Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
 
       2.times { Delayed::Job.enqueue(SimpleJob.new, run_at: initial_run_at, max_attempts: 4) }
       @alive_job = Delayed::Job.first
       @alive_job.update!({
-        locked_by: 'alive',
-        locked_at: initial_run_at
-      })
+                           locked_by: "alive",
+                           locked_at: initial_run_at
+                         })
       @dead_job = Delayed::Job.last
       @dead_job.update!({
-        locked_by: 'dead',
-        locked_at: initial_run_at
-      })
+                          locked_by: "dead",
+                          locked_at: initial_run_at
+                        })
       Delayed::Settings.worker_health_check_type = :fake
       Delayed::Settings.worker_health_check_config = {}
     end
 
     after do
-      Delayed::Worker::HealthCheck.subclasses.delete(klass)
+      described_class.subclasses.delete(klass)
       Delayed::Settings.worker_health_check_type = :none
       Delayed::Settings.worker_health_check_config = {}
     end
 
-    it 'must leave jobs locked by live workers alone' do
-      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+    it "must leave jobs locked by live workers alone" do
+      described_class.reschedule_abandoned_jobs
       @alive_job.reload
       expect(@alive_job.run_at.to_i).to eq initial_run_at.to_i
       expect(@alive_job.locked_at.to_i).to eq initial_run_at.to_i
-      expect(@alive_job.locked_by).to eq 'alive'
+      expect(@alive_job.locked_by).to eq "alive"
     end
 
-    it 'must reschedule jobs locked by dead workers' do
-      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+    it "must reschedule jobs locked by dead workers" do
+      described_class.reschedule_abandoned_jobs
       @dead_job.reload
       expect(@dead_job.run_at).to be > initial_run_at
       expect(@dead_job.locked_at).to be_nil
       expect(@dead_job.locked_by).to be_nil
     end
 
-    it 'ignores jobs that are re-locked after fetching from db' do
-      Delayed::Job.where(id: @dead_job).update_all(locked_by: 'someone_else')
-      allow(Delayed::Job).to receive(:running_jobs).and_return([@dead_job])
-      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+    it "ignores jobs that are re-locked after fetching from db" do
+      Delayed::Job.where(id: @dead_job).update_all(locked_by: "someone_else")
+      # we need to return @dead_job itself, which doesn't match the database
+      jobs_scope = double
+      allow(jobs_scope).to receive(:where).and_return(jobs_scope)
+      allow(jobs_scope).to receive(:not).and_return(jobs_scope)
+      allow(jobs_scope).to receive(:limit).and_return(jobs_scope)
+      allow(jobs_scope).to receive(:to_a).and_return([@dead_job], [])
+      allow(Delayed::Job).to receive(:running_jobs).and_return(jobs_scope)
+      described_class.reschedule_abandoned_jobs
       @dead_job.reload
-      expect(@dead_job.locked_by).to eq 'someone_else'
+      expect(@dead_job.locked_by).to eq "someone_else"
     end
 
-    it 'ignores jobs that are prefetched' do
-      Delayed::Job.where(id: @dead_job).update_all(locked_by: 'prefetch:some_node')
-      allow(Delayed::Job).to receive(:running_jobs).and_return([@dead_job])
-      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+    it "ignores jobs that are prefetched" do
+      Delayed::Job.where(id: @dead_job).update_all(locked_by: "prefetch:some_node")
+      allow(Delayed::Job).to receive(:running_jobs).and_return(Delayed::Job.where(id: @dead_job.id))
+      described_class.reschedule_abandoned_jobs
       @dead_job.reload
-      expect(@dead_job.locked_by).to eq 'prefetch:some_node'
+      expect(@dead_job.locked_by).to eq "prefetch:some_node"
     end
 
     it "bails immediately if advisory lock already taken" do
-      allow(Delayed::Worker::HealthCheck).to receive(:attempt_advisory_lock).and_return(false)
-      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+      allow(Delayed::Job).to receive(:attempt_advisory_lock).and_return(false)
+      described_class.reschedule_abandoned_jobs
       @dead_job.reload
       expect(@dead_job.run_at.to_i).to eq(initial_run_at.to_i)
-      expect(@dead_job.locked_at).to_not be_nil
-      expect(@dead_job.locked_by).to_not be_nil
+      expect(@dead_job.locked_at).not_to be_nil
+      expect(@dead_job.locked_by).not_to be_nil
     end
   end
 
-  describe '#initialize' do
-    it 'must raise ArgumentError when the worker name is not supplied' do
+  describe "#initialize" do
+    it "must raise ArgumentError when the worker name is not supplied" do
       expect { klass.new }.to raise_error ArgumentError
     end
   end

data/spec/delayed/worker_spec.rb

@@ -3,45 +3,73 @@
 require_relative "../spec_helper"
 
 describe Delayed::Worker do
-  let(:worker_config) { {
-      queue: "test", min_priority: 1, max_priority: 2, stuff: "stuff",
-  }.freeze }
   subject { described_class.new(worker_config.dup) }
 
-  after { Delayed::Worker.lifecycle.reset! }
+  let(:worker_config) do
+    {
+      queue: "test", min_priority: 1, max_priority: 2, stuff: "stuff"
+    }.freeze
+  end
+  let(:job_attrs) do
+    {
+      id: 42, name: "testjob", full_name: "testfullname", :last_error= => nil,
+      attempts: 1, reschedule: nil, :expired? => false,
+      payload_object: {}, priority: 25
+    }.freeze
+  end
+
+  after { described_class.lifecycle.reset! }
 
   describe "#perform" do
     it "fires off an error callback when a job raises an exception" do
       fired = false
-      Delayed::Worker.lifecycle.before(:error) {|worker, exception| fired = true}
-      job = double(:last_error= => nil, attempts: 1, reschedule: nil)
-      subject.perform(job)
+      described_class.lifecycle.before(:error) { |_worker, _exception| fired = true }
+      job = double(job_attrs)
+      output_count = subject.perform(job)
       expect(fired).to be_truthy
+      expect(output_count).to eq(1)
+    end
+
+    it "uses the retry callback for a retriable exception" do
+      error_fired = retry_fired = false
+      described_class.lifecycle.before(:error) { |_worker, _exception| error_fired = true }
+      described_class.lifecycle.before(:retry) { |_worker, _exception| retry_fired = true }
+      job = Delayed::Job.new(payload_object: {}, priority: 25, strand: "test_jobs", max_attempts: 3)
+      expect(job).to receive(:invoke_job) do
+        raise Delayed::RetriableError, "that's all this job does"
+      end
+      output_count = subject.perform(job)
+      expect(error_fired).to be_falsey
+      expect(retry_fired).to be_truthy
+      expect(output_count).to eq(1)
     end
 
-    it "reloads" do
-      fakeApplication = double('Rails.application',
-          config: double('Rails.application.config',
-          cache_classes: false,
-          reload_classes_only_on_change: false
-        ),
-        reloader: double()
-      )
+    it "reloads Rails classes (never more than once)" do
+      fake_application = double("Rails.application",
+                                config: double("Rails.application.config",
+                                               cache_classes: false,
+                                               reload_classes_only_on_change: false),
+                                reloader: double)
 
-      allow(Rails).to receive(:application).and_return(fakeApplication)
+      allow(Rails).to receive(:application).and_return(fake_application)
       if Rails::VERSION::MAJOR >= 5
         expect(Rails.application.reloader).to receive(:reload!).once
       else
         expect(ActionDispatch::Reloader).to receive(:prepare!).once
         expect(ActionDispatch::Reloader).to receive(:cleanup!).once
       end
-      job = double(:last_error= => nil, attempts: 0, reschedule: nil, expired?: false)
+      job = double(job_attrs)
+
+      # Create extra workers to make sure we don't reload multiple times
+      described_class.new(worker_config.dup)
+      described_class.new(worker_config.dup)
+
       subject.perform(job)
     end
   end
 
   describe "#log_job" do
-    around(:each) do |block|
+    around do |block|
       prev_logger = Delayed::Settings.job_detailed_log_format
       block.call
       Delayed::Settings.job_detailed_log_format = prev_logger
@@ -53,24 +81,25 @@ describe Delayed::Worker do
       short_log_format = subject.log_job(job, :short)
       expect(short_log_format).to eq("RSpec::Mocks::Double")
       long_format = subject.log_job(job, :long)
-      expect(long_format).to eq("RSpec::Mocks::Double {\"priority\":25,\"attempts\":0,\"created_at\":null,\"tag\":\"RSpec::Mocks::Double#perform\",\"max_attempts\":null,\"strand\":\"test_jobs\",\"source\":null}")
+      expect(long_format).to eq("RSpec::Mocks::Double {\"priority\":25,\"attempts\":0,\"created_at\":null,\"tag\":\"RSpec::Mocks::Double#perform\",\"max_attempts\":null,\"strand\":\"test_jobs\",\"source\":null,\"singleton\":null}") # rubocop:disable Layout/LineLength
     end
 
     it "logging format can be changed with settings" do
-      Delayed::Settings.job_detailed_log_format = ->(job){ "override format #{job.strand}"}
+      Delayed::Settings.job_detailed_log_format = ->(job) { "override format detailed #{job.strand}" }
+      Delayed::Settings.job_short_log_format = ->(_job) { "override format short" }
       payload = double(perform: nil)
       job = Delayed::Job.new(payload_object: payload, priority: 25, strand: "test_jobs")
       short_log_format = subject.log_job(job, :short)
-      expect(short_log_format).to eq("RSpec::Mocks::Double")
+      expect(short_log_format).to eq("RSpec::Mocks::Double override format short")
       long_format = subject.log_job(job, :long)
-      expect(long_format).to eq("RSpec::Mocks::Double override format test_jobs")
+      expect(long_format).to eq("RSpec::Mocks::Double override format detailed test_jobs")
     end
   end
 
   describe "#run" do
     it "passes extra config options through to the WorkQueue" do
-      expect(subject.work_queue).to receive(:get_and_lock_next_available).
-        with(subject.name, worker_config).and_return(nil)
+      expect(subject.work_queue).to receive(:get_and_lock_next_available)
+        .with(subject.name, worker_config).and_return(nil)
       subject.run
     end
   end

data/spec/sample_jobs.rb

@@ -1,49 +1,79 @@
 # frozen_string_literal: true
 
 class SimpleJob
-  cattr_accessor :runs; self.runs = 0
-  def perform; @@runs += 1; end
+  class << self
+    attr_accessor :runs
+  end
+
+  self.runs = 0
+
+  def perform
+    self.class.runs += 1
+  end
 end
 
 class ErrorJob
-  cattr_accessor :runs; self.runs = 0
-  def perform; raise 'did not work'; end
+  class << self
+    attr_accessor :runs, :last_error, :failure_runs, :permanent_failure_runs
+  end
 
-  cattr_accessor :last_error; self.last_error = nil
+  self.runs = 0
+  def perform
+    raise "did not work"
+  end
 
-  cattr_accessor :failure_runs; self.failure_runs = 0
-  def on_failure(error); @@last_error = error; @@failure_runs += 1; end
+  self.last_error = nil
+  self.failure_runs = 0
+  def on_failure(error)
+    self.class.last_error = error
+    self.class.failure_runs += 1
+  end
 
-  cattr_accessor :permanent_failure_runs; self.permanent_failure_runs = 0
-  def on_permanent_failure(error); @@last_error = error; @@permanent_failure_runs += 1; end
+  self.permanent_failure_runs = 0
+  def on_permanent_failure(error)
+    self.class.last_error = error
+    self.class.permanent_failure_runs += 1
+  end
 end
 
 class UnlockJob
   attr_accessor :times_to_unlock
+
   def initialize(times_to_unlock)
     @times_to_unlock = times_to_unlock
   end
 
-  def perform; raise SystemExit, 'raising to trigger on_failure'; end
+  def perform
+    raise SystemExit, "raising to trigger on_failure"
+  end
 
-  def on_failure(error)
+  def on_failure(_error)
     times_to_unlock -= 1
     :unlock if times_to_unlock <= 0
   end
 end
 
 class LongRunningJob
-  def perform; sleep 250; end
+  def perform
+    sleep 250
+  end
 end
 
 module M
   class ModuleJob
-    cattr_accessor :runs; self.runs = 0
-    def perform; @@runs += 1; end
+    class << self
+      attr_accessor :runs
+    end
+
+    cattr_accessor :runs
+    self.runs = 0
+    def perform
+      self.class.runs += 1
+    end
   end
 end
 
 class DeserializeErrorJob < SimpleJob; end
-Psych.add_domain_type("ruby/object", "DeserializeErrorJob") do |_type, val|
+Psych.add_domain_type("ruby/object", "DeserializeErrorJob") do |_type, _val|
   raise "error deserializing"
 end

data/spec/shared/delayed_batch.rb

@@ -1,98 +1,105 @@
 # frozen_string_literal: true
 
-shared_examples_for 'Delayed::Batch' do
+shared_examples_for "Delayed::Batch" do
   context "batching" do
-    it "should batch up all deferrable delayed methods" do
+    it "batches up all deferrable delayed methods" do
       later = 1.hour.from_now
-      Delayed::Batch.serial_batch {
-        "string".delay(ignore_transaction: true).size.should be true
-        "string".delay(run_at: later, ignore_transaction: true).reverse.should be_truthy # won't be batched, it'll get its own job
-        "string".delay(ignore_transaction: true).gsub(/./, "!").should be_truthy
-      }
+      Delayed::Batch.serial_batch do
+        expect("string".delay(ignore_transaction: true).size).to be true
+        # won't be batched, it'll get its own job
+        expect("string".delay(run_at: later, ignore_transaction: true).reverse).to be_truthy
+        expect("string".delay(ignore_transaction: true).gsub(/./, "!")).to be_truthy
+      end
       batch_jobs = Delayed::Job.find_available(5)
       regular_jobs = Delayed::Job.list_jobs(:future, 5)
-      regular_jobs.size.should == 1
-      regular_jobs.first.batch?.should == false
-      batch_jobs.size.should == 1
+      expect(regular_jobs.size).to eq(1)
+      expect(regular_jobs.first.batch?).to be(false)
+      expect(batch_jobs.size).to eq(1)
       batch_job = batch_jobs.first
-      batch_job.batch?.should == true
-      batch_job.payload_object.mode.should  == :serial
-      batch_job.payload_object.jobs.map { |j| [j.payload_object.object, j.payload_object.method, j.payload_object.args] }.should  == [
-        ["string", :size, []],
-        ["string", :gsub, [/./, "!"]]
-      ]
+      expect(batch_job.batch?).to be(true)
+      expect(batch_job.payload_object.mode).to eq(:serial)
+      expect(batch_job.payload_object.jobs.map do |j|
+               [j.payload_object.object, j.payload_object.method, j.payload_object.args]
+             end).to eq([
+                          [
+                            "string", :size, []
+                          ],
+                          [
+                            "string", :gsub, [
+                              /./, "!"
+                            ]
+                          ]
+                        ])
     end
 
-    it "should not let you invoke it directly" do
-      later = 1.hour.from_now
-      Delayed::Batch.serial_batch {
-        "string".delay(ignore_transaction: true).size.should be true
-        "string".delay(ignore_transaction: true).gsub(/./, "!").should be true
-      }
-      Delayed::Job.jobs_count(:current).should == 1
+    it "does not let you invoke it directly" do
+      Delayed::Batch.serial_batch do
+        expect("string".delay(ignore_transaction: true).size).to be true
+        expect("string".delay(ignore_transaction: true).gsub(/./, "!")).to be true
+      end
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
       job = Delayed::Job.find_available(1).first
-      expect{ job.invoke_job }.to raise_error(RuntimeError)
+      expect { job.invoke_job }.to raise_error(RuntimeError)
     end
 
-    it "should create valid jobs" do
-      Delayed::Batch.serial_batch {
-        "string".delay(ignore_transaction: true).size.should be true
-        "string".delay(ignore_transaction: true).gsub(/./, "!").should be true
-      }
-      Delayed::Job.jobs_count(:current).should == 1
+    it "creates valid jobs" do
+      Delayed::Batch.serial_batch do
+        expect("string".delay(ignore_transaction: true).size).to be true
+        expect("string".delay(ignore_transaction: true).gsub(/./, "!")).to be true
+      end
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
 
       batch_job = Delayed::Job.find_available(1).first
-      batch_job.batch?.should == true
+      expect(batch_job.batch?).to be(true)
       jobs = batch_job.payload_object.jobs
-      jobs.size.should == 2
-      jobs[0].should be_new_record
-      jobs[0].payload_object.class.should   == Delayed::PerformableMethod
-      jobs[0].payload_object.method.should  == :size
-      jobs[0].payload_object.args.should    == []
-      jobs[0].payload_object.perform.should == 6
-      jobs[1].should be_new_record
-      jobs[1].payload_object.class.should   == Delayed::PerformableMethod
-      jobs[1].payload_object.method.should  == :gsub
-      jobs[1].payload_object.args.should    == [/./, "!"]
-      jobs[1].payload_object.perform.should == "!!!!!!"
+      expect(jobs.size).to eq(2)
+      expect(jobs[0]).to be_new_record
+      expect(jobs[0].payload_object.class).to   eq(Delayed::PerformableMethod)
+      expect(jobs[0].payload_object.method).to  eq(:size)
+      expect(jobs[0].payload_object.args).to    eq([])
+      expect(jobs[0].payload_object.perform).to eq(6)
+      expect(jobs[1]).to be_new_record
+      expect(jobs[1].payload_object.class).to   eq(Delayed::PerformableMethod)
+      expect(jobs[1].payload_object.method).to  eq(:gsub)
+      expect(jobs[1].payload_object.args).to    eq([/./, "!"])
+      expect(jobs[1].payload_object.perform).to eq("!!!!!!")
     end
 
-    it "should create a different batch for each priority" do
-      later = 1.hour.from_now
-      Delayed::Batch.serial_batch {
-        "string".delay(priority: Delayed::LOW_PRIORITY, ignore_transaction: true).size.should be true
-        "string".delay(ignore_transaction: true).gsub(/./, "!").should be true
-      }
-      Delayed::Job.jobs_count(:current).should == 2
+    it "creates a different batch for each priority" do
+      Delayed::Batch.serial_batch do
+        expect("string".delay(priority: Delayed::LOW_PRIORITY, ignore_transaction: true).size).to be true
+        expect("string".delay(ignore_transaction: true).gsub(/./, "!")).to be true
+      end
+      expect(Delayed::Job.jobs_count(:current)).to eq(2)
     end
 
-    it "should use the given priority for all, if specified" do
-      Delayed::Batch.serial_batch(:priority => 11) {
-        "string".delay(priority: 20, ignore_transaction: true).size.should be true
-        "string".delay(priority: 15, ignore_transaction: true).gsub(/./, "!").should be true
-      }
-      Delayed::Job.jobs_count(:current).should == 1
-      Delayed::Job.find_available(1).first.priority.should == 11
+    it "uses the given priority for all, if specified" do
+      Delayed::Batch.serial_batch(priority: 11) do
+        expect("string".delay(priority: 20, ignore_transaction: true).size).to be true
+        expect("string".delay(priority: 15, ignore_transaction: true).gsub(/./, "!")).to be true
+      end
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
+      expect(Delayed::Job.find_available(1).first.priority).to eq(11)
     end
 
-    it "should just create the job, if there's only one in the batch" do
-      Delayed::Batch.serial_batch(:priority => 11) {
-        "string".delay(ignore_transaction: true).size.should be true
-      }
-      Delayed::Job.jobs_count(:current).should == 1
-      Delayed::Job.find_available(1).first.tag.should == "String#size"
-      Delayed::Job.find_available(1).first.priority.should == 11
+    it "justs create the job, if there's only one in the batch" do
+      Delayed::Batch.serial_batch(priority: 11) do
+        expect("string".delay(ignore_transaction: true).size).to be true
+      end
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
+      expect(Delayed::Job.find_available(1).first.tag).to eq("String#size")
+      expect(Delayed::Job.find_available(1).first.priority).to eq(11)
     end
 
-    it "should list a job only once when the same call is made multiple times" do
-      Delayed::Batch.serial_batch(:priority => 11) {
+    it "lists a job only once when the same call is made multiple times" do
+      Delayed::Batch.serial_batch(priority: 11) do
         "string".delay(ignore_transaction: true).size
         "string".delay(ignore_transaction: true).gsub(/./, "!")
         "string".delay(ignore_transaction: true).size
-      }
+      end
       batch_job = Delayed::Job.find_available(1).first
       jobs = batch_job.payload_object.jobs
-      jobs.size.should == 2
+      expect(jobs.size).to eq(2)
     end
   end
 end