inst-jobs 2.4.10 → 3.1.7

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,233 +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
-
-  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

data/spec/delayed/work_queue/parent_process_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "fileutils"
-
-RSpec.describe Delayed::WorkQueue::ParentProcess do
-  before :all do
-    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"
-    }
-  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
-
-  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")
-    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"
-    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"
-    end
-  end
-
-  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
-    server = subject.server
-    client = subject.client
-    expect(client).to be_a(Delayed::WorkQueue::ParentProcess::Client)
-    expect(client.addrinfo.unix?).to be(true)
-    expect(client.addrinfo.unix_path).to eq(server.listen_socket.local_address.unix_path)
-  end
-end

data/spec/delayed/worker/consul_health_check_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Delayed::Worker::ConsulHealthCheck do
-  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 = 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 = 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"
-    end
-  end
-
-  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" }))
-
-      health_check.start
-
-      expect(stub).to have_been_requested
-    end
-
-    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 }) }))
-
-      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
-      stub = stub_request(:put, "localhost:8500/v1/agent/service/register")
-             .with(body: hash_including({ check:  WebMock::API.hash_including({ docker_container_id: anything }) }))
-
-      local_health_check = described_class.new(
-        worker_name: "foobar",
-        config: { docker: true }
-      )
-      local_health_check.start
-
-      expect(stub).to have_been_requested
-    end
-  end
-
-  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
-      expect(stub).to have_been_requested
-    end
-  end
-end

data/spec/delayed/worker/health_check_spec.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Delayed::Worker::HealthCheck do
-  let(:klass) { Class.new(Delayed::Worker::HealthCheck) { self.type_name = :test } }
-
-  before do
-    klass # Gotta make sure the class has been defined before we try to use it
-  end
-
-  after do
-    described_class.subclasses.delete(klass)
-  end
-
-  it "must maintain a list of its subclasses" do
-    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 = 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 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 = 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) 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
-    end
-
-    let(:initial_run_at) { 10.minutes.ago }
-
-    before do
-      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
-                         })
-      @dead_job = Delayed::Job.last
-      @dead_job.update!({
-                          locked_by: "dead",
-                          locked_at: initial_run_at
-                        })
-      Delayed::Settings.worker_health_check_type = :fake
-      Delayed::Settings.worker_health_check_config = {}
-    end
-
-    after do
-      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
-      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"
-    end
-
-    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")
-      # we need to return @dead_job itself, which doesn't match the database
-      jobs_scope = double
-      allow(jobs_scope).to receive(:where).and_return(jobs_scope)
-      allow(jobs_scope).to receive(:not).and_return(jobs_scope)
-      allow(jobs_scope).to receive(:limit).and_return(jobs_scope)
-      allow(jobs_scope).to receive(:to_a).and_return([@dead_job], [])
-      allow(Delayed::Job).to receive(:running_jobs).and_return(jobs_scope)
-      described_class.reschedule_abandoned_jobs
-      @dead_job.reload
-      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")
-      allow(Delayed::Job).to receive(:running_jobs).and_return(Delayed::Job.where(id: @dead_job.id))
-      described_class.reschedule_abandoned_jobs
-      @dead_job.reload
-      expect(@dead_job.locked_by).to eq "prefetch:some_node"
-    end
-
-    it "bails immediately if advisory lock already taken" do
-      allow(Delayed::Job).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).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
-      expect { klass.new }.to raise_error ArgumentError
-    end
-  end
-end

data/spec/delayed/worker_spec.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../spec_helper"
-
-describe Delayed::Worker do
-  subject { described_class.new(worker_config.dup) }
-
-  let(:worker_config) do
-    {
-      queue: "test", min_priority: 1, max_priority: 2, stuff: "stuff"
-    }.freeze
-  end
-  let(:job_attrs) do
-    {
-      id: 42, name: "testjob", full_name: "testfullname", :last_error= => nil,
-      attempts: 1, reschedule: nil, :expired? => false,
-      payload_object: {}, priority: 25
-    }.freeze
-  end
-
-  after { described_class.lifecycle.reset! }
-
-  describe "#perform" do
-    it "fires off an error callback when a job raises an exception" do
-      fired = false
-      described_class.lifecycle.before(:error) { |_worker, _exception| fired = true }
-      job = double(job_attrs)
-      output_count = subject.perform(job)
-      expect(fired).to be_truthy
-      expect(output_count).to eq(1)
-    end
-
-    it "uses the retry callback for a retriable exception" do
-      error_fired = retry_fired = false
-      described_class.lifecycle.before(:error) { |_worker, _exception| error_fired = true }
-      described_class.lifecycle.before(:retry) { |_worker, _exception| retry_fired = true }
-      job = Delayed::Job.new(payload_object: {}, priority: 25, strand: "test_jobs", max_attempts: 3)
-      expect(job).to receive(:invoke_job) do
-        raise Delayed::RetriableError, "that's all this job does"
-      end
-      output_count = subject.perform(job)
-      expect(error_fired).to be_falsey
-      expect(retry_fired).to be_truthy
-      expect(output_count).to eq(1)
-    end
-
-    it "reloads" do
-      fake_application = double("Rails.application",
-                                config: double("Rails.application.config",
-                                               cache_classes: false,
-                                               reload_classes_only_on_change: false),
-                                reloader: double)
-
-      allow(Rails).to receive(:application).and_return(fake_application)
-      if Rails::VERSION::MAJOR >= 5
-        expect(Rails.application.reloader).to receive(:reload!).once
-      else
-        expect(ActionDispatch::Reloader).to receive(:prepare!).once
-        expect(ActionDispatch::Reloader).to receive(:cleanup!).once
-      end
-      job = double(job_attrs)
-      subject.perform(job)
-    end
-  end
-
-  describe "#log_job" do
-    around do |block|
-      prev_logger = Delayed::Settings.job_detailed_log_format
-      block.call
-      Delayed::Settings.job_detailed_log_format = prev_logger
-    end
-
-    it "has a reasonable default format" do
-      payload = double(perform: nil)
-      job = Delayed::Job.new(payload_object: payload, priority: 25, strand: "test_jobs")
-      short_log_format = subject.log_job(job, :short)
-      expect(short_log_format).to eq("RSpec::Mocks::Double")
-      long_format = subject.log_job(job, :long)
-      expect(long_format).to eq("RSpec::Mocks::Double {\"priority\":25,\"attempts\":0,\"created_at\":null,\"tag\":\"RSpec::Mocks::Double#perform\",\"max_attempts\":null,\"strand\":\"test_jobs\",\"source\":null}") # rubocop:disable Layout/LineLength
-    end
-
-    it "logging format can be changed with settings" do
-      Delayed::Settings.job_detailed_log_format = ->(job) { "override format #{job.strand}" }
-      payload = double(perform: nil)
-      job = Delayed::Job.new(payload_object: payload, priority: 25, strand: "test_jobs")
-      short_log_format = subject.log_job(job, :short)
-      expect(short_log_format).to eq("RSpec::Mocks::Double")
-      long_format = subject.log_job(job, :long)
-      expect(long_format).to eq("RSpec::Mocks::Double override format test_jobs")
-    end
-  end
-
-  describe "#run" do
-    it "passes extra config options through to the WorkQueue" do
-      expect(subject.work_queue).to receive(:get_and_lock_next_available)
-        .with(subject.name, worker_config).and_return(nil)
-      subject.run
-    end
-  end
-end

data/spec/migrate/20140924140513_add_story_table.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class AddStoryTable < ActiveRecord::Migration[4.2]
-  def change
-    create_table :stories do |table|
-      table.string :text
-    end
-  end
-end