inst-jobs 3.0.8 → 3.1.11

data/spec/shared/testing.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-class TestingWorker
-  cattr_accessor :runs
-
-  def self.run
-    self.runs += 1
-  end
-end
-
-shared_examples_for "Delayed::Testing" do
-  before do
-    TestingWorker.runs = 0
-  end
-
-  describe ".run_job" do
-    it "runs a single queued job" do
-      job = TestingWorker.delay(ignore_transaction: true).run
-      Delayed::Testing.run_job(job)
-      expect(TestingWorker.runs).to eq 1
-    end
-  end
-
-  describe ".drain" do
-    it "runs all queued jobs" do
-      3.times { TestingWorker.delay.run }
-      YAML.dump(TestingWorker)
-      Delayed::Testing.drain
-      expect(TestingWorker.runs).to eq 3
-    end
-  end
-
-  describe "track_created" do
-    it "returns the list of jobs created in the block" do
-      3.times { TestingWorker.delay.run }
-      jobs = Delayed::Testing.track_created { 2.times { TestingWorker.delay.run } }
-      expect(jobs.size).to eq 2
-      expect(jobs.first.tag).to eq "TestingWorker.run"
-    end
-  end
-
-  describe "clear_all!" do
-    it "deletes all queued jobs" do
-      3.times { TestingWorker.delay.run }
-      Delayed::Testing.clear_all!
-      Delayed::Testing.drain
-      expect(TestingWorker.runs).to eq 0
-    end
-  end
-end

data/spec/shared/worker.rb

@@ -1,413 +0,0 @@
-# frozen_string_literal: true
-
-class TestPlugin < ::Delayed::Plugin
-  cattr_accessor :runs
-  self.runs = 0
-  callbacks do |lifecycle|
-    lifecycle.around(:invoke_job) do |job, *args, &block|
-      TestPlugin.runs += 1
-      block.call(job, *args)
-    end
-  end
-end
-
-shared_examples_for "Delayed::Worker" do
-  def job_create(opts = {})
-    Delayed::Job.create({ payload_object: SimpleJob.new, queue: Delayed::Settings.queue }.merge(opts))
-  end
-
-  def worker_create(opts = {})
-    Delayed::Worker.new(opts.merge(max_priority: nil, min_priority: nil, quiet: true))
-  end
-
-  before do
-    @worker = worker_create
-    SimpleJob.runs = 0
-    Delayed::Worker.on_max_failures = nil
-    Delayed::Settings.sleep_delay = -> { 0.01 }
-  end
-
-  after do
-    Delayed::Settings.sleep_delay = 2.0
-  end
-
-  describe "running a job" do
-    it "does not fail when running a job with a % in the name" do
-      @job = "Some % Name here".delay(ignore_transaction: true).start_with?("Some % Name")
-      @worker.perform(@job)
-    end
-  end
-
-  describe "running a batch" do
-    context "serially" do
-      before do
-        @runs = 0
-        Delayed::Worker.lifecycle.after(:perform) { @runs += 1 }
-      end
-
-      after do
-        Delayed::Worker.lifecycle.reset!
-      end
-
-      it "runs each job in order" do
-        bar = +"bar"
-        expect(bar).to receive(:scan).with("b").ordered
-        expect(bar).to receive(:scan).with("a").ordered
-        expect(bar).to receive(:scan).with("r").ordered
-        batch = Delayed::Batch::PerformableBatch.new(:serial, [
-                                                       { payload_object: Delayed::PerformableMethod.new(bar, :scan,
-                                                                                                        args: ["b"]) },
-                                                       { payload_object: Delayed::PerformableMethod.new(bar, :scan,
-                                                                                                        args: ["a"]) },
-                                                       { payload_object: Delayed::PerformableMethod.new(bar, :scan,
-                                                                                                        args: ["r"]) }
-                                                     ])
-
-        batch_job = Delayed::Job.create payload_object: batch
-        expect(@worker.perform(batch_job)).to eq(3)
-        expect(@runs).to be 4 # batch, plus all jobs
-      end
-
-      it "succeeds regardless of the success/failure of its component jobs" do
-        change_setting(Delayed::Settings, :max_attempts, 2) do
-          batch = Delayed::Batch::PerformableBatch.new(:serial, [
-                                                         { payload_object: Delayed::PerformableMethod.new("foo",
-                                                                                                          :reverse) },
-                                                         { payload_object: Delayed::PerformableMethod.new(1, :/,
-                                                                                                          args: [0]) },
-                                                         { payload_object: Delayed::PerformableMethod.new("bar", :scan,
-                                                                                                          args: ["r"]) }
-                                                       ])
-          batch_job = Delayed::Job.create payload_object: batch
-
-          expect(@worker.perform(batch_job)).to eq(3)
-          expect(@runs).to be 3 # batch, plus two successful jobs
-
-          to_retry = Delayed::Job.list_jobs(:future, 100)
-          expect(to_retry.size).to be 1
-          expect(to_retry[0].payload_object.method).to be :/
-          expect(to_retry[0].last_error).to match(/divided by 0/)
-          expect(to_retry[0].attempts).to eq(1)
-        end
-      end
-
-      it "retries a failed individual job" do
-        batch = Delayed::Batch::PerformableBatch.new(:serial, [
-                                                       { payload_object: Delayed::PerformableMethod.new(1,
-                                                                                                        :/,
-                                                                                                        args: [0]) }
-                                                     ])
-        batch_job = Delayed::Job.create payload_object: batch
-
-        expect_any_instance_of(Delayed::Job).to receive(:reschedule).once
-        expect(@worker.perform(batch_job)).to eq(1)
-        expect(@runs).to be 1 # just the batch
-      end
-    end
-  end
-
-  context "worker prioritization" do
-    before do
-      @worker = Delayed::Worker.new(max_priority: 5, min_priority: 2, quiet: true)
-    end
-
-    it "onlies run jobs that are >= min_priority" do
-      expect(SimpleJob.runs).to eq(0)
-
-      job_create(priority: 1)
-      job_create(priority: 3)
-      @worker.run
-
-      expect(SimpleJob.runs).to eq(1)
-    end
-
-    it "onlies run jobs that are <= max_priority" do
-      expect(SimpleJob.runs).to eq(0)
-
-      job_create(priority: 10)
-      job_create(priority: 4)
-
-      @worker.run
-
-      expect(SimpleJob.runs).to eq(1)
-    end
-  end
-
-  context "while running with locked jobs" do
-    it "does not run jobs locked by another worker" do
-      job_create(locked_by: "other_worker", locked_at: (Delayed::Job.db_time_now - 1.minute))
-      expect { @worker.run }.not_to(change(SimpleJob, :runs))
-    end
-
-    it "runs open jobs" do
-      job_create
-      expect { @worker.run }.to change(SimpleJob, :runs).from(0).to(1)
-    end
-  end
-
-  describe "failed jobs" do
-    before do
-      # reset defaults
-      Delayed::Settings.max_attempts = 25
-      @job = Delayed::Job.enqueue ErrorJob.new
-    end
-
-    it "records last_error when destroy_failed_jobs = false, max_attempts = 1" do
-      Delayed::Worker.on_max_failures = proc { false }
-      @job.max_attempts = 1
-      @job.save!
-      expect(job = Delayed::Job.get_and_lock_next_available("w1")).to eq(@job)
-      @worker.perform(job)
-      old_id = @job.id
-      @job = Delayed::Job.list_jobs(:failed, 1).first
-      expect(@job.original_job_id).to eq(old_id)
-      expect(@job.last_error).to match(/did not work/)
-      expect(@job.last_error).to match(%r{shared/worker.rb})
-      expect(@job.attempts).to eq(1)
-      expect(@job.failed_at).not_to be_nil
-      expect(@job.run_at).to be > Delayed::Job.db_time_now - 10.minutes
-      expect(@job.run_at).to be < Delayed::Job.db_time_now + 10.minutes
-      # job stays locked after failing, for record keeping of time/worker
-      expect(@job).to be_locked
-
-      expect(Delayed::Job.find_available(100, @job.queue)).to eq([])
-    end
-
-    it "re-schedules jobs after failing" do
-      @worker.perform(@job)
-      @job = Delayed::Job.find(@job.id)
-      expect(@job.last_error).to match(/did not work/)
-      expect(@job.last_error).to match(/sample_jobs.rb:22:in `perform'/)
-      expect(@job.attempts).to eq(1)
-      expect(@job.run_at).to be > Delayed::Job.db_time_now - 10.minutes
-      expect(@job.run_at).to be < Delayed::Job.db_time_now + 10.minutes
-    end
-
-    it "accepts :unlock return value from on_failure during reschedule and unlock the job" do
-      expect_any_instance_of(Delayed::Job).to receive(:unlock).once
-      @job = Delayed::Job.enqueue(UnlockJob.new(1))
-      @worker.perform(@job)
-    end
-
-    it "notifies jobs on failure" do
-      ErrorJob.failure_runs = 0
-      @worker.perform(@job)
-      expect(ErrorJob.failure_runs).to eq(1)
-    end
-
-    it "notifies jobs on permanent failure" do
-      (Delayed::Settings.max_attempts - 1).times { @job.reschedule }
-      ErrorJob.permanent_failure_runs = 0
-      @worker.perform(@job)
-      expect(ErrorJob.permanent_failure_runs).to eq(1)
-    end
-  end
-
-  context "reschedule" do
-    before do
-      @job = Delayed::Job.create payload_object: SimpleJob.new
-    end
-
-    context "and we want to destroy jobs" do
-      it "is destroyed if it failed more than Settings.max_attempts times" do
-        expect(@job).to receive(:destroy)
-        Delayed::Settings.max_attempts.times { @job.reschedule }
-      end
-
-      it "is not destroyed if failed fewer than Settings.max_attempts times" do
-        expect(@job).not_to receive(:destroy)
-        (Delayed::Settings.max_attempts - 1).times { @job.reschedule }
-      end
-
-      it "is destroyed if failed more than Job#max_attempts times" do
-        Delayed::Settings.max_attempts = 25
-        expect(@job).to receive(:destroy)
-        @job.max_attempts = 2
-        @job.save!
-        2.times { @job.reschedule }
-      end
-
-      it "is destroyed if it has expired" do
-        job = Delayed::Job.create payload_object: SimpleJob.new, expires_at: Delayed::Job.db_time_now - 1.day
-        expect(job).to receive(:destroy)
-        job.reschedule
-      end
-    end
-
-    context "and we don't want to destroy jobs" do
-      before do
-        Delayed::Worker.on_max_failures = proc { false }
-      end
-
-      after do
-        Delayed::Worker.on_max_failures = nil
-      end
-
-      it "is failed if it failed more than Settings.max_attempts times" do
-        expect(@job.failed_at).to eq(nil)
-        Delayed::Settings.max_attempts.times { @job.reschedule }
-        expect(Delayed::Job.list_jobs(:failed, 100).size).to eq(1)
-      end
-
-      it "is not failed if it failed fewer than Settings.max_attempts times" do
-        (Delayed::Settings.max_attempts - 1).times { @job.reschedule }
-        @job = Delayed::Job.find(@job.id)
-        expect(@job.failed_at).to eq(nil)
-      end
-
-      it "is failed if it has expired" do
-        job = Delayed::Job.create payload_object: SimpleJob.new, expires_at: Delayed::Job.db_time_now - 1.day
-        expect(job).to receive(:fail!)
-        job.reschedule
-      end
-    end
-
-    context "and we give an on_max_failures callback" do
-      it "is failed max_attempts times and cb is false" do
-        Delayed::Worker.on_max_failures = proc do |job, _ex|
-          expect(job).to eq(@job)
-          false
-        end
-        expect(@job).to receive(:fail!)
-        Delayed::Settings.max_attempts.times { @job.reschedule }
-      end
-
-      it "is destroyed if it failed max_attempts times and cb is true" do
-        Delayed::Worker.on_max_failures = proc do |job, _ex|
-          expect(job).to eq(@job)
-          true
-        end
-        expect(@job).to receive(:destroy)
-        Delayed::Settings.max_attempts.times { @job.reschedule }
-      end
-    end
-  end
-
-  context "Queue workers" do
-    before do
-      Delayed::Settings.queue = "Queue workers test"
-      job_create(queue: "queue1")
-      job_create(queue: "queue2")
-    end
-
-    it "onlies work off jobs assigned to themselves" do
-      worker = worker_create(queue: "queue1")
-      expect(SimpleJob.runs).to eq(0)
-      worker.run
-      expect(SimpleJob.runs).to eq(1)
-
-      SimpleJob.runs = 0
-
-      worker = worker_create(queue: "queue2")
-      expect(SimpleJob.runs).to eq(0)
-      worker.run
-      expect(SimpleJob.runs).to eq(1)
-    end
-
-    it "does not work off jobs not assigned to themselves" do
-      worker = worker_create(queue: "queue3")
-
-      expect(SimpleJob.runs).to eq(0)
-      worker.run
-      expect(SimpleJob.runs).to eq(0)
-    end
-
-    it "gets the default queue if none is set" do
-      queue_name = "default_queue"
-      Delayed::Settings.queue = queue_name
-      worker = worker_create(queue: nil)
-      expect(worker.queue_name).to eq(queue_name)
-    end
-
-    it "overrides default queue name if specified in initialize" do
-      queue_name = "my_queue"
-      Delayed::Settings.queue = "default_queue"
-      worker = worker_create(queue: queue_name)
-      expect(worker.queue_name).to eq(queue_name)
-    end
-  end
-
-  context "plugins" do
-    it "creates and call the plugin callbacks" do
-      TestPlugin.runs = 0
-      Delayed::Worker.plugins << TestPlugin
-      job_create
-      @worker = Delayed::Worker.new(quiet: true)
-      @worker.run
-      expect(TestPlugin.runs).to eq(1)
-      expect(SimpleJob.runs).to eq(1)
-    end
-  end
-
-  describe "expires_at" do
-    it "runs non-expired jobs" do
-      Delayed::Job.enqueue SimpleJob.new, expires_at: Delayed::Job.db_time_now + 1.day
-      expect { @worker.run }.to change(SimpleJob, :runs).by(1)
-    end
-
-    it "does not run expired jobs" do
-      Delayed::Job.enqueue SimpleJob.new, expires_at: Delayed::Job.db_time_now - 1.day
-      expect { @worker.run }.to change(SimpleJob, :runs).by(0)
-    end
-
-    it "reports a permanent failure when an expired job is dequeued" do
-      ErrorJob.last_error = nil
-      Delayed::Job.enqueue ErrorJob.new, expires_at: Delayed::Job.db_time_now - 1.day
-      expect { @worker.run }.to change(ErrorJob, :permanent_failure_runs).by(1)
-      expect(ErrorJob.last_error).to be_a Delayed::Backend::JobExpired
-    end
-  end
-
-  describe "delay failure callbacks" do
-    it "calls the on_failure callback" do
-      ErrorJob.last_error = nil
-      ErrorJob.new.delay(max_attempts: 2, on_failure: :on_failure).perform
-      expect { @worker.run }.to change(ErrorJob, :failure_runs).by(1)
-      expect(ErrorJob.last_error.to_s).to eq "did not work"
-    end
-
-    it "calls the on_permanent_failure callback" do
-      ErrorJob.last_error = nil
-      ErrorJob.new.delay(max_attempts: 1, on_permanent_failure: :on_failure).perform
-      expect { @worker.run }.to change(ErrorJob, :failure_runs).by(1)
-      expect(ErrorJob.last_error.to_s).to eq "did not work"
-    end
-  end
-
-  describe "custom deserialization errors" do
-    it "reschedules with more attempts left" do
-      job = Delayed::Job.create({ payload_object: DeserializeErrorJob.new, max_attempts: 2 })
-      job.instance_variable_set("@payload_object", nil)
-      worker = Delayed::Worker.new(max_priority: nil, min_priority: nil, quiet: true)
-      expect { worker.perform(job) }.not_to raise_error
-    end
-
-    it "run permanent failure code on last attempt" do
-      job = Delayed::Job.create({ payload_object: DeserializeErrorJob.new, max_attempts: 1 })
-      job.instance_variable_set("@payload_object", nil)
-      worker = Delayed::Worker.new(max_priority: nil, min_priority: nil, quiet: true)
-      expect { worker.perform(job) }.not_to raise_error
-    end
-  end
-
-  describe "#start" do
-    it "fires off an execute callback on the processing jobs loop" do
-      fired = false
-      expect(@worker).to receive(:exit?).and_return(true)
-      Delayed::Worker.lifecycle.before(:execute) { |w| w == @worker && fired = true }
-      @worker.start
-      expect(fired).to eq(true)
-    end
-  end
-
-  describe "#run" do
-    it "fires off a loop callback on each call to run" do
-      fired = 0
-      Delayed::Worker.lifecycle.before(:loop) { |w| w == @worker && fired += 1 }
-      expect(Delayed::Job).to receive(:get_and_lock_next_available).twice.and_return(nil)
-      @worker.run
-      @worker.run
-      expect(fired).to eq(2)
-    end
-  end
-end

data/spec/shared_jobs_specs.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "shared/delayed_batch"
-require_relative "shared/delayed_method"
-require_relative "shared/performable_method"
-require_relative "shared/shared_backend"
-require_relative "shared/testing"
-require_relative "shared/worker"
-
-shared_examples_for "a delayed_jobs implementation" do
-  include_examples "a backend"
-  include_examples "Delayed::Batch"
-  include_examples "random ruby objects"
-  include_examples "Delayed::PerformableMethod"
-  include_examples "Delayed::Worker"
-  include_examples "Delayed::Testing"
-end

data/spec/spec_helper.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-require "delayed_job"
-require "delayed/testing"
-
-require "database_cleaner"
-require "fileutils"
-require "rack/test"
-require "timecop"
-require "webmock/rspec"
-
-require "pry"
-require "byebug"
-
-RSpec.configure do |config|
-  config.expect_with(:rspec) do |c|
-    c.syntax = %i[should expect]
-  end
-
-  config.before(:suite) do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.clean_with(:truncation)
-    WebMock.disable_net_connect!
-  end
-
-  config.before do |example|
-    DatabaseCleaner.strategy = if example.metadata[:sinatra] || example.metadata[:non_transactional]
-                                 :truncation
-                               else
-                                 :transaction
-                               end
-    DatabaseCleaner.start
-  end
-
-  config.after do
-    DatabaseCleaner.clean
-  end
-end
-
-module NoYamlDump
-  def encode_with(coder); end
-end
-# example groups are often the sender, and if we try to serialize them,
-# the resultant object is then encoded in the sender, and then we serialize
-# again, and it just keeps getting bigger and bigger and bigger...
-RSpec::Core::ExampleGroup.include(NoYamlDump)
-
-ENV["TEST_ENV_NUMBER"] ||= "1"
-ENV["TEST_DB_HOST"] ||= "localhost"
-ENV["TEST_DB_DATABASE"] ||= "inst-jobs-test-#{ENV['TEST_ENV_NUMBER']}"
-
-connection_config = {
-  adapter: :postgresql,
-  host: ENV["TEST_DB_HOST"].presence,
-  encoding: "utf8",
-  username: ENV["TEST_DB_USERNAME"],
-  database: ENV["TEST_DB_DATABASE"],
-  min_messages: "notice"
-}
-
-def migrate(file)
-  ActiveRecord::MigrationContext.new(file, ActiveRecord::SchemaMigration).migrate
-end
-
-# create the test db if it does not exist, to help out wwtd
-ActiveRecord::Base.establish_connection(connection_config.merge(database: "postgres"))
-begin
-  ActiveRecord::Base.connection.create_database(connection_config[:database])
-rescue ActiveRecord::StatementInvalid
-  nil
-end
-ActiveRecord::Base.establish_connection(connection_config)
-
-# we need to ensure this callback is called for activerecord-pg-extensions,
-# which isn't running because we're not using Rails to setup the database
-ActiveRecord::PGExtensions::Railtie.run_initializers
-
-# TODO: reset db and migrate again, to test migrations
-
-migrate("db/migrate")
-migrate("spec/migrate")
-Delayed::Backend::ActiveRecord::Job.reset_column_information
-Delayed::Backend::ActiveRecord::Job::Failed.reset_column_information
-
-Time.zone = "UTC" # rubocop:disable Rails/TimeZoneAssignment
-FileUtils.mkdir_p("tmp")
-ActiveRecord::Base.logger = Rails.logger = Logger.new("tmp/test.log")
-
-# Purely useful for test cases...
-class Story < ActiveRecord::Base
-  def tell
-    text
-  end
-
-  def whatever(times, _)
-    tell * times
-  end
-
-  def whatever_else(times, _)
-    tell * times
-  end
-
-  handle_asynchronously :whatever
-  handle_asynchronously :whatever_else, queue: "testqueue"
-end
-
-class StoryReader
-  def read(story)
-    "Epilog: #{story.tell}"
-  end
-
-  def self.reverse(str)
-    str.reverse
-  end
-end
-
-module MyReverser
-  def self.reverse(str)
-    str.reverse
-  end
-end
-
-def change_setting(klass, setting_name, value)
-  old_val = klass.send(setting_name)
-  klass.send("#{setting_name}=", value)
-  yield
-ensure
-  klass.send("#{setting_name}=", old_val)
-end
-
-def run_job(job)
-  Delayed::Testing.run_job(job)
-end
-
-require_relative "sample_jobs"
-require_relative "shared_jobs_specs"