inst-jobs 2.2.1 → 2.4.0

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

@@ -1,20 +1,20 @@
 # 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
   let(:parent) { Delayed::WorkQueue::ParentProcess.new }
   let(:subject) { described_class.new(listen_socket) }
   let(:listen_socket) { Socket.unix_server_socket(parent.server_address) }
@@ -26,7 +26,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
   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 +34,27 @@ 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")
   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 +62,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 +73,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 +108,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 +119,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 +129,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 +142,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 +155,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 +165,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 +183,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 +191,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)
@@ -201,4 +205,3 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     expect(called).to eq(true)
   end
 end
-

data/spec/delayed/work_queue/parent_process_spec.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'fileutils'
+require "spec_helper"
+require "fileutils"
 
 RSpec.describe Delayed::WorkQueue::ParentProcess do
   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)
     Delayed::Settings.parent_process = {
-      'server_address' => '/tmp/inst-jobs-test.sock'
+      "server_address" => "/tmp/inst-jobs-test.sock"
     }
   end
 
@@ -16,43 +16,43 @@ RSpec.describe Delayed::WorkQueue::ParentProcess 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
 
   let(:subject) { described_class.new }
 
-  describe '#initalize(config = Settings.parent_process)' do
-    it 'must expand a relative path to be within the Rails root' do
-      queue = described_class.new('server_address' => 'tmp/foo.sock')
-      expect(queue.server_address).to eq Delayed::Settings.expand_rails_path('tmp/foo.sock')
+  describe "#initalize(config = Settings.parent_process)" do
+    it "must expand a relative path to be within the Rails root" do
+      queue = described_class.new("server_address" => "tmp/foo.sock")
+      expect(queue.server_address).to eq Delayed::Settings.expand_rails_path("tmp/foo.sock")
     end
 
-    it 'must add a file name when a relative path to a directory is supplied' do
-      queue = described_class.new('server_address' => 'tmp')
-      expect(queue.server_address).to eq Delayed::Settings.expand_rails_path('tmp/inst-jobs.sock')
+    it "must add a file name when a relative path to a directory is supplied" do
+      queue = described_class.new("server_address" => "tmp")
+      expect(queue.server_address).to eq Delayed::Settings.expand_rails_path("tmp/inst-jobs.sock")
     end
 
-    it 'must capture a full absolute path' do
-      queue = described_class.new('server_address' => '/tmp/foo.sock')
-      expect(queue.server_address).to eq '/tmp/foo.sock'
+    it "must capture a full absolute path" do
+      queue = described_class.new("server_address" => "/tmp/foo.sock")
+      expect(queue.server_address).to eq "/tmp/foo.sock"
     end
 
-    it 'must add a file name when an absolute path to a directory is supplied' do
-      queue = described_class.new('server_address' => '/tmp')
-      expect(queue.server_address).to eq '/tmp/inst-jobs.sock'
+    it "must add a file name when an absolute path to a directory is supplied" do
+      queue = described_class.new("server_address" => "/tmp")
+      expect(queue.server_address).to eq "/tmp/inst-jobs.sock"
     end
   end
 
-  it 'generates a server listening on a valid unix socket' do
+  it "generates a server listening on a valid unix socket" do
     server = subject.server
     expect(server).to be_a(Delayed::WorkQueue::ParentProcess::Server)
     expect(server.listen_socket.local_address.unix?).to be(true)
     expect { server.listen_socket.accept_nonblock }.to raise_error(IO::WaitReadable)
   end
 
-  it 'generates a client connected to the server unix socket' do
+  it "generates a client connected to the server unix socket" do
     server = subject.server
     client = subject.client
     expect(client).to be_a(Delayed::WorkQueue::ParentProcess::Client)

data/spec/delayed/worker/consul_health_check_spec.rb

@@ -1,50 +1,50 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Delayed::Worker::ConsulHealthCheck do
-  let(:health_check) { Delayed::Worker::ConsulHealthCheck.new(worker_name: 'foobar') }
+  let(:health_check) { described_class.new(worker_name: "foobar") }
 
-  describe '#initialize' do
-    it 'must use a default service client when the config is mostly empty' do
-      check = Delayed::Worker::ConsulHealthCheck.new(worker_name: 'foobar')
-      expect(check.service_client.configuration.url.to_s).to eq 'http://localhost:8500'
+  describe "#initialize" do
+    it "must use a default service client when the config is mostly empty" do
+      check = described_class.new(worker_name: "foobar")
+      expect(check.service_client.configuration.url.to_s).to eq "http://localhost:8500"
     end
 
-    it 'must create a new service API client when the config has relevant keys set' do
-      check = Delayed::Worker::ConsulHealthCheck.new(worker_name: 'foobar', config: {url: 'http://consul.example.com:8500'})
+    it "must create a new service API client when the config has relevant keys set" do
+      check = described_class.new(worker_name: "foobar",
+                                  config: { url: "http://consul.example.com:8500" })
       service_client = check.service_client
-      expect(service_client.configuration.url.to_s).to eq 'http://consul.example.com:8500'
+      expect(service_client.configuration.url.to_s).to eq "http://consul.example.com:8500"
     end
   end
 
-  describe '#start' do
-    it 'must register this process as a service with consul' do
+  describe "#start" do
+    it "must register this process as a service with consul" do
       stub = stub_request(:put, "localhost:8500/v1/agent/service/register")
-        .with(body: hash_including({id: 'foobar' }))
+             .with(body: hash_including({ id: "foobar" }))
 
       health_check.start
 
       expect(stub).to have_been_requested
     end
 
-
-    it 'must supply a args style check' do
+    it "must supply a args style check" do
       stub = stub_request(:put, "localhost:8500/v1/agent/service/register")
-        .with(body: hash_including({check:  WebMock::API.hash_including({args: anything})}))
+             .with(body: hash_including({ check:  WebMock::API.hash_including({ args: anything }) }))
 
       health_check.start
 
       expect(stub).to have_been_requested
     end
 
-    it 'must include the docker container id when the docker option is set to true' do
+    it "must include the docker container id when the docker option is set to true" do
       stub = stub_request(:put, "localhost:8500/v1/agent/service/register")
-        .with(body: hash_including({check:  WebMock::API.hash_including({docker_container_id: anything})}))
+             .with(body: hash_including({ check:  WebMock::API.hash_including({ docker_container_id: anything }) }))
 
-      local_health_check = Delayed::Worker::ConsulHealthCheck.new(
-        worker_name: 'foobar',
-        config: {docker: true}
+      local_health_check = described_class.new(
+        worker_name: "foobar",
+        config: { docker: true }
       )
       local_health_check.start
 
@@ -52,8 +52,8 @@ RSpec.describe Delayed::Worker::ConsulHealthCheck do
     end
   end
 
-  describe '#stop' do
-    it 'must deregister the service from consul' do
+  describe "#stop" do
+    it "must deregister the service from consul" do
       stub = stub_request(:put, "localhost:8500/v1/agent/service/deregister/foobar")
 
       health_check.stop

data/spec/delayed/worker/health_check_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Delayed::Worker::HealthCheck do
   let(:klass) { Class.new(Delayed::Worker::HealthCheck) { self.type_name = :test } }
@@ -10,116 +10,118 @@ RSpec.describe Delayed::Worker::HealthCheck do
   end
 
   after do
-    Delayed::Worker::HealthCheck.subclasses.delete(klass)
+    described_class.subclasses.delete(klass)
   end
 
   it "must maintain a list of its subclasses" do
     klass
-    expect(Delayed::Worker::HealthCheck.subclasses).to include klass
+    expect(described_class.subclasses).to include klass
   end
 
-  describe '.build(type:, config: {})' do
-    it 'must select the concrete class to use by the type_name in the subclass' do
-      check = Delayed::Worker::HealthCheck.build(type: 'test', worker_name: 'foobar')
+  describe ".build(type:, config: {})" do
+    it "must select the concrete class to use by the type_name in the subclass" do
+      check = described_class.build(type: "test", worker_name: "foobar")
       expect(check).to be_a(klass)
     end
 
     it "must raise ArgumentError when the specified type doesn't exist" do
-      expect {
-        Delayed::Worker::HealthCheck.build(type: 'nope', config: {worker_name: 'foobar'})
-      }.to raise_error ArgumentError
+      expect do
+        described_class.build(type: "nope", config: { worker_name: "foobar" })
+      end.to raise_error ArgumentError
     end
 
-    it 'must initiaize the specified class using the supplied config' do
-      config = {foo: 'bar'}.with_indifferent_access
-      check = Delayed::Worker::HealthCheck.build(type: 'test', worker_name: 'foobar', config: config)
+    it "must initiaize the specified class using the supplied config" do
+      config = { foo: "bar" }.with_indifferent_access
+      check = described_class.build(type: "test", worker_name: "foobar", config: config)
       expect(check.config).to eq config
     end
   end
 
-  describe '.reschedule_abandoned_jobs' do
-    let(:klass) { Class.new(Delayed::Worker::HealthCheck) {
-      self.type_name = :fake
-      class << self
-        attr_accessor :live_workers
+  describe ".reschedule_abandoned_jobs" do
+    let(:klass) do
+      Class.new(Delayed::Worker::HealthCheck) do
+        self.type_name = :fake
+        class << self
+          attr_accessor :live_workers
+        end
+
+        def live_workers
+          self.class.live_workers
+        end
       end
-
-      def live_workers
-        self.class.live_workers
-      end
-    } }
+    end
 
     let(:initial_run_at) { Time.zone.now }
 
     before do
-      klass.live_workers = %w{alive}
+      klass.live_workers = %w[alive]
       Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
 
       2.times { Delayed::Job.enqueue(SimpleJob.new, run_at: initial_run_at, max_attempts: 4) }
       @alive_job = Delayed::Job.first
       @alive_job.update!({
-        locked_by: 'alive',
-        locked_at: initial_run_at
-      })
+                           locked_by: "alive",
+                           locked_at: initial_run_at
+                         })
       @dead_job = Delayed::Job.last
       @dead_job.update!({
-        locked_by: 'dead',
-        locked_at: initial_run_at
-      })
+                          locked_by: "dead",
+                          locked_at: initial_run_at
+                        })
       Delayed::Settings.worker_health_check_type = :fake
       Delayed::Settings.worker_health_check_config = {}
     end
 
     after do
-      Delayed::Worker::HealthCheck.subclasses.delete(klass)
+      described_class.subclasses.delete(klass)
       Delayed::Settings.worker_health_check_type = :none
       Delayed::Settings.worker_health_check_config = {}
     end
 
-    it 'must leave jobs locked by live workers alone' do
-      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+    it "must leave jobs locked by live workers alone" do
+      described_class.reschedule_abandoned_jobs
       @alive_job.reload
       expect(@alive_job.run_at.to_i).to eq initial_run_at.to_i
       expect(@alive_job.locked_at.to_i).to eq initial_run_at.to_i
-      expect(@alive_job.locked_by).to eq 'alive'
+      expect(@alive_job.locked_by).to eq "alive"
     end
 
-    it 'must reschedule jobs locked by dead workers' do
-      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+    it "must reschedule jobs locked by dead workers" do
+      described_class.reschedule_abandoned_jobs
       @dead_job.reload
       expect(@dead_job.run_at).to be > initial_run_at
       expect(@dead_job.locked_at).to be_nil
       expect(@dead_job.locked_by).to be_nil
     end
 
-    it 'ignores jobs that are re-locked after fetching from db' do
-      Delayed::Job.where(id: @dead_job).update_all(locked_by: 'someone_else')
+    it "ignores jobs that are re-locked after fetching from db" do
+      Delayed::Job.where(id: @dead_job).update_all(locked_by: "someone_else")
       allow(Delayed::Job).to receive(:running_jobs).and_return([@dead_job])
-      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+      described_class.reschedule_abandoned_jobs
       @dead_job.reload
-      expect(@dead_job.locked_by).to eq 'someone_else'
+      expect(@dead_job.locked_by).to eq "someone_else"
     end
 
-    it 'ignores jobs that are prefetched' do
-      Delayed::Job.where(id: @dead_job).update_all(locked_by: 'prefetch:some_node')
+    it "ignores jobs that are prefetched" do
+      Delayed::Job.where(id: @dead_job).update_all(locked_by: "prefetch:some_node")
       allow(Delayed::Job).to receive(:running_jobs).and_return([@dead_job])
-      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+      described_class.reschedule_abandoned_jobs
       @dead_job.reload
-      expect(@dead_job.locked_by).to eq 'prefetch:some_node'
+      expect(@dead_job.locked_by).to eq "prefetch:some_node"
     end
 
     it "bails immediately if advisory lock already taken" do
-      allow(Delayed::Worker::HealthCheck).to receive(:attempt_advisory_lock).and_return(false)
-      Delayed::Worker::HealthCheck.reschedule_abandoned_jobs
+      allow(described_class).to receive(:attempt_advisory_lock).and_return(false)
+      described_class.reschedule_abandoned_jobs
       @dead_job.reload
       expect(@dead_job.run_at.to_i).to eq(initial_run_at.to_i)
-      expect(@dead_job.locked_at).to_not be_nil
-      expect(@dead_job.locked_by).to_not be_nil
+      expect(@dead_job.locked_at).not_to be_nil
+      expect(@dead_job.locked_by).not_to be_nil
     end
   end
 
-  describe '#initialize' do
-    it 'must raise ArgumentError when the worker name is not supplied' do
+  describe "#initialize" do
+    it "must raise ArgumentError when the worker name is not supplied" do
       expect { klass.new }.to raise_error ArgumentError
     end
   end