sidekiq-status 0.5.0 → 3.0.3

data/spec/lib/sidekiq-status/server_middleware_spec.rb

@@ -5,62 +5,134 @@ describe Sidekiq::Status::ServerMiddleware do
   let!(:redis) { Sidekiq.redis { |conn| conn } }
   let!(:job_id) { SecureRandom.hex(12) }
 
-  # Clean Redis before each test
-  # Seems like flushall has no effect on recently published messages,
-  # so we should wait till they expire
-  before { redis.flushall; sleep 0.1 }
-
-  describe "#call" do
+  describe "without :expiration parameter" do
     it "sets working/complete status" do
-      thread = confirmations_thread 4, "status_updates", "job_messages_#{job_id}"
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
       start_server do
-        ConfirmationJob.perform_async(:arg1 => 'val1').should == job_id
-        thread.value.should == [job_id, job_id,
-                                "while in #perform, status = working",
-                                job_id]
+        thread = branched_redis_thread 4, "status_updates", "job_messages_#{job_id}" do
+          expect(ConfirmationJob.perform_async 'arg1' => 'val1').to eq(job_id)
+        end
+        expect(thread.value).to eq([
+          job_id,
+          job_id,
+          "while in #perform, status = working",
+          job_id
+        ])
       end
-      redis.hget(job_id, :status).should == 'complete'
-      Sidekiq::Status::complete?(job_id).should be_true
+      expect(redis.hget("sidekiq:status:#{job_id}", :status)).to eq('complete')
+      expect(Sidekiq::Status::complete?(job_id)).to be_truthy
     end
 
     it "sets failed status" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+      start_server do
+        expect(capture_status_updates(3) {
+          expect(FailingJob.perform_async).to eq(job_id)
+        }).to eq([job_id]*3)
+      end
+      expect(redis.hget("sidekiq:status:#{job_id}", :status)).to eq('failed')
+      expect(Sidekiq::Status::failed?(job_id)).to be_truthy
+    end
+
+    it "sets failed status when Exception raised" do
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
       start_server do
-        capture_status_updates(3) {
-          FailingJob.perform_async.should == job_id
-        }.should == [job_id]*3
+      expect(capture_status_updates(3) {
+        expect(FailingHardJob.perform_async).to eq(job_id)
+      }).to eq([job_id]*3)
       end
-      redis.hget(job_id, :status).should == 'failed'
-      Sidekiq::Status::failed?(job_id).should be_true
+      expect(redis.hget("sidekiq:status:#{job_id}", :status)).to eq('failed')
+      expect(Sidekiq::Status::failed?(job_id)).to be_truthy
+    end
+
+    context "when Sidekiq::Status::Worker is not included in the job" do
+      it "should not set a failed status" do
+        allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+        start_server do
+          expect(FailingNoStatusJob.perform_async).to eq(job_id)
+        end
+        expect(redis.hget("sidekiq:status:#{job_id}", :status)).to be_nil
+      end
+
+      it "should not set any status when Exception raised" do
+        allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+        start_server do
+          expect(FailingHardNoStatusJob.perform_async).to eq(job_id)
+        end
+        expect(redis.hget("sidekiq:status:#{job_id}", :status)).to be_nil
+      end
+
+      it "should not set any status on system exit signal" do
+        allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+        start_server do
+          expect(ExitedNoStatusJob.perform_async).to eq(job_id)
+        end
+        expect(redis.hget("sidekiq:status:#{job_id}", :status)).to be_nil
+      end
+
+      it "should not set any status on interrupt signal" do
+        allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+        start_server do
+          expect(InterruptedNoStatusJob.perform_async).to eq(job_id)
+        end
+        expect(redis.hget("sidekiq:status:#{job_id}", :status)).to be_nil
+      end
+    end
+
+    context "sets interrupted status" do
+      it "on system exit signal" do
+        allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+        start_server do
+        expect(capture_status_updates(3) {
+          expect(ExitedJob.perform_async).to eq(job_id)
+        }).to eq([job_id]*3)
+        end
+        expect(redis.hget("sidekiq:status:#{job_id}", :status)).to eq('interrupted')
+        expect(Sidekiq::Status::interrupted?(job_id)).to be_truthy
+      end
+
+      it "on interrupt signal" do
+        allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+        start_server do
+          expect(capture_status_updates(3) {
+            expect(InterruptedJob.perform_async).to eq(job_id)
+          }).to eq([job_id]*3)
+        end
+        expect(redis.hget("sidekiq:status:#{job_id}", :status)).to eq('interrupted')
+        expect(Sidekiq::Status::interrupted?(job_id)).to be_truthy
+      end
+
     end
 
     it "sets status hash ttl" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
-      StubJob.perform_async(:arg1 => 'val1').should == job_id
-      (1..Sidekiq::Status::DEFAULT_EXPIRY).should cover redis.ttl(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+      start_server do
+        expect(StubJob.perform_async 'arg1' => 'val1').to eq(job_id)
+      end
+      expect(1..Sidekiq::Status::DEFAULT_EXPIRY).to cover redis.ttl("sidekiq:status:#{job_id}")
     end
   end
 
-  describe ":expiration parameter" do
+  describe "with :expiration parameter" do
     let(:huge_expiration) { Sidekiq::Status::DEFAULT_EXPIRY * 100 }
     before do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
     end
+
     it "overwrites default expiry value" do
       start_server(:expiration => huge_expiration) do
-        StubJob.perform_async(:arg1 => 'val1')
+        StubJob.perform_async 'arg1' => 'val1'
       end
-      ((Sidekiq::Status::DEFAULT_EXPIRY+1)..huge_expiration).should cover redis.ttl(job_id)
+      expect((Sidekiq::Status::DEFAULT_EXPIRY-1)..huge_expiration).to cover redis.ttl("sidekiq:status:#{job_id}")
     end
 
     it "can be overwritten by worker expiration method" do
       overwritten_expiration = huge_expiration * 100
-      StubJob.any_instance.stub(expiration: overwritten_expiration)
+      allow_any_instance_of(StubJob).to receive(:expiration).and_return(overwritten_expiration)
       start_server(:expiration => huge_expiration) do
-        StubJob.perform_async(:arg1 => 'val1')
+        StubJob.perform_async 'arg1' => 'val1'
       end
-      ((huge_expiration+1)..overwritten_expiration).should cover redis.ttl(job_id)
+      expect((huge_expiration+1)..overwritten_expiration).to cover redis.ttl("sidekiq:status:#{job_id}")
     end
   end
 end

data/spec/lib/sidekiq-status/web_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'sidekiq-status/web'
+require 'rack/test'
+
+describe 'sidekiq status web' do
+  include Rack::Test::Methods
+
+  let!(:redis) { Sidekiq.redis { |conn| conn } }
+  let!(:job_id) { SecureRandom.hex(12) }
+
+  def app
+    Sidekiq::Web
+  end
+
+  before do
+    env 'rack.session', csrf: Base64.urlsafe_encode64('token')
+    client_middleware
+    allow(SecureRandom).to receive(:hex).and_return(job_id)
+  end
+
+  around { |example| start_server(&example) }
+
+  it 'shows the list of jobs in progress' do
+    capture_status_updates(2) do
+      expect(LongJob.perform_async(0.5)).to eq(job_id)
+    end
+
+    get '/statuses'
+    expect(last_response).to be_ok
+    expect(last_response.body).to match(/#{job_id}/)
+    expect(last_response.body).to match(/LongJob/)
+    expect(last_response.body).to match(/working/)
+  end
+
+  it 'allows filtering the list of jobs by status' do
+    capture_status_updates(2) do
+      LongJob.perform_async(0.5)
+    end
+
+    get '/statuses?status=working'
+    expect(last_response).to be_ok
+    expect(last_response.body).to match(/#{job_id}/)
+    expect(last_response.body).to match(/LongJob/)
+    expect(last_response.body).to match(/working/)
+  end
+
+  it 'allows filtering the list of jobs by completed status' do
+    capture_status_updates(2) do
+      LongJob.perform_async(0.5)
+    end
+    get '/statuses?status=completed'
+    expect(last_response).to be_ok
+    expect(last_response.body).to_not match(/LongJob/)
+  end
+
+  it 'shows a single job in progress' do
+    capture_status_updates(2) do
+      LongJob.perform_async(1, 'another argument')
+    end
+
+    get "/statuses/#{job_id}"
+    expect(last_response).to be_ok
+    expect(last_response.body).to match(/#{job_id}/)
+    expect(last_response.body).to match(/1,"another argument"/)
+    expect(last_response.body).to match(/working/)
+  end
+
+  it 'shows custom data for a single job' do
+    capture_status_updates(3) do
+      CustomDataJob.perform_async
+    end
+
+    get "/statuses/#{job_id}"
+    expect(last_response).to be_ok
+    expect(last_response.body).to match(/mister_cat/)
+    expect(last_response.body).to match(/meow/)
+  end
+
+  it 'show an error when the requested job ID is not found' do
+    get '/statuses/12345'
+    expect(last_response).to be_not_found
+    expect(last_response.body).to match(/That job can't be found/)
+  end
+end

data/spec/lib/sidekiq-status/worker_spec.rb

@@ -6,17 +6,36 @@ describe Sidekiq::Status::Worker do
 
   describe ".perform_async" do
     it "generates and returns job id" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
-      StubJob.perform_async().should == job_id
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+      expect(StubJob.perform_async()).to eq(job_id)
     end
   end
 
   describe ".expiration" do
     subject { StubJob.new }
+
     it "allows to set/get expiration" do
       expect(subject.expiration).to be_nil
       subject.expiration = :val
       expect(subject.expiration).to eq(:val)
     end
   end
+
+  describe ".at" do
+    subject { StubJob.new }
+
+    it "records when the worker has started" do
+      expect { subject.at(0) }.to(change { subject.retrieve('working_at') })
+    end
+
+    context "when setting the total for the worker" do
+      it "records when the worker has started" do
+        expect { subject.total(100) }.to(change { subject.retrieve('working_at') })
+      end
+    end
+
+    it "records when the worker last worked" do
+      expect { subject.at(0) }.to(change { subject.retrieve('update_time') })
+    end
+  end
 end

data/spec/lib/sidekiq-status_spec.rb

@@ -8,113 +8,132 @@ describe Sidekiq::Status do
   let!(:unused_id) { SecureRandom.hex(12) }
   let!(:plain_sidekiq_job_id) { SecureRandom.hex(12) }
   let!(:retried_job_id) { SecureRandom.hex(12) }
-
-  # Clean Redis before each test
-  # Seems like flushall has no effect on recently published messages,
-  # so we should wait till they expire
-  before { redis.flushall; sleep 0.1 }
+  let!(:retry_and_fail_job_id) { SecureRandom.hex(12) }
 
   describe ".status, .working?, .complete?" do
     it "gets job status by id as symbol" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
 
       start_server do
-        capture_status_updates(2) {
-          LongJob.perform_async(1).should == job_id
-        }.should == [job_id]*2
-        Sidekiq::Status.status(job_id).should == :working
-        Sidekiq::Status.working?(job_id).should be_true
-        Sidekiq::Status::queued?(job_id).should be_false
-        Sidekiq::Status::failed?(job_id ).should be_false
-        Sidekiq::Status::complete?(job_id).should be_false
-        Sidekiq::Status::stopped?(job_id).should be_false
-      end
-      Sidekiq::Status.status(job_id).should == :complete
-      Sidekiq::Status.complete?(job_id).should be_true
+        expect(capture_status_updates(2) {
+          expect(LongJob.perform_async(0.5)).to eq(job_id)
+        }).to eq([job_id]*2)
+        expect(Sidekiq::Status.status(job_id)).to eq(:working)
+        expect(Sidekiq::Status.working?(job_id)).to be_truthy
+        expect(Sidekiq::Status::queued?(job_id)).to be_falsey
+        expect(Sidekiq::Status::retrying?(job_id)).to be_falsey
+        expect(Sidekiq::Status::failed?(job_id)).to be_falsey
+        expect(Sidekiq::Status::complete?(job_id)).to be_falsey
+        expect(Sidekiq::Status::stopped?(job_id)).to be_falsey
+        expect(Sidekiq::Status::interrupted?(job_id)).to be_falsey
+      end
+      expect(Sidekiq::Status.status(job_id)).to eq(:complete)
+      expect(Sidekiq::Status.complete?(job_id)).to be_truthy
     end
   end
 
   describe ".get" do
     it "gets a single value from data hash as string" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
 
       start_server do
-        capture_status_updates(3) {
-          DataJob.perform_async.should == job_id
-        }.should == [job_id]*3
-        Sidekiq::Status.get(job_id, :status).should == 'working'
+        expect(capture_status_updates(3) {
+          expect(DataJob.perform_async).to eq(job_id)
+        }).to eq([job_id]*3)
+        expect(Sidekiq::Status.get(job_id, :status)).to eq('working')
       end
-      Sidekiq::Status.get(job_id, :data).should == 'meow'
+      expect(Sidekiq::Status.get(job_id, :data)).to eq('meow')
     end
   end
 
   describe ".at, .total, .pct_complete, .message" do
     it "should return job progress with correct type to it" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
 
       start_server do
-        capture_status_updates(3) {
-          ProgressJob.perform_async.should == job_id
-        }.should == [job_id]*3
+        expect(capture_status_updates(4) {
+          expect(ProgressJob.perform_async).to eq(job_id)
+        }).to eq([job_id]*4)
       end
-      Sidekiq::Status.at(job_id).should == 100
-      Sidekiq::Status.total(job_id).should == 500
-      Sidekiq::Status.pct_complete(job_id).should == 20
-      Sidekiq::Status.message(job_id).should == 'howdy, partner?'
+      expect(Sidekiq::Status.at(job_id)).to be(100)
+      expect(Sidekiq::Status.total(job_id)).to be(500)
+      # It returns a float therefor we need eq()
+      expect(Sidekiq::Status.pct_complete(job_id)).to eq(20)
+      expect(Sidekiq::Status.message(job_id)).to eq('howdy, partner?')
     end
   end
 
   describe ".get_all" do
     it "gets the job hash by id" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+
+      start_server do
+        expect(capture_status_updates(2) {
+          expect(LongJob.perform_async(0.5)).to eq(job_id)
+        }).to eq([job_id]*2)
+        expect(hash = Sidekiq::Status.get_all(job_id)).to include 'status' => 'working'
+        expect(hash).to include 'update_time'
+      end
+      expect(hash = Sidekiq::Status.get_all(job_id)).to include 'status' => 'complete'
+      expect(hash).to include 'update_time'
+    end
+  end
 
+  describe '.delete' do
+    it 'deletes the status hash for given job id' do
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
       start_server do
-        capture_status_updates(2) {
-          LongJob.perform_async(1).should == job_id
-        }.should == [job_id]*2
-        (hash = Sidekiq::Status.get_all(job_id)).should include 'status' => 'working'
-        hash.should include 'update_time'
+        expect(capture_status_updates(2) {
+          expect(LongJob.perform_async(0.5)).to eq(job_id)
+        }).to eq([job_id]*2)
       end
-      (hash = Sidekiq::Status.get_all(job_id)).should include 'status' => 'complete'
-      hash.should include 'update_time'
+      expect(Sidekiq::Status.delete(job_id)).to eq(1)
+    end
+
+    it 'should not raise error while deleting status hash if invalid job id' do
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+      expect(Sidekiq::Status.delete(job_id)).to eq(0)
     end
   end
 
   describe ".cancel" do
     it "cancels a job by id" do
-      SecureRandom.should_receive(:hex).twice.and_return(job_id, job_id_1)
+      allow(SecureRandom).to receive(:hex).twice.and_return(job_id, job_id_1)
       start_server do
         job = LongJob.perform_in(3600)
-        job.should == job_id
+        expect(job).to eq(job_id)
         second_job = LongJob.perform_in(3600)
-        second_job.should == job_id_1
+        expect(second_job).to eq(job_id_1)
 
-        initial_schedule = redis.zrange "schedule", 0, -1, {withscores: true}
-        initial_schedule.size.should be 2
-        initial_schedule.select {|scheduled_job| JSON.parse(scheduled_job[0])["jid"] == job_id }.size.should be 1
+        initial_schedule = redis.zrange "schedule", 0, -1, withscores: true
+        expect(initial_schedule.size).to  be(2)
+        expect(initial_schedule.select {|scheduled_job| JSON.parse(scheduled_job[0])["jid"] == job_id }.size).to be(1)
 
-        Sidekiq::Status.unschedule(job_id).should be_true
-        Sidekiq::Status.cancel(unused_id).should be_false # Unused, therefore unfound => false
+        expect(Sidekiq::Status.unschedule(job_id)).to be_truthy
+        # Unused, therefore unfound => false
+        expect(Sidekiq::Status.cancel(unused_id)).to be_falsey
 
-        remaining_schedule = redis.zrange "schedule", 0, -1, {withscores: true}
-        remaining_schedule.size.should == (initial_schedule.size - 1)
-        remaining_schedule.select {|scheduled_job| JSON.parse(scheduled_job[0])["jid"] == job_id }.size.should be 0
+        remaining_schedule = redis.zrange "schedule", 0, -1, withscores: true
+        expect(remaining_schedule.size).to be(initial_schedule.size - 1)
+        expect(remaining_schedule.select {|scheduled_job| JSON.parse(scheduled_job[0])["jid"] == job_id }.size).to be(0)
       end
     end
 
     it "does not cancel a job with correct id but wrong time" do
-      SecureRandom.should_receive(:hex).once.and_return(job_id)
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
       start_server do
         scheduled_time = Time.now.to_i + 3600
         returned_job_id = LongJob.perform_at(scheduled_time)
-        returned_job_id.should == job_id
+        expect(returned_job_id).to eq(job_id)
 
-        initial_schedule = redis.zrange "schedule", 0, -1, {withscores: true}
-        initial_schedule.size.should == 1
-        Sidekiq::Status.cancel(returned_job_id, (scheduled_time + 1)).should be_false # wrong time, therefore unfound => false
-        (redis.zrange "schedule", 0, -1, {withscores: true}).size.should be 1
-        Sidekiq::Status.cancel(returned_job_id, (scheduled_time)).should be_true # same id, same time, deletes
-        (redis.zrange "schedule", 0, -1, {withscores: true}).size.should be_zero
+        initial_schedule = redis.zrange "schedule", 0, -1, withscores: true
+        expect(initial_schedule.size).to be(1)
+        # wrong time, therefore unfound => false
+        expect(Sidekiq::Status.cancel(returned_job_id, (scheduled_time + 1))).to be_falsey
+        expect((redis.zrange "schedule", 0, -1, withscores: true).size).to be(1)
+        # same id, same time, deletes
+        expect(Sidekiq::Status.cancel(returned_job_id, (scheduled_time))).to be_truthy
+        expect(redis.zrange "schedule", 0, -1, withscores: true).to be_empty
       end
     end
   end
@@ -129,14 +148,63 @@ describe Sidekiq::Status do
       expect_2_jobs_ttl_covers 1..Sidekiq::Status::DEFAULT_EXPIRY
     end
 
+    it "does jobs without a known class" do
+      seed_secure_random_with_job_ids
+      start_server(:expiration => expiration_param) do
+        expect {
+          Sidekiq::Client.new(Sidekiq.redis_pool).
+            push("class" => "NotAKnownClass", "args" => [])
+        }.to_not raise_error
+      end
+    end
+
     it "retries failed jobs" do
-      SecureRandom.should_receive(:hex).once.and_return(retried_job_id)
+      allow(SecureRandom).to receive(:hex).exactly(3).times.and_return(retried_job_id)
       start_server do
-        capture_status_updates(5) {
-          RetriedJob.perform_async().should == retried_job_id
-        }.should == [retried_job_id] * 5
+        expect(capture_status_updates(3) {
+          expect(RetriedJob.perform_async()).to eq(retried_job_id)
+        }).to eq([retried_job_id] * 3)
+        expect(Sidekiq::Status.status(retried_job_id)).to eq(:retrying)
+        expect(Sidekiq::Status.working?(retried_job_id)).to be_falsey
+        expect(Sidekiq::Status::queued?(retried_job_id)).to be_falsey
+        expect(Sidekiq::Status::retrying?(retried_job_id)).to be_truthy
+        expect(Sidekiq::Status::failed?(retried_job_id)).to be_falsey
+        expect(Sidekiq::Status::complete?(retried_job_id)).to be_falsey
+        expect(Sidekiq::Status::stopped?(retried_job_id)).to be_falsey
+        expect(Sidekiq::Status::interrupted?(retried_job_id)).to be_falsey
+      end
+      expect(Sidekiq::Status.status(retried_job_id)).to eq(:retrying)
+      expect(Sidekiq::Status::retrying?(retried_job_id)).to be_truthy
+
+      # restarting and waiting for the job to complete
+      start_server do
+        expect(capture_status_updates(3) {}).to eq([retried_job_id] * 3)
+        expect(Sidekiq::Status.status(retried_job_id)).to eq(:complete)
+        expect(Sidekiq::Status.complete?(retried_job_id)).to be_truthy
+        expect(Sidekiq::Status::retrying?(retried_job_id)).to be_falsey
+      end
+    end
+
+    it "marks retried jobs as failed once they do eventually fail" do
+      allow(SecureRandom).to receive(:hex).and_return(retry_and_fail_job_id)
+      start_server do
+        expect(
+          capture_status_updates(3) {
+            expect(RetryAndFailJob.perform_async).to eq(retry_and_fail_job_id)
+          }
+        ).to eq([retry_and_fail_job_id] * 3)
+
+        expect(Sidekiq::Status.status(retry_and_fail_job_id)).to eq(:retrying)
+      end
+
+      # restarting and waiting for the job to fail
+      start_server do
+        expect(capture_status_updates(3) {}).to eq([retry_and_fail_job_id] * 3)
+
+        expect(Sidekiq::Status.status(retry_and_fail_job_id)).to eq(:failed)
+        expect(Sidekiq::Status.failed?(retry_and_fail_job_id)).to be_truthy
+        expect(Sidekiq::Status::retrying?(retry_and_fail_job_id)).to be_falsey
       end
-      Sidekiq::Status.status(retried_job_id).should == :complete
     end
 
     context ":expiration param" do
@@ -149,40 +217,53 @@ describe Sidekiq::Status do
         expect_2_jobs_ttl_covers (Sidekiq::Status::DEFAULT_EXPIRY+1)..expiration_param
       end
 
-      it "allow to overwrite :expiration parameter by .expiration method from worker" do
+      it "allow to overwrite :expiration parameter by #expiration method from worker" do
         overwritten_expiration = expiration_param * 100
-        NoStatusConfirmationJob.any_instance.stub(:expiration => overwritten_expiration)
-        StubJob.any_instance.stub(:expiration => overwritten_expiration)
+        allow_any_instance_of(NoStatusConfirmationJob).to receive(:expiration).
+          and_return(overwritten_expiration)
+        allow_any_instance_of(StubJob).to receive(:expiration).
+          and_return(overwritten_expiration)
         run_2_jobs!
         expect_2_jobs_are_done_and_status_eq :complete
         expect_2_jobs_ttl_covers (expiration_param+1)..overwritten_expiration
       end
+
+      it "reads #expiration from a method when defined" do
+        allow(SecureRandom).to receive(:hex).once.and_return(job_id, job_id_1)
+        start_server do
+          expect(StubJob.perform_async).to eq(job_id)
+          expect(ExpiryJob.perform_async).to eq(job_id_1)
+          expect(redis.ttl("sidekiq:status:#{job_id}")).to eq(30 * 60)
+          expect(redis.ttl("sidekiq:status:#{job_id_1}")).to eq(15)
+        end
+      end
     end
 
     def seed_secure_random_with_job_ids
-      SecureRandom.should_receive(:hex).exactly(4).times.and_return(plain_sidekiq_job_id, plain_sidekiq_job_id, job_id_1, job_id_1)
+      allow(SecureRandom).to receive(:hex).exactly(4).times.
+        and_return(plain_sidekiq_job_id, plain_sidekiq_job_id, job_id_1, job_id_1)
     end
 
     def run_2_jobs!
       start_server(:expiration => expiration_param) do
-        capture_status_updates(12) {
-          StubJob.perform_async.should == plain_sidekiq_job_id
+        expect(capture_status_updates(6) {
+          expect(StubJob.perform_async).to eq(plain_sidekiq_job_id)
           NoStatusConfirmationJob.perform_async(1)
-          StubJob.perform_async.should == job_id_1
+          expect(StubJob.perform_async).to eq(job_id_1)
           NoStatusConfirmationJob.perform_async(2)
-        }.should =~ [plain_sidekiq_job_id, job_id_1] * 6
+        }).to match_array([plain_sidekiq_job_id, job_id_1] * 3)
       end
     end
 
     def expect_2_jobs_ttl_covers(range)
-      range.should cover redis.ttl(plain_sidekiq_job_id)
-      range.should cover redis.ttl(job_id_1)
+      expect(range).to cover redis.ttl("sidekiq:status:#{plain_sidekiq_job_id}")
+      expect(range).to cover redis.ttl("sidekiq:status:#{job_id_1}")
     end
 
     def expect_2_jobs_are_done_and_status_eq(status)
-      redis.mget('NoStatusConfirmationJob_1', 'NoStatusConfirmationJob_2').should == %w(done)*2
-      Sidekiq::Status.status(plain_sidekiq_job_id).should == status
-      Sidekiq::Status.status(job_id_1).should == status
+      expect(redis.mget('NoStatusConfirmationJob_1', 'NoStatusConfirmationJob_2')).to eq(%w(done)*2)
+      expect(Sidekiq::Status.status(plain_sidekiq_job_id)).to eq(status)
+      expect(Sidekiq::Status.status(job_id_1)).to eq(status)
     end
   end