delayed 2.1.0 → 3.0.0

data/spec/delayed/job_spec.rb

@@ -13,18 +13,19 @@ describe Delayed::Job do
     Delayed::Worker.max_claims = 1 # disable multithreading because SimpleJob is not threadsafe
     Delayed::Worker.default_priority = 99
     Delayed::Worker.delay_jobs = true
+    Delayed::Worker.deny_stale_enqueues = false
     Delayed::Worker.default_queue_name = 'default_tracking'
     SimpleJob.runs = 0
     described_class.delete_all
   end
 
   it 'sets run_at automatically if not set' do
-    expect(described_class.create(payload_object: ErrorJob.new).run_at).not_to be_nil
+    expect(described_class.enqueue(payload_object: ErrorJob.new).run_at).not_to be_nil
   end
 
   it 'does not set run_at automatically if already set' do
     later = described_class.db_time_now + 5.minutes
-    job = described_class.create(payload_object: ErrorJob.new, run_at: later)
+    job = described_class.enqueue(payload_object: ErrorJob.new, run_at: later)
     expect(job.run_at).to be_within(1).of(later)
   end
 
@@ -36,12 +37,6 @@ describe Delayed::Job do
   end
 
   describe 'enqueue' do
-    it "allows enqueue hook to modify job at DB level" do
-      later = described_class.db_time_now + 20.minutes
-      job = described_class.enqueue payload_object: EnqueueJobMod.new
-      expect(described_class.find(job.id).run_at).to be_within(1).of(later)
-    end
-
     context 'with a hash' do
       it "raises ArgumentError when handler doesn't respond_to :perform" do
         expect { described_class.enqueue(payload_object: Object.new) }.to raise_error(ArgumentError)
@@ -133,6 +128,187 @@ describe Delayed::Job do
         expect(described_class.enqueue(SimpleJob.new)).to be_instance_of(described_class)
       end
     end
+
+    context 'with deny_stale_enqueues = true' do
+      before { Delayed::Worker.deny_stale_enqueues = true }
+
+      it 'raises StaleEnqueueError when run_at is beyond lock_timeout in the past' do
+        stale_time = described_class.db_time_now - described_class.lock_timeout - 1.minute
+        expect {
+          described_class.enqueue SimpleJob.new, run_at: stale_time
+        }.to raise_error(Delayed::StaleEnqueueError, /Cannot enqueue a job in the distant past/)
+      end
+
+      it 'allows run_at within lock_timeout of now' do
+        recent_past = described_class.db_time_now - described_class.lock_timeout + 1.minute
+        job = described_class.enqueue SimpleJob.new, run_at: recent_past
+        expect(job).to be_persisted
+      end
+
+      it 'allows run_at in the future' do
+        future = described_class.db_time_now + 5.minutes
+        job = described_class.enqueue SimpleJob.new, run_at: future
+        expect(job).to be_persisted
+      end
+
+      it 'allows enqueue without run_at' do
+        job = described_class.enqueue SimpleJob.new
+        expect(job).to be_persisted
+      end
+    end
+
+    context 'with deny_stale_enqueues = false (default)' do
+      it 'allows run_at far in the past' do
+        stale_time = described_class.db_time_now - 1.day
+        job = described_class.enqueue SimpleJob.new, run_at: stale_time
+        expect(job).to be_persisted
+      end
+    end
+
+    context 'when payload defines an :enqueue hook' do
+      before do
+        stub_const('JobWithEnqueueHook', Class.new do
+          def enqueue(_job); end
+
+          def perform; end
+        end)
+      end
+
+      it 'raises an error naming the payload class' do
+        expect { described_class.enqueue(JobWithEnqueueHook.new) }
+          .to raise_error(RuntimeError, ':enqueue hook on JobWithEnqueueHook is no longer supported')
+      end
+
+      it 'does not invoke the payload enqueue method' do
+        payload = JobWithEnqueueHook.new
+        expect(payload).not_to receive(:enqueue)
+        expect { described_class.enqueue(payload) }.to raise_error(RuntimeError, /:enqueue hook/)
+      end
+    end
+
+    context 'when payload does not define :enqueue' do
+      it 'does not raise' do
+        expect { described_class.enqueue(SimpleJob.new) }.not_to raise_error
+      end
+    end
+
+    context 'when payload is an ActiveJob wrapper that responds to :enqueue' do
+      it 'does not raise' do
+        wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(ActiveJobJob.new.serialize)
+        expect { described_class.enqueue(payload_object: wrapper) }.not_to raise_error
+      end
+    end
+
+    context 'when payload is a bare ActiveJob::Base instance' do
+      it 'raises' do
+        expect { described_class.enqueue(payload_object: ActiveJobJob.new) }.to raise_error(RuntimeError, /Delayed::Job enqueue methods do not accept ActiveJobs/)
+      end
+    end
+
+    context 'when passed a bare ActiveJob::Base instance' do
+      it 'raises' do
+        expect { described_class.enqueue(ActiveJobJob.new) }.to raise_error(RuntimeError, /Delayed::Job enqueue methods do not accept ActiveJobs/)
+      end
+    end
+  end
+
+  describe '.enqueue_all' do
+    def build_job(payload = SimpleJob.new, opts = {})
+      described_class.new(Delayed::Backend::JobPreparer.new(payload, opts).prepare)
+    end
+
+    it 'returns 0 when given no jobs' do
+      expect(described_class.enqueue_all([])).to eq(0)
+    end
+
+    it 'inserts all jobs in a single INSERT' do
+      jobs = Array.new(3) { build_job }
+      expect { described_class.enqueue_all(jobs) }
+        .to emit_notification('sql.active_record').with_payload(hash_including(sql: a_string_matching(/\AINSERT INTO/i)))
+      expect(described_class.count).to eq(3)
+    end
+
+    it 'returns the count of enqueued jobs' do
+      jobs = Array.new(3) { build_job }
+      expect(described_class.enqueue_all(jobs)).to eq(3)
+    end
+
+    it 'sets id on each job from INSERT RETURNING when supported' do
+      skip 'requires INSERT ... RETURNING support' unless described_class.connection.supports_insert_returning?
+
+      jobs = Array.new(2) { build_job }
+      described_class.enqueue_all(jobs)
+      expect(jobs.map(&:id)).to match_array(described_class.pluck(:id))
+    end
+
+    it 'fires :enqueue lifecycle once with the jobs array' do
+      observed = []
+      lifecycle_was = Delayed.lifecycle
+      Delayed.instance_variable_set(:@lifecycle, Delayed::Lifecycle.new)
+      Delayed.lifecycle.before(:enqueue) { |jobs| observed << jobs }
+
+      jobs = [build_job]
+      described_class.enqueue_all(jobs)
+
+      expect(observed.size).to eq(1)
+      expect(observed.first).to eq(jobs)
+    ensure
+      Delayed.instance_variable_set(:@lifecycle, lifecycle_was)
+    end
+
+    context 'when delay_jobs is false' do
+      before { Delayed::Worker.delay_jobs = false }
+
+      it 'inline-invokes each job and inserts nothing' do
+        payload = SimpleJob.new
+        expect(payload).to receive(:perform)
+        described_class.enqueue_all([build_job(payload)])
+        expect(described_class.count).to eq(0)
+      end
+    end
+
+    context 'when a job payload defines an :enqueue hook' do
+      before do
+        stub_const('JobWithEnqueueHook', Class.new do
+          def enqueue(_job); end
+
+          def perform; end
+        end)
+      end
+
+      it 'raises before inserting anything' do
+        jobs = [build_job(JobWithEnqueueHook.new)]
+        expect { described_class.enqueue_all(jobs) }
+          .to raise_error(RuntimeError, ':enqueue hook on JobWithEnqueueHook is no longer supported')
+        expect(described_class.count).to eq(0)
+      end
+    end
+
+    context 'when a job payload is a bare ActiveJob::Base instance' do
+      it 'raises' do
+        jobs = [build_job(ActiveJobJob.new)]
+        expect { described_class.enqueue_all(jobs) }.to raise_error(RuntimeError, /Delayed::Job enqueue methods do not accept ActiveJobs/)
+      end
+    end
+  end
+
+  describe '#hook' do
+    context 'with :enqueue' do
+      before do
+        stub_const('JobWithEnqueueHook', Class.new do
+          def enqueue(_job); end
+
+          def perform; end
+        end)
+      end
+
+      it 'raises rather than invoking the payload hook' do
+        job = described_class.new(payload_object: JobWithEnqueueHook.new)
+        expect(job.payload_object).not_to receive(:enqueue)
+        expect { job.hook(:enqueue) }
+          .to raise_error(RuntimeError, ':enqueue hook is no longer supported')
+      end
+    end
   end
 
   describe 'callbacks' do
@@ -150,9 +326,9 @@ describe Delayed::Job do
 
     it 'calls before and after callbacks' do
       job = described_class.enqueue(CallbackJob.new)
-      expect(CallbackJob.messages).to eq(['enqueue'])
+      expect(CallbackJob.messages).to eq([])
       job.invoke_job
-      expect(CallbackJob.messages).to eq(%w(enqueue before perform success after))
+      expect(CallbackJob.messages).to eq(%w(before perform success after))
     end
 
     it 'calls the after callback with an error' do
@@ -160,14 +336,14 @@ describe Delayed::Job do
       expect(job.payload_object).to receive(:perform).and_raise(RuntimeError.new('fail'))
 
       expect { job.invoke_job }.to raise_error(RuntimeError, 'fail')
-      expect(CallbackJob.messages).to eq(['enqueue', 'before', 'error: RuntimeError', 'after'])
+      expect(CallbackJob.messages).to eq(['before', 'error: RuntimeError', 'after'])
     end
 
     it 'calls error when before raises an error' do
       job = described_class.enqueue(CallbackJob.new)
       expect(job.payload_object).to receive(:before).and_raise(RuntimeError.new('fail'))
       expect { job.invoke_job }.to raise_error(RuntimeError, 'fail')
-      expect(CallbackJob.messages).to eq(['enqueue', 'error: RuntimeError', 'after'])
+      expect(CallbackJob.messages).to eq(['error: RuntimeError', 'after'])
     end
   end
 
@@ -425,26 +601,23 @@ describe Delayed::Job do
   describe '#name' do
     context 'when name column is populated' do
       it 'is the class name of the job that was enqueued' do
-        job = described_class.new(payload_object: ErrorJob.new)
+        job = described_class.enqueue(payload_object: ErrorJob.new)
         expect(job.name).to eq('ErrorJob')
-        job.save!
         expect(job.reload.name).to eq('ErrorJob')
         expect(described_class.group(:name).count).to eq('ErrorJob' => 1)
       end
 
       it 'is the class name of the performable job if it is an ActiveJob' do
         job_wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(ActiveJobJob.new.serialize)
-        job = described_class.new(payload_object: job_wrapper)
+        job = described_class.enqueue(payload_object: job_wrapper)
         expect(job.name).to eq('ActiveJobJob')
-        job.save!
         expect(job.reload.name).to eq('ActiveJobJob')
         expect(described_class.group(:name).count).to eq('ActiveJobJob' => 1)
       end
 
       it 'is the returned display_name if display_name is defined on the job object' do
-        job = described_class.new(payload_object: NamedJob.new)
+        job = described_class.enqueue(payload_object: NamedJob.new)
         expect(job.name).to eq('named_job')
-        job.save!
         expect(job.reload.name).to eq('named_job')
         expect(described_class.group(:name).count).to eq('named_job' => 1)
       end
@@ -456,25 +629,38 @@ describe Delayed::Job do
       end
 
       it 'is the custom name value when set explicitly' do
-        job = described_class.new(payload_object: ErrorJob.new)
-        job.name = 'Custom Name'
-        job.save!
+        job = described_class.enqueue(payload_object: ErrorJob.new, name: 'Custom Name')
         expect(job.reload.name).to eq('Custom Name')
         expect(described_class.group(:name).count).to eq('Custom Name' => 1)
       end
     end
 
     context 'when name column is NULL' do
+      before do
+        ActiveRecord::Schema.define do
+          ValidateRunAtAndNameNotNull.migrate(:down)
+          AddRunAtAndNameNotNullCheck.migrate(:down)
+        end
+        described_class.reset_column_information
+      end
+
+      after do
+        described_class.delete_all
+        ActiveRecord::Schema.define do
+          AddRunAtAndNameNotNullCheck.migrate(:up)
+          ValidateRunAtAndNameNotNull.migrate(:up)
+        end
+        described_class.reset_column_information
+      end
+
       it 'is the class name of the job that was enqueued' do
-        job = described_class.create(payload_object: ErrorJob.new)
-        job.update_column(:name, nil) # rubocop:disable Rails/SkipsModelValidations
+        job = described_class.enqueue(payload_object: ErrorJob.new)
         expect(job.reload.name).to eq('ErrorJob')
       end
 
       it 'is the class name of the performable job if it is an ActiveJob' do
         job_wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(ActiveJobJob.new.serialize)
-        job = described_class.create(payload_object: job_wrapper)
-        job.update_column(:name, nil) # rubocop:disable Rails/SkipsModelValidations
+        job = described_class.enqueue(payload_object: job_wrapper)
         expect(job.reload.name).to eq('ActiveJobJob')
       end
 
@@ -505,7 +691,7 @@ describe Delayed::Job do
       end
 
       it 'is the class name of the job that was enqueued' do
-        job = described_class.new(payload_object: ErrorJob.new)
+        job = described_class.new(payload_object: ErrorJob.new, run_at: Time.current)
         expect(job.name).to eq('ErrorJob')
         job.save!
         expect(job.reload.name).to eq('ErrorJob')
@@ -513,14 +699,14 @@ describe Delayed::Job do
 
       it 'is the class name of the performable job if it is an ActiveJob' do
         job_wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(ActiveJobJob.new.serialize)
-        job = described_class.new(payload_object: job_wrapper)
+        job = described_class.new(payload_object: job_wrapper, run_at: Time.current)
         expect(job.name).to eq('ActiveJobJob')
         job.save!
         expect(job.reload.name).to eq('ActiveJobJob')
       end
 
       it 'is the returned display_name if display_name is defined on the job object' do
-        job = described_class.new(payload_object: NamedJob.new)
+        job = described_class.new(payload_object: NamedJob.new, run_at: Time.current)
         expect(job.name).to eq('named_job')
         job.save!
         expect(job.reload.name).to eq('named_job')
@@ -798,7 +984,7 @@ describe Delayed::Job do
     describe 'running a job' do
       it 'fails after Worker.max_run_time' do
         Delayed::Worker.max_run_time = 1.second
-        job = described_class.create payload_object: LongRunningJob.new
+        job = described_class.enqueue payload_object: LongRunningJob.new
         worker.perform(job)
         expect(job.error).not_to be_nil
         expect(job.reload.last_error).to match(/expired/)
@@ -808,7 +994,7 @@ describe Delayed::Job do
 
       context 'when the job raises a deserialization error' do
         it 'marks the job as failed' do
-          job = described_class.create! payload_object: LongRunningJob.new
+          job = described_class.enqueue payload_object: LongRunningJob.new
           job.update_columns(handler: '--- !ruby/object:JobThatDoesNotExist {}') # rubocop:disable Rails/SkipsModelValidations
           expect_any_instance_of(described_class).to receive(:destroy_failed_jobs?).and_return(false)
           worker.work_off
@@ -863,13 +1049,13 @@ describe Delayed::Job do
 
     context 'reschedule' do
       before do
-        @job = described_class.create payload_object: SimpleJob.new
+        @job = described_class.enqueue payload_object: SimpleJob.new
       end
 
       shared_examples_for 'any failure more than Worker.max_attempts times' do
         context "when the job's payload has a #failure hook" do
           before do
-            @job = described_class.create payload_object: OnPermanentFailureJob.new
+            @job = described_class.enqueue payload_object: OnPermanentFailureJob.new
             expect(@job.payload_object).to respond_to(:failure)
           end
 

data/spec/delayed/monitor_spec.rb

@@ -123,6 +123,7 @@ RSpec.describe Delayed::Monitor do
           run_at: now,
           queue: 'default',
           handler: "--- !ruby/object:SimpleJob\n",
+          name: 'SimpleJob',
           attempts: 0,
         }
       end
@@ -345,7 +346,7 @@ RSpec.describe Delayed::Monitor do
     end
   end
 
-  describe '#query_for' do
+  describe 'SQL' do
     let(:monitor) { described_class.new }
     let(:queries) { [] }
     let(:now) { '2025-11-10 17:20:13 UTC' }
@@ -360,30 +361,28 @@ RSpec.describe Delayed::Monitor do
           value = value.value if value.is_a?(ActiveModel::Attribute)
           sql = sql.sub(/(\?|\$\d)/, ActiveRecord::Base.connection.quote(value))
         end
-        queries << sql
+        queries << QueryUnderTest.for(sql)
+        queries << "---"
       end
     end
 
-    def queries_for(metric)
-      monitor.query_for(metric)
-      queries.map { |q| QueryUnderTest.for(q) }
+    def query_descriptions
+      described_class::METRICS.each do |metric|
+        queries << "-- QUERIES FOR `#{metric}`:"
+        queries << "---------------------------------"
+        monitor.query_for(metric)
+        queries << "-- (no new queries)" unless queries.last == '---'
+      end
+      queries.dup.map { |query| query.try(:full_description) || query }
     end
 
-    described_class::METRICS.each do |metric|
-      context "('#{metric}')" do
-        it "runs the expected #{current_adapter} query for #{metric}" do
-          expect(queries_for(metric).map(&:formatted).join("\n")).to match_snapshot
-        end
-
-        it "produces the expected #{current_adapter} query plan for #{metric}" do
-          expect(queries_for(metric).map(&:explain).join("\n")).to match_snapshot
-        end
+    it "runs the expected #{current_adapter} queries with the expected plans" do
+      expect(query_descriptions.join("\n")).to match_snapshot
+    end
 
-        context 'when using the legacy index', :with_legacy_table_index do
-          it "[legacy index] produces the expected #{current_adapter} query plan for #{metric}" do
-            expect(queries_for(metric).map(&:explain).join("\n")).to match_snapshot
-          end
-        end
+    context 'when using the legacy index', :with_legacy_table_index do
+      it "[legacy index] runs the expected #{current_adapter} queries with the expected plans" do
+        expect(query_descriptions.join("\n")).to match_snapshot
       end
     end
   end

data/spec/delayed/plugins/instrumentation_spec.rb

@@ -3,6 +3,47 @@ require 'helper'
 RSpec.describe Delayed::Plugins::Instrumentation do
   let!(:job) { Delayed::Job.enqueue SimpleJob.new, priority: 13, queue: 'test' }
 
+  it 'emits delayed.job.enqueue when a job is enqueued' do
+    expect { Delayed::Job.enqueue SimpleJob.new }.to emit_notification('delayed.job.enqueue').with_payload(
+      jobs: [
+        hash_including(
+          job_name: 'SimpleJob',
+          table: 'delayed_jobs',
+          database: current_database,
+          database_adapter: current_adapter,
+          job: an_instance_of(Delayed::Job),
+        ),
+      ],
+    )
+  end
+
+  it 'emits a single delayed.job.enqueue when a batch is enqueued via the ActiveJob adapter' do
+    job_class = Class.new(ActiveJob::Base) do
+      def perform; end
+    end
+    stub_const('BatchedJob', job_class)
+
+    adapter_was = ActiveJob::Base.queue_adapter
+    ActiveJob::Base.queue_adapter = :delayed
+    begin
+      jobs = Array.new(3) { BatchedJob.new }
+      expect { ActiveJob::Base.queue_adapter.enqueue_all(jobs) }
+        .to emit_notification('delayed.job.enqueue').with_payload(
+          jobs: Array.new(3) {
+            hash_including(
+              job_name: 'BatchedJob',
+              table: 'delayed_jobs',
+              database: current_database,
+              database_adapter: current_adapter,
+              job: an_instance_of(Delayed::Job),
+            )
+          },
+        )
+    ensure
+      ActiveJob::Base.queue_adapter = adapter_was
+    end
+  end
+
   it 'emits delayed.job.run' do
     expect { Delayed::Worker.new.work_off }.to emit_notification('delayed.job.run').with_payload(
       job_name: 'SimpleJob',

data/spec/helper.rb

@@ -92,6 +92,8 @@ ActiveRecord::Schema.define do
     run_migration(IndexFailedJobs)
     run_migration(SetPostgresFillfactor)
     run_migration(RemoveLegacyIndex)
+    run_migration(AddRunAtAndNameNotNullCheck)
+    run_migration(ValidateRunAtAndNameNotNull)
 
     # Test that these index migrations can be re-applied idempotently.
     # (In case identical indexes had been manually applied previously.)
@@ -228,10 +230,7 @@ RSpec::Matchers.define :emit_notification do |expected_event_name|
   diffable
 
   match do |block|
-    if @approximately && current_adapter != 'postgresql'
-      @expected_value = a_value_within([2, @expected_value.abs * 0.05].max).of(@expected_value)
-    end
-
+    @expected_value = a_value_within([2, @expected_value.abs * 0.05].max).of(@expected_value) if @approximately
     @expected = { event_name: expected_event_name, payload: expected_payload, value: @expected_value }
     @actuals = []
     callback = ->(name, _started, _finished, _unique_id, payload) do
@@ -269,11 +268,19 @@ def current_database
   end
 end
 
+def current_database_name
+  current_adapter == 'sqlite3' ? 'tmp/database.sqlite' : 'delayed_job_test'
+end
+
 QueryUnderTest = Struct.new(:sql, :connection) do
   def self.for(query, connection: ActiveRecord::Base.connection)
     new(query.respond_to?(:to_sql) ? query.to_sql : query.to_s, connection)
   end
 
+  def full_description
+    [formatted, explain].join("\n\n")
+  end
+
   def formatted
     fmt = sql.squish
 
@@ -287,6 +294,8 @@ QueryUnderTest = Struct.new(:sql, :connection) do
       .gsub(/ (AND|OR) /) { "\n    #{Regexp.last_match(1).strip} " }
       # normalize and truncate 'AS' names/aliases (changes across Rails versions)
       .gsub(/AS ("|`)?(\w+)("|`)?/) { "AS #{Regexp.last_match(2)[0...63]}" }
+      # newline and indent when aliased columns are listed
+      .gsub(/AS (\w+),/) { "AS #{Regexp.last_match(1)},\n      " }
       # remove quotes around column names in aggregate functions
       .gsub(/(MIN|MAX|COUNT|SUM)\(("|`)(\w+)("|`)\)/) { "#{Regexp.last_match(1)}(#{Regexp.last_match(3)})" }
   end
@@ -302,16 +311,18 @@ QueryUnderTest = Struct.new(:sql, :connection) do
   def postgresql_explain
     connection.execute("SET seq_page_cost = 100")
     connection.execute("SET enable_hashagg = off")
+    connection.execute("SET enable_incremental_sort = off")
     connection.execute("SET plan_cache_mode TO force_generic_plan")
     connection.execute("EXPLAIN (VERBOSE) #{sql}").values.flatten.join("\n")
   ensure
     connection.execute("RESET plan_cache_mode")
+    connection.execute("RESET enable_incremental_sort")
     connection.execute("RESET enable_hashagg")
     connection.execute("RESET seq_page_cost")
   end
 
   def mysql2_explain
-    seed_rows! # MySQL needs a bit of data to reach for indexes
+    seed_rows! if Delayed::Job.none? # MySQL needs a bit of data to reach for indexes
     connection.execute("ANALYZE TABLE #{Delayed::Job.table_name}")
     connection.execute("SET SESSION max_seeks_for_key = 1")
     connection.execute("EXPLAIN FORMAT=TREE #{sql}").to_a.map(&:first).join("\n")
@@ -325,12 +336,13 @@ QueryUnderTest = Struct.new(:sql, :connection) do
 
   def seed_rows!
     now = Delayed::Job.db_time_now
-    10.times do
+    100.times do
       [true, false].repeated_combination(5).each_with_index do |(erroring, failed, locked, future), i|
         Delayed::Job.create!(
           run_at: now + (future ? i.minutes : -i.minutes),
           queue: "queue_#{i}",
           handler: "--- !ruby/object:SimpleJob\n",
+          name: 'SimpleJob',
           attempts: erroring ? i : 0,
           failed_at: failed ? now - i.minutes : nil,
           locked_at: locked ? now - i.seconds : nil,

data/spec/lifecycle_spec.rb

@@ -3,7 +3,7 @@ require 'helper'
 describe Delayed::Lifecycle do
   let(:lifecycle) { described_class.new }
   let(:callback) { lambda { |*_args| } }
-  let(:arguments) { [1] }
+  let(:arguments) { [%i(job_a job_b)] }
   let(:behavior) { double(Object, before!: nil, after!: nil, inside!: nil) }
   let(:wrapped_block) { proc { behavior.inside! } }
 

data/spec/message_sending_spec.rb

@@ -136,23 +136,13 @@ describe Delayed::MessageSending do
       }.to change { Delayed::Job.count }.by(1)
     end
 
-    it 'does delay when delay_jobs is a proc returning true' do
-      Delayed::Worker.delay_jobs = ->(_job) { true }
+    it 'raises when delay_jobs is a Proc' do
+      Delayed::Worker.delay_jobs = -> { true }
       fairy_tail = FairyTail.new
       expect {
         expect {
           fairy_tail.delay.tell('a', kwarg: 'b')
-        }.not_to change { fairy_tail.happy_ending }
-      }.to change { Delayed::Job.count }.by(1)
-    end
-
-    it 'does not delay the job when delay_jobs is a proc returning false' do
-      Delayed::Worker.delay_jobs = ->(_job) { false }
-      fairy_tail = FairyTail.new
-      expect {
-        expect {
-          fairy_tail.delay.tell('a', kwarg: 'b')
-        }.to change { fairy_tail.happy_ending }.from(nil).to %w(a b)
+        }.to raise_error('Delayed::Worker.delay_jobs may not be a Proc')
       }.not_to(change { Delayed::Job.count })
     end
   end

data/spec/performable_method_spec.rb

@@ -95,12 +95,6 @@ describe Delayed::PerformableMethod do
       end
     end
 
-    it 'delegates enqueue hook to object' do
-      story = Story.create
-      expect(story).to receive(:enqueue).with(an_instance_of(Delayed::Job))
-      story.delay.tell
-    end
-
     it 'delegates error hook to object' do
       story = Story.create
       expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))

data/spec/sample_jobs.rb

@@ -77,10 +77,6 @@ end
 class CallbackJob
   cattr_accessor :messages
 
-  def enqueue(_job)
-    self.class.messages << 'enqueue'
-  end
-
   def before(_job)
     self.class.messages << 'before'
   end
@@ -106,12 +102,6 @@ class CallbackJob
   end
 end
 
-class EnqueueJobMod < SimpleJob
-  def enqueue(job)
-    job.run_at = 20.minutes.from_now
-  end
-end
-
 class ActiveJobJob < ActiveJob::Base # rubocop:disable Rails/ApplicationJob
   def perform(*args, **kwargs); end
 end