inst-jobs 2.3.2 → 2.4.2

data/spec/shared/performable_method.rb

@@ -1,73 +1,74 @@
 # frozen_string_literal: true
 
-shared_examples_for 'Delayed::PerformableMethod' do
-
-  it "should not ignore ActiveRecord::RecordNotFound errors because they are not always permanent" do
-    story = Story.create :text => 'Once upon...'
+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
-    lambda { YAML.load(p.to_yaml) }.should raise_error(Delayed::Backend::RecordNotFound)
+    expect { YAML.load(p.to_yaml) }.to raise_error(Delayed::Backend::RecordNotFound)
   end
 
-  it "should store the object using native YAML even if its an active record" do
-    story = Story.create :text => 'Once upon...'
+  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)
-    p.class.should   == Delayed::PerformableMethod
-    p.object.should  == story
-    p.method.should  == :tell
-    p.args.should    == []
-    p.perform.should == 'Once upon...'
+    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 "should allow class methods to be called on ActiveRecord models" do
-    Story.create!(:text => 'Once upon a...')
+  it "allows class methods to be called on ActiveRecord models" do
+    Story.create!(text: "Once upon a...")
     p = Delayed::PerformableMethod.new(Story, :count)
-    lambda { expect(p.send(:perform)).to eql 1 }.should_not raise_error
+    expect { expect(p.send(:perform)).to be 1 }.not_to raise_error
   end
 
-  it "should allow class methods to be called" do
+  it "allows class methods to be called" do
     p = Delayed::PerformableMethod.new(StoryReader, :reverse, args: ["ohai"])
-    lambda { p.send(:perform).should == "iaho" }.should_not raise_error
+    expect { expect(p.send(:perform)).to eq("iaho") }.not_to raise_error
   end
 
-  it "should allow module methods to be called" do
+  it "allows module methods to be called" do
     p = Delayed::PerformableMethod.new(MyReverser, :reverse, args: ["ohai"])
-    lambda { p.send(:perform).should == "iaho" }.should_not raise_error
+    expect { expect(p.send(:perform)).to eq("iaho") }.not_to raise_error
   end
 
-  it "should store arguments as native YAML if they are active record objects" do
-    story = Story.create :text => 'Once upon...'
+  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])
-    p.class.should   == Delayed::PerformableMethod
-    p.method.should  == :read
-    p.args.should    == [story]
-    p.perform.should == 'Epilog: Once upon...'
+    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 "should deeply de-AR-ize arguments in full name" do
-    story = Story.create :text => 'Once upon...'
+  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 }]])
-    p.full_name.should == "StoryReader#read([\"arg1\", Story.find(#{story.id}), {[:key, 1] => Story.find(#{story.id})}])"
+    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 "should call the on_failure callback" do
-    story = Story.create :text => 'wat'
+  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')
-    story.text.should == 'fail'
+    p.send(:on_failure, "fail")
+    expect(story.text).to eq("fail")
   end
 
-  it "should call the on_permanent_failure callback" do
-    story = Story.create :text => 'wat'
+  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')
-    story.text.should == 'fail_frd'
+    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'
+    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

data/spec/shared/shared_backend.rb

@@ -1,220 +1,225 @@
 # frozen_string_literal: true
 
-shared_examples_for 'a backend' do
+module InDelayedJobTest
+  def self.check_in_job
+    Delayed::Job.in_delayed_job?.should == true
+  end
+end
+
+shared_examples_for "a backend" do
   def create_job(opts = {})
-    Delayed::Job.enqueue(SimpleJob.new, **{ :queue => nil }.merge(opts))
+    Delayed::Job.enqueue(SimpleJob.new, **{ queue: nil }.merge(opts))
   end
 
   before do
     SimpleJob.runs = 0
   end
 
-  it "should set run_at automatically if not set" do
-    Delayed::Job.create(:payload_object => ErrorJob.new).run_at.should_not be_nil
+  it "sets run_at automatically if not set" do
+    expect(Delayed::Job.create(payload_object: ErrorJob.new).run_at).not_to be_nil
   end
 
-  it "should not set run_at automatically if already set" do
+  it "does not set run_at automatically if already set" do
     later = Delayed::Job.db_time_now + 5.minutes
-    Delayed::Job.create(:payload_object => ErrorJob.new, :run_at => later).run_at.should be_within(1).of(later)
+    expect(Delayed::Job.create(payload_object: ErrorJob.new, run_at: later).run_at).to be_within(1).of(later)
   end
 
-  it "should raise ArgumentError when handler doesn't respond_to :perform" do
-    lambda { Delayed::Job.enqueue(Object.new) }.should raise_error(ArgumentError)
+  it "raises ArgumentError when handler doesn't respond_to :perform" do
+    expect { Delayed::Job.enqueue(Object.new) }.to raise_error(ArgumentError)
   end
 
-  it "should increase count after enqueuing items" do
+  it "increases count after enqueuing items" do
     Delayed::Job.enqueue SimpleJob.new
-    Delayed::Job.jobs_count(:current).should == 1
+    expect(Delayed::Job.jobs_count(:current)).to eq(1)
   end
 
-  it "should be able to set priority when enqueuing items" do
-    @job = Delayed::Job.enqueue SimpleJob.new, :priority => 5
-    @job.priority.should == 5
+  it "is able to set priority when enqueuing items" do
+    @job = Delayed::Job.enqueue SimpleJob.new, priority: 5
+    expect(@job.priority).to eq(5)
   end
 
-  it "should use the default priority when enqueuing items" do
+  it "uses the default priority when enqueuing items" do
     Delayed::Job.default_priority = 0
     @job = Delayed::Job.enqueue SimpleJob.new
-    @job.priority.should == 0
+    expect(@job.priority).to eq(0)
     Delayed::Job.default_priority = 10
     @job = Delayed::Job.enqueue SimpleJob.new
-    @job.priority.should == 10
+    expect(@job.priority).to eq(10)
     Delayed::Job.default_priority = 0
   end
 
-  it "should be able to set run_at when enqueuing items" do
+  it "is able to set run_at when enqueuing items" do
     later = Delayed::Job.db_time_now + 5.minutes
-    @job = Delayed::Job.enqueue SimpleJob.new, :priority => 5, :run_at => later
-    @job.run_at.should be_within(1).of(later)
+    @job = Delayed::Job.enqueue SimpleJob.new, priority: 5, run_at: later
+    expect(@job.run_at).to be_within(1).of(later)
   end
 
-  it "should be able to set expires_at when enqueuing items" do
+  it "is able to set expires_at when enqueuing items" do
     later = Delayed::Job.db_time_now + 1.day
-    @job = Delayed::Job.enqueue SimpleJob.new, :expires_at => later
-    @job.expires_at.should be_within(1).of(later)
+    @job = Delayed::Job.enqueue SimpleJob.new, expires_at: later
+    expect(@job.expires_at).to be_within(1).of(later)
   end
 
-  it "should work with jobs in modules" do
+  it "works with jobs in modules" do
     M::ModuleJob.runs = 0
     job = Delayed::Job.enqueue M::ModuleJob.new
-    lambda { job.invoke_job }.should change { M::ModuleJob.runs }.from(0).to(1)
+    expect { job.invoke_job }.to change { M::ModuleJob.runs }.from(0).to(1)
   end
 
-  it "should raise an DeserializationError when the job class is totally unknown" do
-    job = Delayed::Job.new :handler => "--- !ruby/object:JobThatDoesNotExist {}"
-    lambda { job.payload_object.perform }.should raise_error(Delayed::Backend::DeserializationError)
+  it "raises an DeserializationError when the job class is totally unknown" do
+    job = Delayed::Job.new handler: "--- !ruby/object:JobThatDoesNotExist {}"
+    expect { job.payload_object.perform }.to raise_error(Delayed::Backend::DeserializationError)
   end
 
-  it "should try to load the class when it is unknown at the time of the deserialization" do
-    job = Delayed::Job.new :handler => "--- !ruby/object:JobThatDoesNotExist {}"
-    lambda { job.payload_object.perform }.should raise_error(Delayed::Backend::DeserializationError)
+  it "tries to load the class when it is unknown at the time of the deserialization" do
+    job = Delayed::Job.new handler: "--- !ruby/object:JobThatDoesNotExist {}"
+    expect { job.payload_object.perform }.to raise_error(Delayed::Backend::DeserializationError)
   end
 
-  it "should try include the namespace when loading unknown objects" do
-    job = Delayed::Job.new :handler => "--- !ruby/object:Delayed::JobThatDoesNotExist {}"
-    lambda { job.payload_object.perform }.should raise_error(Delayed::Backend::DeserializationError)
+  it "tries include the namespace when loading unknown objects" do
+    job = Delayed::Job.new handler: "--- !ruby/object:Delayed::JobThatDoesNotExist {}"
+    expect { job.payload_object.perform }.to raise_error(Delayed::Backend::DeserializationError)
   end
 
-  it "should also try to load structs when they are unknown (raises TypeError)" do
-    job = Delayed::Job.new :handler => "--- !ruby/struct:JobThatDoesNotExist {}"
-    lambda { job.payload_object.perform }.should raise_error(Delayed::Backend::DeserializationError)
+  it "alsoes try to load structs when they are unknown (raises TypeError)" do
+    job = Delayed::Job.new handler: "--- !ruby/struct:JobThatDoesNotExist {}"
+    expect { job.payload_object.perform }.to raise_error(Delayed::Backend::DeserializationError)
   end
 
-  it "should try include the namespace when loading unknown structs" do
-    job = Delayed::Job.new :handler => "--- !ruby/struct:Delayed::JobThatDoesNotExist {}"
-    lambda { job.payload_object.perform }.should raise_error(Delayed::Backend::DeserializationError)
+  it "tries include the namespace when loading unknown structs" do
+    job = Delayed::Job.new handler: "--- !ruby/struct:Delayed::JobThatDoesNotExist {}"
+    expect { job.payload_object.perform }.to raise_error(Delayed::Backend::DeserializationError)
   end
 
-  it "should raise an DeserializationError when the handler is invalid YAML" do
-    job = Delayed::Job.new :handler => %{test: ""11"}
-    lambda { job.payload_object.perform }.should raise_error(Delayed::Backend::DeserializationError, /parsing error/)
+  it "raises an DeserializationError when the handler is invalid YAML" do
+    job = Delayed::Job.new handler: %(test: ""11")
+    expect { job.payload_object.perform }.to raise_error(Delayed::Backend::DeserializationError, /parsing error/)
   end
 
   describe "find_available" do
-    it "should not find failed jobs" do
-      @job = create_job :attempts => 50
+    it "does not find failed jobs" do
+      @job = create_job attempts: 50
       @job.fail!
-      Delayed::Job.find_available(5).should_not include(@job)
+      expect(Delayed::Job.find_available(5)).not_to include(@job)
     end
 
-    it "should not find jobs scheduled for the future" do
-      @job = create_job :run_at => (Delayed::Job.db_time_now + 1.minute)
-      Delayed::Job.find_available(5).should_not include(@job)
+    it "does not find jobs scheduled for the future" do
+      @job = create_job run_at: (Delayed::Job.db_time_now + 1.minute)
+      expect(Delayed::Job.find_available(5)).not_to include(@job)
     end
 
-    it "should not find jobs locked by another worker" do
+    it "does not find jobs locked by another worker" do
       @job = create_job
-      Delayed::Job.get_and_lock_next_available('other_worker').should == @job
-      Delayed::Job.find_available(5).should_not include(@job)
+      expect(Delayed::Job.get_and_lock_next_available("other_worker")).to eq(@job)
+      expect(Delayed::Job.find_available(5)).not_to include(@job)
     end
 
-    it "should find open jobs" do
+    it "finds open jobs" do
       @job = create_job
-      Delayed::Job.find_available(5).should include(@job)
+      expect(Delayed::Job.find_available(5)).to include(@job)
     end
 
     it "returns an empty hash when asking for multiple jobs, and there aren't any" do
-      locked_jobs = Delayed::Job.get_and_lock_next_available(['worker1', 'worker2'])
-      locked_jobs.should == {}
+      locked_jobs = Delayed::Job.get_and_lock_next_available(%w[worker1 worker2])
+      expect(locked_jobs).to eq({})
     end
   end
 
   context "when another worker is already performing an task, it" do
-
-    before :each do
-      @job = Delayed::Job.create :payload_object => SimpleJob.new
-      Delayed::Job.get_and_lock_next_available('worker1').should == @job
+    before do
+      @job = Delayed::Job.create payload_object: SimpleJob.new
+      expect(Delayed::Job.get_and_lock_next_available("worker1")).to eq(@job)
     end
 
-    it "should not allow a second worker to get exclusive access" do
-      Delayed::Job.get_and_lock_next_available('worker2').should be_nil
+    it "does not allow a second worker to get exclusive access" do
+      expect(Delayed::Job.get_and_lock_next_available("worker2")).to be_nil
     end
 
-    it "should not be found by another worker" do
-      Delayed::Job.find_available(1).length.should == 0
+    it "is not found by another worker" do
+      expect(Delayed::Job.find_available(1).length).to eq(0)
     end
   end
 
-  context "#name" do
-    it "should be the class name of the job that was enqueued" do
-      Delayed::Job.create(:payload_object => ErrorJob.new ).name.should == 'ErrorJob'
+  describe "#name" do
+    it "is the class name of the job that was enqueued" do
+      expect(Delayed::Job.create(payload_object: ErrorJob.new).name).to eq("ErrorJob")
     end
 
-    it "should be the method that will be called if its a performable method object" do
+    it "is the method that will be called if its a performable method object" do
       @job = Story.delay(ignore_transaction: true).create
-      @job.name.should == "Story.create"
+      expect(@job.name).to eq("Story.create")
     end
 
-    it "should be the instance method that will be called if its a performable method object" do
-      @job = Story.create(:text => "...").delay(ignore_transaction: true).save
-      @job.name.should == 'Story#save'
+    it "is the instance method that will be called if its a performable method object" do
+      @job = Story.create(text: "...").delay(ignore_transaction: true).save
+      expect(@job.name).to eq("Story#save")
     end
   end
 
   context "worker prioritization" do
-    it "should fetch jobs ordered by priority" do
-      10.times { create_job :priority => rand(10) }
+    it "fetches jobs ordered by priority" do
+      10.times { create_job priority: rand(10) }
       jobs = Delayed::Job.find_available(10)
-      jobs.size.should == 10
+      expect(jobs.size).to eq(10)
       jobs.each_cons(2) do |a, b|
-        a.priority.should <= b.priority
+        expect(a.priority).to be <= b.priority
       end
     end
 
-    it "should not find jobs lower than the given priority" do
-      job1 = create_job :priority => 5
-      found = Delayed::Job.get_and_lock_next_available('test1', Delayed::Settings.queue, 10, 20)
-      found.should be_nil
-      job2 = create_job :priority => 10
-      found = Delayed::Job.get_and_lock_next_available('test1', Delayed::Settings.queue, 10, 20)
-      found.should == job2
-      job3 = create_job :priority => 15
-      found = Delayed::Job.get_and_lock_next_available('test2', Delayed::Settings.queue, 10, 20)
-      found.should == job3
+    it "does not find jobs lower than the given priority" do
+      create_job priority: 5
+      found = Delayed::Job.get_and_lock_next_available("test1", Delayed::Settings.queue, 10, 20)
+      expect(found).to be_nil
+      job2 = create_job priority: 10
+      found = Delayed::Job.get_and_lock_next_available("test1", Delayed::Settings.queue, 10, 20)
+      expect(found).to eq(job2)
+      job3 = create_job priority: 15
+      found = Delayed::Job.get_and_lock_next_available("test2", Delayed::Settings.queue, 10, 20)
+      expect(found).to eq(job3)
     end
 
-    it "should not find jobs higher than the given priority" do
-      job1 = create_job :priority => 25
-      found = Delayed::Job.get_and_lock_next_available('test1', Delayed::Settings.queue, 10, 20)
-      found.should be_nil
-      job2 = create_job :priority => 20
-      found = Delayed::Job.get_and_lock_next_available('test1', Delayed::Settings.queue, 10, 20)
-      found.should == job2
-      job3 = create_job :priority => 15
-      found = Delayed::Job.get_and_lock_next_available('test2', Delayed::Settings.queue, 10, 20)
-      found.should == job3
+    it "does not find jobs higher than the given priority" do
+      create_job priority: 25
+      found = Delayed::Job.get_and_lock_next_available("test1", Delayed::Settings.queue, 10, 20)
+      expect(found).to be_nil
+      job2 = create_job priority: 20
+      found = Delayed::Job.get_and_lock_next_available("test1", Delayed::Settings.queue, 10, 20)
+      expect(found).to eq(job2)
+      job3 = create_job priority: 15
+      found = Delayed::Job.get_and_lock_next_available("test2", Delayed::Settings.queue, 10, 20)
+      expect(found).to eq(job3)
     end
   end
 
   context "clear_locks!" do
     before do
-      @job = create_job(:locked_by => 'worker', :locked_at => Delayed::Job.db_time_now)
+      @job = create_job(locked_by: "worker", locked_at: Delayed::Job.db_time_now)
     end
 
-    it "should clear locks for the given worker" do
-      Delayed::Job.clear_locks!('worker')
-      Delayed::Job.find_available(5).should include(@job)
+    it "clears locks for the given worker" do
+      Delayed::Job.clear_locks!("worker")
+      expect(Delayed::Job.find_available(5)).to include(@job)
     end
 
-    it "should not clear locks for other workers" do
-      Delayed::Job.clear_locks!('worker1')
-      Delayed::Job.find_available(5).should_not include(@job)
+    it "does not clear locks for other workers" do
+      Delayed::Job.clear_locks!("worker1")
+      expect(Delayed::Job.find_available(5)).not_to include(@job)
     end
   end
 
   context "unlock" do
     before do
-      @job = create_job(:locked_by => 'worker', :locked_at => Delayed::Job.db_time_now)
+      @job = create_job(locked_by: "worker", locked_at: Delayed::Job.db_time_now)
     end
 
-    it "should clear locks" do
+    it "clears locks" do
       @job.unlock
-      @job.locked_by.should be_nil
-      @job.locked_at.should be_nil
+      expect(@job.locked_by).to be_nil
+      expect(@job.locked_at).to be_nil
     end
 
     it "clears locks from multiple jobs" do
-      job2 = create_job(:locked_by => 'worker', :locked_at => Delayed::Job.db_time_now)
+      job2 = create_job(locked_by: "worker", locked_at: Delayed::Job.db_time_now)
       Delayed::Job.unlock([@job, job2])
       expect(@job.locked_at).to be_nil
       expect(job2.locked_at).to be_nil
@@ -225,302 +230,393 @@ 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(Delayed::Job.find(job.id).locked_by).to eq 'worker2'
+      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(Delayed::Job.find(job.id).locked_by).to eq "worker2"
     end
   end
 
   context "strands" do
-    it "should run strand jobs in strict order" do
-      job1 = create_job(:strand => 'myjobs')
-      job2 = create_job(:strand => 'myjobs')
-      Delayed::Job.get_and_lock_next_available('w1').should == job1
-      Delayed::Job.get_and_lock_next_available('w2').should == nil
+    it "runs strand jobs in strict order" 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)
       job1.destroy
       # update time since the failed lock pushed it forward
       job2.run_at = 1.minute.ago
       job2.save!
-      Delayed::Job.get_and_lock_next_available('w3').should == job2
-      Delayed::Job.get_and_lock_next_available('w4').should == nil
+      expect(Delayed::Job.get_and_lock_next_available("w3")).to eq(job2)
+      expect(Delayed::Job.get_and_lock_next_available("w4")).to eq(nil)
     end
 
-    it "should fail to lock if an earlier job gets locked" do
-      job1 = create_job(:strand => 'myjobs')
-      job2 = create_job(:strand => 'myjobs')
-      Delayed::Job.find_available(2).should == [job1]
-      Delayed::Job.find_available(2).should == [job1]
+    it "fails to lock if an earlier job gets locked" do
+      job1 = create_job(strand: "myjobs")
+      job2 = create_job(strand: "myjobs")
+      expect(Delayed::Job.find_available(2)).to eq([job1])
+      expect(Delayed::Job.find_available(2)).to eq([job1])
 
       # job1 gets locked by w1
-      Delayed::Job.get_and_lock_next_available('w1').should == job1
+      expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(job1)
 
       # normally w2 would now be able to lock job2, but strands prevent it
-      Delayed::Job.get_and_lock_next_available('w2').should be_nil
+      expect(Delayed::Job.get_and_lock_next_available("w2")).to be_nil
 
       # now job1 is done
       job1.destroy
       # update time since the failed lock pushed it forward
       job2.run_at = 1.minute.ago
       job2.save!
-      Delayed::Job.get_and_lock_next_available('w2').should == job2
+      expect(Delayed::Job.get_and_lock_next_available("w2")).to eq(job2)
     end
 
-    it "should keep strand jobs in order as they are rescheduled" do
-      job1 = create_job(:strand => 'myjobs')
-      job2 = create_job(:strand => 'myjobs')
-      job3 = create_job(:strand => 'myjobs')
-      Delayed::Job.get_and_lock_next_available('w1').should == job1
-      Delayed::Job.find_available(1).should == []
+    it "keeps strand jobs in order as they are rescheduled" do
+      job1 = create_job(strand: "myjobs")
+      job2 = create_job(strand: "myjobs")
+      job3 = create_job(strand: "myjobs")
+      expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(job1)
+      expect(Delayed::Job.find_available(1)).to eq([])
       job1.destroy
-      Delayed::Job.find_available(1).should == [job2]
+      expect(Delayed::Job.find_available(1)).to eq([job2])
       # move job2's time forward
       job2.run_at = 1.second.ago
       job2.save!
       job3.run_at = 5.seconds.ago
       job3.save!
       # we should still get job2, not job3
-      Delayed::Job.get_and_lock_next_available('w1').should == job2
+      expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(job2)
     end
 
-    it "should allow to run the next job if a failed job is present" do
-      job1 = create_job(:strand => 'myjobs')
-      job2 = create_job(:strand => 'myjobs')
+    it "allows to run the next job if a failed job is present" do
+      job1 = create_job(strand: "myjobs")
+      job2 = create_job(strand: "myjobs")
       job1.fail!
-      Delayed::Job.get_and_lock_next_available('w1').should == job2
+      expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(job2)
     end
 
-    it "should not interfere with jobs with no strand" do
-      jobs = [create_job(:strand => nil), create_job(:strand => 'myjobs')]
-      locked = [Delayed::Job.get_and_lock_next_available('w1'),
-                Delayed::Job.get_and_lock_next_available('w2')]
-      jobs.should =~ locked
-      Delayed::Job.get_and_lock_next_available('w3').should == nil
+    it "does not interfere with jobs with no strand" do
+      jobs = [create_job(strand: nil), create_job(strand: "myjobs")]
+      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)
     end
 
-    it "should not interfere with jobs in other strands" do
-      jobs = [create_job(:strand => 'strand1'), create_job(:strand => 'strand2')]
-      locked = [Delayed::Job.get_and_lock_next_available('w1'),
-                Delayed::Job.get_and_lock_next_available('w2')]
-      jobs.should =~ locked
-      Delayed::Job.get_and_lock_next_available('w3').should == nil
+    it "does not interfere with jobs in other strands" do
+      jobs = [create_job(strand: "strand1"), create_job(strand: "strand2")]
+      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)
     end
 
-    it "should not find next jobs when given no priority" do
-      jobs = [create_job(:strand => 'strand1'), create_job(:strand => 'strand1')]
-      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)
+    it "does not find next jobs when given no priority" do
+      jobs = [create_job(strand: "strand1"), create_job(strand: "strand1")]
+      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
     end
 
     it "complains if you pass more than one strand-based option" do
-      expect { create_job(strand: 'a', n_strand: 'b') }.to raise_error(ArgumentError)
-      expect { create_job(strand: 'a', singleton: 'b') }.to raise_error(ArgumentError)
-      expect { create_job(n_strand: 'a', singleton: 'b') }.to raise_error(ArgumentError)
-      expect { create_job(strand: 'a', n_strand: 'b', singleton: 'c') }.to raise_error(ArgumentError)
+      expect { create_job(strand: "a", n_strand: "b") }.to raise_error(ArgumentError)
     end
 
-    context 'singleton' do
-      it "should create if there's no jobs on the strand" do
-        @job = create_job(:singleton => 'myjobs')
-        @job.should be_present
-        Delayed::Job.get_and_lock_next_available('w1').should == @job
+    context "singleton" do
+      it "creates if there's no jobs on the strand" do
+        @job = create_job(singleton: "myjobs")
+        expect(@job).to be_present
+        expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(@job)
       end
 
-      it "should create if there's another job on the strand, but it's running" do
-        @job = create_job(:singleton => 'myjobs')
-        @job.should be_present
-        Delayed::Job.get_and_lock_next_available('w1').should == @job
+      it "creates if there's another job on the strand, but it's running" do
+        @job = create_job(singleton: "myjobs")
+        expect(@job).to be_present
+        expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(@job)
 
-        @job2 = create_job(:singleton => 'myjobs')
-        @job.should be_present
-        @job2.should_not == @job
+        @job2 = create_job(singleton: "myjobs")
+        expect(@job).to be_present
+        expect(@job2).not_to eq(@job)
       end
 
-      it "should not create if there's another non-running job on the strand" do
-        @job = create_job(:singleton => 'myjobs')
-        @job.should be_present
+      it "does not create if there's another non-running job on the strand" do
+        @job = create_job(singleton: "myjobs")
+        expect(@job).to be_present
 
-        @job2 = create_job(:singleton => 'myjobs')
-        @job2.should == @job
+        @job2 = create_job(singleton: "myjobs")
+        expect(@job2).to be_new_record
       end
 
-      it "should not create if there's a job running and one waiting on the strand" do
-        @job = create_job(:singleton => 'myjobs')
-        @job.should be_present
-        Delayed::Job.get_and_lock_next_available('w1').should == @job
+      it "does not create if there's a job running and one waiting on the strand" do
+        @job = create_job(singleton: "myjobs")
+        expect(@job).to be_present
+        expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(@job)
 
-        @job2 = create_job(:singleton => 'myjobs')
-        @job2.should be_present
-        @job2.should_not == @job
+        @job2 = create_job(singleton: "myjobs")
+        expect(@job2).to be_present
+        expect(@job2).not_to eq(@job)
 
-        @job3 = create_job(:singleton => 'myjobs')
-        @job3.should == @job2
+        @job3 = create_job(singleton: "myjobs")
+        expect(@job3).to be_new_record
       end
 
-      it "should update existing job if new job is set to run sooner" do
-        job1 = create_job(singleton: 'myjobs', run_at: 1.hour.from_now)
-        job2 = create_job(singleton: 'myjobs')
-        job2.should == job1
+      it "updates existing job if new job is set to run sooner" do
+        job1 = create_job(singleton: "myjobs", run_at: 1.hour.from_now)
+        job2 = create_job(singleton: "myjobs")
+        expect(job2).to eq(job1)
         # it should be scheduled to run immediately
-        Delayed::Job.get_and_lock_next_available('w1').should == job1
+        expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(job1)
       end
 
-      it "should update existing job to a later date if requested" do
+      it "updates existing job to a later date if requested" do
         t1 = 1.hour.from_now
         t2 = 2.hours.from_now
-        job1 = create_job(singleton: 'myjobs', run_at: t1)
-        job2 = create_job(singleton: 'myjobs', run_at: t2)
-        job2.should == job1
-        job2.run_at.to_i.should == t1.to_i
-
-        job3 = create_job(singleton: 'myjobs', run_at: t2, on_conflict: :overwrite)
-        job3.should == job1
-        job3.run_at.to_i.should == t2.to_i
+        job1 = create_job(singleton: "myjobs", run_at: t1)
+        job2 = create_job(singleton: "myjobs", run_at: t2)
+        expect(job2).to be_new_record
+
+        job3 = create_job(singleton: "myjobs", run_at: t2, on_conflict: :overwrite)
+        expect(job3).to eq(job1)
+        expect(job3.run_at.to_i).to eq(t2.to_i)
       end
 
-      it "should update existing singleton job handler if requested" do
-        job1 = Delayed::Job.enqueue(SimpleJob.new, queue: nil, singleton: 'myjobs', on_conflict: :overwrite)
-        job2 = Delayed::Job.enqueue(ErrorJob.new, queue: nil, singleton: 'myjobs', on_conflict: :overwrite)
-        job2.should == job1
-        expect(job2.handler).to include("ErrorJob")
+      it "updates existing singleton job handler if requested" do
+        job1 = Delayed::Job.enqueue(SimpleJob.new, queue: nil, singleton: "myjobs", on_conflict: :overwrite)
+        job2 = Delayed::Job.enqueue(ErrorJob.new, queue: nil, singleton: "myjobs", on_conflict: :overwrite)
+        expect(job2).to eq(job1)
+        expect(job1.reload.handler).to include("ErrorJob")
       end
 
-      it "does not create even if it's earlier when in loose mode" do
-        t1 = 1.hour.from_now
-        job1 = create_job(singleton: 'myjobs', run_at: t1)
-        job2 = create_job(singleton: 'myjobs', on_conflict: :loose)
-        job1.should == job2
-        job2.run_at.to_i.should == t1.to_i
+      context "next_in_strand management" do
+        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
+
+          @job1.destroy
+          expect(@job2.reload.next_in_strand).to eq true
+        end
+
+        it "when combined with a strand" do
+          job1 = create_job(singleton: "singleton", strand: "strand")
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job1
+          job2 = create_job(singleton: "singleton", strand: "strand")
+          expect(job2).not_to eq job1
+          expect(job2).not_to be_new_record
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          job3 = create_job(strand: "strand")
+          job4 = create_job(strand: "strand")
+          expect(job3.reload).not_to be_next_in_strand
+          expect(job4.reload).not_to be_next_in_strand
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          job1.destroy
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job2
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          job2.destroy
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job3
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          job3.destroy
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job4
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+        end
+
+        it "when combined with a small n_strand" do
+          allow(Delayed::Settings).to receive(:num_strands).and_return(->(*) { 2 })
+
+          job1 = create_job(singleton: "singleton", n_strand: "strand")
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job1
+          job2 = create_job(singleton: "singleton", n_strand: "strand")
+          expect(job2).not_to eq job1
+          expect(job2).not_to be_new_record
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          job3 = create_job(n_strand: "strand")
+          job4 = create_job(n_strand: "strand")
+          expect(job3.reload).to be_next_in_strand
+          expect(job4.reload).not_to be_next_in_strand
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job3
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          # this doesn't unlock job2, even though it's ahead of job4
+          job3.destroy
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job4
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          job4.destroy
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          job1.destroy
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job2
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+        end
+
+        it "when combined with a larger n_strand" do
+          allow(Delayed::Settings).to receive(:num_strands).and_return(->(*) { 10 })
+
+          job1 = create_job(singleton: "singleton", n_strand: "strand")
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job1
+          job2 = create_job(singleton: "singleton", n_strand: "strand")
+          expect(job2).not_to eq job1
+          expect(job2).not_to be_new_record
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          job3 = create_job(n_strand: "strand")
+          job4 = create_job(n_strand: "strand")
+          expect(job3.reload).to be_next_in_strand
+          expect(job4.reload).to be_next_in_strand
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job3
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job4
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          # this doesn't unlock job2
+          job3.destroy
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          job4.destroy
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+          job1.destroy
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to eq job2
+          expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
+        end
+      end
+
+      context "with on_conflict: loose and strand-inferred-from-singleton" do
+        around do |example|
+          Delayed::Settings.infer_strand_from_singleton = true
+          example.call
+        ensure
+          Delayed::Settings.infer_strand_from_singleton = false
+        end
+
+        it "does not create if there's another non-running job on the strand" do
+          @job = create_job(singleton: "myjobs", on_conflict: :loose)
+          expect(@job).to be_present
+
+          @job2 = create_job(singleton: "myjobs", on_conflict: :loose)
+          expect(@job2).to be_new_record
+        end
       end
     end
   end
 
   context "on hold" do
-    it "should hold/unhold jobs" do
-      job1 = create_job()
+    it "hold/unholds jobs" do
+      job1 = create_job
       job1.hold!
-      Delayed::Job.get_and_lock_next_available('w1').should be_nil
+      expect(Delayed::Job.get_and_lock_next_available("w1")).to be_nil
 
       job1.unhold!
-      Delayed::Job.get_and_lock_next_available('w1').should == job1
+      expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(job1)
     end
   end
 
   context "periodic jobs" do
-    before(:each) do
+    before do
       # make the periodic job get scheduled in the past
       @cron_time = 10.minutes.ago
       allow(Delayed::Periodic).to receive(:now).and_return(@cron_time)
       Delayed::Periodic.scheduled = {}
-      Delayed::Periodic.cron('my SimpleJob', '*/5 * * * * *') do
+      Delayed::Periodic.cron("my SimpleJob", "*/5 * * * * *") do
         Delayed::Job.enqueue(SimpleJob.new)
       end
     end
 
-    it "should schedule jobs if they aren't scheduled yet" do
-      Delayed::Job.jobs_count(:current).should == 0
+    it "schedules jobs if they aren't scheduled yet" do
+      expect(Delayed::Job.jobs_count(:current)).to eq(0)
       Delayed::Periodic.perform_audit!
-      Delayed::Job.jobs_count(:current).should == 1
-      job = Delayed::Job.get_and_lock_next_available('test1')
-      job.tag.should == 'periodic: my SimpleJob'
-      job.payload_object.should == Delayed::Periodic.scheduled['my SimpleJob']
-      job.run_at.should >= @cron_time
-      job.run_at.should <= @cron_time + 6.minutes
-      job.strand.should == job.tag
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
+      job = Delayed::Job.get_and_lock_next_available("test1")
+      expect(job.tag).to eq("periodic: my SimpleJob")
+      expect(job.payload_object).to eq(Delayed::Periodic.scheduled["my SimpleJob"])
+      expect(job.run_at).to be >= @cron_time
+      expect(job.run_at).to be <= @cron_time + 6.minutes
+      expect(job.singleton).to eq(job.tag)
     end
 
-    it "should schedule jobs if there are only failed jobs on the queue" do
-      Delayed::Job.jobs_count(:current).should == 0
+    it "schedules jobs if there are only failed jobs on the queue" do
+      expect(Delayed::Job.jobs_count(:current)).to eq(0)
       expect { Delayed::Periodic.perform_audit! }.to change { Delayed::Job.jobs_count(:current) }.by(1)
-      Delayed::Job.jobs_count(:current).should == 1
-      job = Delayed::Job.get_and_lock_next_available('test1')
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
+      job = Delayed::Job.get_and_lock_next_available("test1")
       job.fail!
-      expect { Delayed::Periodic.perform_audit! }.to change{ Delayed::Job.jobs_count(:current) }.by(1)
+      expect { Delayed::Periodic.perform_audit! }.to change { Delayed::Job.jobs_count(:current) }.by(1)
     end
 
-    it "should not schedule jobs that are already scheduled" do
-      Delayed::Job.jobs_count(:current).should == 0
+    it "does not schedule jobs that are already scheduled" do
+      expect(Delayed::Job.jobs_count(:current)).to eq(0)
       Delayed::Periodic.perform_audit!
-      Delayed::Job.jobs_count(:current).should == 1
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
       job = Delayed::Job.find_available(1).first
       Delayed::Periodic.perform_audit!
-      Delayed::Job.jobs_count(:current).should == 1
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
       # verify that the same job still exists, it wasn't just replaced with a new one
-      job.should == Delayed::Job.find_available(1).first
+      expect(job).to eq(Delayed::Job.find_available(1).first)
     end
 
-    it "should schedule the next job run after performing" do
-      Delayed::Job.jobs_count(:current).should == 0
+    it "schedules the next job run after performing" do
+      expect(Delayed::Job.jobs_count(:current)).to eq(0)
       Delayed::Periodic.perform_audit!
-      Delayed::Job.jobs_count(:current).should == 1
-      job = Delayed::Job.get_and_lock_next_available('test')
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
+      job = Delayed::Job.get_and_lock_next_available("test")
       run_job(job)
 
-      job = Delayed::Job.get_and_lock_next_available('test1')
-      job.tag.should == 'SimpleJob#perform'
+      job = Delayed::Job.get_and_lock_next_available("test1")
+      expect(job.tag).to eq("SimpleJob#perform")
 
-      next_scheduled = Delayed::Job.get_and_lock_next_available('test2')
-      next_scheduled.tag.should == 'periodic: my SimpleJob'
-      next_scheduled.payload_object.should be_is_a(Delayed::Periodic)
+      next_scheduled = Delayed::Job.get_and_lock_next_available("test2")
+      expect(next_scheduled.tag).to eq("periodic: my SimpleJob")
+      expect(next_scheduled.payload_object).to be_is_a(Delayed::Periodic)
     end
 
-    it "should reject duplicate named jobs" do
-      proc { Delayed::Periodic.cron('my SimpleJob', '*/15 * * * * *') {} }.should raise_error(ArgumentError)
+    it "rejects duplicate named jobs" do
+      expect { Delayed::Periodic.cron("my SimpleJob", "*/15 * * * * *") { nil } }.to raise_error(ArgumentError)
     end
 
-    it "should handle jobs that are no longer scheduled" do
+    it "handles jobs that are no longer scheduled" do
       Delayed::Periodic.perform_audit!
       Delayed::Periodic.scheduled = {}
-      job = Delayed::Job.get_and_lock_next_available('test')
+      job = Delayed::Job.get_and_lock_next_available("test")
       run_job(job)
       # shouldn't error, and the job should now be deleted
-      Delayed::Job.jobs_count(:current).should == 0
+      expect(Delayed::Job.jobs_count(:current)).to eq(0)
     end
 
-    it "should allow overriding schedules using periodic_jobs.yml" do
-      change_setting(Delayed::Periodic, :overrides, { 'my ChangedJob' => '*/10 * * * * *' }) do
+    it "allows overriding schedules using periodic_jobs.yml" do
+      change_setting(Delayed::Periodic, :overrides, { "my ChangedJob" => "*/10 * * * * *" }) do
         Delayed::Periodic.scheduled = {}
-        Delayed::Periodic.cron('my ChangedJob', '*/5 * * * * *') do
+        Delayed::Periodic.cron("my ChangedJob", "*/5 * * * * *") do
           Delayed::Job.enqueue(SimpleJob.new)
         end
-        Delayed::Periodic.scheduled['my ChangedJob'].cron.original.should == '*/10 * * * * *'
+        expect(Delayed::Periodic.scheduled["my ChangedJob"].cron.original).to eq("*/10 * * * * *")
       end
     end
 
-    it "should fail if the override cron line is invalid" do
-      change_setting(Delayed::Periodic, :overrides, { 'my ChangedJob' => '*/10 * * * * * *' }) do # extra asterisk
+    it "fails if the override cron line is invalid" do
+      change_setting(Delayed::Periodic, :overrides, { "my ChangedJob" => "*/10 * * * * * *" }) do # extra asterisk
         Delayed::Periodic.scheduled = {}
-        expect { Delayed::Periodic.cron('my ChangedJob', '*/5 * * * * *') do
-          Delayed::Job.enqueue(SimpleJob.new)
-        end }.to raise_error(ArgumentError)
+        expect do
+          Delayed::Periodic.cron("my ChangedJob", "*/5 * * * * *") do
+            Delayed::Job.enqueue(SimpleJob.new)
+          end
+        end.to raise_error(ArgumentError)
       end
 
-      expect { Delayed::Periodic.add_overrides({ 'my ChangedJob' => '*/10 * * * * * *' }) }.to raise_error(ArgumentError)
+      expect do
+        Delayed::Periodic.add_overrides({ "my ChangedJob" => "*/10 * * * * * *" })
+      end.to raise_error(ArgumentError)
     end
   end
 
-  module InDelayedJobTest
-    def self.check_in_job
-      Delayed::Job.in_delayed_job?.should == true
-    end
-  end
-
-  it "should set in_delayed_job?" do
+  it "sets in_delayed_job?" do
     job = InDelayedJobTest.delay(ignore_transaction: true).check_in_job
-    Delayed::Job.in_delayed_job?.should == false
+    expect(Delayed::Job.in_delayed_job?).to eq(false)
     job.invoke_job
-    Delayed::Job.in_delayed_job?.should == false
+    expect(Delayed::Job.in_delayed_job?).to eq(false)
   end
 
-  it "should fail on job creation if an unsaved AR object is used" do
-    story = Story.new :text => "Once upon..."
-    lambda { story.delay.text }.should raise_error(RuntimeError)
+  it "fails on job creation if an unsaved AR object is used" do
+    story = Story.new text: "Once upon..."
+    expect { story.delay.text }.to raise_error(RuntimeError)
 
     reader = StoryReader.new
-    lambda { reader.delay.read(story) }.should raise_error(RuntimeError)
+    expect { reader.delay.read(story) }.to raise_error(RuntimeError)
 
-    lambda { [story, 1, story, false].delay.first }.should raise_error(RuntimeError)
+    expect { [story, 1, story, false].delay.first }.to raise_error(RuntimeError)
   end
 
   # the sort order of current_jobs and list_jobs depends on the back-end
@@ -528,62 +624,62 @@ shared_examples_for 'a backend' do
   describe "current jobs, queue size, strand_size" do
     before do
       @jobs = []
-      3.times { @jobs << create_job(:priority => 3) }
-      @jobs.unshift create_job(:priority => 2)
-      @jobs.unshift create_job(:priority => 1)
-      @jobs << create_job(:priority => 3, :strand => "test1")
-      @future_job = create_job(:run_at => 5.hours.from_now)
-      2.times { @jobs << create_job(:priority => 3) }
-      @jobs << create_job(:priority => 3, :strand => "test1")
-      @failed_job = create_job.tap { |j| j.fail! }
-      @other_queue_job = create_job(:queue => "another")
+      3.times { @jobs << create_job(priority: 3) }
+      @jobs.unshift create_job(priority: 2)
+      @jobs.unshift create_job(priority: 1)
+      @jobs << create_job(priority: 3, strand: "test1")
+      @future_job = create_job(run_at: 5.hours.from_now)
+      2.times { @jobs << create_job(priority: 3) }
+      @jobs << create_job(priority: 3, strand: "test1")
+      @failed_job = create_job.tap(&:fail!)
+      @other_queue_job = create_job(queue: "another")
     end
 
-    it "should return the queued jobs" do
-      Delayed::Job.list_jobs(:current, 100).map(&:id).sort.should == @jobs.map(&:id).sort
+    it "returns the queued jobs" do
+      expect(Delayed::Job.list_jobs(:current, 100).map(&:id).sort).to eq(@jobs.map(&:id).sort)
     end
 
-    it "should paginate the returned jobs" do
+    it "paginates the returned jobs" do
       @returned = []
       @returned += Delayed::Job.list_jobs(:current, 3, 0)
       @returned += Delayed::Job.list_jobs(:current, 4, 3)
       @returned += Delayed::Job.list_jobs(:current, 100, 7)
-      @returned.sort_by { |j| j.id }.should == @jobs.sort_by { |j| j.id }
+      expect(@returned.sort_by(&:id)).to eq(@jobs.sort_by(&:id))
     end
 
-    it "should return other queues" do
-      Delayed::Job.list_jobs(:current, 5, 0, "another").should == [@other_queue_job]
+    it "returns other queues" do
+      expect(Delayed::Job.list_jobs(:current, 5, 0, "another")).to eq([@other_queue_job])
     end
 
-    it "should return queue size" do
-      Delayed::Job.jobs_count(:current).should == @jobs.size
-      Delayed::Job.jobs_count(:current, "another").should == 1
-      Delayed::Job.jobs_count(:current, "bogus").should == 0
+    it "returns queue size" do
+      expect(Delayed::Job.jobs_count(:current)).to eq(@jobs.size)
+      expect(Delayed::Job.jobs_count(:current, "another")).to eq(1)
+      expect(Delayed::Job.jobs_count(:current, "bogus")).to eq(0)
     end
 
-    it "should return strand size" do
-      Delayed::Job.strand_size("test1").should == 2
-      Delayed::Job.strand_size("bogus").should == 0
+    it "returns strand size" do
+      expect(Delayed::Job.strand_size("test1")).to eq(2)
+      expect(Delayed::Job.strand_size("bogus")).to eq(0)
     end
   end
 
-  it "should return the jobs in a strand" do
+  it "returns the jobs in a strand" do
     strand_jobs = []
-    3.times { strand_jobs << create_job(:strand => 'test1') }
-    2.times { create_job(:strand => 'test2') }
-    strand_jobs << create_job(:strand => 'test1', :run_at => 5.hours.from_now)
+    3.times { strand_jobs << create_job(strand: "test1") }
+    2.times { create_job(strand: "test2") }
+    strand_jobs << create_job(strand: "test1", run_at: 5.hours.from_now)
     create_job
 
     jobs = Delayed::Job.list_jobs(:strand, 3, 0, "test1")
-    jobs.size.should == 3
+    expect(jobs.size).to eq(3)
 
     jobs += Delayed::Job.list_jobs(:strand, 3, 3, "test1")
-    jobs.size.should == 4
+    expect(jobs.size).to eq(4)
 
-    jobs.sort_by { |j| j.id }.should == strand_jobs.sort_by { |j| j.id }
+    expect(jobs.sort_by(&:id)).to eq(strand_jobs.sort_by(&:id))
   end
 
-  it "should return the jobs for a tag" do
+  it "returns the jobs for a tag" do
     tag_jobs = []
     3.times { tag_jobs << "test".delay(ignore_transaction: true).to_s }
     2.times { "test".delay.to_i }
@@ -593,62 +689,62 @@ shared_examples_for 'a backend' do
     create_job
 
     jobs = Delayed::Job.list_jobs(:tag, 3, 0, "String#to_s")
-    jobs.size.should == 3
+    expect(jobs.size).to eq(3)
 
     jobs += Delayed::Job.list_jobs(:tag, 3, 3, "String#to_s")
-    jobs.size.should == 5
+    expect(jobs.size).to eq(5)
 
-    jobs.sort_by { |j| j.id }.should == tag_jobs.sort_by { |j| j.id }
+    expect(jobs.sort_by(&:id)).to eq(tag_jobs.sort_by(&:id))
   end
 
   describe "running_jobs" do
-    it "should return the running jobs, ordered by locked_at" do
+    it "returns the running jobs, ordered by locked_at" do
       Timecop.freeze(10.minutes.ago) { 3.times { create_job } }
-      j1 = Timecop.freeze(2.minutes.ago) { Delayed::Job.get_and_lock_next_available('w1') }
-      j2 = Timecop.freeze(5.minutes.ago) { Delayed::Job.get_and_lock_next_available('w2') }
-      j3 = Timecop.freeze(5.seconds.ago) { Delayed::Job.get_and_lock_next_available('w3') }
-      [j1, j2, j3].compact.size.should == 3
+      j1 = Timecop.freeze(2.minutes.ago) { Delayed::Job.get_and_lock_next_available("w1") }
+      j2 = Timecop.freeze(5.minutes.ago) { Delayed::Job.get_and_lock_next_available("w2") }
+      j3 = Timecop.freeze(5.seconds.ago) { Delayed::Job.get_and_lock_next_available("w3") }
+      expect([j1, j2, j3].compact.size).to eq(3)
 
-      Delayed::Job.running_jobs.should == [j2, j1, j3]
+      expect(Delayed::Job.running_jobs).to eq([j2, j1, j3])
     end
   end
 
   describe "future jobs" do
-    it "should find future jobs once their run_at rolls by" do
-      Timecop.freeze {
-        @job = create_job :run_at => 5.minutes.from_now
+    it "finds future jobs once their run_at rolls by" do
+      Timecop.freeze do
+        @job = create_job run_at: 5.minutes.from_now
         expect(Delayed::Job.find_available(5)).not_to include(@job)
-      }
-      Timecop.freeze(1.hour.from_now) {
+      end
+      Timecop.freeze(1.hour.from_now) do
         expect(Delayed::Job.find_available(5)).to include(@job)
-        Delayed::Job.get_and_lock_next_available('test').should == @job
-      }
+        expect(Delayed::Job.get_and_lock_next_available("test")).to eq(@job)
+      end
     end
 
-    it "should return future jobs sorted by their run_at" do
+    it "returns future jobs sorted by their run_at" do
       @j1 = create_job
-      @j2 = create_job :run_at => 1.hour.from_now
-      @j3 = create_job :run_at => 30.minutes.from_now
-      Delayed::Job.list_jobs(:future, 1).should == [@j3]
-      Delayed::Job.list_jobs(:future, 5).should == [@j3, @j2]
-      Delayed::Job.list_jobs(:future, 1, 1).should == [@j2]
+      @j2 = create_job run_at: 1.hour.from_now
+      @j3 = create_job run_at: 30.minutes.from_now
+      expect(Delayed::Job.list_jobs(:future, 1)).to eq([@j3])
+      expect(Delayed::Job.list_jobs(:future, 5)).to eq([@j3, @j2])
+      expect(Delayed::Job.list_jobs(:future, 1, 1)).to eq([@j2])
     end
   end
 
   describe "failed jobs" do
     # the sort order of failed_jobs depends on the back-end implementation,
     # so sort order isn't tested here
-    it "should return the list of failed jobs" do
+    it "returns the list of failed jobs" do
       jobs = []
-      3.times { jobs << create_job(:priority => 3) }
-      jobs = jobs.sort_by { |j| j.id }
-      Delayed::Job.list_jobs(:failed, 1).should == []
+      3.times { jobs << create_job(priority: 3) }
+      jobs = jobs.sort_by(&:id)
+      expect(Delayed::Job.list_jobs(:failed, 1)).to eq([])
       jobs[0].fail!
       jobs[1].fail!
-      failed = (Delayed::Job.list_jobs(:failed, 1, 0) + Delayed::Job.list_jobs(:failed, 1, 1)).sort_by { |j| j.id }
-      failed.size.should == 2
-      failed[0].original_job_id.should == jobs[0].id
-      failed[1].original_job_id.should == jobs[1].id
+      failed = (Delayed::Job.list_jobs(:failed, 1, 0) + Delayed::Job.list_jobs(:failed, 1, 1)).sort_by(&:id)
+      expect(failed.size).to eq(2)
+      expect(failed[0].original_job_id).to eq(jobs[0].id)
+      expect(failed[1].original_job_id).to eq(jobs[1].id)
     end
   end
 
@@ -659,126 +755,123 @@ shared_examples_for 'a backend' do
         @ignored_jobs = []
       end
 
-      it "should hold and unhold a scope of jobs" do
-        @affected_jobs.all? { |j| j.on_hold? }.should be false
-        @ignored_jobs.any? { |j| j.on_hold? }.should be false
-        Delayed::Job.bulk_update('hold', :flavor => @flavor, :query => @query).should == @affected_jobs.size
+      it "holds and unhold a scope of jobs" do
+        expect(@affected_jobs.all?(&:on_hold?)).to be false
+        expect(@ignored_jobs.any?(&:on_hold?)).to be false
+        expect(Delayed::Job.bulk_update("hold", flavor: @flavor, query: @query)).to eq(@affected_jobs.size)
 
-        @affected_jobs.all? { |j| Delayed::Job.find(j.id).on_hold? }.should be true
-        @ignored_jobs.any? { |j| Delayed::Job.find(j.id).on_hold? }.should be false
+        expect(@affected_jobs.all? { |j| Delayed::Job.find(j.id).on_hold? }).to be true
+        expect(@ignored_jobs.any? { |j| Delayed::Job.find(j.id).on_hold? }).to be false
 
-        # redis holding seems busted - it removes from the tag set and strand list, so you can't use a query
-        # to un-hold them
-        next if Delayed::Job == Delayed::Backend::Redis::Job
-        Delayed::Job.bulk_update('unhold', :flavor => @flavor, :query => @query).should == @affected_jobs.size
+        expect(Delayed::Job.bulk_update("unhold", flavor: @flavor, query: @query)).to eq(@affected_jobs.size)
 
-        @affected_jobs.any? { |j| Delayed::Job.find(j.id).on_hold? }.should be false
-        @ignored_jobs.any? { |j| Delayed::Job.find(j.id).on_hold? }.should be false
+        expect(@affected_jobs.any? { |j| Delayed::Job.find(j.id).on_hold? }).to be false
+        expect(@ignored_jobs.any? { |j| Delayed::Job.find(j.id).on_hold? }).to be false
       end
 
-      it "should delete a scope of jobs" do
-        Delayed::Job.bulk_update('destroy', :flavor => @flavor, :query => @query).should == @affected_jobs.size
-        @affected_jobs.map { |j| Delayed::Job.find(j.id) rescue nil }.compact.should be_blank
-        @ignored_jobs.map { |j| Delayed::Job.find(j.id) rescue nil }.compact.size.should == @ignored_jobs.size
+      it "deletes a scope of jobs" do
+        expect(Delayed::Job.bulk_update("destroy", flavor: @flavor, query: @query)).to eq(@affected_jobs.size)
+        expect(Delayed::Job.where(id: @affected_jobs.map(&:id))).not_to exist
+        expect(Delayed::Job.where(id: @ignored_jobs.map(&:id)).count).to eq @ignored_jobs.size
       end
     end
 
     describe "scope: current" do
       include_examples "scope"
-      before do
-        @flavor = 'current'
+      before do # rubocop:disable RSpec/HooksBeforeExamples
+        @flavor = "current"
         Timecop.freeze(5.minutes.ago) do
           3.times { @affected_jobs << create_job }
-          @ignored_jobs << create_job(:run_at => 2.hours.from_now)
-          @ignored_jobs << create_job(:queue => 'q2')
+          @ignored_jobs << create_job(run_at: 2.hours.from_now)
+          @ignored_jobs << create_job(queue: "q2")
         end
       end
     end
 
     describe "scope: future" do
       include_examples "scope"
-      before do
-        @flavor = 'future'
+      before do # rubocop:disable RSpec/HooksBeforeExamples
+        @flavor = "future"
         Timecop.freeze(5.minutes.ago) do
-          3.times { @affected_jobs << create_job(:run_at => 2.hours.from_now) }
+          3.times { @affected_jobs << create_job(run_at: 2.hours.from_now) }
           @ignored_jobs << create_job
-          @ignored_jobs << create_job(:queue => 'q2', :run_at => 2.hours.from_now)
+          @ignored_jobs << create_job(queue: "q2", run_at: 2.hours.from_now)
         end
       end
     end
 
     describe "scope: strand" do
       include_examples "scope"
-      before do
-        @flavor = 'strand'
-        @query = 's1'
+      before do # rubocop:disable RSpec/HooksBeforeExamples
+        @flavor = "strand"
+        @query = "s1"
         Timecop.freeze(5.minutes.ago) do
-          @affected_jobs << create_job(:strand => 's1')
-          @affected_jobs << create_job(:strand => 's1', :run_at => 2.hours.from_now)
+          @affected_jobs << create_job(strand: "s1")
+          @affected_jobs << create_job(strand: "s1", run_at: 2.hours.from_now)
           @ignored_jobs << create_job
-          @ignored_jobs << create_job(:strand => 's2')
-          @ignored_jobs << create_job(:strand => 's2', :run_at => 2.hours.from_now)
+          @ignored_jobs << create_job(strand: "s2")
+          @ignored_jobs << create_job(strand: "s2", run_at: 2.hours.from_now)
         end
       end
     end
 
     describe "scope: tag" do
       include_examples "scope"
-      before do
-        @flavor = 'tag'
-        @query = 'String#to_i'
+      before do # rubocop:disable RSpec/HooksBeforeExamples
+        @flavor = "tag"
+        @query = "String#to_i"
         Timecop.freeze(5.minutes.ago) do
           @affected_jobs << "test".delay(ignore_transaction: true).to_i
-          @affected_jobs << "test".delay(strand: 's1', ignore_transaction: true).to_i
+          @affected_jobs << "test".delay(strand: "s1", ignore_transaction: true).to_i
           @affected_jobs << "test".delay(run_at: 2.hours.from_now, ignore_transaction: true).to_i
           @ignored_jobs << create_job
-          @ignored_jobs << create_job(:run_at => 1.hour.from_now)
+          @ignored_jobs << create_job(run_at: 1.hour.from_now)
         end
       end
     end
 
-    it "should hold and un-hold given job ids" do
+    it "holds and un-hold given job ids" do
       j1 = "test".delay(ignore_transaction: true).to_i
-      j2 = create_job(:run_at => 2.hours.from_now)
-      j3 = "test".delay(strand: 's1', ignore_transaction: true).to_i
-      Delayed::Job.bulk_update('hold', :ids => [j1.id, j2.id]).should == 2
-      Delayed::Job.find(j1.id).on_hold?.should be true
-      Delayed::Job.find(j2.id).on_hold?.should be true
-      Delayed::Job.find(j3.id).on_hold?.should be false
+      j2 = create_job(run_at: 2.hours.from_now)
+      j3 = "test".delay(strand: "s1", ignore_transaction: true).to_i
+      expect(Delayed::Job.bulk_update("hold", ids: [j1.id, j2.id])).to eq(2)
+      expect(Delayed::Job.find(j1.id).on_hold?).to be true
+      expect(Delayed::Job.find(j2.id).on_hold?).to be true
+      expect(Delayed::Job.find(j3.id).on_hold?).to be false
 
-      Delayed::Job.bulk_update('unhold', :ids => [j2.id, j3.id]).should == 1
-      Delayed::Job.find(j1.id).on_hold?.should be true
-      Delayed::Job.find(j2.id).on_hold?.should be false
-      Delayed::Job.find(j3.id).on_hold?.should be false
+      expect(Delayed::Job.bulk_update("unhold", ids: [j2.id, j3.id])).to eq(1)
+      expect(Delayed::Job.find(j1.id).on_hold?).to be true
+      expect(Delayed::Job.find(j2.id).on_hold?).to be false
+      expect(Delayed::Job.find(j3.id).on_hold?).to be false
     end
 
-    it "should not hold locked jobs" do
-      job1 = Delayed::Job.new(:tag => 'tag')
+    it "does not hold locked jobs" do
+      job1 = Delayed::Job.new(tag: "tag")
       job1.create_and_lock!("worker")
-      job1.on_hold?.should be false
-      Delayed::Job.bulk_update('hold', ids: [job1.id]).should == 0
-      Delayed::Job.find(job1.id).on_hold?.should be false
+      expect(job1.on_hold?).to be false
+      expect(Delayed::Job.bulk_update("hold", ids: [job1.id])).to eq(0)
+      expect(Delayed::Job.find(job1.id).on_hold?).to be false
     end
 
-    it "should not unhold locked jobs" do
-      job1 = Delayed::Job.new(:tag => 'tag')
+    it "does not unhold locked jobs" do
+      job1 = Delayed::Job.new(tag: "tag")
       job1.create_and_lock!("worker")
-      Delayed::Job.bulk_update('unhold', ids: [job1.id]).should == 0
-      Delayed::Job.find(job1.id).on_hold?.should be false
-      Delayed::Job.find(job1.id).locked?.should be true
+      expect(Delayed::Job.bulk_update("unhold", ids: [job1.id])).to eq(0)
+      expect(Delayed::Job.find(job1.id).on_hold?).to be false
+      expect(Delayed::Job.find(job1.id).locked?).to be true
     end
 
-    it "should delete given job ids" do
+    it "deletes given job ids" do
       jobs = (0..2).map { create_job }
-      Delayed::Job.bulk_update('destroy', :ids => jobs[0,2].map(&:id)).should == 2
-      jobs.map { |j| Delayed::Job.find(j.id) rescue nil }.compact.should == jobs[2,1]
+      expect(Delayed::Job.bulk_update("destroy", ids: jobs[0, 2].map(&:id))).to eq(2)
+      expect(Delayed::Job.order(:id).where(id: jobs.map(&:id))).to eq jobs[2, 1]
     end
 
-    it "should not delete locked jobs" do
-      job1 = Delayed::Job.new(:tag => 'tag')
+    it "does not delete locked jobs" do
+      job1 = Delayed::Job.new(tag: "tag")
       job1.create_and_lock!("worker")
-      Delayed::Job.bulk_update('destroy', ids: [job1.id]).should == 0
-      Delayed::Job.find(job1.id).locked?.should be true
+      expect(Delayed::Job.bulk_update("destroy", ids: [job1.id])).to eq(0)
+      expect(Delayed::Job.find(job1.id).locked?).to be true
     end
   end
 
@@ -786,7 +879,7 @@ shared_examples_for 'a backend' do
     before do
       @cur = []
       3.times { @cur << "test".delay(ignore_transaction: true).to_s }
-      5.times { @cur << "test".delay(ignore_transaction: true).to_i}
+      5.times { @cur << "test".delay(ignore_transaction: true).to_i }
       2.times { @cur << "test".delay(ignore_transaction: true).upcase }
       "test".delay(ignore_transaction: true).downcase.fail!
       @future = []
@@ -794,48 +887,48 @@ shared_examples_for 'a backend' do
       @cur << "test".delay(ignore_transaction: true).downcase
     end
 
-    it "should return a sorted list of popular current tags" do
-      Delayed::Job.tag_counts(:current, 1).should == [{ :tag => "String#to_i", :count => 5 }]
-      Delayed::Job.tag_counts(:current, 1, 1).should == [{ :tag => "String#to_s", :count => 3 }]
-      Delayed::Job.tag_counts(:current, 5).should == [{ :tag => "String#to_i", :count => 5 },
-                                                      { :tag => "String#to_s", :count => 3 },
-                                                      { :tag => "String#upcase", :count => 2 },
-                                                      { :tag => "String#downcase", :count => 1 }]
-      @cur[0,4].each { |j| j.destroy }
+    it "returns a sorted list of popular current tags" do
+      expect(Delayed::Job.tag_counts(:current, 1)).to eq([{ tag: "String#to_i", count: 5 }])
+      expect(Delayed::Job.tag_counts(:current, 1, 1)).to eq([{ tag: "String#to_s", count: 3 }])
+      expect(Delayed::Job.tag_counts(:current, 5)).to eq([{ tag: "String#to_i", count: 5 },
+                                                          { tag: "String#to_s", count: 3 },
+                                                          { tag: "String#upcase", count: 2 },
+                                                          { tag: "String#downcase", count: 1 }])
+      @cur[0, 4].each(&:destroy)
       @future[0].run_at = @future[1].run_at = 1.hour.ago
       @future[0].save!
       @future[1].save!
 
-      Delayed::Job.tag_counts(:current, 5).should == [{ :tag => "String#to_i", :count => 4 },
-                                                      { :tag => "String#downcase", :count => 3 },
-                                                      { :tag => "String#upcase", :count => 2 },]
+      expect(Delayed::Job.tag_counts(:current, 5)).to eq([{ tag: "String#to_i", count: 4 },
+                                                          { tag: "String#downcase", count: 3 },
+                                                          { tag: "String#upcase", count: 2 }])
     end
 
-    it "should return a sorted list of all popular tags" do
-      Delayed::Job.tag_counts(:all, 1).should == [{ :tag => "String#downcase", :count => 6 }]
-      Delayed::Job.tag_counts(:all, 1, 1).should == [{ :tag => "String#to_i", :count => 5 }]
-      Delayed::Job.tag_counts(:all, 5).should == [{ :tag => "String#downcase", :count => 6 },
-                                                  { :tag => "String#to_i", :count => 5 },
-                                                  { :tag => "String#to_s", :count => 3 },
-                                                  { :tag => "String#upcase", :count => 2 },]
+    it "returns a sorted list of all popular tags" do
+      expect(Delayed::Job.tag_counts(:all, 1)).to eq([{ tag: "String#downcase", count: 6 }])
+      expect(Delayed::Job.tag_counts(:all, 1, 1)).to eq([{ tag: "String#to_i", count: 5 }])
+      expect(Delayed::Job.tag_counts(:all, 5)).to eq([{ tag: "String#downcase", count: 6 },
+                                                      { tag: "String#to_i", count: 5 },
+                                                      { tag: "String#to_s", count: 3 },
+                                                      { tag: "String#upcase", count: 2 }])
 
-      @cur[0,4].each { |j| j.destroy }
+      @cur[0, 4].each(&:destroy)
       @future[0].destroy
       @future[1].fail!
       @future[2].fail!
 
-      Delayed::Job.tag_counts(:all, 5).should == [{ :tag => "String#to_i", :count => 4 },
-                                                  { :tag => "String#downcase", :count => 3 },
-                                                  { :tag => "String#upcase", :count => 2 },]
+      expect(Delayed::Job.tag_counts(:all, 5)).to eq([{ tag: "String#to_i", count: 4 },
+                                                      { tag: "String#downcase", count: 3 },
+                                                      { tag: "String#upcase", count: 2 }])
     end
   end
 
-  it "should unlock orphaned jobs" do
+  it "unlocks orphaned jobs" do
     change_setting(Delayed::Settings, :max_attempts, 2) do
-      job1 = Delayed::Job.new(:tag => 'tag')
-      job2 = Delayed::Job.new(:tag => 'tag')
-      job3 = Delayed::Job.new(:tag => 'tag')
-      job4 = Delayed::Job.new(:tag => 'tag')
+      job1 = Delayed::Job.new(tag: "tag")
+      job2 = Delayed::Job.new(tag: "tag")
+      job3 = Delayed::Job.new(tag: "tag")
+      job4 = Delayed::Job.new(tag: "tag")
       job1.create_and_lock!("Jobworker:#{Process.pid}")
       `echo ''`
       child_pid = $?.pid
@@ -843,23 +936,23 @@ shared_examples_for 'a backend' do
       job3.create_and_lock!("someoneelse:#{Process.pid}")
       job4.create_and_lock!("Jobworker:notanumber")
 
-      Delayed::Job.unlock_orphaned_jobs(nil, "Jobworker").should == 1
+      expect(Delayed::Job.unlock_orphaned_jobs(nil, "Jobworker")).to eq(1)
 
-      Delayed::Job.find(job1.id).locked_by.should_not be_nil
-      Delayed::Job.find(job2.id).locked_by.should be_nil
-      Delayed::Job.find(job3.id).locked_by.should_not be_nil
-      Delayed::Job.find(job4.id).locked_by.should_not be_nil
+      expect(Delayed::Job.find(job1.id).locked_by).not_to be_nil
+      expect(Delayed::Job.find(job2.id).locked_by).to be_nil
+      expect(Delayed::Job.find(job3.id).locked_by).not_to be_nil
+      expect(Delayed::Job.find(job4.id).locked_by).not_to be_nil
 
-      Delayed::Job.unlock_orphaned_jobs(nil, "Jobworker").should == 0
+      expect(Delayed::Job.unlock_orphaned_jobs(nil, "Jobworker")).to eq(0)
     end
   end
 
-  it "should unlock orphaned jobs given a pid" do
+  it "unlocks orphaned jobs given a pid" do
     change_setting(Delayed::Settings, :max_attempts, 2) do
-      job1 = Delayed::Job.new(:tag => 'tag')
-      job2 = Delayed::Job.new(:tag => 'tag')
-      job3 = Delayed::Job.new(:tag => 'tag')
-      job4 = Delayed::Job.new(:tag => 'tag')
+      job1 = Delayed::Job.new(tag: "tag")
+      job2 = Delayed::Job.new(tag: "tag")
+      job3 = Delayed::Job.new(tag: "tag")
+      job4 = Delayed::Job.new(tag: "tag")
       job1.create_and_lock!("Jobworker:#{Process.pid}")
       `echo ''`
       child_pid = $?.pid
@@ -869,15 +962,15 @@ shared_examples_for 'a backend' do
       job3.create_and_lock!("someoneelse:#{Process.pid}")
       job4.create_and_lock!("Jobworker:notanumber")
 
-      Delayed::Job.unlock_orphaned_jobs(child_pid2, "Jobworker").should == 0
-      Delayed::Job.unlock_orphaned_jobs(child_pid, "Jobworker").should == 1
+      expect(Delayed::Job.unlock_orphaned_jobs(child_pid2, "Jobworker")).to eq(0)
+      expect(Delayed::Job.unlock_orphaned_jobs(child_pid, "Jobworker")).to eq(1)
 
-      Delayed::Job.find(job1.id).locked_by.should_not be_nil
-      Delayed::Job.find(job2.id).locked_by.should be_nil
-      Delayed::Job.find(job3.id).locked_by.should_not be_nil
-      Delayed::Job.find(job4.id).locked_by.should_not be_nil
+      expect(Delayed::Job.find(job1.id).locked_by).not_to be_nil
+      expect(Delayed::Job.find(job2.id).locked_by).to be_nil
+      expect(Delayed::Job.find(job3.id).locked_by).not_to be_nil
+      expect(Delayed::Job.find(job4.id).locked_by).not_to be_nil
 
-      Delayed::Job.unlock_orphaned_jobs(child_pid, "Jobworker").should == 0
+      expect(Delayed::Job.unlock_orphaned_jobs(child_pid, "Jobworker")).to eq(0)
     end
   end
 end