inst-jobs 3.1.2 → 3.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95bdbd537405c6325f378bed05570a3149053ba8a2e290893010c590df72ea9a
-  data.tar.gz: 6f0d577f1fba37bb01e3e0a4ec05b600e65ebb77d001e29e38b479f6facde73b
+  metadata.gz: dfa0a9108f1f1440f7e5a1e85751f9b359c87a07c96ef915e957fd7273f03e70
+  data.tar.gz: '081a50c77e4cab9add18ab344778d9eed42ca67d9c20a8e8c2fff9a47c0984f9'
 SHA512:
-  metadata.gz: 38392cab25180d44f40960ffb15b2dd3241bd739980b9d0962b93020a809497bb1a9022caf7a05f4ba40f4cc3792281f03468946c33a1fc62891dec3b411f7cf
-  data.tar.gz: cbea2ab6e762a876994179ac1c9ffd414ea2ec13905931b2cddb087d816664e8b682ecf8f9406726d8f80a0867b8e44bc1331b6e0e73de3415b4ab31090d1ee9
+  metadata.gz: 82752f8b1dcade468721c7a5e22680d875a799476380b0351b8eda4346aa914032efbd89c401d99d2de23b84c09c559d3a825c44e682b83ec3c6f3ce658e7d6e
+  data.tar.gz: 5db1c149af1f02f111998096dfe6207f622aa13481b8b6c8170153968c2e90c1319783932ea8bea0e31feb8589589f4c15c0dafda3205bfec61e26cf16c5caa4

data/lib/delayed/lifecycle.rb

@@ -77,7 +77,13 @@ module Delayed
     def execute(*args, &block)
       @before.each { |c| c.call(*args) }
       result = @around.call(*args, &block)
-      @after.each { |c| c.call(*args, result: result) }
+      @after.each do |c|
+        if c.arity == args.length + 1 # don't fail for methods that don't define `result:`
+          c.call(*args, result: result)
+        else
+          c.call(*args)
+        end
+      end
       result
     end
 

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = "3.1.2"
+  VERSION = "3.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.1.3
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-05-25 00:00:00.000000000 Z
+date: 2022-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -500,30 +500,6 @@ files:
 - lib/delayed/yaml_extensions.rb
 - lib/delayed_job.rb
 - lib/inst-jobs.rb
-- spec/active_record_job_spec.rb
-- spec/delayed/cli_spec.rb
-- spec/delayed/daemon_spec.rb
-- spec/delayed/message_sending_spec.rb
-- spec/delayed/periodic_spec.rb
-- spec/delayed/server_spec.rb
-- spec/delayed/settings_spec.rb
-- spec/delayed/work_queue/in_process_spec.rb
-- spec/delayed/work_queue/parent_process/client_spec.rb
-- spec/delayed/work_queue/parent_process/server_spec.rb
-- spec/delayed/work_queue/parent_process_spec.rb
-- spec/delayed/worker/consul_health_check_spec.rb
-- spec/delayed/worker/health_check_spec.rb
-- spec/delayed/worker_spec.rb
-- spec/migrate/20140924140513_add_story_table.rb
-- spec/sample_jobs.rb
-- spec/shared/delayed_batch.rb
-- spec/shared/delayed_method.rb
-- spec/shared/performable_method.rb
-- spec/shared/shared_backend.rb
-- spec/shared/testing.rb
-- spec/shared/worker.rb
-- spec/shared_jobs_specs.rb
-- spec/spec_helper.rb
 homepage: https://github.com/instructure/inst-jobs
 licenses: []
 metadata:
@@ -547,28 +523,4 @@ rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Instructure-maintained fork of delayed_job
-test_files:
-- spec/active_record_job_spec.rb
-- spec/delayed/cli_spec.rb
-- spec/delayed/daemon_spec.rb
-- spec/delayed/message_sending_spec.rb
-- spec/delayed/periodic_spec.rb
-- spec/delayed/server_spec.rb
-- spec/delayed/settings_spec.rb
-- spec/delayed/work_queue/in_process_spec.rb
-- spec/delayed/work_queue/parent_process/client_spec.rb
-- spec/delayed/work_queue/parent_process/server_spec.rb
-- spec/delayed/work_queue/parent_process_spec.rb
-- spec/delayed/worker/consul_health_check_spec.rb
-- spec/delayed/worker/health_check_spec.rb
-- spec/delayed/worker_spec.rb
-- spec/migrate/20140924140513_add_story_table.rb
-- spec/sample_jobs.rb
-- spec/shared/delayed_batch.rb
-- spec/shared/delayed_method.rb
-- spec/shared/performable_method.rb
-- spec/shared/shared_backend.rb
-- spec/shared/testing.rb
-- spec/shared/worker.rb
-- spec/shared_jobs_specs.rb
-- spec/spec_helper.rb
+test_files: []

data/spec/active_record_job_spec.rb

@@ -1,326 +0,0 @@
-# frozen_string_literal: true
-
-describe "Delayed::Backed::ActiveRecord::Job" do
-  before :all do
-    Delayed.select_backend(Delayed::Backend::ActiveRecord::Job)
-  end
-
-  before do
-    Delayed::Testing.clear_all!
-  end
-
-  include_examples "a delayed_jobs implementation"
-
-  it "recovers as well as possible from a failure failing a job" do
-    allow(Delayed::Job::Failed).to receive(:create).and_raise(RuntimeError)
-    job = "test".delay(ignore_transaction: true).reverse
-    job_id = job.id
-    expect { job.fail! }.to raise_error(RuntimeError)
-    expect { Delayed::Job.find(job_id) }.to raise_error(ActiveRecord::RecordNotFound)
-    expect(Delayed::Job.count).to eq(0)
-  end
-
-  context "when another worker has worked on a task since the job was found to be available, it" do
-    before do
-      @job = Delayed::Job.create payload_object: SimpleJob.new
-      @job_copy_for_worker2 = Delayed::Job.find(@job.id)
-    end
-
-    it "does not allow a second worker to get exclusive access if already successfully processed by worker1" do
-      @job.destroy
-      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to be(false)
-    end
-
-    it "doesn't allow a second worker to get exclusive access if failed to be " \
-       "processed by worker1 and run_at time is now in future (due to backing off behaviour)" do
-      @job.update(attempts: 1, run_at: 1.day.from_now)
-      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to be(false)
-    end
-
-    it "selects the next job at random if enabled" do
-      Delayed::Settings.select_random_from_batch = true
-      15.times { "test".delay.length }
-      founds = []
-      15.times do
-        job = Delayed::Job.get_and_lock_next_available("tester")
-        founds << job
-        job.unlock
-        job.save!
-      end
-      expect(founds.uniq.size).to be > 1
-    ensure
-      Delayed::Settings.select_random_from_batch = false
-    end
-  end
-
-  it "unlocks a successfully locked job and persist the job's unlocked state" do
-    job = Delayed::Job.create payload_object: SimpleJob.new
-    expect(job.send(:lock_exclusively!, "worker1")).to be(true)
-    job.reload
-    job.unlock
-    job.save!
-    job.reload
-    expect(job.locked_by).to be_nil
-    expect(job.locked_at).to be_nil
-  end
-
-  describe "bulk_update failed jobs" do
-    context "holding/unholding failed jobs" do
-      before do
-        @job = Delayed::Job.create payload_object: SimpleJob.new
-        expect(Delayed::Job.get_and_lock_next_available("worker1")).to eq(@job)
-        @job.fail!
-      end
-
-      it "raises error when holding failed jobs" do
-        expect { Delayed::Job.bulk_update("hold", flavor: "failed", query: @query) }.to raise_error(RuntimeError)
-      end
-
-      it "raises error unholding failed jobs" do
-        expect { Delayed::Job.bulk_update("unhold", flavor: "failed", query: @query) }.to raise_error(RuntimeError)
-      end
-    end
-
-    context "deleting failed jobs" do
-      before do
-        2.times do
-          j = Delayed::Job.create(payload_object: SimpleJob.new)
-          expect(j.send(:lock_exclusively!, "worker1")).to be(true)
-          j.fail!
-        end
-      end
-
-      it "deletes failed jobs by id" do
-        target_ids = Delayed::Job::Failed.all[0..2].map(&:id)
-        expect(Delayed::Job.bulk_update("destroy", ids: target_ids, flavor: "failed",
-                                                   query: @query)).to eq(target_ids.length)
-      end
-
-      it "deletes all failed jobs" do
-        failed_count = Delayed::Job::Failed.count
-        expect(Delayed::Job.bulk_update("destroy", flavor: "failed", query: @query)).to eq(failed_count)
-      end
-
-      it "deletes all failed jobs before a given date" do
-        Delayed::Job::Failed.first.update!(failed_at: 3.hours.ago)
-        Delayed::Job::Failed.last.update!(failed_at: 1.hour.ago)
-
-        expect(Delayed::Job::Failed.count).to eq 2
-        Delayed::Job::Failed.cleanup_old_jobs(2.hours.ago)
-        expect(Delayed::Job::Failed.count).to eq 1
-      end
-    end
-  end
-
-  context "n_strand" do
-    it "defaults to 1" do
-      expect(Delayed::Job).not_to receive(:rand)
-      job = Delayed::Job.enqueue(SimpleJob.new, n_strand: "njobs")
-      expect(job.strand).to eq("njobs")
-    end
-
-    it "sets max_concurrent based on num_strands" do
-      change_setting(Delayed::Settings, :num_strands, lambda { |strand_name|
-                                                        expect(strand_name).to eql "njobs"
-                                                        "3"
-                                                      }) do
-        job = Delayed::Job.enqueue(SimpleJob.new, n_strand: "njobs")
-        expect(job.strand).to eq("njobs")
-        expect(job.max_concurrent).to eq(3)
-      end
-    end
-
-    context "with two parameters" do
-      it "uses the first param as the setting to read" do
-        job = Delayed::Job.enqueue(SimpleJob.new, n_strand: %w[njobs 123])
-        expect(job.strand).to eq("njobs/123")
-        change_setting(Delayed::Settings, :num_strands, lambda { |strand_name|
-          case strand_name
-          when "njobs" then 3
-          end
-        }) do
-          job = Delayed::Job.enqueue(SimpleJob.new, n_strand: %w[njobs 123])
-          expect(job.strand).to eq("njobs/123")
-          expect(job.max_concurrent).to eq(3)
-        end
-      end
-
-      it "allows overridding the setting based on the second param" do
-        change_setting(Delayed::Settings, :num_strands, lambda { |strand_name|
-          case strand_name
-          when "njobs/123" then 5
-          end
-        }) do
-          job = Delayed::Job.enqueue(SimpleJob.new, n_strand: %w[njobs 123])
-          expect(job.strand).to eq("njobs/123")
-          expect(job.max_concurrent).to eq(5)
-          job = Delayed::Job.enqueue(SimpleJob.new, n_strand: %w[njobs 456])
-          expect(job.strand).to eq("njobs/456")
-          expect(job.max_concurrent).to eq(1)
-        end
-
-        change_setting(Delayed::Settings, :num_strands, lambda { |strand_name|
-          case strand_name
-          when "njobs/123" then 5
-          when "njobs" then 3
-          end
-        }) do
-          job = Delayed::Job.enqueue(SimpleJob.new, n_strand: %w[njobs 123])
-          expect(job.strand).to eq("njobs/123")
-          expect(job.max_concurrent).to eq(5)
-          job = Delayed::Job.enqueue(SimpleJob.new, n_strand: %w[njobs 456])
-          expect(job.strand).to eq("njobs/456")
-          expect(job.max_concurrent).to eq(3)
-        end
-      end
-    end
-
-    context "max_concurrent triggers" do
-      it "sets one job as next_in_strand at a time with max_concurrent of 1" do
-        job1 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
-        job1.reload
-        expect(job1.next_in_strand).to be(true)
-        job2 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
-        job2.reload
-        expect(job2.next_in_strand).to be(false)
-        run_job(job1)
-        job2.reload
-        expect(job2.next_in_strand).to be(true)
-      end
-
-      it "sets multiple jobs as next_in_strand at a time based on max_concurrent" do
-        change_setting(Delayed::Settings, :num_strands, lambda { |strand_name|
-          case strand_name
-          when "njobs" then 2
-          end
-        }) do
-          job1 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
-          job1.reload
-          expect(job1.next_in_strand).to be(true)
-          job2 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
-          job2.reload
-          expect(job2.next_in_strand).to be(true)
-          job3 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
-          job3.reload
-          expect(job3.next_in_strand).to be(false)
-          run_job(job1)
-          job3.reload
-          expect(job3.next_in_strand).to be(true)
-        end
-      end
-    end
-  end
-
-  it "unlocks orphaned prefetched_jobs" do
-    job1 = Delayed::Job.new(tag: "tag")
-    job2 = Delayed::Job.new(tag: "tag")
-
-    job1.create_and_lock!("prefetch:a")
-    job1.locked_at = Delayed::Job.db_time_now - (15 * 60)
-    job1.save!
-    job2.create_and_lock!("prefetch:a")
-
-    expect(Delayed::Job.unlock_orphaned_prefetched_jobs).to eq 1
-    expect(Delayed::Job.unlock_orphaned_prefetched_jobs).to eq 0
-
-    expect(Delayed::Job.find(job1.id).locked_by).to be_nil
-    expect(Delayed::Job.find(job2.id).locked_by).to eq "prefetch:a"
-  end
-
-  it "gets process ids from locked_by" do
-    Array.new(3) { Delayed::Job.create payload_object: SimpleJob.new }
-    Delayed::Job.get_and_lock_next_available(["job42:2", "job42:9001"])
-    expect(Delayed::Job.processes_locked_locally(name: "job42").sort).to eq [2, 9001]
-    expect(Delayed::Job.processes_locked_locally(name: "jobnotme")).to be_empty
-  end
-
-  it "allows fetching multiple jobs at once" do
-    jobs = Array.new(3) { Delayed::Job.create payload_object: SimpleJob.new }
-    locked_jobs = Delayed::Job.get_and_lock_next_available(%w[worker1 worker2])
-    expect(locked_jobs.length).to eq(2)
-    expect(locked_jobs.keys).to eq(%w[worker1 worker2])
-    expect(locked_jobs.values).to eq(jobs[0..1])
-    expect(jobs.map(&:reload).map(&:locked_by)).to eq(["worker1", "worker2", nil])
-  end
-
-  it "allows fetching extra jobs" do
-    jobs = Array.new(5) { Delayed::Job.create payload_object: SimpleJob.new }
-    locked_jobs = Delayed::Job.get_and_lock_next_available(["worker1"],
-                                                           prefetch: 2,
-                                                           prefetch_owner: "work_queue")
-    expect(locked_jobs.length).to eq 2
-    expect(locked_jobs.keys).to eq %w[worker1 work_queue]
-    expect(locked_jobs["worker1"]).to eq jobs[0]
-    expect(locked_jobs["work_queue"]).to eq jobs[1..2]
-    expect(jobs.map(&:reload).map(&:locked_by)).to eq(["worker1", "work_queue", "work_queue", nil, nil])
-  end
-
-  it "does not find jobs scheduled for now when we have forced latency" do
-    job = create_job
-    expect(Delayed::Job.get_and_lock_next_available("worker", forced_latency: 60.0)).to be_nil
-    expect(Delayed::Job.get_and_lock_next_available("worker")).to eq job
-  end
-
-  context "non-transactional", non_transactional: true do
-    it "creates a stranded job in a single statement" do
-      allow(Delayed::Job.connection).to receive(:prepared_statements).and_return(false)
-      allow(Delayed::Job.connection).to receive(:execute).with(be_include("pg_advisory_xact_lock"),
-                                                               anything).and_call_original.once
-      expect(Delayed::Job.connection).not_to receive(:insert)
-      j = create_job(strand: "test1")
-      allow(Delayed::Job.connection).to receive(:execute).and_call_original
-      expect(Delayed::Job.find(j.id)).to eq j
-    end
-
-    it "creates a non-stranded job in a single statement" do
-      allow(Delayed::Job.connection).to receive(:prepared_statements).and_return(false)
-      call_count = 0
-      allow(Delayed::Job.connection).to receive(:execute).and_wrap_original do |m, (arg1, arg2)|
-        call_count += 1
-        m.call(arg1, arg2)
-      end
-      expect(Delayed::Job.connection).not_to receive(:insert)
-      j = create_job(strand: "test1")
-      expect(call_count).to eq 1
-      expect(Delayed::Job.find(j.id)).to eq j
-    end
-
-    it "does not lock a stranded failed job creation" do
-      j = create_job(strand: "test1")
-      # query for metadata to ensure it's loaded before we start mucking with the connection
-      Delayed::Backend::ActiveRecord::Job::Failed.new
-
-      allow(Delayed::Job.connection).to receive(:prepared_statements).and_return(false)
-      allow(Delayed::Job.connection).to receive(:execute).and_wrap_original do |original, *args|
-        expect(args.first).not_to include("pg_advisory_xact_lock")
-        original.call(*args)
-      end
-      expect(Delayed::Job.connection).not_to receive(:insert)
-      j.fail!
-      allow(Delayed::Job.connection).to receive(:execute).and_call_original
-    end
-  end
-
-  context "Failed#requeue!" do
-    it "requeues a failed job" do
-      j = create_job(attempts: 1, max_attempts: 1)
-      fj = j.fail!
-
-      lifecycle_args = nil
-      Delayed::Worker.lifecycle.after(:create) do |args|
-        lifecycle_args = args
-      end
-      j2 = fj.requeue!
-      expect(lifecycle_args["payload_object"].class).to eq SimpleJob
-      expect(fj.reload.requeued_job_id).to eq j2.id
-
-      orig_atts = j.attributes.except("id", "locked_at", "locked_by")
-      new_atts = j2.attributes.except("id", "locked_at", "locked_by")
-      expect(orig_atts).to eq(new_atts)
-
-      # ensure the requeued job actually runs even though `attempts` are maxed out
-      # (so it will not be retried after being manually requeued)
-      expect { run_job(j2) }.to change(SimpleJob, :runs).by(1)
-    end
-  end
-end

data/spec/delayed/cli_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Delayed::CLI do
-  describe "#parse_cli_options!" do
-    it "correctly parses the --config option" do
-      cli = described_class.new(%w[run --config /path/to/some/file.yml])
-      options = cli.parse_cli_options!
-      expect(options).to include config_file: "/path/to/some/file.yml"
-    end
-  end
-
-  describe "#run" do
-    before do
-      expect(Delayed::Settings).to receive(:worker_config).and_return({})
-    end
-
-    it "prints help when no command is given" do
-      cli = described_class.new([])
-      expect(cli).to receive(:puts).with(/Usage/)
-      cli.run
-    end
-  end
-end

data/spec/delayed/daemon_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Delayed::Daemon do
-  subject { described_class.new(pid_folder) }
-
-  let(:pid_folder) { "/test/pid/folder" }
-  let(:pid) { 9999 }
-
-  before do
-    allow(subject).to receive(:pid).and_return(pid)
-  end
-
-  describe "#stop" do
-    it "prints status if not running" do
-      expect(subject).to receive(:status).with(print: false, pid: pid).and_return(false)
-      expect(subject).to receive(:status).with(no_args)
-      expect(Process).not_to receive(:kill)
-      subject.stop
-    end
-
-    it "prints status if draining" do
-      expect(subject).to receive(:status).with(print: false, pid: pid).and_return(:draining)
-      expect(subject).to receive(:status).with(no_args)
-      expect(Process).not_to receive(:kill)
-      subject.stop
-    end
-
-    it "sends QUIT by default" do
-      expect(subject).to receive(:status).with(print: false, pid: pid).and_return(:running)
-      expect(subject).to receive(:puts).with(/Stopping pool/)
-      expect(Process).to receive(:kill).with("QUIT", pid)
-      expect(subject).to receive(:wait).with(false)
-      subject.stop
-    end
-  end
-end

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