inst-jobs 2.3.1 → 2.4.1

data/spec/gemfiles/61.gemfile

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
-gemspec :path => "../../"
+gemspec path: "../../"
 
 gem "rails", "~> 6.1.0"
-gem 'sinatra', "~> 2.0"
-gem 'sinatra-contrib', "~> 2.0"
+gem "sinatra", "~> 2.0"
+gem "sinatra-contrib", "~> 2.0"

data/spec/sample_jobs.rb

@@ -1,49 +1,79 @@
 # frozen_string_literal: true
 
 class SimpleJob
-  cattr_accessor :runs; self.runs = 0
-  def perform; @@runs += 1; end
+  class << self
+    attr_accessor :runs
+  end
+
+  self.runs = 0
+
+  def perform
+    self.class.runs += 1
+  end
 end
 
 class ErrorJob
-  cattr_accessor :runs; self.runs = 0
-  def perform; raise 'did not work'; end
+  class << self
+    attr_accessor :runs, :last_error, :failure_runs, :permanent_failure_runs
+  end
 
-  cattr_accessor :last_error; self.last_error = nil
+  self.runs = 0
+  def perform
+    raise "did not work"
+  end
 
-  cattr_accessor :failure_runs; self.failure_runs = 0
-  def on_failure(error); @@last_error = error; @@failure_runs += 1; end
+  self.last_error = nil
+  self.failure_runs = 0
+  def on_failure(error)
+    self.class.last_error = error
+    self.class.failure_runs += 1
+  end
 
-  cattr_accessor :permanent_failure_runs; self.permanent_failure_runs = 0
-  def on_permanent_failure(error); @@last_error = error; @@permanent_failure_runs += 1; end
+  self.permanent_failure_runs = 0
+  def on_permanent_failure(error)
+    self.class.last_error = error
+    self.class.permanent_failure_runs += 1
+  end
 end
 
 class UnlockJob
   attr_accessor :times_to_unlock
+
   def initialize(times_to_unlock)
     @times_to_unlock = times_to_unlock
   end
 
-  def perform; raise SystemExit, 'raising to trigger on_failure'; end
+  def perform
+    raise SystemExit, "raising to trigger on_failure"
+  end
 
-  def on_failure(error)
+  def on_failure(_error)
     times_to_unlock -= 1
     :unlock if times_to_unlock <= 0
   end
 end
 
 class LongRunningJob
-  def perform; sleep 250; end
+  def perform
+    sleep 250
+  end
 end
 
 module M
   class ModuleJob
-    cattr_accessor :runs; self.runs = 0
-    def perform; @@runs += 1; end
+    class << self
+      attr_accessor :runs
+    end
+
+    cattr_accessor :runs
+    self.runs = 0
+    def perform
+      self.class.runs += 1
+    end
   end
 end
 
 class DeserializeErrorJob < SimpleJob; end
-Psych.add_domain_type("ruby/object", "DeserializeErrorJob") do |_type, val|
+Psych.add_domain_type("ruby/object", "DeserializeErrorJob") do |_type, _val|
   raise "error deserializing"
 end

data/spec/shared/delayed_batch.rb

@@ -1,98 +1,105 @@
 # frozen_string_literal: true
 
-shared_examples_for 'Delayed::Batch' do
+shared_examples_for "Delayed::Batch" do
   context "batching" do
-    it "should batch up all deferrable delayed methods" do
+    it "batches up all deferrable delayed methods" do
       later = 1.hour.from_now
-      Delayed::Batch.serial_batch {
-        "string".delay(ignore_transaction: true).size.should be true
-        "string".delay(run_at: later, ignore_transaction: true).reverse.should be_truthy # won't be batched, it'll get its own job
-        "string".delay(ignore_transaction: true).gsub(/./, "!").should be_truthy
-      }
+      Delayed::Batch.serial_batch do
+        expect("string".delay(ignore_transaction: true).size).to be true
+        # won't be batched, it'll get its own job
+        expect("string".delay(run_at: later, ignore_transaction: true).reverse).to be_truthy
+        expect("string".delay(ignore_transaction: true).gsub(/./, "!")).to be_truthy
+      end
       batch_jobs = Delayed::Job.find_available(5)
       regular_jobs = Delayed::Job.list_jobs(:future, 5)
-      regular_jobs.size.should == 1
-      regular_jobs.first.batch?.should == false
-      batch_jobs.size.should == 1
+      expect(regular_jobs.size).to eq(1)
+      expect(regular_jobs.first.batch?).to eq(false)
+      expect(batch_jobs.size).to eq(1)
       batch_job = batch_jobs.first
-      batch_job.batch?.should == true
-      batch_job.payload_object.mode.should  == :serial
-      batch_job.payload_object.jobs.map { |j| [j.payload_object.object, j.payload_object.method, j.payload_object.args] }.should  == [
-        ["string", :size, []],
-        ["string", :gsub, [/./, "!"]]
-      ]
+      expect(batch_job.batch?).to eq(true)
+      expect(batch_job.payload_object.mode).to eq(:serial)
+      expect(batch_job.payload_object.jobs.map do |j|
+               [j.payload_object.object, j.payload_object.method, j.payload_object.args]
+             end).to eq([
+                          [
+                            "string", :size, []
+                          ],
+                          [
+                            "string", :gsub, [
+                              /./, "!"
+                            ]
+                          ]
+                        ])
     end
 
-    it "should not let you invoke it directly" do
-      later = 1.hour.from_now
-      Delayed::Batch.serial_batch {
-        "string".delay(ignore_transaction: true).size.should be true
-        "string".delay(ignore_transaction: true).gsub(/./, "!").should be true
-      }
-      Delayed::Job.jobs_count(:current).should == 1
+    it "does not let you invoke it directly" do
+      Delayed::Batch.serial_batch do
+        expect("string".delay(ignore_transaction: true).size).to be true
+        expect("string".delay(ignore_transaction: true).gsub(/./, "!")).to be true
+      end
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
       job = Delayed::Job.find_available(1).first
-      expect{ job.invoke_job }.to raise_error(RuntimeError)
+      expect { job.invoke_job }.to raise_error(RuntimeError)
     end
 
-    it "should create valid jobs" do
-      Delayed::Batch.serial_batch {
-        "string".delay(ignore_transaction: true).size.should be true
-        "string".delay(ignore_transaction: true).gsub(/./, "!").should be true
-      }
-      Delayed::Job.jobs_count(:current).should == 1
+    it "creates valid jobs" do
+      Delayed::Batch.serial_batch do
+        expect("string".delay(ignore_transaction: true).size).to be true
+        expect("string".delay(ignore_transaction: true).gsub(/./, "!")).to be true
+      end
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
 
       batch_job = Delayed::Job.find_available(1).first
-      batch_job.batch?.should == true
+      expect(batch_job.batch?).to eq(true)
       jobs = batch_job.payload_object.jobs
-      jobs.size.should == 2
-      jobs[0].should be_new_record
-      jobs[0].payload_object.class.should   == Delayed::PerformableMethod
-      jobs[0].payload_object.method.should  == :size
-      jobs[0].payload_object.args.should    == []
-      jobs[0].payload_object.perform.should == 6
-      jobs[1].should be_new_record
-      jobs[1].payload_object.class.should   == Delayed::PerformableMethod
-      jobs[1].payload_object.method.should  == :gsub
-      jobs[1].payload_object.args.should    == [/./, "!"]
-      jobs[1].payload_object.perform.should == "!!!!!!"
+      expect(jobs.size).to eq(2)
+      expect(jobs[0]).to be_new_record
+      expect(jobs[0].payload_object.class).to   eq(Delayed::PerformableMethod)
+      expect(jobs[0].payload_object.method).to  eq(:size)
+      expect(jobs[0].payload_object.args).to    eq([])
+      expect(jobs[0].payload_object.perform).to eq(6)
+      expect(jobs[1]).to be_new_record
+      expect(jobs[1].payload_object.class).to   eq(Delayed::PerformableMethod)
+      expect(jobs[1].payload_object.method).to  eq(:gsub)
+      expect(jobs[1].payload_object.args).to    eq([/./, "!"])
+      expect(jobs[1].payload_object.perform).to eq("!!!!!!")
     end
 
-    it "should create a different batch for each priority" do
-      later = 1.hour.from_now
-      Delayed::Batch.serial_batch {
-        "string".delay(priority: Delayed::LOW_PRIORITY, ignore_transaction: true).size.should be true
-        "string".delay(ignore_transaction: true).gsub(/./, "!").should be true
-      }
-      Delayed::Job.jobs_count(:current).should == 2
+    it "creates a different batch for each priority" do
+      Delayed::Batch.serial_batch do
+        expect("string".delay(priority: Delayed::LOW_PRIORITY, ignore_transaction: true).size).to be true
+        expect("string".delay(ignore_transaction: true).gsub(/./, "!")).to be true
+      end
+      expect(Delayed::Job.jobs_count(:current)).to eq(2)
     end
 
-    it "should use the given priority for all, if specified" do
-      Delayed::Batch.serial_batch(:priority => 11) {
-        "string".delay(priority: 20, ignore_transaction: true).size.should be true
-        "string".delay(priority: 15, ignore_transaction: true).gsub(/./, "!").should be true
-      }
-      Delayed::Job.jobs_count(:current).should == 1
-      Delayed::Job.find_available(1).first.priority.should == 11
+    it "uses the given priority for all, if specified" do
+      Delayed::Batch.serial_batch(priority: 11) do
+        expect("string".delay(priority: 20, ignore_transaction: true).size).to be true
+        expect("string".delay(priority: 15, ignore_transaction: true).gsub(/./, "!")).to be true
+      end
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
+      expect(Delayed::Job.find_available(1).first.priority).to eq(11)
     end
 
-    it "should just create the job, if there's only one in the batch" do
-      Delayed::Batch.serial_batch(:priority => 11) {
-        "string".delay(ignore_transaction: true).size.should be true
-      }
-      Delayed::Job.jobs_count(:current).should == 1
-      Delayed::Job.find_available(1).first.tag.should == "String#size"
-      Delayed::Job.find_available(1).first.priority.should == 11
+    it "justs create the job, if there's only one in the batch" do
+      Delayed::Batch.serial_batch(priority: 11) do
+        expect("string".delay(ignore_transaction: true).size).to be true
+      end
+      expect(Delayed::Job.jobs_count(:current)).to eq(1)
+      expect(Delayed::Job.find_available(1).first.tag).to eq("String#size")
+      expect(Delayed::Job.find_available(1).first.priority).to eq(11)
     end
 
-    it "should list a job only once when the same call is made multiple times" do
-      Delayed::Batch.serial_batch(:priority => 11) {
+    it "lists a job only once when the same call is made multiple times" do
+      Delayed::Batch.serial_batch(priority: 11) do
         "string".delay(ignore_transaction: true).size
         "string".delay(ignore_transaction: true).gsub(/./, "!")
         "string".delay(ignore_transaction: true).size
-      }
+      end
       batch_job = Delayed::Job.find_available(1).first
       jobs = batch_job.payload_object.jobs
-      jobs.size.should == 2
+      expect(jobs.size).to eq(2)
     end
   end
 end

data/spec/shared/delayed_method.rb

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