sidekiq-status 0.6.0 → 3.0.3

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

@@ -5,20 +5,19 @@ 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}"
       allow(SecureRandom).to receive(:hex).once.and_return(job_id)
       start_server do
-        expect(ConfirmationJob.perform_async(:arg1 => 'val1')).to eq(job_id)
-        expect(thread.value).to eq([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
       expect(redis.hget("sidekiq:status:#{job_id}", :status)).to eq('complete')
       expect(Sidekiq::Status::complete?(job_id)).to be_truthy
@@ -35,19 +34,64 @@ describe Sidekiq::Status::ServerMiddleware do
       expect(Sidekiq::Status::failed?(job_id)).to be_truthy
     end
 
-    context "sets interrupted status" do 
-      it "on system exit signal" do 
+    it "sets failed status when Exception raised" do
+      allow(SecureRandom).to receive(:hex).once.and_return(job_id)
+      start_server do
+      expect(capture_status_updates(3) {
+        expect(FailingHardJob.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
+
+    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(capture_status_updates(3) {
-            expect(ExitedJob.perform_async).to eq(job_id)
-          }).to eq([job_id]*3)
+          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 
+      it "on interrupt signal" do
         allow(SecureRandom).to receive(:hex).once.and_return(job_id)
         start_server do
           expect(capture_status_updates(3) {
@@ -63,13 +107,13 @@ describe Sidekiq::Status::ServerMiddleware do
     it "sets status hash ttl" do
       allow(SecureRandom).to receive(:hex).once.and_return(job_id)
       start_server do
-        expect(StubJob.perform_async(:arg1 => 'val1')).to eq(job_id)
+        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
       allow(SecureRandom).to receive(:hex).once.and_return(job_id)
@@ -77,16 +121,16 @@ describe Sidekiq::Status::ServerMiddleware do
 
     it "overwrites default expiry value" do
       start_server(:expiration => huge_expiration) do
-        StubJob.perform_async(:arg1 => 'val1')
+        StubJob.perform_async 'arg1' => 'val1'
       end
-      expect((Sidekiq::Status::DEFAULT_EXPIRY+1)..huge_expiration).to cover redis.ttl("sidekiq:status:#{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
       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
       expect((huge_expiration+1)..overwritten_expiration).to cover redis.ttl("sidekiq:status:#{job_id}")
     end

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

@@ -8,30 +8,77 @@ describe 'sidekiq status web' 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 }
-
   def app
     Sidekiq::Web
   end
 
-  it 'shows a job in progress' do
+  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
 
-    start_server do
-      capture_status_updates(2) do
-        expect(LongJob.perform_async(1)).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
 
-      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/)
+  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

@@ -13,11 +13,29 @@ describe Sidekiq::Status::Worker do
 
   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,11 +8,7 @@ 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
@@ -20,11 +16,12 @@ describe Sidekiq::Status do
 
       start_server do
         expect(capture_status_updates(2) {
-          expect(LongJob.perform_async(1)).to eq(job_id)
+          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
@@ -54,9 +51,9 @@ describe Sidekiq::Status do
       allow(SecureRandom).to receive(:hex).once.and_return(job_id)
 
       start_server do
-        expect(capture_status_updates(3) {
+        expect(capture_status_updates(4) {
           expect(ProgressJob.perform_async).to eq(job_id)
-        }).to eq([job_id]*3)
+        }).to eq([job_id]*4)
       end
       expect(Sidekiq::Status.at(job_id)).to be(100)
       expect(Sidekiq::Status.total(job_id)).to be(500)
@@ -72,7 +69,7 @@ describe Sidekiq::Status do
 
       start_server do
         expect(capture_status_updates(2) {
-          expect(LongJob.perform_async(1)).to eq(job_id)
+          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'
@@ -82,6 +79,23 @@ describe Sidekiq::Status do
     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
+        expect(capture_status_updates(2) {
+          expect(LongJob.perform_async(0.5)).to eq(job_id)
+        }).to eq([job_id]*2)
+      end
+      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
       allow(SecureRandom).to receive(:hex).twice.and_return(job_id, job_id_1)
@@ -91,7 +105,7 @@ describe Sidekiq::Status do
         second_job = LongJob.perform_in(3600)
         expect(second_job).to eq(job_id_1)
 
-        initial_schedule = redis.zrange "schedule", 0, -1, {withscores: true}
+        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)
 
@@ -99,7 +113,7 @@ describe Sidekiq::Status do
         # Unused, therefore unfound => false
         expect(Sidekiq::Status.cancel(unused_id)).to be_falsey
 
-        remaining_schedule = redis.zrange "schedule", 0, -1, {withscores: true}
+        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
@@ -112,14 +126,14 @@ describe Sidekiq::Status do
         returned_job_id = LongJob.perform_at(scheduled_time)
         expect(returned_job_id).to eq(job_id)
 
-        initial_schedule = redis.zrange "schedule", 0, -1, {withscores: true}
+        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)
+        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
+        expect(redis.zrange "schedule", 0, -1, withscores: true).to be_empty
       end
     end
   end
@@ -134,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
-      allow(SecureRandom).to receive(:hex).once.and_return(retried_job_id)
+      allow(SecureRandom).to receive(:hex).exactly(3).times.and_return(retried_job_id)
       start_server do
-        expect(capture_status_updates(5) {
+        expect(capture_status_updates(3) {
           expect(RetriedJob.perform_async()).to eq(retried_job_id)
-        }).to eq([retried_job_id] * 5)
+        }).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
-      expect(Sidekiq::Status.status(retried_job_id)).to eq(:complete)
     end
 
     context ":expiration param" do
@@ -154,7 +217,7 @@ 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
         allow_any_instance_of(NoStatusConfirmationJob).to receive(:expiration).
           and_return(overwritten_expiration)
@@ -164,6 +227,16 @@ describe Sidekiq::Status do
         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
@@ -173,12 +246,12 @@ describe Sidekiq::Status do
 
     def run_2_jobs!
       start_server(:expiration => expiration_param) do
-        expect(capture_status_updates(12) {
+        expect(capture_status_updates(6) {
           expect(StubJob.perform_async).to eq(plain_sidekiq_job_id)
           NoStatusConfirmationJob.perform_async(1)
           expect(StubJob.perform_async).to eq(job_id_1)
           NoStatusConfirmationJob.perform_async(2)
-        }).to match_array([plain_sidekiq_job_id, job_id_1] * 6)
+        }).to match_array([plain_sidekiq_job_id, job_id_1] * 3)
       end
     end
 

data/spec/spec_helper.rb

@@ -1,71 +1,149 @@
 require "rspec"
-
-require 'celluloid'
+require 'colorize'
 require 'sidekiq'
+
+# Celluloid should only be manually required before Sidekiq versions 4.+
+require 'sidekiq/version'
+require 'celluloid' if Gem::Version.new(Sidekiq::VERSION) < Gem::Version.new('4.0')
+
 require 'sidekiq/processor'
 require 'sidekiq/manager'
 require 'sidekiq-status'
 
+# Clears jobs before every test
+RSpec.configure do |config|
+  config.before(:each) do
+    Sidekiq.redis { |conn| conn.flushall }
+    client_middleware
+    sleep 0.05
+  end
+end
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
-def client_middleware(client_middleware_options={}) 
+# Configures client middleware
+def client_middleware client_middleware_options = {}
   Sidekiq.configure_client do |config|
-    config.client_middleware do |chain|
-      chain.add Sidekiq::Status::ClientMiddleware, client_middleware_options
-    end
+    Sidekiq::Status.configure_client_middleware config, client_middleware_options
   end
 end
 
-def confirmations_thread(messages_limit, *channels)
+def redis_thread messages_limit, *channels
+
   parent = Thread.current
   thread = Thread.new {
-    confirmations = []
+    messages = []
     Sidekiq.redis do |conn|
-      conn.subscribe *channels do |on|
+      puts "Subscribing to #{channels} for #{messages_limit.to_s.bold} messages".cyan if ENV['DEBUG']
+      conn.subscribe_with_timeout 60, *channels do |on|
         on.subscribe do |ch, subscriptions|
+          puts "Subscribed to #{ch}".cyan if ENV['DEBUG']
           if subscriptions == channels.size
             sleep 0.1 while parent.status != "sleep"
             parent.run
           end
         end
         on.message do |ch, msg|
-          confirmations << msg
-          conn.unsubscribe if confirmations.length >= messages_limit
+          puts "Message received: #{ch} -> #{msg}".white if ENV['DEBUG']
+          messages << msg
+          conn.unsubscribe if messages.length >= messages_limit
         end
       end
     end
-    confirmations
+    puts "Returing from thread".cyan if ENV['DEBUG']
+    messages
   }
+
   Thread.stop
   yield if block_given?
   thread
+
+end
+
+def redis_client_thread message_limit, *channels
+  thread = Thread.new {
+    messages = []
+    Sidekiq.redis do |conn|
+      puts "Subscribing to #{channels} for #{message_limit.to_s.bold} messages".cyan if ENV['DEBUG']
+      pubsub = conn.pubsub
+      pubsub.call("SUBSCRIBE", *channels)
+
+      timeouts = 0
+      loop do
+        type, ch, msg = pubsub.next_event(2)
+        next if type == "subscribe"
+        if msg
+          puts "Message received: #{ch} -> #{msg}".white if ENV['DEBUG']
+          messages << msg
+          break if messages.length >= message_limit
+        else
+          # no new message was received in the allocated timeout
+          timeouts += 1
+          break if timeouts >= 30
+        end
+      end
+    end
+    puts "Returing from thread".cyan if ENV['DEBUG']
+    messages
+  }
+  sleep 0.1
+  yield if block_given?
+  thread.join
+end
+
+def branched_redis_thread n, *channels, &block
+  if Sidekiq.major_version < 7
+    redis_thread(n, *channels, &block)
+  else
+    redis_client_thread(n, *channels, &block)
+  end
 end
 
-def capture_status_updates(n, &block)
-  confirmations_thread(n, "status_updates", &block).value
+def capture_status_updates n, &block
+  branched_redis_thread(n, "status_updates", &block).value
 end
 
-def start_server(server_middleware_options={})
+# Configures server middleware and launches a sidekiq server
+def start_server server_middleware_options = {}
+
+  # Creates a process for the Sidekiq server
   pid = Process.fork do
-    $stdout.reopen File::NULL, 'w'
-    $stderr.reopen File::NULL, 'w'
+
+    # Redirect the server's outputs
+    $stdout.reopen File::NULL, 'w' unless ENV['DEBUG']
+    $stderr.reopen File::NULL, 'w' unless ENV['DEBUG']
+
+    # Load and configure server options
     require 'sidekiq/cli'
-    Sidekiq.options[:queues] << 'default'
-    Sidekiq.options[:require] =  File.expand_path('../support/test_jobs.rb', __FILE__)
+
+    # Add the server middleware
     Sidekiq.configure_server do |config|
-      config.redis = Sidekiq::RedisConnection.create
-      config.server_middleware do |chain|
-        chain.add Sidekiq::Status::ServerMiddleware, server_middleware_options
-      end
+      config.concurrency = 5
+      config.redis = Sidekiq::RedisConnection.create if Sidekiq.major_version < 7
+      Sidekiq::Status.configure_server_middleware config, server_middleware_options
     end
-    Sidekiq::CLI.instance.run
+
+    # Launch
+    puts "Server starting".yellow if ENV['DEBUG']
+    instance = Sidekiq::CLI.instance
+    instance.parse(['-r', File.expand_path('environment.rb', File.dirname(__FILE__))])
+    instance.run
+
   end
 
+  # Run the client-side code
   yield
-  sleep 0.1
+
+  # Pause to ensure all jobs are picked up & started before TERM is sent
+  sleep 0.2
+
+  # Attempt to shut down the server normally
   Process.kill 'TERM', pid
-  Timeout::timeout(10) { Process.wait pid } rescue Timeout::Error
+  Process.wait pid
+
 ensure
+
+  # Ensure the server is actually dead
   Process.kill 'KILL', pid rescue "OK" # it's OK if the process is gone already
+
 end