resque-approve 0.0.4 → 0.0.12

data/lib/resque/server/views/approval_keys.erb

@@ -28,6 +28,9 @@
               order_param("num_jobs", @sort_by, @sort_order) }.to_param %>">
         Pending Jobs
       </a></th>
+      <th>
+        Num Running
+      </th>
       <th><a href="<%= u("approve") %>?<%=
         { sort:      "first_enqueued",
           page_size: @page_size,
@@ -64,3 +67,6 @@
 </div>
 <div class="approve_reset"/>
 <br/>
+<div>
+  Approval v<%= VERSION %>
+</div>

data/lib/resque/server/views/job_details.erb

@@ -80,3 +80,6 @@
 <div class="approve_reset"/>
 
 <br/>
+<div>
+  Approval v<%= VERSION %>
+</div>

data/lib/resque/server/views/job_list.erb

@@ -12,6 +12,10 @@
   </a>
 </p>
 
+<p>
+  Num active jobs in this queue = <%= pending_queue.num_running %>
+</p>
+
 <% if pending_queue.paused? %>
   <p>
     Paused. Skipped <%= pending_queue.num_ignored %> resume actions.
@@ -39,23 +43,16 @@
 
   <br/>
 
+  <form method="POST" action="<%= u("approve/reset_running") %>?<%=
+    { approval_key: pending_queue.approval_key }.to_param %>">
+    <input type="submit" name="" value="Reset Running"/>
+  </form>
+
   <form method="POST" action="<%= u("approve/delete_queue") %>?<%=
     { approval_key: pending_queue.approval_key }.to_param %>">
     <input type="submit" name="" value="Delete All"/>
   </form>
 
-  <% if pending_queue.paused? %>
-    <form method="POST" action="<%= u("approve/resume") %>?<%=
-      { approval_key: pending_queue.approval_key }.to_param %>">
-      <input type="submit" name="" value="Resume"/>
-    </form>
-  <% else %>
-    <form method="POST" action="<%= u("approve/pause") %>?<%=
-      { approval_key: pending_queue.approval_key }.to_param %>">
-      <input type="submit" name="" value="Pause"/>
-    </form>
-  <% end %>
-
   <form method="POST" action="<%= u("approve/delete_one_queue") %>?<%=
     { approval_key: pending_queue.approval_key }.to_param %>">
     <input type="submit" name="" value="Delete One"/>
@@ -72,5 +69,22 @@
   </form>
 <% end %>
 
+<% if pending_queue.paused? %>
+  <form method="POST" action="<%= u("approve/resume") %>?<%=
+    { approval_key: pending_queue.approval_key }.to_param %>">
+    <input type="submit" name="" value="Resume"/>
+  </form>
+<% else %>
+  <form method="POST" action="<%= u("approve/pause") %>?<%=
+    { approval_key: pending_queue.approval_key }.to_param %>">
+    <input type="submit" name="" value="Pause"/>
+  </form>
+<% end %>
+
 <div class="approve_reset"/>
-<br/>
+<br/>
+<div>
+  <p>
+    Approval v<%= VERSION %>
+  </p>
+</div>

data/spec/approve/pending_job_queue_spec.rb

@@ -123,6 +123,33 @@ RSpec.describe Resque::Plugins::Approve::PendingJobQueue do
     end
   end
 
+  describe "approve_num" do
+    it "enqueues the first x jobs" do
+      job_queue.approve_num 3
+
+      expect(Resque).to have_received(:enqueue_to).with "Some_Queue", BasicJob, 0
+      expect(Resque).to have_received(:enqueue_to).with "Some_Queue", BasicJob, 1
+      expect(Resque).to have_received(:enqueue_to).with "Some_Queue", BasicJob, 2
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 3
+
+      expect(job_queue.jobs).not_to be_include jobs[0]
+      expect(job_queue.num_jobs).to eq 1
+    end
+
+    it "does not enqueues the first x jobs if paused" do
+      job_queue.pause
+      job_queue.approve_num 3
+
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 0
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 1
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 2
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 3
+
+      expect(job_queue.jobs).to be_include jobs[0]
+      expect(job_queue.num_jobs).to eq 4
+    end
+  end
+
   describe "pop_job" do
     it "enqueues the last job" do
       job_queue.pop_job
@@ -190,7 +217,7 @@ RSpec.describe Resque::Plugins::Approve::PendingJobQueue do
       expect(job_queue.num_jobs).to eq 3
     end
 
-    it "removes the first job" do
+    it "removes the first job if paused" do
       job_queue.pause
       job_queue.remove_one
 
@@ -204,6 +231,37 @@ RSpec.describe Resque::Plugins::Approve::PendingJobQueue do
     end
   end
 
+  describe "remove_num" do
+    it "removes the first x jobs" do
+      job_queue.remove_num 3
+
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 0
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 1
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 2
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 3
+
+      expect(job_queue.jobs).not_to be_include jobs[0]
+      expect(job_queue.jobs).not_to be_include jobs[1]
+      expect(job_queue.jobs).not_to be_include jobs[2]
+      expect(job_queue.num_jobs).to eq 1
+    end
+
+    it "removes the first x jobs if paused" do
+      job_queue.pause
+      job_queue.remove_num 3
+
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 0
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 1
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 2
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 3
+
+      expect(job_queue.jobs).not_to be_include jobs[0]
+      expect(job_queue.jobs).not_to be_include jobs[1]
+      expect(job_queue.jobs).not_to be_include jobs[2]
+      expect(job_queue.num_jobs).to eq 1
+    end
+  end
+
   describe "remove_job_pop" do
     it "removes the last job" do
       job_queue.remove_job_pop
@@ -297,7 +355,7 @@ RSpec.describe Resque::Plugins::Approve::PendingJobQueue do
   describe "first_enqueued" do
     it "returns the time of the first enqueued item" do
       4.times do |index|
-        expect(job_queue.first_enqueued).to be_within(1.second).of((5 - index).hours.ago)
+        expect(job_queue.first_enqueued).to be_within(2.seconds).of((5 - index).hours.ago)
 
         job_queue.remove_one
       end
@@ -319,14 +377,34 @@ RSpec.describe Resque::Plugins::Approve::PendingJobQueue do
       expect(job_queue).to be_paused
     end
 
+    it "counts approvals while paused" do
+      expect(job_queue).not_to be_paused
+      job_queue.pause
+      expect(job_queue).to be_paused
+      job_queue.pause
+      expect(job_queue).to be_paused
+
+      job_queue.approve_num 8
+      job_queue.approve_one
+      expect(job_queue).to be_paused
+      expect(job_queue.num_ignored).to eq 9
+    end
+
     it "can be resumed" do
       expect(job_queue).not_to be_paused
       job_queue.resume
       expect(job_queue).not_to be_paused
       job_queue.pause
       expect(job_queue).to be_paused
+
+      job_queue.approve_num 8
+      job_queue.approve_one
+      expect(job_queue).to be_paused
+      expect(job_queue.num_ignored).to eq 9
+
       job_queue.resume
       expect(job_queue).not_to be_paused
+      expect(job_queue.num_ignored).to be_zero
     end
   end
 end

data/spec/approve/pending_job_spec.rb

@@ -2,7 +2,6 @@
 
 require "rails_helper"
 
-# rubocop:disable Layout/AlignHash
 RSpec.describe Resque::Plugins::Approve::PendingJob do
   let(:key_list) { Resque::Plugins::Approve::ApprovalKeyList.new }
   let!(:key) { Faker::Lorem.sentence }
@@ -38,6 +37,20 @@ RSpec.describe Resque::Plugins::Approve::PendingJob do
 
     job
   end
+  let(:approval_require_approval_job) do
+    job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: [requires_approval: true])
+
+    key_list.add_job(job)
+
+    job
+  end
+  let(:approval_hash_only_args_job) do
+    job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: [some_hash: "hash", approval_key: key])
+
+    key_list.add_job(job)
+
+    job
+  end
   let(:approval_no_hash_args_job) do
     job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid,
                                                    class_name: job_class,
@@ -87,36 +100,58 @@ RSpec.describe Resque::Plugins::Approve::PendingJob do
   describe "initialize" do
     it "extracts delay arguments from job with no argument" do
       expect(no_args_job.args).to eq []
+      expect(Resque::Plugins::Approve::PendingJob.new(no_args_job.id).args).to eq []
       expect(no_args_job.approve_options).to eq({}.with_indifferent_access)
     end
 
     it "extracts delay arguments from job with no hash arguments" do
       expect(no_hash_args_job.args).to eq [1, "fred", "something else", 888]
+      expect(Resque::Plugins::Approve::PendingJob.new(no_hash_args_job.id).args).to eq [1, "fred", "something else", 888]
       expect(no_hash_args_job.approve_options).to eq({}.with_indifferent_access)
     end
 
     it "extracts delay arguments from job with no approval arguments" do
       expect(hash_args_job.args).to eq [1, "fred", "something else", 888, "other_arg" => 1, "something else" => "something"]
+      expect(Resque::Plugins::Approve::PendingJob.new(hash_args_job.id).args).
+          to eq [1, "fred", "something else", 888, "other_arg" => 1, "something else" => "something"]
       expect(hash_args_job.approve_options).to eq({}.with_indifferent_access)
     end
 
     it "extracts delay arguments from job with no argument and approval_args" do
       expect(approval_only_args_job.args).to eq []
+      expect(Resque::Plugins::Approve::PendingJob.new(approval_only_args_job.id).args).to eq []
       expect(approval_only_args_job.approve_options).to eq("approval_key" => key)
     end
 
+    it "extracts delay arguments from job with no argument and require_approval" do
+      expect(approval_require_approval_job.args).to eq []
+      expect(Resque::Plugins::Approve::PendingJob.new(approval_require_approval_job.id).args).to eq []
+      expect(approval_require_approval_job.approve_options).to eq("approval_key" => "Some_Queue", "requires_approval" => true)
+    end
+
+    it "extracts delay arguments from job with only hash arguments and approval_args" do
+      expect(approval_hash_only_args_job.args).to eq [{ "some_hash" => "hash" }]
+      expect(Resque::Plugins::Approve::PendingJob.new(approval_hash_only_args_job.id).args).to eq [{ "some_hash" => "hash" }]
+      expect(approval_hash_only_args_job.approve_options).to eq("approval_key" => key)
+    end
+
     it "extracts delay arguments from job with no hash arguments and approval args" do
       expect(approval_no_hash_args_job.args).to eq [1, "fred", "something else", 888]
+      expect(Resque::Plugins::Approve::PendingJob.new(approval_no_hash_args_job.id).args).to eq [1, "fred", "something else", 888]
       expect(approval_no_hash_args_job.approve_options).to eq("approval_key" => key)
     end
 
     it "extracts delay arguments from job with no approval arguments and approval args" do
       expect(approval_hash_args_job.args).to eq [1, "fred", "something else", 888, "other_arg" => 1, "something else" => "something"]
+      expect(Resque::Plugins::Approve::PendingJob.new(approval_hash_args_job.id).args).
+          to eq [1, "fred", "something else", 888, "other_arg" => 1, "something else" => "something"]
       expect(approval_hash_args_job.approve_options).to eq("approval_key" => key)
     end
 
     it "extracts all delay arguments from job with no approval arguments and approval args" do
       expect(approval_all_args_job.args).to eq [1, "fred", "something else", 888, "other_arg" => 1, "something else" => "something"]
+      expect(Resque::Plugins::Approve::PendingJob.new(approval_all_args_job.id).args).
+          to eq [1, "fred", "something else", 888, "other_arg" => 1, "something else" => "something"]
 
       expect(approval_all_args_job.approve_options[:approval_key]).to eq key
       expect(approval_all_args_job.approve_options["approval_key"]).to eq key
@@ -124,8 +159,8 @@ RSpec.describe Resque::Plugins::Approve::PendingJob do
       expect(approval_all_args_job.approve_options[:approval_queue]).to eq "Another Queue"
       expect(approval_all_args_job.approve_options["approval_queue"]).to eq "Another Queue"
 
-      expect(approval_all_args_job.approve_options[:approval_at]).to be_within(2.seconds).of(2.hours.from_now)
-      expect(approval_all_args_job.approve_options["approval_at"]).to be_within(2.seconds).of(2.hours.from_now)
+      expect(approval_all_args_job.approve_options[:approval_at].to_time).to be_within(2.seconds).of(2.hours.from_now)
+      expect(approval_all_args_job.approve_options["approval_at"].to_time).to be_within(2.seconds).of(2.hours.from_now)
     end
   end
 
@@ -165,6 +200,8 @@ RSpec.describe Resque::Plugins::Approve::PendingJob do
 
     it "has args" do
       expect(job.args).to eq [1, "fred", "something else", 888, "other_arg" => 1, "something else" => "something"]
+      expect(Resque::Plugins::Approve::PendingJob.new(job.id).args).
+          to eq [1, "fred", "something else", 888, "other_arg" => 1, "something else" => "something"]
     end
 
     it "has the approval_key" do
@@ -176,11 +213,11 @@ RSpec.describe Resque::Plugins::Approve::PendingJob do
     end
 
     it "has the approval_at" do
-      expect(job.approval_at).to be_within(1.second).of(2.hours.from_now)
+      expect(job.approval_at).to be_within(2.seconds).of(2.hours.from_now)
     end
 
     it "has the queue_time" do
-      expect(job.queue_time).to be_within(1.second).of(2.hours.ago)
+      expect(job.queue_time).to be_within(2.seconds).of(2.hours.ago)
     end
 
     it "has the queue" do
@@ -245,6 +282,146 @@ RSpec.describe Resque::Plugins::Approve::PendingJob do
 
       expect(job).not_to be_requires_approval
     end
+
+    it "requires approval if requires_approval is passed" do
+      expect(approval_require_approval_job).to be_requires_approval
+    end
+
+    context "MaxActiveJob" do
+      let(:job_class) { MaxActiveJob }
+      let(:num_queue) { Resque::Plugins::Approve::PendingJobQueue.new("Some_Queue") }
+
+      before(:each) do
+        num_queue.reset_running
+      end
+
+      it "does not require approval if num jobs below max" do
+        expect(approval_require_approval_job).not_to be_requires_approval
+
+        expect(approval_require_approval_job.args).to eq ["approval_key" => "Some_Queue"]
+        expect(Resque::Plugins::Approve::PendingJob.new(approval_require_approval_job.id).args).to eq ["approval_key" => "Some_Queue"]
+        expect(approval_require_approval_job.approve_options).to eq("approval_key" => "Some_Queue", "requires_approval" => true)
+      end
+
+      it "does require approval if num jobs above max" do
+        10.times { num_queue.increment_running }
+
+        expect(approval_require_approval_job).to be_requires_approval
+
+        expect(approval_require_approval_job.args).to eq ["approval_key" => "Some_Queue"]
+        expect(Resque::Plugins::Approve::PendingJob.new(approval_require_approval_job.id).args).to eq ["approval_key" => "Some_Queue"]
+        expect(approval_require_approval_job.approve_options).to eq("approval_key" => "Some_Queue", "requires_approval" => true)
+      end
+
+      it "calls the perform function" do
+        allow(Resque.logger).to receive(:warn).and_call_original
+
+        MaxActiveJob.perform(*approval_require_approval_job.args)
+
+        expect(Resque.logger).to have_received(:warn).with("Args:\n[]").exactly(2).times
+      end
+
+      it "does not approve if number of running jobs too high" do
+        approval_require_approval_job
+
+        expect(Resque::Plugins::Approve::PendingJobQueue.new("Some_Queue").num_jobs).to eq 1
+
+        10.times { num_queue.increment_running }
+
+        allow(Resque.logger).to receive(:warn).and_call_original
+
+        job_class.approve_one
+
+        expect(Resque.logger).not_to have_received(:warn)
+        expect(Resque::Plugins::Approve::PendingJobQueue.new("Some_Queue").num_jobs).to eq 1
+
+        expect(num_queue.num_running.to_i).to eq 10
+      end
+
+      it "approves the next item in the queue" do
+        allow(Resque::Plugins::Approve).to receive(:approve_one).and_call_original
+
+        MaxActiveJob.perform(*approval_require_approval_job.args)
+
+        expect(Resque::Plugins::Approve).to have_received(:approve_one).with("Some_Queue").exactly(2).times
+      end
+
+      it "approves the next item in the queue even if there is an exception" do
+        allow(Resque.logger).to receive(:warn).with("Args:\n[]").and_raise "Error"
+        allow(Resque::Plugins::Approve).to receive(:approve_one).and_call_original
+
+        expect { MaxActiveJob.perform(*approval_require_approval_job.args) }.to raise_error
+
+        expect(Resque.logger).to have_received(:warn).with("Args:\n[]").exactly(2).times
+        expect(Resque::Plugins::Approve).to have_received(:approve_one).with("Some_Queue").exactly(2).times
+      end
+
+      it "approves the next item in the queue if non-default queue used" do
+        job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: [approval_key: "New Key"])
+
+        key_list.add_job(job)
+
+        allow(Resque.logger).to receive(:warn).and_call_original
+        allow(Resque::Plugins::Approve).to receive(:approve_one).and_call_original
+
+        MaxActiveJob.perform(*job.args)
+
+        expect(Resque.logger).to have_received(:warn).with("Args:\n[]").exactly(2).times
+        expect(Resque::Plugins::Approve).to have_received(:approve_one).with("New Key").exactly(2).times
+      end
+
+      it "approves the next item in the queue if non-default queue used and queue full" do
+        job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: [requires_approval: true])
+
+        10.times { num_queue.increment_running }
+        key_list.add_job(job)
+
+        allow(Resque.logger).to receive(:warn).and_call_original
+        allow(Resque::Plugins::Approve).to receive(:approve_one).and_call_original
+
+        MaxActiveJob.perform(*job.args)
+
+        expect(Resque::Plugins::Approve).to have_received(:approve_one).with("Some_Queue").exactly(2).times
+        expect(Resque.logger).to have_received(:warn).with("Args:\n[]").exactly(2).times
+        expect(num_queue.num_running.to_i).to eq 9
+      end
+
+      it "enqueues a job" do
+        allow(Resque.logger).to receive(:warn).and_call_original
+        allow(Resque::Plugins::Approve).to receive(:approve_one).and_call_original
+
+        Resque.enqueue MaxActiveJob, requires_approval: true
+
+        expect(Resque.logger).to have_received(:warn).with("Args:\n[]")
+        expect(Resque::Plugins::Approve).to have_received(:approve_one).with("Some_Queue")
+      end
+
+      it "enqueues a job with arguments" do
+        allow(Resque.logger).to receive(:warn).and_call_original
+        allow(Resque::Plugins::Approve).to receive(:approve_one).and_call_original
+
+        Resque.enqueue MaxActiveJob, param: "value", requires_approval: true
+
+        expect(Resque.logger).to have_received(:warn).with("Args:\n[{\"param\":\"value\"}]")
+        expect(Resque::Plugins::Approve).to have_received(:approve_one).with("Some_Queue")
+      end
+
+      it "does not enqueue a job if paused" do
+        num_queue.pause
+
+        expect(num_queue.num_jobs).to be_zero
+
+        allow(Resque.logger).to receive(:warn).and_call_original
+        allow(Resque::Plugins::Approve).to receive(:approve_one).and_call_original
+
+        Resque.enqueue MaxActiveJob, requires_approval: true
+
+        expect(Resque.logger).not_to have_received(:warn).with("Args:\n[]")
+        expect(Resque::Plugins::Approve).not_to have_received(:approve_one).with("Some_Queue")
+
+        expect(num_queue.num_jobs).to eq 1
+      end
+    end
   end
 
   describe "enqueue_job" do
@@ -322,5 +499,44 @@ RSpec.describe Resque::Plugins::Approve::PendingJob do
       expect(Resque::Plugins::Approve::ApprovalKeyList.new.num_queues).to eq 0
     end
   end
+
+  describe "max_active_jobs?" do
+    it "returns false if not set on class" do
+      expect(no_args_job.max_active_jobs?).to be_falsey
+    end
+
+    context "MaxActiveJob" do
+      let(:job_class) { MaxActiveJob }
+
+      it "returns true if a max is set" do
+        expect(no_args_job.max_active_jobs?).to be_truthy
+      end
+    end
+  end
+
+  describe "requires_approval" do
+    context "DefaultApprovalQueue" do
+      let(:job_class) { DefaultApprovalQueue }
+
+      it "sets the key to the default queue" do
+        expect(approval_require_approval_job.args).to eq []
+        expect(Resque::Plugins::Approve::PendingJob.new(approval_require_approval_job.id).args).to eq []
+        expect(approval_require_approval_job.approve_options).to eq("approval_key" => "Default Approval Queue", "requires_approval" => true)
+      end
+    end
+  end
+
+  describe "max_active_jobs" do
+    it "returns -1 if not set on class" do
+      expect(no_args_job.max_active_jobs).to eq(-1)
+    end
+
+    context "MaxActiveJob" do
+      let(:job_class) { MaxActiveJob }
+
+      it "returns value if max set" do
+        expect(no_args_job.max_active_jobs).to eq 10
+      end
+    end
+  end
 end
-# rubocop:enable Layout/AlignHash