inst-jobs 3.0.9 → 3.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 953dc843cf3274fd2fc62ea200636e9663147e6aec0465ca4d258216a3394fc2
-  data.tar.gz: 46012d5b8466f7178c868564ebb2500f159ff769f879d263247ac4abfa196335
+  metadata.gz: 80d0bc1d05ae57467d66361e81fa51a5b45e3fa391250005c59229554757ec08
+  data.tar.gz: 32d3df9f6085199fa1e9586330c6ba255f898602eb546ea94f49de52b628e7df
 SHA512:
-  metadata.gz: 124abbec91c97e76383eeb503ccc125333cad963120d8e58df674f910860beebbd8f6069b6a83eeb2fdc03b8a475ffe11472be93e584d85195eba0d1226dccae
-  data.tar.gz: b422a5a470cea805d37b9398b7a380191b50cc387d5f6ce75245b0f677e4e6b73d816f4cf8ae1a2433b4c8533496394d5f275a7aa52d08e3b9e949ef77473871
+  metadata.gz: 3befc529f42b4ebcba81aacea9bb4c4401a9daa06708c545572b6d6485db85b3d650b9d12baec0dadad9c7387b30ec5e051493b2992a0f6cd41ced9bcfca2485
+  data.tar.gz: 3a3629c08198e0e17455468fd670f4acdd05b28d76b4fbe88516f50692852b6edaf4ed29b6fc26babdfbcca669c9502e88c37616a24cbed5e82611664a3262de

data/lib/delayed/backend/active_record.rb

@@ -62,11 +62,21 @@ module Delayed
             _write_attribute(column, current_time) unless attribute_present?(column)
           end
 
-          attribute_names = attribute_names_for_partial_writes
+          attribute_names = if Rails.version < "7.0"
+                              attribute_names_for_partial_writes
+                            else
+                              attribute_names_for_partial_inserts
+                            end
           attribute_names = attributes_for_create(attribute_names)
           values = attributes_with_values(attribute_names)
 
-          im = self.class.arel_table.compile_insert(self.class.send(:_substitute_values, values))
+          im = if Rails.version < "7.0"
+                 self.class.arel_table.compile_insert(self.class.send(:_substitute_values, values))
+               else
+                 im = Arel::InsertManager.new(self.class.arel_table)
+                 im.insert(values.transform_keys { |name| self.class.arel_table[name] })
+                 im
+               end
 
           lock_and_insert = values["strand"] && instance_of?(Job)
           # can't use prepared statements if we're combining multiple statemenets
@@ -101,7 +111,8 @@ module Delayed
             # but we don't need to lock when inserting into Delayed::Failed
             if values["strand"] && instance_of?(Job)
               fn_name = connection.quote_table_name("half_md5_as_bigint")
-              sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{connection.quote(values['strand'])})); #{sql}"
+              quoted_strand = connection.quote(Rails.version < "7.0" ? values["strand"] : values["strand"].value)
+              sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{quoted_strand})); #{sql}"
             end
             result = connection.execute(sql, "#{self.class} Create")
             self.id = result.values.first&.first
@@ -471,7 +482,7 @@ module Delayed
           transaction do
             # for db performance reasons, we only need one process doing this at a time
             # so if we can't get an advisory lock, just abort. we'll try again soon
-            return unless attempt_advisory_lock(prefetch_jobs_lock_name)
+            next unless attempt_advisory_lock(prefetch_jobs_lock_name)
 
             horizon = db_time_now - (Settings.parent_process[:prefetched_jobs_timeout] * 4)
             where("locked_by LIKE 'prefetch:%' AND locked_at<?", horizon).update_all(locked_at: nil, locked_by: nil)

data/lib/delayed/periodic.rb

@@ -36,7 +36,7 @@ module Delayed
       Delayed::Job.transaction do
         # for db performance reasons, we only need one process doing this at a time
         # so if we can't get an advisory lock, just abort. we'll try again soon
-        return unless Delayed::Job.attempt_advisory_lock("Delayed::Periodic#audit_queue")
+        next unless Delayed::Job.attempt_advisory_lock("Delayed::Periodic#audit_queue")
 
         perform_audit!
       end

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = "3.0.9"
+  VERSION = "3.0.10"
 end

data/lib/delayed/worker/health_check.rb

@@ -34,7 +34,7 @@ module Delayed
             # no other worker is trying to do this right now (and if we abandon the
             # operation, the transaction will end, releasing the advisory lock).
             result = Delayed::Job.attempt_advisory_lock("Delayed::Worker::HealthCheck#reschedule_abandoned_jobs")
-            return unless result
+            next unless result
 
             horizon = 5.minutes.ago
 

data/spec/active_record_job_spec.rb

@@ -28,13 +28,13 @@ describe "Delayed::Backed::ActiveRecord::Job" do
 
     it "does not allow a second worker to get exclusive access if already successfully processed by worker1" do
       @job.destroy
-      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to eq(false)
+      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to be(false)
     end
 
     it "doesn't allow a second worker to get exclusive access if failed to be " \
        "processed by worker1 and run_at time is now in future (due to backing off behaviour)" do
       @job.update(attempts: 1, run_at: 1.day.from_now)
-      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to eq(false)
+      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to be(false)
     end
 
     it "selects the next job at random if enabled" do
@@ -55,13 +55,13 @@ describe "Delayed::Backed::ActiveRecord::Job" do
 
   it "unlocks a successfully locked job and persist the job's unlocked state" do
     job = Delayed::Job.create payload_object: SimpleJob.new
-    expect(job.send(:lock_exclusively!, "worker1")).to eq(true)
+    expect(job.send(:lock_exclusively!, "worker1")).to be(true)
     job.reload
     job.unlock
     job.save!
     job.reload
-    expect(job.locked_by).to eq(nil)
-    expect(job.locked_at).to eq(nil)
+    expect(job.locked_by).to be_nil
+    expect(job.locked_at).to be_nil
   end
 
   describe "bulk_update failed jobs" do
@@ -85,7 +85,7 @@ describe "Delayed::Backed::ActiveRecord::Job" do
       before do
         2.times do
           j = Delayed::Job.create(payload_object: SimpleJob.new)
-          expect(j.send(:lock_exclusively!, "worker1")).to eq(true)
+          expect(j.send(:lock_exclusively!, "worker1")).to be(true)
           j.fail!
         end
       end
@@ -170,13 +170,13 @@ describe "Delayed::Backed::ActiveRecord::Job" do
       it "sets one job as next_in_strand at a time with max_concurrent of 1" do
         job1 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
         job1.reload
-        expect(job1.next_in_strand).to eq(true)
+        expect(job1.next_in_strand).to be(true)
         job2 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
         job2.reload
-        expect(job2.next_in_strand).to eq(false)
+        expect(job2.next_in_strand).to be(false)
         run_job(job1)
         job2.reload
-        expect(job2.next_in_strand).to eq(true)
+        expect(job2.next_in_strand).to be(true)
       end
 
       it "sets multiple jobs as next_in_strand at a time based on max_concurrent" do
@@ -187,16 +187,16 @@ describe "Delayed::Backed::ActiveRecord::Job" do
         }) do
           job1 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
           job1.reload
-          expect(job1.next_in_strand).to eq(true)
+          expect(job1.next_in_strand).to be(true)
           job2 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
           job2.reload
-          expect(job2.next_in_strand).to eq(true)
+          expect(job2.next_in_strand).to be(true)
           job3 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
           job3.reload
-          expect(job3.next_in_strand).to eq(false)
+          expect(job3.next_in_strand).to be(false)
           run_job(job1)
           job3.reload
-          expect(job3.next_in_strand).to eq(true)
+          expect(job3.next_in_strand).to be(true)
         end
       end
     end

data/spec/delayed/work_queue/in_process_spec.rb

@@ -26,6 +26,6 @@ RSpec.describe Delayed::WorkQueue::InProcess do
     end
     job = subject.get_and_lock_next_available(*args)
     expect(job).to eq(:job)
-    expect(called).to eq(true)
+    expect(called).to be(true)
   end
 end

data/spec/delayed/work_queue/parent_process/server_spec.rb

@@ -255,7 +255,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     subject.run_once
 
     expect(Marshal.load(client)).to eq(job)
-    expect(called).to eq(true)
+    expect(called).to be(true)
   end
 
   it "deletes the correct worker when transferring jobs" do

data/spec/shared/delayed_batch.rb

@@ -13,10 +13,10 @@ shared_examples_for "Delayed::Batch" do
       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(regular_jobs.first.batch?).to be(false)
       expect(batch_jobs.size).to eq(1)
       batch_job = batch_jobs.first
-      expect(batch_job.batch?).to eq(true)
+      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]
@@ -50,7 +50,7 @@ shared_examples_for "Delayed::Batch" do
       expect(Delayed::Job.jobs_count(:current)).to eq(1)
 
       batch_job = Delayed::Job.find_available(1).first
-      expect(batch_job.batch?).to eq(true)
+      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

data/spec/shared/delayed_method.rb

@@ -140,7 +140,7 @@ shared_examples_for "random ruby objects" do
         obj.test_method(7, synchronous: true)
         expect(obj.ran).to eq([7])
         obj.ran = nil
-        expect(obj.ran).to eq(nil)
+        expect(obj.ran).to be_nil
         obj.test_method(8, 9, synchronous: true)
         expect(obj.ran).to eq([8, 9])
       end

data/spec/shared/shared_backend.rb

@@ -233,7 +233,7 @@ shared_examples_for "a backend" do
   describe "#transfer_lock" do
     it "works" do
       job = create_job(locked_by: "worker", locked_at: Delayed::Job.db_time_now)
-      expect(job.transfer_lock!(from: "worker", to: "worker2")).to eq true
+      expect(job.transfer_lock!(from: "worker", to: "worker2")).to be true
       expect(Delayed::Job.find(job.id).locked_by).to eq "worker2"
     end
   end
@@ -243,13 +243,13 @@ shared_examples_for "a backend" do
       job1 = create_job(strand: "myjobs")
       job2 = create_job(strand: "myjobs")
       expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(job1)
-      expect(Delayed::Job.get_and_lock_next_available("w2")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w2")).to be_nil
       job1.destroy
       # update time since the failed lock pushed it forward
       job2.run_at = 1.minute.ago
       job2.save!
       expect(Delayed::Job.get_and_lock_next_available("w3")).to eq(job2)
-      expect(Delayed::Job.get_and_lock_next_available("w4")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w4")).to be_nil
     end
 
     it "fails to lock if an earlier job gets locked" do
@@ -301,7 +301,7 @@ shared_examples_for "a backend" do
       locked = [Delayed::Job.get_and_lock_next_available("w1"),
                 Delayed::Job.get_and_lock_next_available("w2")]
       expect(jobs).to eq locked
-      expect(Delayed::Job.get_and_lock_next_available("w3")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w3")).to be_nil
     end
 
     it "does not interfere with jobs in other strands" do
@@ -309,7 +309,7 @@ shared_examples_for "a backend" do
       locked = [Delayed::Job.get_and_lock_next_available("w1"),
                 Delayed::Job.get_and_lock_next_available("w2")]
       expect(jobs).to eq locked
-      expect(Delayed::Job.get_and_lock_next_available("w3")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w3")).to be_nil
     end
 
     it "does not find next jobs when given no priority" do
@@ -317,7 +317,7 @@ shared_examples_for "a backend" do
       first = Delayed::Job.get_and_lock_next_available("w1", Delayed::Settings.queue, nil, nil)
       second = Delayed::Job.get_and_lock_next_available("w2", Delayed::Settings.queue, nil, nil)
       expect(first).to eq jobs.first
-      expect(second).to eq nil
+      expect(second).to be_nil
     end
 
     it "complains if you pass more than one strand-based option" do
@@ -538,11 +538,11 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job2 = create_job(singleton: "myjobs")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be false
 
           @job1.destroy
-          expect(@job2.reload.next_in_strand).to eq true
+          expect(@job2.reload.next_in_strand).to be true
         end
 
         it "handles transitions correctly when going from not stranded to stranded" do
@@ -552,13 +552,13 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job3 = create_job(singleton: "myjobs", strand: "myjobs2")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
 
           @job2.destroy
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq true
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be true
         end
 
         it "does not violate n_strand=1 constraints when going from not stranded to stranded" do
@@ -568,13 +568,13 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job3 = create_job(singleton: "myjobs", strand: "myjobs")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
 
           @job2.destroy
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
         end
 
         it "handles transitions correctly when going from stranded to another strand" do
@@ -582,11 +582,11 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job2 = create_job(singleton: "myjobs", strand: "myjobs2")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be false
 
           @job1.destroy
-          expect(@job2.reload.next_in_strand).to eq true
+          expect(@job2.reload.next_in_strand).to be true
         end
 
         it "does not violate n_strand=1 constraints when going from stranded to another strand" do
@@ -596,24 +596,24 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job3 = create_job(singleton: "myjobs", strand: "myjobs2")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
 
           @job2.destroy
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
         end
 
         it "creates first as true, and second as false, then transitions to second when deleted" do
           @job1 = create_job(singleton: "myjobs")
           Delayed::Job.get_and_lock_next_available("w1")
           @job2 = create_job(singleton: "myjobs")
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be false
 
           @job1.destroy
-          expect(@job2.reload.next_in_strand).to eq true
+          expect(@job2.reload.next_in_strand).to be true
         end
 
         it "when combined with a strand" do
@@ -834,9 +834,9 @@ shared_examples_for "a backend" do
 
   it "sets in_delayed_job?" do
     job = InDelayedJobTest.delay(ignore_transaction: true).check_in_job
-    expect(Delayed::Job.in_delayed_job?).to eq(false)
+    expect(Delayed::Job.in_delayed_job?).to be(false)
     job.invoke_job
-    expect(Delayed::Job.in_delayed_job?).to eq(false)
+    expect(Delayed::Job.in_delayed_job?).to be(false)
   end
 
   it "fails on job creation if an unsaved AR object is used" do

data/spec/shared/worker.rb

@@ -244,7 +244,7 @@ shared_examples_for "Delayed::Worker" do
       end
 
       it "is failed if it failed more than Settings.max_attempts times" do
-        expect(@job.failed_at).to eq(nil)
+        expect(@job.failed_at).to be_nil
         Delayed::Settings.max_attempts.times { @job.reschedule }
         expect(Delayed::Job.list_jobs(:failed, 100).size).to eq(1)
       end
@@ -252,7 +252,7 @@ shared_examples_for "Delayed::Worker" do
       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)
+        expect(@job.failed_at).to be_nil
       end
 
       it "is failed if it has expired" do
@@ -396,7 +396,7 @@ shared_examples_for "Delayed::Worker" do
       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)
+      expect(fired).to be(true)
     end
   end
 

data/spec/spec_helper.rb

@@ -55,14 +55,16 @@ connection_config = {
   encoding: "utf8",
   username: ENV["TEST_DB_USERNAME"],
   database: ENV["TEST_DB_DATABASE"],
-  min_messages: "notice"
+  min_messages: "notice",
+  # Ensure the pool is big enough the deadlock tests don't get starved for connections by rails instead
+  pool: 20
 }
 
 def migrate(file)
   ActiveRecord::MigrationContext.new(file, ActiveRecord::SchemaMigration).migrate
 end
 
-# create the test db if it does not exist, to help out wwtd
+# create the test db if it does not exist
 ActiveRecord::Base.establish_connection(connection_config.merge(database: "postgres"))
 begin
   ActiveRecord::Base.connection.create_database(connection_config[:database])

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 3.0.9
+  version: 3.0.10
 platform: ruby
 authors:
 - Cody Cutrer
 - Ethan Vizitei
 - Jacob Burroughs
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-02-23 00:00:00.000000000 Z
+date: 2022-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -32,14 +32,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.4.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.4.4
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -410,21 +410,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: wwtd
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-description: 
+description:
 email:
 - cody@instructure.com
 - evizitei@instructure.com
@@ -538,8 +524,9 @@ files:
 - spec/spec_helper.rb
 homepage: https://github.com/instructure/inst-jobs
 licenses: []
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -555,31 +542,31 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.4
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Instructure-maintained fork of delayed_job
 test_files:
-- spec/active_record_job_spec.rb
+- spec/sample_jobs.rb
+- spec/spec_helper.rb
+- spec/shared_jobs_specs.rb
+- spec/shared/performable_method.rb
+- spec/shared/testing.rb
+- spec/shared/delayed_batch.rb
+- spec/shared/worker.rb
+- spec/shared/delayed_method.rb
+- spec/shared/shared_backend.rb
+- spec/migrate/20140924140513_add_story_table.rb
+- spec/delayed/server_spec.rb
 - spec/delayed/cli_spec.rb
 - spec/delayed/daemon_spec.rb
-- spec/delayed/message_sending_spec.rb
+- spec/delayed/worker_spec.rb
 - spec/delayed/periodic_spec.rb
-- spec/delayed/server_spec.rb
+- spec/delayed/message_sending_spec.rb
 - spec/delayed/settings_spec.rb
 - spec/delayed/work_queue/in_process_spec.rb
+- spec/delayed/work_queue/parent_process_spec.rb
 - spec/delayed/work_queue/parent_process/client_spec.rb
 - spec/delayed/work_queue/parent_process/server_spec.rb
-- spec/delayed/work_queue/parent_process_spec.rb
-- spec/delayed/worker/consul_health_check_spec.rb
 - spec/delayed/worker/health_check_spec.rb
-- spec/delayed/worker_spec.rb
-- spec/migrate/20140924140513_add_story_table.rb
-- spec/sample_jobs.rb
-- spec/shared/delayed_batch.rb
-- spec/shared/delayed_method.rb
-- spec/shared/performable_method.rb
-- spec/shared/shared_backend.rb
-- spec/shared/testing.rb
-- spec/shared/worker.rb
-- spec/shared_jobs_specs.rb
-- spec/spec_helper.rb
+- spec/delayed/worker/consul_health_check_spec.rb
+- spec/active_record_job_spec.rb