inst-jobs 3.0.8 → 3.1.11

data/spec/delayed/message_sending_spec.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "debug_inspector"
-
-RSpec.describe Delayed::MessageSending do
-  before do
-    allow(::Rails.env).to receive(:test?).and_return(true)
-  end
-
-  before(:all) do
-    # this has to be a "real" constant
-    class SpecClass # rubocop:disable RSpec/LeakyConstantDeclaration, Lint/ConstantDefinitionInBlock
-      def call_private(**enqueue_args)
-        delay(**enqueue_args).private_method
-      end
-
-      def call_protected(**enqueue_args)
-        other = self.class.new
-        other.delay(**enqueue_args).protected_method
-      end
-
-      def call_public(**_kwargs)
-        42
-      end
-
-      private
-
-      def private_method; end
-
-      protected
-
-      def protected_method; end
-    end
-  end
-
-  after(:all) do
-    Object.send(:remove_const, :SpecClass)
-  end
-
-  let(:klass) { SpecClass }
-
-  it "allows an object to send a private message to itself" do
-    job = klass.new.call_private(ignore_transaction: true)
-    job.invoke_job
-  end
-
-  it "allows an object to send a private message to itself synchronouosly" do
-    klass.new.call_private(synchronous: true)
-  end
-
-  it "warns about directly sending a private message asynchronously" do
-    expect { klass.new.delay.private_method }.to raise_error(NoMethodError)
-  end
-
-  it "warns about directly sending a private message synchronusly" do
-    expect { klass.new.delay(synchronous: true).private_method }.to raise_error(NoMethodError)
-  end
-
-  it "does not warn about directly sending a private message in production" do
-    allow(::Rails.env).to receive(:test?).and_return(false)
-    allow(::Rails.env).to receive(:development?).and_return(false)
-    klass.new.delay.private_method
-  end
-
-  it "does not warn about directly sending a private message synchronously in production" do
-    allow(::Rails.env).to receive(:test?).and_return(false)
-    allow(::Rails.env).to receive(:development?).and_return(false)
-    klass.new.delay(synchronous: true).private_method
-  end
-
-  it "allows an object to send a protected message to itself" do
-    job = klass.new.call_protected(ignore_transaction: true)
-    job.invoke_job
-  end
-
-  it "allows an object to send a protected message to itself synchronouosly" do
-    klass.new.call_protected(synchronous: true)
-  end
-
-  it "directly calls a public method on an object with kwargs" do
-    expect(klass.new.delay(synchronous: true).call_public(kwarg: 10)).to eq 42
-  end
-
-  it "warns about directly sending a protected message asynchronously" do
-    expect { klass.new.delay.protected_method }.to raise_error(NoMethodError)
-  end
-
-  it "warns about directly sending a protected message synchronusly" do
-    expect { klass.new.delay(synchronous: true).protected_method }.to raise_error(NoMethodError)
-  end
-
-  it "doesn't explode if you can't dump the sender" do
-    klass = Class.new do
-      def delay_something
-        Kernel.delay.sleep(1)
-      end
-
-      def encode_with(_encoder)
-        raise "yaml encoding failed"
-      end
-    end
-
-    obj = klass.new
-    expect { YAML.dump(obj) }.to raise_error("yaml encoding failed")
-    expect { obj.delay_something }.not_to raise_error
-  end
-end

data/spec/delayed/periodic_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Delayed::Periodic do
-  around do |block|
-    # make sure we can use ".cron" and
-    # such safely without leaking global state
-    prev_sched = described_class.scheduled
-    prev_ovr = described_class.overrides
-    described_class.scheduled = {}
-    described_class.overrides = {}
-    block.call
-  ensure
-    described_class.scheduled = prev_sched
-    described_class.overrides = prev_ovr
-    Delayed::Job.delete_all
-  end
-
-  describe ".cron" do
-    let(:job_name) { "just a test" }
-
-    it "provides a tag by default for periodic jobs" do
-      described_class.cron job_name, "*/10 * * * *" do
-        # no-op
-      end
-      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
-end

data/spec/delayed/server_spec.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "delayed/server"
-
-RSpec.describe Delayed::Server, sinatra: true do
-  include Rack::Test::Methods
-
-  @update = false
-
-  def app
-    described_class.new(update: @update)
-  end
-
-  def parsed_body
-    @parsed_body ||= JSON.parse(last_response.body)
-  end
-
-  before :all do
-    Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
-  end
-
-  describe "get '/running'" do
-    before do
-      3.times do |i|
-        Delayed::Job.create!({
-                               run_at: Time.zone.now,
-                               locked_at: Time.zone.now,
-                               locked_by: "dummy-runner-#{i}:${$$}"
-                             })
-      end
-      get "/running"
-    end
-
-    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
-    end
-  end
-
-  describe "get '/jobs'" do
-    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
-      before do
-        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 [job2.id]
-      end
-
-      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!(: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
-      before do
-        @update = true
-        post "/bulk_update", JSON.generate(action: "destroy", ids: [job1.id])
-      end
-
-      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
-        expect(last_response.ok?).to be true
-      end
-    end
-
-    context "with update disabled" do
-      before do
-        @update = false
-        post "/bulk_update", JSON.generate(action: "destroy", ids: [job1.id])
-      end
-
-      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
-        expect(last_response.forbidden?).to be true
-      end
-    end
-  end
-end

data/spec/delayed/settings_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Delayed::Settings do
-  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
-      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 }
-                                     ])
-    end
-  end
-
-  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)
-    end
-
-    it "merges in parent_process overrides to default config" do
-      described_class.apply_worker_config!("parent_process" => { "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
-      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,31 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Delayed::WorkQueue::InProcess do
-  before :all do
-    Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
-  end
-
-  after do
-    Delayed::Worker.lifecycle.reset!
-  end
-
-  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
-    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)
-      called = true
-      cb.call(queue)
-    end
-    job = subject.get_and_lock_next_available(*args)
-    expect(job).to eq(:job)
-    expect(called).to eq(true)
-  end
-end

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

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Delayed::WorkQueue::ParentProcess::Client do
-  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"))
-    Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
-  end
-
-  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])
-    expect(Marshal).to receive(:dump).with(args, connection).ordered
-    expect(Marshal).to receive(:load).with(connection).and_return(job).ordered
-    response = subject.get_and_lock_next_available(*args)
-    expect(response).to eq(job)
-  end
-
-  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])
-    expect(connection).to receive(:close)
-    response = subject.get_and_lock_next_available(*args)
-    expect(response).to be_nil
-
-    expect(addrinfo).to receive(:connect).once.and_return(connection)
-    expect(Marshal).to receive(:dump).with(args, connection)
-    expect(connection).to receive(:eof?).and_return(false)
-    expect(Marshal).to receive(:load).with(connection).and_return(job)
-    response = subject.get_and_lock_next_available(*args)
-    expect(response).to eq(job)
-  end
-
-  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
-    expect(IO).to receive(:select).and_return([[connection], nil, nil])
-    expect(connection).to receive(:close)
-    response = subject.get_and_lock_next_available(*args)
-    expect(response).to be_nil
-
-    expect(addrinfo).to receive(:connect).once.and_return(connection)
-    expect(Marshal).to receive(:dump).with(args, connection)
-    expect(connection).to receive(:eof?).and_return(false)
-    expect(Marshal).to receive(:load).with(connection).and_return(job)
-    response = subject.get_and_lock_next_available(*args)
-    expect(response).to eq(job)
-  end
-
-  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 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
-    expect(addrinfo).to receive(:connect).once.and_return(connection)
-    expect(Marshal).to receive(:dump).with(args, connection)
-    job.locked_by = "somebody_else"
-    expect(IO).to receive(:select).and_return([[connection], nil, nil])
-    expect(Marshal).to receive(:load).with(connection).and_return(job)
-    expect(connection).to receive(:eof?).and_return(false)
-
-    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,280 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-class JobClass
-  attr_reader :id
-
-  def initialize
-    @id = rand
-  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(: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"
-    }
-  end
-
-  after :all do
-    Delayed::Settings.parent_process = {}
-  end
-
-  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
-    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
-    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)
-    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
-    client1 = Socket.unix(subject.listen_socket.local_address.unix_path)
-    subject.run_once
-    client2 = Socket.unix(subject.listen_socket.local_address.unix_path)
-    subject.run_once
-
-    job1 = JobClass.new
-    job2 = JobClass.new
-    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)
-    Marshal.dump(["worker_name2", worker_config], client2)
-    subject.run_once
-    expect(Marshal.load(client1)).to eq(job1)
-    expect(Marshal.load(client2)).to eq(job2)
-  end
-
-  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] }
-
-    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).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).not_to be_all_workers_idle
-    expect(Marshal.load(client)).to eq(job2)
-  end
-
-  context "prefetched job unlocking" do
-    let(:job_args) do
-      [["worker_name1"], "queue_name", 1, 2,
-       { prefetch: 4, prefetch_owner: "prefetch:work_queue:X", forced_latency: 6.0 }]
-    end
-    let(:job2) { Delayed::Job.new(tag: "tag").tap { |j| j.create_and_lock!("prefetch:work_queue:X") } }
-    let(:job3) { Delayed::Job.new(tag: "tag").tap { |j| j.create_and_lock!("prefetch:work_queue:X") } }
-
-    before do
-      client = Socket.unix(subject.listen_socket.local_address.unix_path)
-      subject.run_once
-
-      jobs = { "worker_name1" => job, "prefetch:work_queue:X" => [job2, job3] }
-      allow(subject).to receive(:prefetch_owner).and_return("prefetch:work_queue:X")
-      allow(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
-    end
-
-    it "doesn't unlock anything if nothing is timed out" do
-      expect(Delayed::Job).not_to receive(:advisory_lock)
-      expect(Delayed::Job).not_to receive(:unlock)
-      subject.unlock_timed_out_prefetched_jobs
-    end
-
-    it "unlocks timed out prefetched jobs" do
-      allow(Delayed::Settings).to receive(:parent_process).and_return(prefetched_jobs_timeout: -1)
-      expect(Delayed::Job).to receive(:unlock).with([job2, job3])
-      subject.unlock_timed_out_prefetched_jobs
-      expect(subject.instance_variable_get(:@prefetched_jobs).values.sum(&:length)).to eq 0
-    end
-
-    it "fails gracefully if the lock times out" do
-      allow(Delayed::Settings).to receive(:parent_process).and_return(prefetched_jobs_timeout: -1)
-      expect(Delayed::Job).not_to receive(:unlock)
-      expect(Delayed::Job).to receive(:advisory_lock).and_raise(ActiveRecord::QueryCanceled)
-      subject.unlock_timed_out_prefetched_jobs
-      expect(subject.instance_variable_get(:@prefetched_jobs).values.sum(&:length)).to eq 2
-    end
-
-    it "unlocks all jobs" do
-      expect(Delayed::Job).to receive(:unlock).with([job2, job3])
-      subject.unlock_all_prefetched_jobs
-      expect(subject.instance_variable_get(:@prefetched_jobs).values.sum(&:length)).to eq 0
-    end
-  end
-
-  it "doesn't respond immediately if there are no jobs available" 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({}).ordered
-    Marshal.dump(args, client)
-    subject.run_once
-    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
-    allow(Delayed::Settings).to receive(:sleep_delay).and_return(0)
-    allow(Delayed::Settings).to receive(:sleep_delay_stagger).and_return(0)
-    subject.run_once
-    expect(client).to be_ready
-    expect(Marshal.load(client)).to eq(job)
-  end
-
-  it "drops the client on i/o error" do
-    client = Socket.unix(subject.listen_socket.local_address.unix_path)
-    subject.run_once
-
-    Marshal.dump(args, client)
-
-    expect(Marshal).to receive(:load).and_raise(IOError.new("socket went away"))
-    expect { subject.run_once }.to change(subject, :connected_clients).by(-1)
-  end
-
-  it "drops the client when the client disconnects" do
-    client = Socket.unix(subject.listen_socket.local_address.unix_path)
-    subject.run_once
-
-    Marshal.dump(args, client)
-    # make sure the server knows the client is waiting for a job
-    subject.run_once
-
-    client.close
-    expect { subject.run_once }.to change(subject, :connected_clients).by(-1)
-    expect(subject.instance_variable_get(:@waiting_clients).first.last).to eq []
-  end
-
-  it "drops the client when a write fails" do
-    client = Socket.unix(subject.listen_socket.local_address.unix_path)
-    subject.run_once
-
-    Marshal.dump(args, client)
-    subject.run_once
-
-    client.close
-
-    server_client_socket = subject.clients.keys.first
-    # 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)
-    # the job gets unlocked
-    expect(Delayed::Job).to receive(:unlock).with([job])
-    subject.run_once
-
-    # and the server removes the client from both of its internal state arrays
-    expect(subject.connected_clients).to eq 0
-    expect(subject.instance_variable_get(:@waiting_clients).first.last).to eq []
-  end
-
-  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)
-    Marshal.dump(args, client)
-    subject.run_once
-    expect(subject.all_workers_idle?).to be(false)
-
-    expect(Delayed::Job).to receive(:get_and_lock_next_available).with(*job_args).and_return({})
-    Marshal.dump(args, client)
-    subject.run_once
-    expect(subject.all_workers_idle?).to be(true)
-  end
-
-  it "triggers the lifecycle event around the pop" do
-    called = false
-    client = Socket.unix(subject.listen_socket.local_address.unix_path)
-    subject.run_once
-
-    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)
-      called = true
-      res = cb.call(queue)
-      expect(subject.all_workers_idle?).to be(false)
-      res
-    end
-
-    Marshal.dump(args, client)
-    subject.run_once
-
-    expect(Marshal.load(client)).to eq(job)
-    expect(called).to eq(true)
-  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