inst-jobs 2.3.3 → 2.4.11

data/spec/delayed/periodic_spec.rb

@@ -1,30 +1,31 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Delayed::Periodic do
-  around(:each) do |block|
+  around do |block|
     # make sure we can use ".cron" and
     # such safely without leaking global state
-    prev_sched = Delayed::Periodic.scheduled
-    prev_ovr = Delayed::Periodic.overrides
-    Delayed::Periodic.scheduled = {}
-    Delayed::Periodic.overrides = {}
+    prev_sched = described_class.scheduled
+    prev_ovr = described_class.overrides
+    described_class.scheduled = {}
+    described_class.overrides = {}
     block.call
   ensure
-    Delayed::Periodic.scheduled = prev_sched
-    Delayed::Periodic.overrides = prev_ovr
+    described_class.scheduled = prev_sched
+    described_class.overrides = prev_ovr
     Delayed::Job.delete_all
   end
 
   describe ".cron" do
-    let(:job_name){ 'just a test'}
+    let(:job_name) { "just a test" }
+
     it "provides a tag by default for periodic jobs" do
-      Delayed::Periodic.cron job_name, '*/10 * * * *' do
+      described_class.cron job_name, "*/10 * * * *" do
         # no-op
       end
-      instance = Delayed::Periodic.scheduled[job_name]
-      expect(instance).to_not be_nil
+      instance = described_class.scheduled[job_name]
+      expect(instance).not_to be_nil
       expect(instance.enqueue_args[:singleton]).to eq("periodic: just a test")
     end
   end

data/spec/delayed/server_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'delayed/server'
+require "spec_helper"
+require "delayed/server"
 
 RSpec.describe Delayed::Server, sinatra: true do
   include Rack::Test::Methods
@@ -24,78 +24,78 @@ RSpec.describe Delayed::Server, sinatra: true do
     before do
       3.times do |i|
         Delayed::Job.create!({
-          run_at: Time.now,
-          locked_at: Time.now,
-          locked_by: "dummy-runner-#{i}:${$$}",
-        })
+                               run_at: Time.zone.now,
+                               locked_at: Time.zone.now,
+                               locked_by: "dummy-runner-#{i}:${$$}"
+                             })
       end
-      get '/running'
+      get "/running"
     end
 
-    it 'must return a json object with the running job data in an array', aggregate_failures: true do
+    it "must return a json object with the running job data in an array", aggregate_failures: true do
       expect(last_response).to be_ok
-      expect(parsed_body['data']).to be_an Array
-      expect(parsed_body['data'].size).to eq 3
+      expect(parsed_body["data"]).to be_an Array
+      expect(parsed_body["data"].size).to eq 3
     end
   end
 
   describe "get '/jobs'" do
-    let!(:job_1) { Delayed::Job.enqueue(SimpleJob.new, strand: 'strand-1') }
-    let!(:job_2) { Delayed::Job.enqueue(SimpleJob.new, strand: 'strand-2') }
-    let!(:job_3) { Delayed::Job.enqueue(SimpleJob.new, strand: 'strand-3') }
+    let!(:job1) { Delayed::Job.enqueue(SimpleJob.new, strand: "strand-1") }
+    let!(:job2) { Delayed::Job.enqueue(SimpleJob.new, strand: "strand-2") }
+    let!(:job3) { Delayed::Job.enqueue(SimpleJob.new, strand: "strand-3") }
 
-    context 'with the flavor param set to id' do
+    context "with the flavor param set to id" do
       before do
-        get "/jobs?flavor=id&search_term=#{job_2.id}"
+        get "/jobs?flavor=id&search_term=#{job2.id}"
       end
 
-      it 'must only return the job with the id specified in the search_term param' do
-        jobs = parsed_body['data']
-        job_ids = jobs.map{ |j| j['id'] }
-        expect(job_ids).to eq [job_2.id]
+      it "must only return the job with the id specified in the search_term param" do
+        jobs = parsed_body["data"]
+        job_ids = jobs.map { |j| j["id"] }
+        expect(job_ids).to eq [job2.id]
       end
 
-      it 'must set recordsFiltered in the response to 1' do
-        expect(parsed_body['recordsFiltered']).to eq 1
+      it "must set recordsFiltered in the response to 1" do
+        expect(parsed_body["recordsFiltered"]).to eq 1
       end
     end
   end
 
   describe "post '/bulk_update'" do
-    let!(:job_1) { Delayed::Job.enqueue(SimpleJob.new, strand: 'strand-1') }
-    let!(:job_2) { Delayed::Job.enqueue(SimpleJob.new, strand: 'strand-2') }
-    let!(:job_3) { Delayed::Job.enqueue(SimpleJob.new, strand: 'strand-3') }
+    let!(:job1) { Delayed::Job.enqueue(SimpleJob.new, strand: "strand-1") }
+    let!(:job2) { Delayed::Job.enqueue(SimpleJob.new, strand: "strand-2") }
+    let!(:job3) { Delayed::Job.enqueue(SimpleJob.new, strand: "strand-3") }
 
-    context 'with update enabled' do
+    context "with update enabled" do
       before do
         @update = true
-        post "/bulk_update", params=JSON.generate(action: 'destroy', ids: [job_1.id])
+        post "/bulk_update", JSON.generate(action: "destroy", ids: [job1.id])
       end
 
-      it 'must remove job_1' do
-        expect{ Delayed::Job.find(job_1.id) }.to raise_error(ActiveRecord::RecordNotFound)
-        expect(Delayed::Job.find(job_2.id)).to_not be_nil
-        expect(Delayed::Job.find(job_3.id)).to_not be_nil
+      it "must remove job1" do
+        expect { Delayed::Job.find(job1.id) }.to raise_error(ActiveRecord::RecordNotFound)
+        expect(Delayed::Job.find(job2.id)).not_to be_nil
+        expect(Delayed::Job.find(job3.id)).not_to be_nil
       end
 
-      it 'must return ok' do
+      it "must return ok" do
         expect(last_response.ok?).to be true
       end
     end
 
-    context 'with update disabled' do
+    context "with update disabled" do
       before do
         @update = false
-        post "/bulk_update", params=JSON.generate(action: 'destroy', ids: [job_1.id])
+        post "/bulk_update", JSON.generate(action: "destroy", ids: [job1.id])
       end
 
-      it 'must not remove job_1' do
-        expect(Delayed::Job.find(job_1.id)).to_not be_nil
-        expect(Delayed::Job.find(job_2.id)).to_not be_nil
-        expect(Delayed::Job.find(job_3.id)).to_not be_nil
+      it "must not remove job1" do
+        expect(Delayed::Job.find(job1.id)).not_to be_nil
+        expect(Delayed::Job.find(job2.id)).not_to be_nil
+        expect(Delayed::Job.find(job3.id)).not_to be_nil
       end
 
-      it 'must return forbidden' do
+      it "must return forbidden" do
         expect(last_response.forbidden?).to be true
       end
     end

data/spec/delayed/settings_spec.rb

@@ -1,47 +1,48 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Delayed::Settings do
-  let(:configfile) {<<-YAML
-default:
-  workers:
-  - queue: myqueue
-    workers: 2
-  - queue: secondqueue
-    max_priority: 7
-  max_attempts: 1
+  let(:configfile) do
+    <<~YAML
+      default:
+        workers:
+        - queue: myqueue
+          workers: 2
+        - queue: secondqueue
+          max_priority: 7
+        max_attempts: 1
     YAML
-  }
+  end
 
-  describe '.worker_config' do
-    it 'merges each worker config with the top-level config' do
+  describe ".worker_config" do
+    it "merges each worker config with the top-level config" do
       expect(File).to receive(:read).with("fname").and_return(configfile)
       config = described_class.worker_config("fname")
       expect(config[:workers]).to eq([
-        {'queue' => 'myqueue', 'workers' => 2, 'max_attempts' => 1},
-        {'queue' => 'secondqueue', 'max_priority' => 7, 'max_attempts' => 1},
-      ])
+                                       { "queue" => "myqueue", "workers" => 2, "max_attempts" => 1 },
+                                       { "queue" => "secondqueue", "max_priority" => 7, "max_attempts" => 1 }
+                                     ])
     end
   end
 
-  describe '.apply_worker_config!' do
-    it 'applies global settings from the given config' do
+  describe ".apply_worker_config!" do
+    it "applies global settings from the given config" do
       expect(described_class).to receive(:last_ditch_logfile=).with(true)
-      described_class.apply_worker_config!('last_ditch_logfile' => true)
+      described_class.apply_worker_config!("last_ditch_logfile" => true)
     end
 
-    it 'merges in parent_process overrides to default config' do
-      described_class.apply_worker_config!('parent_process' => { 'foo' => 'bar' })
+    it "merges in parent_process overrides to default config" do
+      described_class.apply_worker_config!("parent_process" => { "foo" => "bar" })
 
-      expect(Delayed::Settings.parent_process).to include('foo' => 'bar')
+      expect(described_class.parent_process).to include("foo" => "bar")
     end
   end
 
-  describe '.parent_process_client_timeout=' do
-    it 'must update the value in the parent_process settings hash' do
-      Delayed::Settings.parent_process_client_timeout = 42
-      expect(Delayed::Settings.parent_process['server_socket_timeout']).to eq 42
+  describe ".parent_process_client_timeout=" do
+    it "must update the value in the parent_process settings hash" do
+      described_class.parent_process_client_timeout = 42
+      expect(described_class.parent_process["server_socket_timeout"]).to eq 42
     end
   end
 end

data/spec/delayed/work_queue/in_process_spec.rb

@@ -1,27 +1,26 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Delayed::WorkQueue::InProcess do
   before :all do
     Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
   end
 
-  after :each do
+  after do
     Delayed::Worker.lifecycle.reset!
   end
 
-  let(:subject) { described_class.new }
-  let(:worker_config) { {queue: "test", min_priority: 1, max_priority: 2} }
+  let(:worker_config) { { queue: "test", min_priority: 1, max_priority: 2 } }
   let(:args) { ["worker_name", worker_config] }
 
-  it 'triggers the lifecycle event around the pop' do
+  it "triggers the lifecycle event around the pop" do
     called = false
     Delayed::Worker.lifecycle.around(:work_queue_pop) do |queue, &cb|
       expect(queue).to eq(subject)
-      expect(Delayed::Job).to receive(:get_and_lock_next_available).
-        with("worker_name", "test", 1, 2).
-        and_return(:job)
+      expect(Delayed::Job).to receive(:get_and_lock_next_available)
+        .with("worker_name", "test", 1, 2)
+        .and_return(:job)
       called = true
       cb.call(queue)
     end

data/spec/delayed/work_queue/parent_process/client_spec.rb

@@ -1,22 +1,23 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
-  let(:subject) { described_class.new(addrinfo).tap(&:init) }
-  let(:addrinfo) { double('Addrinfo') }
-  let(:connection) { double('Socket') }
+  subject { described_class.new(addrinfo).tap(&:init) }
+
+  let(:addrinfo) { double("Addrinfo") }
+  let(:connection) { double("Socket") }
   let(:job) { Delayed::Job.new(locked_by: "worker_name") }
   let(:worker_config) { { queue: "queue_name", min_priority: 1, max_priority: 2 } }
   let(:args) { ["worker_name", worker_config] }
   let(:job_args) { [["worker_name"], "queue_name", 1, 2] }
 
   before :all do
-    FileUtils.mkdir_p(Delayed::Settings.expand_rails_path('tmp'))
+    FileUtils.mkdir_p(Delayed::Settings.expand_rails_path("tmp"))
     Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
   end
 
-  it 'marshals the given arguments to the server and returns the response' do
+  it "marshals the given arguments to the server and returns the response" do
     expect(addrinfo).to receive(:connect).once.and_return(connection)
     expect(connection).to receive(:eof?).and_return(false)
     expect(IO).to receive(:select).and_return([[connection], nil, nil])
@@ -26,7 +27,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
     expect(response).to eq(job)
   end
 
-  it 'returns nil and then reconnects on socket write error' do
+  it "returns nil and then reconnects on socket write error" do
     expect(addrinfo).to receive(:connect).once.and_return(connection)
     expect(Marshal).to receive(:dump).and_raise(SystemCallError.new("failure"))
     expect(IO).to receive(:select).and_return([[connection], nil, nil])
@@ -42,7 +43,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
     expect(response).to eq(job)
   end
 
-  it 'returns nil and then reconnects when the socket indicates eof' do
+  it "returns nil and then reconnects when the socket indicates eof" do
     expect(addrinfo).to receive(:connect).once.and_return(connection)
     expect(connection).to receive(:eof?).and_return(true)
     expect(Marshal).to receive(:dump).with(args, connection).ordered
@@ -59,17 +60,19 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
     expect(response).to eq(job)
   end
 
-  it 'errors if the response is not a locked job' do
+  it "errors if the response is not a locked job" do
     expect(addrinfo).to receive(:connect).once.and_return(connection)
     expect(Marshal).to receive(:dump).with(args, connection)
     expect(IO).to receive(:select).and_return([[connection], nil, nil])
     expect(Marshal).to receive(:load).with(connection).and_return(:not_a_job)
     expect(connection).to receive(:eof?).and_return(false)
 
-    expect { subject.get_and_lock_next_available(*args) }.to raise_error(Delayed::WorkQueue::ParentProcess::ProtocolError)
+    expect do
+      subject.get_and_lock_next_available(*args)
+    end.to raise_error(Delayed::WorkQueue::ParentProcess::ProtocolError)
   end
 
-  it 'errors if the response is a job not locked by this worker' do
+  it "errors if the response is a job not locked by this worker" do
     expect(addrinfo).to receive(:connect).once.and_return(connection)
     expect(Marshal).to receive(:dump).with(args, connection)
     job.locked_by = "somebody_else"
@@ -77,6 +80,8 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
     expect(Marshal).to receive(:load).with(connection).and_return(job)
     expect(connection).to receive(:eof?).and_return(false)
 
-    expect { subject.get_and_lock_next_available(*args) }.to raise_error(Delayed::WorkQueue::ParentProcess::ProtocolError)
+    expect do
+      subject.get_and_lock_next_available(*args)
+    end.to raise_error(Delayed::WorkQueue::ParentProcess::ProtocolError)
   end
 end

data/spec/delayed/work_queue/parent_process/server_spec.rb

@@ -1,32 +1,37 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
-  class JobClass
-    attr_reader :id
+class JobClass
+  attr_reader :id
 
-    def initialize
-      @id = rand
-    end
+  def initialize
+    @id = rand
+  end
 
-    def ==(other)
-      self.id == other.id
-    end
+  def ==(other)
+    id == other.id
   end
+end
+
+RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
+  subject { described_class.new(listen_socket) }
 
   let(:parent) { Delayed::WorkQueue::ParentProcess.new }
-  let(:subject) { described_class.new(listen_socket) }
   let(:listen_socket) { Socket.unix_server_socket(parent.server_address) }
   let(:job) { JobClass.new }
   let(:worker_config) { { queue: "queue_name", min_priority: 1, max_priority: 2 } }
   let(:args) { ["worker_name", worker_config] }
   let(:job_args) { [["worker_name"], "queue_name", 1, 2, hash_including(prefetch: 4)] }
 
+  before do
+    Delayed::Worker.lifecycle.reset!
+  end
+
   before :all do
     Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
     Delayed::Settings.parent_process = {
-      'server_address' => '/tmp/inst-jobs-test.sock'
+      "server_address" => "/tmp/inst-jobs-test.sock"
     }
   end
 
@@ -34,27 +39,28 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     Delayed::Settings.parent_process = {}
   end
 
-  after :each do
-    File.unlink('/tmp/inst-jobs-test.sock') if File.exist?('/tmp/inst-jobs-test.sock')
+  after do
+    File.unlink("/tmp/inst-jobs-test.sock") if File.exist?("/tmp/inst-jobs-test.sock")
+    Delayed::Worker.lifecycle.reset!
   end
 
-  it 'accepts new clients' do
-    client = Socket.unix(subject.listen_socket.local_address.unix_path)
+  it "accepts new clients" do
+    Socket.unix(subject.listen_socket.local_address.unix_path)
     expect { subject.run_once }.to change(subject, :connected_clients).by(1)
   end
 
-  it 'queries the queue on client request' do
+  it "queries the queue on client request" do
     client = Socket.unix(subject.listen_socket.local_address.unix_path)
     subject.run_once
 
-    expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return('worker_name' => job)
+    expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return("worker_name" => job)
     Marshal.dump(args, client)
     subject.run_once
     expect(client).to be_ready
     expect(Marshal.load(client)).to eq(job)
   end
 
-  it 'can pop multiple jobs at once' do
+  it "can pop multiple jobs at once" do
     client1 = Socket.unix(subject.listen_socket.local_address.unix_path)
     subject.run_once
     client2 = Socket.unix(subject.listen_socket.local_address.unix_path)
@@ -62,8 +68,8 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
 
     job1 = JobClass.new
     job2 = JobClass.new
-    job_args = [["worker_name1", "worker_name2"], "queue_name", 1, 2, hash_including(prefetch: 3)]
-    jobs = { 'worker_name1' => job1, 'worker_name2' => job2 }
+    job_args = [%w[worker_name1 worker_name2], "queue_name", 1, 2, hash_including(prefetch: 3)]
+    jobs = { "worker_name1" => job1, "worker_name2" => job2 }
 
     expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return(jobs)
     Marshal.dump(["worker_name1", worker_config], client1)
@@ -73,27 +79,28 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect(Marshal.load(client2)).to eq(job2)
   end
 
-  it 'will prefetch and use jobs' do
+  it "will prefetch and use jobs" do
     client = Socket.unix(subject.listen_socket.local_address.unix_path)
     subject.run_once
 
-    allow(subject).to receive(:prefetch_owner).and_return('work_queue:X')
-    job_args = [["worker_name1"], "queue_name", 1, 2, prefetch: 4, prefetch_owner: 'work_queue:X', forced_latency: 6.0]
-    job2 = Delayed::Job.new(:tag => 'tag')
-    job2.create_and_lock!('work_queue:X')
-    job3 = Delayed::Job.new(:tag => 'tag')
-    job3.create_and_lock!('work_queue:X')
-    jobs = { 'worker_name1' => job, 'work_queue:X' => [job2, job3]}
+    allow(subject).to receive(:prefetch_owner).and_return("work_queue:X")
+    job_args = [["worker_name1"], "queue_name", 1, 2,
+                { prefetch: 4, prefetch_owner: "work_queue:X", forced_latency: 6.0 }]
+    job2 = Delayed::Job.new(tag: "tag")
+    job2.create_and_lock!("work_queue:X")
+    job3 = Delayed::Job.new(tag: "tag")
+    job3.create_and_lock!("work_queue:X")
+    jobs = { "worker_name1" => job, "work_queue:X" => [job2, job3] }
 
     expect(Delayed::Job).to receive(:get_and_lock_next_available).once.with(*job_args).and_return(jobs)
     Marshal.dump(["worker_name1", worker_config], client)
     subject.run_once
-    expect(subject).to_not be_all_workers_idle
+    expect(subject).not_to be_all_workers_idle
     expect(Marshal.load(client)).to eq(job)
 
     Marshal.dump(["worker_name1", worker_config], client)
     subject.run_once
-    expect(subject).to_not be_all_workers_idle
+    expect(subject).not_to be_all_workers_idle
     expect(Marshal.load(client)).to eq(job2)
   end
 
@@ -107,7 +114,10 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect(client).not_to be_ready
 
     # next time around, return the result
-    expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return('worker_name' => job).ordered
+    expect(Delayed::Job).to receive(:get_and_lock_next_available)
+      .with(*job_args)
+      .and_return("worker_name" => job)
+      .ordered
     allow(Delayed::Settings).to receive(:sleep_delay).and_return(0)
     allow(Delayed::Settings).to receive(:sleep_delay_stagger).and_return(0)
     subject.run_once
@@ -115,7 +125,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect(Marshal.load(client)).to eq(job)
   end
 
-  it 'drops the client on i/o error' do
+  it "drops the client on i/o error" do
     client = Socket.unix(subject.listen_socket.local_address.unix_path)
     subject.run_once
 
@@ -125,7 +135,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect { subject.run_once }.to change(subject, :connected_clients).by(-1)
   end
 
-  it 'drops the client when the client disconnects' do
+  it "drops the client when the client disconnects" do
     client = Socket.unix(subject.listen_socket.local_address.unix_path)
     subject.run_once
 
@@ -138,7 +148,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect(subject.instance_variable_get(:@waiting_clients).first.last).to eq []
   end
 
-  it 'drops the client when a write fails' do
+  it "drops the client when a write fails" do
     client = Socket.unix(subject.listen_socket.local_address.unix_path)
     subject.run_once
 
@@ -151,7 +161,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     # don't let the server see the close and process it there; we want to check a failure later
     expect(subject).to receive(:handle_request).with(server_client_socket)
 
-    expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return('worker_name' => job)
+    expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return("worker_name" => job)
     # the job gets unlocked
     expect(Delayed::Job).to receive(:unlock).with([job])
     subject.run_once
@@ -161,14 +171,14 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect(subject.instance_variable_get(:@waiting_clients).first.last).to eq []
   end
 
-  it 'tracks when clients are idle' do
+  it "tracks when clients are idle" do
     expect(subject.all_workers_idle?).to be(true)
 
     client = Socket.unix(subject.listen_socket.local_address.unix_path)
     subject.run_once
     expect(subject.all_workers_idle?).to be(true)
 
-    expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return('worker_name' => job)
+    expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return("worker_name" => job)
     Marshal.dump(args, client)
     subject.run_once
     expect(subject.all_workers_idle?).to be(false)
@@ -179,7 +189,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect(subject.all_workers_idle?).to be(true)
   end
 
-  it 'triggers the lifecycle event around the pop' do
+  it "triggers the lifecycle event around the pop" do
     called = false
     client = Socket.unix(subject.listen_socket.local_address.unix_path)
     subject.run_once
@@ -187,7 +197,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     Delayed::Worker.lifecycle.around(:work_queue_pop) do |queue, &cb|
       expect(subject.all_workers_idle?).to be(true)
       expect(queue).to eq(subject)
-      expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return('worker_name' => job)
+      expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return("worker_name" => job)
       called = true
       res = cb.call(queue)
       expect(subject.all_workers_idle?).to be(false)
@@ -200,5 +210,24 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect(Marshal.load(client)).to eq(job)
     expect(called).to eq(true)
   end
-end
 
+  it "deletes the correct worker when transferring jobs" do
+    client1 = Socket.unix(subject.listen_socket.local_address.unix_path)
+    client2 = Socket.unix(subject.listen_socket.local_address.unix_path)
+    subject.run_once
+    subject.run_once
+
+    Marshal.dump(args, client1)
+    Marshal.dump(["worker_name2", worker_config], client2)
+    subject.run_once
+    subject.run_once
+
+    waiting_clients = subject.instance_variable_get(:@waiting_clients)
+    expect(waiting_clients.first.last.length).to eq 2
+
+    expect(Delayed::Job).to receive(:get_and_lock_next_available).and_return("worker_name" => job,
+                                                                             "worker_name2" => job)
+    subject.run_once
+    expect(waiting_clients.first.last).to be_empty
+  end
+end