inst-jobs 3.1.2 → 3.1.3

data/spec/delayed/worker/health_check_spec.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Delayed::Worker::HealthCheck do
-  let(:klass) { Class.new(Delayed::Worker::HealthCheck) { self.type_name = :test } }
-
-  before do
-    klass # Gotta make sure the class has been defined before we try to use it
-  end
-
-  after do
-    described_class.subclasses.delete(klass)
-  end
-
-  it "must maintain a list of its subclasses" do
-    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 = 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 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 = 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) 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
-
-    let(:initial_run_at) { 10.minutes.ago }
-
-    before do
-      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
-                         })
-      @dead_job = Delayed::Job.last
-      @dead_job.update!({
-                          locked_by: "dead",
-                          locked_at: initial_run_at
-                        })
-      Delayed::Settings.worker_health_check_type = :fake
-      Delayed::Settings.worker_health_check_config = {}
-    end
-
-    after do
-      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
-      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"
-    end
-
-    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")
-      # 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"
-    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(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"
-    end
-
-    it "bails immediately if advisory lock already taken" do
-      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).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
-      expect { klass.new }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/delayed/worker_spec.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../spec_helper"
-
-describe Delayed::Worker do
-  subject { described_class.new(worker_config.dup) }
-
-  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
-      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 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(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(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 do |block|
-      prev_logger = Delayed::Settings.job_detailed_log_format
-      block.call
-      Delayed::Settings.job_detailed_log_format = prev_logger
-    end
-
-    it "has a reasonable default format" do
-      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")
-      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,\"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 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 override format short")
-      long_format = subject.log_job(job, :long)
-      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)
-      subject.run
-    end
-  end
-end

data/spec/migrate/20140924140513_add_story_table.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class AddStoryTable < ActiveRecord::Migration[4.2]
-  def change
-    create_table :stories do |table|
-      table.string :text
-    end
-  end
-end

data/spec/sample_jobs.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-class SimpleJob
-  class << self
-    attr_accessor :runs
-  end
-
-  self.runs = 0
-
-  def perform
-    self.class.runs += 1
-  end
-end
-
-class ErrorJob
-  class << self
-    attr_accessor :runs, :last_error, :failure_runs, :permanent_failure_runs
-  end
-
-  self.runs = 0
-  def perform
-    raise "did not work"
-  end
-
-  self.last_error = nil
-  self.failure_runs = 0
-  def on_failure(error)
-    self.class.last_error = error
-    self.class.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 on_failure(_error)
-    times_to_unlock -= 1
-    :unlock if times_to_unlock <= 0
-  end
-end
-
-class LongRunningJob
-  def perform
-    sleep 250
-  end
-end
-
-module M
-  class ModuleJob
-    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|
-  raise "error deserializing"
-end

data/spec/shared/delayed_batch.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for "Delayed::Batch" do
-  context "batching" do
-    it "batches up all deferrable delayed methods" do
-      later = 1.hour.from_now
-      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)
-      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
-      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 "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)
-    end
-
-    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
-      expect(batch_job.batch?).to be(true)
-      jobs = batch_job.payload_object.jobs
-      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 "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 "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 "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 "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
-      expect(jobs.size).to eq(2)
-    end
-  end
-end