inst-jobs 0.15.19 → 1.0.0

data/spec/shared/performable_method.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 shared_examples_for 'Delayed::PerformableMethod' do
 
   it "should not ignore ActiveRecord::RecordNotFound errors because they are not always permanent" do
     story = Story.create :text => 'Once upon...'
-    p = Delayed::PerformableMethod.new(story, :tell, [])
+    p = Delayed::PerformableMethod.new(story, :tell)
     story.destroy
     lambda { YAML.load(p.to_yaml) }.should raise_error(Delayed::Backend::RecordNotFound)
   end
 
   it "should store the object using native YAML even if its an active record" do
     story = Story.create :text => 'Once upon...'
-    p = Delayed::PerformableMethod.new(story, :tell, [])
+    p = Delayed::PerformableMethod.new(story, :tell)
     p.class.should   == Delayed::PerformableMethod
     p.object.should  == story
     p.method.should  == :tell
@@ -19,24 +21,24 @@ shared_examples_for 'Delayed::PerformableMethod' do
 
   it "should allow class methods to be called on ActiveRecord models" do
     Story.create!(:text => 'Once upon a...')
-    p = Delayed::PerformableMethod.new(Story, :count, [])
+    p = Delayed::PerformableMethod.new(Story, :count)
     lambda { expect(p.send(:perform)).to eql 1 }.should_not raise_error
   end
 
   it "should allow class methods to be called" do
-    p = Delayed::PerformableMethod.new(StoryReader, :reverse, ["ohai"])
+    p = Delayed::PerformableMethod.new(StoryReader, :reverse, args: ["ohai"])
     lambda { p.send(:perform).should == "iaho" }.should_not raise_error
   end
 
   it "should allow module methods to be called" do
-    p = Delayed::PerformableMethod.new(MyReverser, :reverse, ["ohai"])
+    p = Delayed::PerformableMethod.new(MyReverser, :reverse, args: ["ohai"])
     lambda { p.send(:perform).should == "iaho" }.should_not raise_error
   end
 
   it "should store arguments as native YAML if they are active record objects" do
     story = Story.create :text => 'Once upon...'
     reader = StoryReader.new
-    p = Delayed::PerformableMethod.new(reader, :read, [story])
+    p = Delayed::PerformableMethod.new(reader, :read, args: [story])
     p.class.should   == Delayed::PerformableMethod
     p.method.should  == :read
     p.args.should    == [story]
@@ -46,20 +48,20 @@ shared_examples_for 'Delayed::PerformableMethod' do
   it "should deeply de-AR-ize arguments in full name" do
     story = Story.create :text => 'Once upon...'
     reader = StoryReader.new
-    p = Delayed::PerformableMethod.new(reader, :read, [['arg1', story, { [:key, 1] => story }]])
+    p = Delayed::PerformableMethod.new(reader, :read, args: [['arg1', story, { [:key, 1] => story }]])
     p.full_name.should == "StoryReader#read([\"arg1\", Story.find(#{story.id}), {[:key, 1] => Story.find(#{story.id})}])"
   end
 
   it "should call the on_failure callback" do
     story = Story.create :text => 'wat'
-    p = Delayed::PerformableMethod.new(story, :tell, [], :text=)
+    p = Delayed::PerformableMethod.new(story, :tell, on_failure: :text=)
     p.send(:on_failure, 'fail')
     story.text.should == 'fail'
   end
 
   it "should call the on_permanent_failure callback" do
     story = Story.create :text => 'wat'
-    p = Delayed::PerformableMethod.new(story, :tell, [], nil, :text=)
+    p = Delayed::PerformableMethod.new(story, :tell, on_permanent_failure: :text=)
     p.send(:on_permanent_failure, 'fail_frd')
     story.text.should == 'fail_frd'
   end

data/spec/shared/shared_backend.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 shared_examples_for 'a backend' do
   def create_job(opts = {})
-    Delayed::Job.enqueue(SimpleJob.new, { :queue => nil }.merge(opts))
+    Delayed::Job.enqueue(SimpleJob.new, **{ :queue => nil }.merge(opts))
   end
 
   before do
@@ -139,12 +141,12 @@ shared_examples_for 'a backend' do
     end
 
     it "should be the method that will be called if its a performable method object" do
-      @job = Story.send_later_enqueue_args(:create, no_delay: true)
+      @job = Story.delay(ignore_transaction: true).create
       @job.name.should == "Story.create"
     end
 
     it "should be the instance method that will be called if its a performable method object" do
-      @job = Story.create(:text => "...").send_later_enqueue_args(:save, no_delay: true)
+      @job = Story.create(:text => "...").delay(ignore_transaction: true).save
       @job.name.should == 'Story#save'
     end
   end
@@ -371,8 +373,8 @@ shared_examples_for 'a backend' do
       end
 
       it "should update existing singleton job handler if requested" do
-        job1 = Delayed::Job.enqueue(SimpleJob.new, { :queue => nil, :singleton => 'myjobs', :on_conflict => :overwrite})
-        job2 = Delayed::Job.enqueue(ErrorJob.new, { :queue => nil, :singleton => 'myjobs', :on_conflict => :overwrite})
+        job1 = Delayed::Job.enqueue(SimpleJob.new, queue: nil, singleton: 'myjobs', on_conflict: :overwrite)
+        job2 = Delayed::Job.enqueue(ErrorJob.new, queue: nil, singleton: 'myjobs', on_conflict: :overwrite)
         job2.should == job1
         expect(job2.handler).to include("ErrorJob")
       end
@@ -498,7 +500,7 @@ shared_examples_for 'a backend' do
   end
 
   it "should set in_delayed_job?" do
-    job = InDelayedJobTest.send_later_enqueue_args(:check_in_job, no_delay: true)
+    job = InDelayedJobTest.delay(ignore_transaction: true).check_in_job
     Delayed::Job.in_delayed_job?.should == false
     job.invoke_job
     Delayed::Job.in_delayed_job?.should == false
@@ -506,12 +508,12 @@ shared_examples_for 'a backend' do
 
   it "should fail on job creation if an unsaved AR object is used" do
     story = Story.new :text => "Once upon..."
-    lambda { story.send_later(:text) }.should raise_error(RuntimeError)
+    lambda { story.delay.text }.should raise_error(RuntimeError)
 
     reader = StoryReader.new
-    lambda { reader.send_later(:read, story) }.should raise_error(RuntimeError)
+    lambda { reader.delay.read(story) }.should raise_error(RuntimeError)
 
-    lambda { [story, 1, story, false].send_later(:first) }.should raise_error(RuntimeError)
+    lambda { [story, 1, story, false].delay.first }.should raise_error(RuntimeError)
   end
 
   # the sort order of current_jobs and list_jobs depends on the back-end
@@ -576,11 +578,11 @@ shared_examples_for 'a backend' do
 
   it "should return the jobs for a tag" do
     tag_jobs = []
-    3.times { tag_jobs << "test".send_later_enqueue_args(:to_s, :no_delay => true) }
-    2.times { "test".send_later(:to_i) }
-    tag_jobs << "test".send_later_enqueue_args(:to_s, :run_at => 5.hours.from_now, :no_delay => true)
-    tag_jobs << "test".send_later_enqueue_args(:to_s, :strand => "test1", :no_delay => true)
-    "test".send_later_enqueue_args(:to_i, :strand => "test1")
+    3.times { tag_jobs << "test".delay(ignore_transaction: true).to_s }
+    2.times { "test".delay.to_i }
+    tag_jobs << "test".delay(ignore_transaction: true, run_at: 5.hours.from_now).to_s
+    tag_jobs << "test".delay(ignore_transaction: true, strand: "test1").to_s
+    "test".delay(strand: "test1").to_i
     create_job
 
     jobs = Delayed::Job.list_jobs(:tag, 3, 0, "String#to_s")
@@ -719,9 +721,9 @@ shared_examples_for 'a backend' do
         @flavor = 'tag'
         @query = 'String#to_i'
         Timecop.freeze(5.minutes.ago) do
-          @affected_jobs << "test".send_later_enqueue_args(:to_i, :no_delay => true)
-          @affected_jobs << "test".send_later_enqueue_args(:to_i, :strand => 's1', :no_delay => true)
-          @affected_jobs << "test".send_later_enqueue_args(:to_i, :run_at => 2.hours.from_now, :no_delay => true)
+          @affected_jobs << "test".delay(ignore_transaction: true).to_i
+          @affected_jobs << "test".delay(strand: 's1', ignore_transaction: true).to_i
+          @affected_jobs << "test".delay(run_at: 2.hours.from_now, ignore_transaction: true).to_i
           @ignored_jobs << create_job
           @ignored_jobs << create_job(:run_at => 1.hour.from_now)
         end
@@ -729,9 +731,9 @@ shared_examples_for 'a backend' do
     end
 
     it "should hold and un-hold given job ids" do
-      j1 = "test".send_later_enqueue_args(:to_i, :no_delay => true)
+      j1 = "test".delay(ignore_transaction: true).to_i
       j2 = create_job(:run_at => 2.hours.from_now)
-      j3 = "test".send_later_enqueue_args(:to_i, :strand => 's1', :no_delay => true)
+      j3 = "test".delay(strand: 's1', ignore_transaction: true).to_i
       Delayed::Job.bulk_update('hold', :ids => [j1.id, j2.id]).should == 2
       Delayed::Job.find(j1.id).on_hold?.should be true
       Delayed::Job.find(j2.id).on_hold?.should be true
@@ -776,13 +778,13 @@ shared_examples_for 'a backend' do
   describe "tag_counts" do
     before do
       @cur = []
-      3.times { @cur << "test".send_later_enqueue_args(:to_s, no_delay: true) }
-      5.times { @cur << "test".send_later_enqueue_args(:to_i, no_delay: true) }
-      2.times { @cur << "test".send_later_enqueue_args(:upcase, no_delay: true) }
-      ("test".send_later_enqueue_args :downcase, no_delay: true).fail!
+      3.times { @cur << "test".delay(ignore_transaction: true).to_s }
+      5.times { @cur << "test".delay(ignore_transaction: true).to_i}
+      2.times { @cur << "test".delay(ignore_transaction: true).upcase }
+      "test".delay(ignore_transaction: true).downcase.fail!
       @future = []
-      5.times { @future << "test".send_later_enqueue_args(:downcase, run_at: 3.hours.from_now, no_delay: true) }
-      @cur << "test".send_later_enqueue_args(:downcase, no_delay: true)
+      5.times { @future << "test".delay(run_at: 3.hours.from_now, ignore_transaction: true).downcase }
+      @cur << "test".delay(ignore_transaction: true).downcase
     end
 
     it "should return a sorted list of popular current tags" do

data/spec/shared/testing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples_for 'Delayed::Testing' do
   class TestingWorker
     cattr_accessor :runs
@@ -13,7 +15,7 @@ shared_examples_for 'Delayed::Testing' do
 
   describe '.run_job' do
     it 'should run a single queued job' do
-      job = TestingWorker.send_later_enqueue_args(:run, no_delay: true)
+      job = TestingWorker.delay(ignore_transaction: true).run
       Delayed::Testing.run_job(job)
       expect(TestingWorker.runs).to eq 1
     end
@@ -21,7 +23,7 @@ shared_examples_for 'Delayed::Testing' do
 
   describe '.drain' do
     it 'should run all queued jobs' do
-      3.times { TestingWorker.send_later(:run) }
+      3.times { TestingWorker.delay.run }
       YAML.dump(TestingWorker)
       Delayed::Testing.drain
       expect(TestingWorker.runs).to eq 3
@@ -30,8 +32,8 @@ shared_examples_for 'Delayed::Testing' do
 
   describe 'track_created' do
     it 'should return the list of jobs created in the block' do
-      3.times { TestingWorker.send_later(:run) }
-      jobs = Delayed::Testing.track_created { 2.times { TestingWorker.send_later(:run) } }
+      3.times { TestingWorker.delay.run }
+      jobs = Delayed::Testing.track_created { 2.times { TestingWorker.delay.run } }
       expect(jobs.size).to eq 2
       expect(jobs.first.tag).to eq "TestingWorker.run"
     end
@@ -39,7 +41,7 @@ shared_examples_for 'Delayed::Testing' do
 
   describe 'clear_all!' do
     it 'should delete all queued jobs' do
-      3.times { TestingWorker.send_later(:run) }
+      3.times { TestingWorker.delay.run }
       Delayed::Testing.clear_all!
       Delayed::Testing.drain
       expect(TestingWorker.runs).to eq 0

data/spec/shared/worker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 shared_examples_for 'Delayed::Worker' do
   def job_create(opts = {})
     Delayed::Job.create({:payload_object => SimpleJob.new, :queue => Delayed::Settings.queue}.merge(opts))
@@ -19,7 +21,7 @@ shared_examples_for 'Delayed::Worker' do
 
   describe "running a job" do
     it "should not fail when running a job with a % in the name" do
-      @job = "Some % Name here".send_later_enqueue_args(:starts_with?, { no_delay: true }, "Some % Name")
+      @job = "Some % Name here".delay(ignore_transaction: true).starts_with?("Some % Name")
       @worker.perform(@job)
     end
   end
@@ -36,14 +38,14 @@ shared_examples_for 'Delayed::Worker' do
       end
 
       it "should run each job in order" do
-        bar = "bar"
+        bar = +"bar"
         expect(bar).to receive(:scan).with("b").ordered
         expect(bar).to receive(:scan).with("a").ordered
         expect(bar).to receive(:scan).with("r").ordered
         batch = Delayed::Batch::PerformableBatch.new(:serial, [
-          { :payload_object => Delayed::PerformableMethod.new(bar, :scan, ["b"]) },
-          { :payload_object => Delayed::PerformableMethod.new(bar, :scan, ["a"]) },
-          { :payload_object => Delayed::PerformableMethod.new(bar, :scan, ["r"]) },
+          { :payload_object => Delayed::PerformableMethod.new(bar, :scan, args: ["b"]) },
+          { :payload_object => Delayed::PerformableMethod.new(bar, :scan, args: ["a"]) },
+          { :payload_object => Delayed::PerformableMethod.new(bar, :scan, args: ["r"]) },
         ])
 
         batch_job = Delayed::Job.create :payload_object => batch
@@ -54,9 +56,9 @@ shared_examples_for 'Delayed::Worker' do
       it "should succeed regardless of the success/failure of its component jobs" do
         change_setting(Delayed::Settings, :max_attempts, 2) do
           batch = Delayed::Batch::PerformableBatch.new(:serial, [
-            { :payload_object => Delayed::PerformableMethod.new("foo", :reverse, []) },
-            { :payload_object => Delayed::PerformableMethod.new(1, :/, [0]) },
-            { :payload_object => Delayed::PerformableMethod.new("bar", :scan, ["r"]) },
+            { :payload_object => Delayed::PerformableMethod.new("foo", :reverse) },
+            { :payload_object => Delayed::PerformableMethod.new(1, :/, args: [0]) },
+            { :payload_object => Delayed::PerformableMethod.new("bar", :scan, args: ["r"]) },
           ])
           batch_job = Delayed::Job.create :payload_object => batch
 
@@ -73,7 +75,7 @@ shared_examples_for 'Delayed::Worker' do
 
       it "should retry a failed individual job" do
         batch = Delayed::Batch::PerformableBatch.new(:serial, [
-          { :payload_object => Delayed::PerformableMethod.new(1, :/, [0]) },
+          { :payload_object => Delayed::PerformableMethod.new(1, :/, args: [0]) },
         ])
         batch_job = Delayed::Job.create :payload_object => batch
 
@@ -155,7 +157,7 @@ shared_examples_for 'Delayed::Worker' do
       @worker.perform(@job)
       @job = Delayed::Job.find(@job.id)
       @job.last_error.should =~ /did not work/
-      @job.last_error.should =~ /sample_jobs.rb:8:in `perform'/
+      @job.last_error.should =~ /sample_jobs.rb:10:in `perform'/
       @job.attempts.should == 1
       @job.run_at.should > Delayed::Job.db_time_now - 10.minutes
       @job.run_at.should < Delayed::Job.db_time_now + 10.minutes
@@ -348,17 +350,17 @@ shared_examples_for 'Delayed::Worker' do
     end
   end
 
-  describe "send_later_enqueue_args failure callbacks" do
+  describe "delay failure callbacks" do
     it "should call the on_failure callback" do
       ErrorJob.last_error = nil
-      ErrorJob.new.send_later_enqueue_args(:perform, :max_attempts => 2, :on_failure => :on_failure)
+      ErrorJob.new.delay(max_attempts: 2, on_failure: :on_failure).perform
       expect { @worker.run }.to change { ErrorJob.failure_runs }.by(1)
       expect(ErrorJob.last_error.to_s).to eq 'did not work'
     end
 
     it "should call the on_permanent_failure callback" do
       ErrorJob.last_error = nil
-      ErrorJob.new.send_later_enqueue_args(:perform, :max_attempts => 1, :on_permanent_failure => :on_failure)
+      ErrorJob.new.delay(max_attempts: 1, on_permanent_failure: :on_failure).perform
       expect { @worker.run }.to change { ErrorJob.failure_runs }.by(1)
       expect(ErrorJob.last_error.to_s).to eq 'did not work'
     end

data/spec/shared_jobs_specs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.expand_path('../shared/delayed_batch', __FILE__)
 require File.expand_path('../shared/delayed_method', __FILE__)
 require File.expand_path('../shared/performable_method', __FILE__)

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'delayed_job'
 require 'delayed/testing'
 
@@ -91,7 +93,7 @@ class Story < ActiveRecord::Base
   def whatever_else(n, _); tell*n; end
 
   handle_asynchronously :whatever
-  handle_asynchronously_with_queue :whatever_else, "testqueue"
+  handle_asynchronously :whatever_else, queue: "testqueue"
 end
 
 class StoryReader

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 0.15.19
+  version: 1.0.0
 platform: ruby
 authors:
 - Tobias Luetke
 - Brian Palmer
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-04-13 00:00:00.000000000 Z
+date: 2020-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -311,7 +311,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.4.0
-description: 
+description:
 email:
 - brianp@instructure.com
 executables:
@@ -343,6 +343,8 @@ files:
 - db/migrate/20181217155351_speed_up_max_concurrent_triggers.rb
 - db/migrate/20190726154743_make_critical_columns_not_null.rb
 - db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb
+- db/migrate/20200824222232_speed_up_max_concurrent_delete_trigger.rb
+- db/migrate/20200825011002_add_strand_order_override.rb
 - exe/inst_jobs
 - lib/delayed/backend/active_record.rb
 - lib/delayed/backend/base.rb
@@ -427,7 +429,7 @@ files:
 homepage: https://github.com/instructure/inst-jobs
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -442,8 +444,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Instructure-maintained fork of delayed_job
 test_files: