inst-jobs 3.0.8 → 3.1.14

data/spec/delayed/worker_spec.rb

@@ -1,105 +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}") # 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}" }
-      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 override format 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 eq(false)
-      expect(batch_jobs.size).to eq(1)
-      batch_job = batch_jobs.first
-      expect(batch_job.batch?).to eq(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 eq(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

data/spec/shared/delayed_method.rb

@@ -1,287 +0,0 @@
-# frozen_string_literal: true
-
-module UnlessInJob
-  class << self
-    attr_accessor :runs
-
-    def run
-      self.runs += 1
-    end
-
-    def run_later
-      delay(synchronous: Delayed::Job.in_delayed_job?).run
-    end
-  end
-end
-
-shared_examples_for "random ruby objects" do
-  def set_queue(name) # rubocop:disable Naming/AccessorMethodName
-    old_name = Delayed::Settings.queue
-    Delayed::Settings.queue = name
-  ensure
-    Delayed::Settings.queue = old_name
-  end
-
-  it "respond_toes :delay method" do
-    Object.new.respond_to?(:delay)
-  end
-
-  it "raises a ArgumentError if delay is called but the target method doesn't exist" do
-    expect { Object.new.delay.method_that_deos_not_exist }.to raise_error(NoMethodError)
-  end
-
-  it "adds a new entry to the job table when delay is called on it" do
-    expect { Object.new.delay.to_s }.to change { Delayed::Job.jobs_count(:current) }.by(1)
-  end
-
-  it "adds a new entry to the job table when delay is called on it with a queue" do
-    expect { Object.new.delay(queue: "testqueue").to_s }.to change {
-                                                              Delayed::Job.jobs_count(:current, "testqueue")
-                                                            }.by(1)
-  end
-
-  it "adds a new entry to the job table when delay is called on the class" do
-    expect { Object.delay.to_s }.to change { Delayed::Job.jobs_count(:current) }.by(1)
-  end
-
-  it "adds a new entry to the job table when delay is called on the class with a queue" do
-    expect { Object.delay(queue: "testqueue").to_s }.to change { Delayed::Job.jobs_count(:current, "testqueue") }.by(1)
-  end
-
-  context "class methods" do
-    context "handle_asynchronously" do
-      it "works with default_async" do
-        klass = Class.new do
-          attr_reader :ran
-
-          def test_method
-            @ran = true
-          end
-          handle_asynchronously :test_method
-        end
-        obj = klass.new
-        expect { obj.test_method }.to change { Delayed::Job.jobs_count(:current) }.by(1)
-        expect(obj.ran).to be_falsey
-        expect { obj.test_method(synchronous: true) }.not_to(change { Delayed::Job.jobs_count(:current) })
-        expect(obj.ran).to be true
-      end
-
-      it "must work with enqueue args that are lambdas" do
-        klass = Class.new do
-          attr_reader :ran
-
-          def test_method
-            @ran = true
-          end
-          handle_asynchronously :test_method, singleton: ->(obj) { "foobar:#{obj.object_id}" }
-        end
-
-        obj = klass.new
-        expect { obj.test_method }.to change { Delayed::Job.jobs_count(:current) }.by(1)
-      end
-
-      it "must work with kwargs in the original method" do
-        klass = Class.new do
-          attr_reader :run
-
-          def test_method(my_kwarg: nil)
-            @run = my_kwarg
-          end
-          handle_asynchronously :test_method
-
-          def other_test(arg)
-            @foo = arg
-          end
-          handle_asynchronously :other_test
-        end
-
-        obj = klass.new
-        obj.test_method(my_kwarg: "foo", synchronous: true)
-        expect(obj.run).to eq "foo"
-      end
-
-      it "sends along enqueue args and args" do
-        klass = Class.new do
-          attr_accessor :ran
-
-          def test_method(*args)
-            @ran = args
-          end
-          handle_asynchronously(:test_method, enqueue_arg1: :thing)
-        end
-        obj = klass.new
-        method = double
-
-        expect(Delayed::PerformableMethod).to receive(:new)
-          .with(obj,
-                :test_method,
-                args: [1, 2, 3],
-                kwargs: { synchronous: true },
-                on_failure: nil,
-                on_permanent_failure: nil,
-                sender: obj)
-          .and_return(method)
-        expect(Delayed::Job).to receive(:enqueue).with(method, enqueue_arg1: :thing)
-        obj.test_method(1, 2, 3)
-
-        expect(Delayed::PerformableMethod).to receive(:new)
-          .with(obj,
-                :test_method,
-                args: [4],
-                kwargs: { synchronous: true },
-                on_failure: nil,
-                on_permanent_failure: nil,
-                sender: obj)
-          .and_return(method)
-        expect(Delayed::Job).to receive(:enqueue).with(method, enqueue_arg1: :thing)
-        obj.test_method(4)
-
-        expect(obj.ran).to be_nil
-        obj.test_method(7, synchronous: true)
-        expect(obj.ran).to eq([7])
-        obj.ran = nil
-        expect(obj.ran).to eq(nil)
-        obj.test_method(8, 9, synchronous: true)
-        expect(obj.ran).to eq([8, 9])
-      end
-
-      it "handles punctuation correctly" do
-        klass = Class.new do
-          attr_reader :ran
-
-          def test_method?
-            @ran = true
-          end
-          handle_asynchronously :test_method?
-        end
-        obj = klass.new
-        expect { obj.test_method? }.to change { Delayed::Job.jobs_count(:current) }.by(1)
-        expect(obj.ran).to be_falsey
-        expect { obj.test_method?(synchronous: true) }.not_to(change { Delayed::Job.jobs_count(:current) })
-        expect(obj.ran).to be true
-      end
-
-      it "handles assignment punctuation correctly" do
-        klass = Class.new do
-          attr_reader :ran
-
-          def test_method=(val)
-            @ran = val
-          end
-          handle_asynchronously :test_method=
-        end
-        obj = klass.new
-        expect { obj.test_method = 3 }.to change { Delayed::Job.jobs_count(:current) }.by(1)
-        expect(obj.ran).to be_nil
-        expect { obj.send(:test_method=, 5, synchronous: true) }.not_to(change { Delayed::Job.jobs_count(:current) })
-        expect(obj.ran).to eq(5)
-      end
-
-      it "correctlies sort out method accessibility" do
-        klass1 = Class.new do
-          def test_method; end
-          handle_asynchronously :test_method
-        end
-
-        klass2 = Class.new do
-          protected
-
-          def test_method; end
-          handle_asynchronously :test_method
-        end
-
-        klass3 = Class.new do
-          private
-
-          def test_method; end
-          handle_asynchronously :test_method
-        end
-
-        expect(klass1.public_method_defined?(:test_method)).to be true
-        expect(klass2.protected_method_defined?(:test_method)).to be true
-        expect(klass3.private_method_defined?(:test_method)).to be true
-      end
-    end
-  end
-
-  it "calls send later on methods which are wrapped with handle_asynchronously" do
-    story = Story.create text: "Once upon..."
-
-    expect { story.whatever(1, 5) }.to change { Delayed::Job.jobs_count(:current) }.by(1)
-
-    job = Delayed::Job.list_jobs(:current, 1).first
-    expect(job.payload_object.class).to   eq(Delayed::PerformableMethod)
-    expect(job.payload_object.method).to  eq(:whatever)
-    expect(job.payload_object.args).to    eq([1, 5])
-    expect(job.payload_object.kwargs).to  eq({ synchronous: true })
-    expect(job.payload_object.perform).to eq("Once upon...")
-  end
-
-  context "delay" do
-    it "uses the default queue if there is one" do
-      set_queue("testqueue") do
-        "string".delay.reverse
-        job = Delayed::Job.list_jobs(:current, 1).first
-        expect(job.queue).to eq("testqueue")
-
-        "string".delay(queue: nil).reverse
-        job2 = Delayed::Job.list_jobs(:current, 2).last
-        expect(job2.queue).to eq("testqueue")
-      end
-    end
-
-    it "requires a queue" do
-      expect { set_queue(nil) }.to raise_error(ArgumentError)
-    end
-  end
-
-  context "delay with run_at" do
-    it "queues a new job" do
-      expect do
-        "string".delay(run_at: 1.hour.from_now).length
-      end.to change { Delayed::Job.jobs_count(:future) }.by(1)
-    end
-
-    it "schedules the job in the future" do
-      time = 1.hour.from_now
-      "string".delay(run_at: time).length
-      job = Delayed::Job.list_jobs(:future, 1).first
-      expect(job.run_at.to_i).to eq(time.to_i)
-    end
-
-    it "stores payload as PerformableMethod" do
-      "string".delay(run_at: 1.hour.from_now).count("r")
-      job = Delayed::Job.list_jobs(:future, 1).first
-      expect(job.payload_object.class).to   eq(Delayed::PerformableMethod)
-      expect(job.payload_object.method).to  eq(:count)
-      expect(job.payload_object.args).to    eq(["r"])
-      expect(job.payload_object.perform).to eq(1)
-    end
-
-    it "uses the default queue if there is one" do
-      set_queue("testqueue") do
-        "string".delay(run_at: 1.hour.from_now).reverse
-        job = Delayed::Job.list_jobs(:current, 1).first
-        expect(job.queue).to eq("testqueue")
-      end
-    end
-  end
-
-  describe "delay with synchronous argument" do
-    before do
-      UnlessInJob.runs = 0
-    end
-
-    it "performs immediately if in job" do
-      UnlessInJob.delay.run_later
-      job = Delayed::Job.list_jobs(:current, 1).first
-      job.invoke_job
-      expect(UnlessInJob.runs).to eq(1)
-    end
-
-    it "queues up for later if not in job" do
-      UnlessInJob.run_later
-      expect(UnlessInJob.runs).to eq(0)
-    end
-  end
-end

data/spec/shared/performable_method.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples_for "Delayed::PerformableMethod" do
-  it "does not ignore ActiveRecord::RecordNotFound errors because they are not always permanent" do
-    story = Story.create text: "Once upon..."
-    p = Delayed::PerformableMethod.new(story, :tell)
-    story.destroy
-    expect { YAML.load(p.to_yaml) }.to raise_error(Delayed::Backend::RecordNotFound)
-  end
-
-  it "stores the object using native YAML even if its an active record" do
-    story = Story.create text: "Once upon..."
-    p = Delayed::PerformableMethod.new(story, :tell)
-    expect(p.class).to   eq(Delayed::PerformableMethod)
-    expect(p.object).to  eq(story)
-    expect(p.method).to  eq(:tell)
-    expect(p.args).to    eq([])
-    expect(p.perform).to eq("Once upon...")
-  end
-
-  it "allows class methods to be called on ActiveRecord models" do
-    Story.create!(text: "Once upon a...")
-    p = Delayed::PerformableMethod.new(Story, :count)
-    expect { expect(p.send(:perform)).to be 1 }.not_to raise_error
-  end
-
-  it "allows class methods to be called" do
-    p = Delayed::PerformableMethod.new(StoryReader, :reverse, args: ["ohai"])
-    expect { expect(p.send(:perform)).to eq("iaho") }.not_to raise_error
-  end
-
-  it "allows module methods to be called" do
-    p = Delayed::PerformableMethod.new(MyReverser, :reverse, args: ["ohai"])
-    expect { expect(p.send(:perform)).to eq("iaho") }.not_to raise_error
-  end
-
-  it "stores arguments as native YAML if they are active record objects" do
-    story = Story.create text: "Once upon..."
-    reader = StoryReader.new
-    p = Delayed::PerformableMethod.new(reader, :read, args: [story])
-    expect(p.class).to   eq(Delayed::PerformableMethod)
-    expect(p.method).to  eq(:read)
-    expect(p.args).to    eq([story])
-    expect(p.perform).to eq("Epilog: Once upon...")
-  end
-
-  it "deeplies de-AR-ize arguments in full name" do
-    story = Story.create text: "Once upon..."
-    reader = StoryReader.new
-    p = Delayed::PerformableMethod.new(reader, :read, args: [["arg1", story, { [:key, 1] => story }]])
-    expect(p.full_name).to eq(
-      "StoryReader#read([\"arg1\", Story.find(#{story.id}), {[:key, 1] => Story.find(#{story.id})}])"
-    )
-  end
-
-  it "calls the on_failure callback" do
-    story = Story.create text: "wat"
-    p = Delayed::PerformableMethod.new(story, :tell, on_failure: :text=)
-    p.send(:on_failure, "fail")
-    expect(story.text).to eq("fail")
-  end
-
-  it "calls the on_permanent_failure callback" do
-    story = Story.create text: "wat"
-    p = Delayed::PerformableMethod.new(story, :tell, on_permanent_failure: :text=)
-    p.send(:on_permanent_failure, "fail_frd")
-    expect(story.text).to eq("fail_frd")
-  end
-
-  it "can still generate a name with no kwargs" do
-    story = Story.create text: "wat"
-    p = Delayed::PerformableMethod.new(story, :tell, kwargs: nil)
-    expect(p.full_name).to eq("Story.find(#{story.id}).tell()")
-  end
-end