resque-approve 0.0.7 → 0.0.15

data/lib/resque/plugins/approve/pending_job_queue.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
+
 module Resque
   module Plugins
     module Approve
@@ -15,6 +17,24 @@ module Resque
           @approval_key = approval_key
         end
 
+        def num_running
+          redis.get(running_key)
+        end
+
+        def reset_running
+          redis.set(running_key, 0)
+        end
+
+        def increment_running
+          Resque::Plugins::Approve::ApprovalKeyList.new.add_key approval_key
+          redis.incr(running_key)
+        end
+
+        def decrement_running
+          Resque::Plugins::Approve::ApprovalKeyList.new.add_key approval_key
+          redis.decr(running_key)
+        end
+
         def pause
           redis.set(pause_key, true)
           redis.set(paused_count_key, 0)
@@ -165,6 +185,10 @@ module Resque
           @pause_key ||= "approve.job_queue.#{approval_key}.paused"
         end
 
+        def running_key
+          @running_key ||= "approve.job_queue.#{approval_key}.running"
+        end
+
         def paused_count_key
           @paused_count_key ||= "approve.job_queue.#{approval_key}.paused.count"
         end
@@ -172,3 +196,5 @@ module Resque
     end
   end
 end
+
+# rubocop:enable Metrics/ClassLength

data/lib/resque/plugins/version.rb

@@ -3,7 +3,7 @@
 module Resque
   module Plugins
     module Approve
-      VERSION = "0.0.7"
+      VERSION = "0.0.15"
     end
   end
 end

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

@@ -2,12 +2,15 @@
   <tr>
     <td>
       <a href="<%= u("approve") %>/job_list?<%= { approval_key: pending_job.approval_key }.to_param %>">
-        <%= pending_job.approval_key %>
+        <%= pending_job.approval_key.presence || "&nbsp;&nbsp;&nbsp;".html_safe %>
       </a>
     </td>
     <td>
       <%= pending_job.num_jobs.to_i %>
     </td>
+    <td>
+      <%= pending_job.num_running.to_i %>
+    </td>
     <td>
       <% if pending_job.first_enqueued.present? %>
         <%= time_ago_in_words(pending_job.first_enqueued) %> ago

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

@@ -19,7 +19,7 @@
           (<%= job_details.queue_time %>)
         </td>
         <td>
-          <pre><code><%= "".html_safe + job_details.args.to_yaml %></code></pre>
+          <pre><code><%= "".html_safe + job_details.uncompressed_args.to_yaml %></code></pre>
         </td>
         <td>
           <pre><code><%= "".html_safe + job_details.approve_options.to_hash.to_yaml %></code></pre>

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<%= Resque::Plugins::Approve::VERSION %>
+</div>

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

@@ -41,7 +41,7 @@
         Params
       </td>
       <td>
-        <pre><code><%= "".html_safe + job_details.args.to_yaml %></code></pre>
+        <pre><code><%= "".html_safe + job_details.uncompressed_args.to_yaml %></code></pre>
       </td>
     </tr>
     <tr>
@@ -80,3 +80,6 @@
 <div class="approve_reset"/>
 
 <br/>
+<div>
+  Approval v<%= Resque::Plugins::Approve::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.
@@ -60,6 +64,11 @@
   </form>
 <% end %>
 
+<form method="POST" action="<%= u("approve/reset_running") %>?<%=
+  { approval_key: pending_queue.approval_key }.to_param %>">
+  <input type="submit" name="" value="Reset Running"/>
+</form>
+
 <% if pending_queue.paused? %>
   <form method="POST" action="<%= u("approve/resume") %>?<%=
     { approval_key: pending_queue.approval_key }.to_param %>">
@@ -74,3 +83,8 @@
 
 <div class="approve_reset"/>
 <br/>
+<div>
+  <p>
+    Approval v<%= Resque::Plugins::Approve::VERSION %>
+  </p>
+</div>

data/spec/approve/pending_job_queue_spec.rb

@@ -355,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

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,148 @@ 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).not_to eq ["approval_key" => "Some_Queue"]
+        expect(approval_require_approval_job.uncompressed_args).to eq ["approval_key" => "Some_Queue"]
+        expect(Resque::Plugins::Approve::PendingJob.new(approval_require_approval_job.id).uncompressed_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).not_to eq ["approval_key" => "Some_Queue"]
+        expect(approval_require_approval_job.uncompressed_args).to eq ["approval_key" => "Some_Queue"]
+        expect(Resque::Plugins::Approve::PendingJob.new(approval_require_approval_job.id).uncompressed_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 the 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 +501,84 @@ 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
+
+  describe "uncompressed_args" do
+    let(:test_args) { [1, "fred", "something else", 888, "approval_key" => "Some_Queue", "other_arg" => 1, "something else" => "something"] }
+    let(:compressed_args) { [{ :resque_compressed => true, :payload => MaxActiveJob.compressed_args(test_args) }] }
+    let(:job_class) { MaxActiveJob }
+
+    it "decompresses args" do
+      job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid,
+                                                     class_name: job_class,
+                                                     args:       compressed_args)
+
+      key_list.add_job(job)
+
+      expect(Resque::Plugins::Approve::PendingJob.new(job.id).uncompressed_args).to eq test_args
+    end
+
+    it "does not decompress args if not compressed" do
+      job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid,
+                                                     class_name: job_class,
+                                                     args:       test_args)
+
+      key_list.add_job(job)
+
+      expect(Resque::Plugins::Approve::PendingJob.new(job.id).uncompressed_args).to eq test_args
+    end
+
+    context "Not compressable" do
+      let(:test_args) { [1, "fred", "something else", 888, "other_arg" => 1, "something else" => "something"] }
+
+      it "does not decompress args if not compressable" do
+        job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid,
+                                                       class_name: BasicJob,
+                                                       args:       test_args)
+
+        key_list.add_job(job)
+
+        expect(Resque::Plugins::Approve::PendingJob.new(job.id).uncompressed_args).to eq test_args
+      end
+    end
+  end
 end
-# rubocop:enable Layout/AlignHash