delayed_job_groups_plugin 0.2.0 → 0.5.0

data/lib/generators/delayed_job_groups_plugin/templates/{migration.rb → migration.erb}

@@ -1,6 +1,6 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
-class CreateDelayedJobGroups < ActiveRecord::Migration
+class CreateDelayedJobGroups < ActiveRecord::Migration[<%= ActiveRecord::VERSION::MAJOR %>.<%= ActiveRecord::VERSION::MINOR %>]
 
   def up
     add_column(:delayed_jobs, :blocked, :boolean, default: false, null: false)

data/spec/db/schema.rb

@@ -1,6 +1,6 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
-ActiveRecord::Schema.define(:version => 0) do
+ActiveRecord::Schema.define(version: 0) do
 
   create_table(:delayed_jobs, force: true) do |t|
     t.integer :priority, default: 0

data/spec/delayed/job_groups/job_group_spec.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Delayed::JobGroups::JobGroup do
 
@@ -19,7 +17,7 @@ describe Delayed::JobGroups::JobGroup do
 
   before do
     Timecop.freeze(current_time)
-    Delayed::Job.stub(:enqueue)
+    allow(Delayed::Job).to receive(:enqueue)
   end
 
   after do
@@ -28,21 +26,21 @@ describe Delayed::JobGroups::JobGroup do
 
   shared_examples "the job group was completed" do
     it "queues the completion job" do
-      Delayed::Job.should have_received(:enqueue).with(on_completion_job, on_completion_job_options)
+      expect(Delayed::Job).to have_received(:enqueue).with(on_completion_job, on_completion_job_options)
     end
 
     it "destroys the job group" do
-      job_group.should have_been_destroyed
+      expect(job_group).to have_been_destroyed
     end
   end
 
   shared_examples "the job group was not completed" do
     it "does not queue the completion job" do
-      Delayed::Job.should_not have_received(:enqueue)
+      expect(Delayed::Job).not_to have_received(:enqueue)
     end
 
     it "does not destroy the job group" do
-      job_group.should_not have_been_destroyed
+      expect(job_group).not_to have_been_destroyed
     end
   end
 
@@ -51,15 +49,16 @@ describe Delayed::JobGroups::JobGroup do
     context "when no jobs exist" do
       before { job_group.mark_queueing_complete }
 
-      it { should be_queueing_complete }
+      it { is_expected.to be_queueing_complete }
       it_behaves_like "the job group was completed"
     end
 
     context "when no jobs exist but the job group is blocked" do
       let(:blocked) { true }
+
       before { job_group.mark_queueing_complete }
 
-      it { should be_queueing_complete }
+      it { is_expected.to be_queueing_complete }
       it_behaves_like "the job group was not completed"
     end
 
@@ -69,7 +68,7 @@ describe Delayed::JobGroups::JobGroup do
         job_group.mark_queueing_complete
       end
 
-      it { should be_queueing_complete }
+      it { is_expected.to be_queueing_complete }
       it_behaves_like "the job group was not completed"
     end
   end
@@ -117,11 +116,11 @@ describe Delayed::JobGroups::JobGroup do
       include_context "complete job and check job group complete"
 
       it "queues the completion job with empty options" do
-        Delayed::Job.should have_received(:enqueue).with(on_completion_job, {})
+        expect(Delayed::Job).to have_received(:enqueue).with(on_completion_job, {})
       end
 
       it "destroys the job group" do
-        job_group.should have_been_destroyed
+        expect(job_group).to have_been_destroyed
       end
     end
 
@@ -131,11 +130,11 @@ describe Delayed::JobGroups::JobGroup do
       include_context "complete job and check job group complete"
 
       it "doesn't queues the non-existent completion job" do
-        Delayed::Job.should_not have_received(:enqueue)
+        expect(Delayed::Job).not_to have_received(:enqueue)
       end
 
       it "destroys the job group" do
-        job_group.should have_been_destroyed
+        expect(job_group).to have_been_destroyed
       end
     end
   end
@@ -149,7 +148,7 @@ describe Delayed::JobGroups::JobGroup do
 
     shared_examples "it enqueues the job in the correct blocked state" do
       it "enqueues the job in the same blocked state as the job group" do
-        Delayed::Job.should have_received(:enqueue).with(job, job_group_id: job_group.id, blocked: blocked)
+        expect(Delayed::Job).to have_received(:enqueue).with(job, job_group_id: job_group.id, blocked: blocked)
       end
     end
 
@@ -169,7 +168,7 @@ describe Delayed::JobGroups::JobGroup do
         job_group.unblock
       end
 
-      its(:blocked?) { should be_false }
+      its(:blocked?) { is_expected.to be(false) }
     end
 
     context "when the JobGroup is blocked" do
@@ -184,10 +183,10 @@ describe Delayed::JobGroups::JobGroup do
           Timecop.freeze(unblock_time) { job_group.unblock }
         end
 
-        its(:blocked?) { should be_false }
+        its(:blocked?) { is_expected.to be(false) }
 
         it "sets the job's run_at to the unblocked time" do
-          job.reload.run_at.should eq unblock_time
+          expect(job.reload.run_at).to eq unblock_time
         end
 
         it_behaves_like "the job group was not completed"
@@ -199,7 +198,7 @@ describe Delayed::JobGroups::JobGroup do
           job_group.unblock
         end
 
-        its(:blocked?) { should be_false }
+        its(:blocked?) { is_expected.to be(false) }
         it_behaves_like "the job group was completed"
       end
     end
@@ -214,15 +213,15 @@ describe Delayed::JobGroups::JobGroup do
     end
 
     it "destroys the job group" do
-      job_group.should have_been_destroyed
+      expect(job_group).to have_been_destroyed
     end
 
     it "destroys queued jobs" do
-      queued_job.should have_been_destroyed
+      expect(queued_job).to have_been_destroyed
     end
 
     it "does not destroy running jobs" do
-      running_job.should_not have_been_destroyed
+      expect(running_job).not_to have_been_destroyed
     end
   end
 

data/spec/delayed/job_groups/plugin_spec.rb

@@ -1,77 +1,72 @@
-# encoding: UTF-8
-
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Delayed::JobGroups::Plugin do
-
-  before(:all) do
+  before do
     @old_max_attempts = Delayed::Worker.max_attempts
     Delayed::Worker.max_attempts = 2
-  end
 
-  after(:all) do
-    Delayed::Worker.max_attempts = @old_max_attempts
-  end
-
-  before(:each) do
     CompletionJob.invoked = false
     CancellationJob.invoked = false
   end
 
+  after do
+    Delayed::Worker.max_attempts = @old_max_attempts
+  end
+
   let!(:job_group) { Delayed::JobGroups::JobGroup.create!(on_completion_job: CompletionJob.new) }
 
   it "runs the completion job after completing other jobs" do
     job_group.enqueue(NoOpJob.new)
     job_group.enqueue(NoOpJob.new)
     job_group.mark_queueing_complete
-    job_group_count.should eq 1
-    queued_job_count.should eq 2
+    expect(job_group_count).to eq 1
+    expect(queued_job_count).to eq 2
 
     # Run our first job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be_false
-    job_group_count.should eq 1
-    queued_job_count.should eq 1
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 1
+    expect(queued_job_count).to eq 1
 
     # Run our second job which should enqueue the completion job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be_false
-    job_group_count.should eq 0
-    queued_job_count.should eq 1
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 0
+    expect(queued_job_count).to eq 1
 
     # Now we should run the completion job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be_true
-    queued_job_count.should eq 0
+    expect(CompletionJob.invoked).to be(true)
+    expect(queued_job_count).to eq 0
   end
 
   it "only runs the completion job after queueing is completed" do
     job_group.enqueue(NoOpJob.new)
     job_group.enqueue(NoOpJob.new)
-    job_group_count.should eq 1
-    queued_job_count.should eq 2
+    expect(job_group_count).to eq 1
+    expect(queued_job_count).to eq 2
 
     # Run our first job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be_false
-    job_group_count.should eq 1
-    queued_job_count.should eq 1
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 1
+    expect(queued_job_count).to eq 1
 
     # Run our second job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be_false
-    job_group_count.should eq 1
-    queued_job_count.should eq 0
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 1
+    expect(queued_job_count).to eq 0
 
     # Mark queueing complete which should queue the completion job
     job_group.mark_queueing_complete
-    job_group_count.should eq 0
-    queued_job_count.should eq 1
+    expect(job_group_count).to eq 0
+    expect(queued_job_count).to eq 1
 
     # Now we should run the completion job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be_true
-    queued_job_count.should eq 0
+    expect(CompletionJob.invoked).to be(true)
+    expect(queued_job_count).to eq 0
   end
 
   describe "job failures" do
@@ -83,15 +78,16 @@ describe Delayed::JobGroups::Plugin do
         job_group.enqueue(FailingJob.new)
         job_group.enqueue(NoOpJob.new)
         job_group.mark_queueing_complete
-        queued_job_count.should eq 2
-        job_group_count.should eq 1
+        expect(queued_job_count).to eq 2
+        expect(job_group_count).to eq 1
 
         # Run the job which should fail and cancel the JobGroup
         Delayed::Worker.new.work_off(1)
-        CompletionJob.invoked.should be_false
-        failed_job_count.should eq 1
-        queued_job_count.should eq 0
-        job_group_count.should eq 0
+        # Completion job is not invoked
+        expect(CompletionJob.invoked).to be(false)
+        expect(failed_job_count).to eq 1
+        expect(queued_job_count).to eq 0
+        expect(job_group_count).to eq 0
       end
     end
 
@@ -105,15 +101,68 @@ describe Delayed::JobGroups::Plugin do
         job_group.enqueue(FailingJob.new)
         job_group.enqueue(NoOpJob.new)
         job_group.mark_queueing_complete
-        queued_job_count.should eq 2
-        job_group_count.should eq 1
+        expect(queued_job_count).to eq 2
+        expect(job_group_count).to eq 1
 
         # Run the job which should fail don't cancel the JobGroup
         Delayed::Worker.new.work_off(1)
-        CancellationJob.invoked.should be_false
-        failed_job_count.should eq 1
-        queued_job_count.should eq 1
-        job_group_count.should eq 1
+        expect(CancellationJob.invoked).to be(false)
+        expect(failed_job_count).to eq 1
+        expect(queued_job_count).to eq 1
+        expect(job_group_count).to eq 1
+
+        # Run the last job
+        Delayed::Worker.new.work_off(1)
+        expect(failed_job_count).to eq 1
+        expect(queued_job_count).to eq 1
+        expect(job_group_count).to eq 0
+
+        # Run the completion job
+        Delayed::Worker.new.work_off(1)
+        # Completion job is invoked
+        expect(CompletionJob.invoked).to be(true)
+        expect(failed_job_count).to eq 1
+        expect(queued_job_count).to eq 0
+        expect(job_group_count).to eq 0
+      end
+
+      it "runs completion job if last job failed" do
+        Delayed::Worker.max_attempts = 2
+
+        job_group.enqueue(NoOpJob.new)
+        job_group.enqueue(FailingJob.new)
+        job_group.mark_queueing_complete
+        expect(queued_job_count).to eq 2
+        expect(job_group_count).to eq 1
+
+        # Run the non failing job
+        Delayed::Worker.new.work_off(1)
+        expect(failed_job_count).to eq 0
+        expect(queued_job_count).to eq 1
+        expect(job_group_count).to eq 1
+
+        # Run the job which should error
+        Delayed::Worker.new.work_off(1)
+        # Completion job is not invoked
+        expect(CompletionJob.invoked).to be(false)
+        expect(failed_job_count).to eq 0
+        expect(queued_job_count).to eq 1
+        expect(job_group_count).to eq 1
+
+        # Run the job again which should fail
+        Timecop.travel(1.minute.from_now)
+        Delayed::Worker.new.work_off(1)
+        expect(failed_job_count).to eq 1
+        expect(queued_job_count).to eq 1
+        expect(job_group_count).to eq 0
+
+        # Run the completion job
+        Delayed::Worker.new.work_off(1)
+        # Completion job is invoked
+        expect(CompletionJob.invoked).to be(true)
+        expect(failed_job_count).to eq 1
+        expect(queued_job_count).to eq 0
+        expect(job_group_count).to eq 0
       end
     end
   end
@@ -121,12 +170,12 @@ describe Delayed::JobGroups::Plugin do
   it "doesn't retry failed jobs if the job group has been canceled" do
     job_group.cancel
     Delayed::Job.enqueue(FailingJob.new, job_group_id: job_group.id)
-    queued_job_count.should eq 1
+    expect(queued_job_count).to eq 1
 
     # Run the job which should fail and should not queue a retry
     Delayed::Worker.new.work_off(1)
-    failed_job_count.should eq 1
-    queued_job_count.should eq 0
+    expect(failed_job_count).to eq 1
+    expect(queued_job_count).to eq 0
   end
 
   it "doesn't run jobs until they're unblocked" do
@@ -136,32 +185,32 @@ describe Delayed::JobGroups::Plugin do
     job_group.enqueue(NoOpJob.new)
     job_group.enqueue(NoOpJob.new)
     job_group.mark_queueing_complete
-    Delayed::Job.count.should eq 2
+    expect(Delayed::Job.count).to eq 2
 
     # No jobs should run because they're blocked
     (successes, failures) = Delayed::Worker.new.work_off
-    successes.should eq 0
-    failures.should eq 0
-    Delayed::Job.count.should eq 2
+    expect(successes).to eq 0
+    expect(failures).to eq 0
+    expect(Delayed::Job.count).to eq 2
 
     job_group.unblock
 
     # Run our first job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be_false
-    job_group_count.should eq 1
-    Delayed::Job.count.should eq 1
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 1
+    expect(Delayed::Job.count).to eq 1
 
     # Run our second job which should enqueue the completion job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be_false
-    job_group_count.should eq 0
-    Delayed::Job.count.should eq 1
+    expect(CompletionJob.invoked).to be(false)
+    expect(job_group_count).to eq 0
+    expect(Delayed::Job.count).to eq 1
 
     # Now we should run the completion job
     Delayed::Worker.new.work_off(1)
-    CompletionJob.invoked.should be_true
-    Delayed::Job.count.should eq 0
+    expect(CompletionJob.invoked).to be(true)
+    expect(Delayed::Job.count).to eq 0
   end
 
   context "when a cancellation job is provided" do
@@ -176,23 +225,23 @@ describe Delayed::JobGroups::Plugin do
       job_group.enqueue(FailingJob.new)
       job_group.enqueue(NoOpJob.new)
       job_group.mark_queueing_complete
-      queued_job_count.should eq 2
-      job_group_count.should eq 1
+      expect(queued_job_count).to eq 2
+      expect(job_group_count).to eq 1
 
       # Run the job which should fail and cancel the JobGroup
       Delayed::Worker.new.work_off(1)
-      CompletionJob.invoked.should be_false
-      CancellationJob.invoked.should be_false
-      failed_job_count.should eq 1
+      expect(CompletionJob.invoked).to be(false)
+      expect(CancellationJob.invoked).to be(false)
+      expect(failed_job_count).to eq 1
 
-      queued_job_count.should eq 1
-      job_group_count.should eq 0
+      expect(queued_job_count).to eq 1
+      expect(job_group_count).to eq 0
 
       # Now we should run the cancellation job
       Delayed::Worker.new.work_off(1)
-      CompletionJob.invoked.should be_false
-      CancellationJob.invoked.should be_true
-      queued_job_count.should eq 0
+      expect(CompletionJob.invoked).to be(false)
+      expect(CancellationJob.invoked).to be(true)
+      expect(queued_job_count).to eq 0
     end
 
     it "runs the cancellation job after the job group is cancelled" do
@@ -201,14 +250,14 @@ describe Delayed::JobGroups::Plugin do
       job_group.mark_queueing_complete
       job_group.cancel
 
-      #cancellation job should be queued
-      queued_job_count.should eq 1
-      CancellationJob.invoked.should be_false
+      # cancellation job should be queued
+      expect(queued_job_count).to eq 1
+      expect(CancellationJob.invoked).to be(false)
 
       # Run the cancellation job
       Delayed::Worker.new.work_off(1)
-      CancellationJob.invoked.should be_true
-      queued_job_count.should eq 0
+      expect(CancellationJob.invoked).to be(true)
+      expect(queued_job_count).to eq 0
     end
   end
 
@@ -219,21 +268,21 @@ describe Delayed::JobGroups::Plugin do
       job_group.enqueue(NoOpJob.new)
       job_group.enqueue(NoOpJob.new)
       job_group.mark_queueing_complete
-      job_group_count.should eq 1
-      queued_job_count.should eq 2
-      failed_job_count.should eq 0
+      expect(job_group_count).to eq 1
+      expect(queued_job_count).to eq 2
+      expect(failed_job_count).to eq 0
 
       # Run our first job
       Delayed::Worker.new.work_off(1)
-      job_group_count.should eq 1
-      queued_job_count.should eq 1
-      failed_job_count.should eq 0
+      expect(job_group_count).to eq 1
+      expect(queued_job_count).to eq 1
+      expect(failed_job_count).to eq 0
 
       # Run our second job which should delete the job group
       Delayed::Worker.new.work_off(1)
-      job_group_count.should eq 0
-      queued_job_count.should eq 0
-      failed_job_count.should eq 0
+      expect(job_group_count).to eq 0
+      expect(queued_job_count).to eq 0
+      expect(failed_job_count).to eq 0
     end
   end