resque-approve 0.0.1

data/spec/approve/cleaner_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Resque::Plugins::Approve::Cleaner do
+  let!(:key_list) { Resque::Plugins::Approve::ApprovalKeyList.new }
+  let!(:keys) { Array.new(3) { Faker::Lorem.sentence } }
+  let!(:jobs) do
+    keys.map do |approval_key|
+      Array.new(3) do
+        job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: BasicJob, args: [approval_key: approval_key])
+
+        key_list.add_job(job)
+
+        job
+      end
+    end
+  end
+
+  describe "purge_all" do
+    it "deletes all jobs" do
+      Resque::Plugins::Approve::Cleaner.purge_all
+
+      jobs.flatten.each do |job|
+        expect(Resque::Plugins::Approve::PendingJob.new(job.id).class_name).to be_blank
+      end
+    end
+
+    it "deletes all queues" do
+      Resque::Plugins::Approve::Cleaner.purge_all
+
+      keys.each do |approval_key|
+        expect(Resque::Plugins::Approve::PendingJobQueue.new(approval_key).num_jobs).to be_zero
+      end
+    end
+
+    it "deletes all queue names" do
+      Resque::Plugins::Approve::Cleaner.purge_all
+
+      expect(key_list.num_queues).to be_zero
+    end
+  end
+
+  describe "cleanup_jobs" do
+    it "re-adds the job to the queue" do
+      job = jobs.first.first
+
+      queue = Resque::Plugins::Approve::PendingJobQueue.new(job.approval_key)
+
+      queue.remove_job(job)
+      expect(queue.num_jobs).to eq 2
+      expect(queue.jobs).not_to be_include(job)
+
+      Resque::Plugins::Approve::Cleaner.cleanup_jobs
+
+      queue = Resque::Plugins::Approve::PendingJobQueue.new(job.approval_key)
+
+      expect(queue.num_jobs).to eq 3
+      expect(queue.jobs).to be_include(job)
+    end
+
+    it "re-adds the queue to the list" do
+      job = jobs.first.first
+
+      key_list.remove_key(job.approval_key)
+
+      list = Resque::Plugins::Approve::ApprovalKeyList.new
+      expect(list.num_queues).to eq 2
+      expect(list.queues.map(&:approval_key)).not_to be_include(job.approval_key)
+
+      Resque::Plugins::Approve::Cleaner.cleanup_jobs
+
+      list = Resque::Plugins::Approve::ApprovalKeyList.new
+      expect(list.num_queues).to eq 3
+      expect(list.queues.map(&:approval_key)).to be_include(job.approval_key)
+    end
+  end
+
+  describe "cleanup_queues" do
+    it "removes empty queues" do
+      job = jobs.first.first
+
+      jobs.first.each(&:delete)
+
+      list = Resque::Plugins::Approve::ApprovalKeyList.new
+      expect(list.num_queues).to eq 3
+      expect(list.queues.map(&:approval_key)).to be_include(job.approval_key)
+
+      Resque::Plugins::Approve::Cleaner.cleanup_queues
+
+      list = Resque::Plugins::Approve::ApprovalKeyList.new
+      expect(list.num_queues).to eq 2
+      expect(list.queues.map(&:approval_key)).not_to be_include(job.approval_key)
+    end
+  end
+end

data/spec/approve/pending_job_queue_spec.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Resque::Plugins::Approve::PendingJobQueue do
+  let(:key_list) { Resque::Plugins::Approve::ApprovalKeyList.new }
+  let!(:key) { Faker::Lorem.sentence }
+  let(:job_queue) { Resque::Plugins::Approve::PendingJobQueue.new(key) }
+  let(:job_class) { BasicJob }
+  let!(:jobs) do
+    Array.new(4) do |index|
+      Timecop.freeze((5 - index).hours.ago) do
+        job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: [index, approval_key: key])
+
+        key_list.add_job(job)
+
+        job
+      end
+    end
+  end
+
+  before(:each) do
+    allow(Resque).to receive(:enqueue_to).and_call_original
+  end
+
+  describe "delete" do
+    it "deletes all jobs" do
+      job_queue.delete
+
+      jobs.flatten.each do |job|
+        expect(Resque::Plugins::Approve::PendingJob.new(job.id).class_name).to be_blank
+      end
+    end
+
+    it "removes all jobs from the queue" do
+      job_queue.delete
+
+      expect(job_queue.num_jobs).to eq 0
+    end
+
+    it "does not remove the key from the key_list" do
+      job_queue.delete
+
+      expect(key_list.queue_keys).to be_include key
+    end
+
+    context("auto-delete") do
+      let(:job_class) { AutoDeleteApprovalKeyJob }
+
+      it "removes the key from the key_list" do
+        job_queue.delete
+
+        expect(key_list.queue_keys).not_to be_include key
+      end
+    end
+  end
+
+  describe "verify_job" do
+    let(:other_key) { Faker::Lorem.sentence }
+
+    it "adds the queue to the list" do
+      job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: [approval_key: other_key])
+
+      job.save!
+
+      expect(key_list.queue_keys).not_to be_include other_key
+
+      job_queue.verify_job(job)
+
+      expect(Resque::Plugins::Approve::ApprovalKeyList.new.queue_keys).to be_include other_key
+    end
+
+    it "adds the job to the list" do
+      job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: [approval_key: other_key])
+
+      job.save!
+
+      expect(job_queue.jobs).not_to be_include job
+
+      job_queue.verify_job(job)
+
+      expect(job_queue.jobs).to be_include job
+
+      expect { job_queue.verify_job(job) }.not_to(change { job_queue.num_jobs })
+    end
+  end
+
+  describe "approve_one" do
+    it "enqueues the first job" do
+      job_queue.approve_one
+
+      expect(Resque).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.num_jobs).to eq 3
+    end
+  end
+
+  describe "pop_job" do
+    it "enqueues the last job" do
+      job_queue.pop_job
+
+      expect(Resque).to have_received(:enqueue_to).with "Some_Queue", BasicJob, 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(job_queue.jobs).not_to be_include jobs[3]
+      expect(job_queue.num_jobs).to eq 3
+    end
+  end
+
+  describe "approve_all" do
+    it "enqueues all jobs" do
+      job_queue.approve_all
+
+      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).to have_received(:enqueue_to).with "Some_Queue", BasicJob, 3
+
+      expect(job_queue.jobs).to be_blank
+    end
+  end
+
+  describe "remove_one" do
+    it "enqueues the first job" do
+      job_queue.remove_one
+
+      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.num_jobs).to eq 3
+    end
+  end
+
+  describe "remove_job_pop" do
+    it "enqueues the last job" do
+      job_queue.remove_job_pop
+
+      expect(Resque).not_to have_received(:enqueue_to).with "Some_Queue", BasicJob, 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(job_queue.jobs).not_to be_include jobs[3]
+      expect(job_queue.num_jobs).to eq 3
+    end
+  end
+
+  describe "remove_all" do
+    it "enqueues all jobs" do
+      job_queue.remove_all
+
+      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_blank
+    end
+  end
+
+  describe "paged_jobs" do
+    let!(:jobs) do
+      Array.new(30) do |index|
+        job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: [index, approval_key: key])
+
+        key_list.add_job(job)
+
+        job
+      end
+    end
+
+    it "defaults to the first 20 jobs" do
+      expect(job_queue.paged_jobs).to eq jobs[0..19]
+    end
+
+    it "pages jobs" do
+      expect(job_queue.paged_jobs(4, 3)).to eq jobs[9..11]
+    end
+
+    it "deals with too small a page" do
+      expect(job_queue.paged_jobs(-4, 3)).to eq jobs[0..2]
+    end
+
+    it "deals with too large a page" do
+      expect(job_queue.paged_jobs(400, 3)).to eq jobs[0..2]
+    end
+
+    it "deals with invalid page size" do
+      expect(job_queue.paged_jobs(4, 0)).to eq jobs[0..19]
+    end
+  end
+
+  describe "num_jobs" do
+    it "returns the number of jobs" do
+      expect(job_queue.num_jobs).to eq 4
+    end
+  end
+
+  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)
+
+        job_queue.remove_one
+      end
+
+      expect(job_queue.first_enqueued).to be_nil
+    end
+  end
+end

data/spec/approve/pending_job_spec.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+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 }
+  let(:job_queue) { Resque::Plugins::Approve::PendingJobQueue.new(key) }
+  let(:job_class) { BasicJob }
+  let(:no_args_job) do
+    job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: nil)
+
+    key_list.add_job(job)
+
+    job
+  end
+  let(:no_hash_args_job) do
+    job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: [1, "fred", "something else", 888])
+
+    key_list.add_job(job)
+
+    job
+  end
+  let(:hash_args_job) do
+    job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid,
+                                                   class_name: job_class,
+                                                   args:       [1, "fred", "something else", 888, other_arg: 1, "something else" => "something"])
+
+    key_list.add_job(job)
+
+    job
+  end
+  let(:approval_only_args_job) do
+    job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid, class_name: job_class, args: [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,
+                                                   args:       [1, "fred", "something else", 888, approval_key: key])
+
+    key_list.add_job(job)
+
+    job
+  end
+  let(:approval_hash_args_job) do
+    job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid,
+                                                   class_name: job_class,
+                                                   args:       [1,
+                                                                "fred",
+                                                                "something else",
+                                                                888,
+                                                                other_arg:       1,
+                                                                "approval_key"   => key,
+                                                                "something else" => "something"])
+
+    key_list.add_job(job)
+
+    job
+  end
+  let(:approval_all_args_job) do
+    job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid,
+                                                   class_name: job_class,
+                                                   args:       [1,
+                                                                "fred",
+                                                                "something else",
+                                                                888,
+                                                                approval_queue:  "Another Queue",
+                                                                approval_at:     2.hours.from_now,
+                                                                other_arg:       1,
+                                                                "approval_key"   => key,
+                                                                "something else" => "something"])
+
+    key_list.add_job(job)
+
+    job
+  end
+
+  before(:each) do
+    allow(Resque).to receive(:enqueue_to).and_call_original
+  end
+
+  describe "initialize" do
+    it "extracts delay arguments from job with no argument" do
+      expect(no_args_job.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(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(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(approval_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(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(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(approval_all_args_job.approve_options[:approval_key]).to eq key
+      expect(approval_all_args_job.approve_options["approval_key"]).to eq key
+
+      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)
+    end
+  end
+
+  describe "<=>" do
+    let(:a_job) { Resque::Plugins::Approve::PendingJob.new("A") }
+    let(:a_job_too) { Resque::Plugins::Approve::PendingJob.new("A") }
+    let(:b_job) { Resque::Plugins::Approve::PendingJob.new("B") }
+
+    it "compares two jobs" do
+      expect(no_hash_args_job).not_to eq no_args_job
+      expect(no_hash_args_job).to eq Resque::Plugins::Approve::PendingJob.new(no_hash_args_job.id)
+    end
+
+    it "compares <" do
+      expect(a_job).to be < b_job
+    end
+
+    it "compares >" do
+      expect(b_job).to be > a_job
+    end
+
+    it "compares <=" do
+      expect(a_job).to be <= b_job
+      expect(a_job).to be <= a_job_too
+    end
+
+    it "compares >=" do
+      expect(b_job).to be >= a_job
+      expect(a_job).to be >= a_job
+    end
+  end
+
+  RSpec.shared_examples "pending job attributes" do
+    it "has a class_name" do
+      expect(job.class_name).to eq "BasicJob"
+    end
+
+    it "has args" do
+      expect(job.args).to eq [1, "fred", "something else", 888, "other_arg" => 1, "something else" => "something"]
+    end
+
+    it "has the approval_key" do
+      expect(job.approval_key).to eq key
+    end
+
+    it "has the approval_queue" do
+      expect(job.approval_queue).to eq "Another Queue"
+    end
+
+    it "has the approval_at" do
+      expect(job.approval_at).to be_within(1.second).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)
+    end
+
+    it "has the queue" do
+      expect(job.queue.approval_key).to eq key
+    end
+  end
+
+  describe "initialized object" do
+    let(:job) { approval_all_args_job }
+
+    before(:each) do
+      job
+
+      Timecop.freeze(2.hours.ago) do
+        job.save!
+      end
+    end
+
+    it_behaves_like "pending job attributes"
+  end
+
+  describe "saved object" do
+    let(:job) { Resque::Plugins::Approve::PendingJob.new(approval_all_args_job.id) }
+
+    before(:each) do
+      approval_all_args_job
+
+      Timecop.freeze(2.hours.ago) do
+        approval_all_args_job.save!
+      end
+    end
+
+    it_behaves_like "pending job attributes"
+  end
+
+  describe "approval_queue" do
+    it "returns the classes default queue" do
+      expect(no_args_job.approval_queue).to eq "Some_Queue"
+    end
+  end
+
+  describe "requires_approval?" do
+    it "requires_approval only if approval_key is set" do
+      expect(no_args_job).not_to be_requires_approval
+      expect(no_hash_args_job).not_to be_requires_approval
+      expect(hash_args_job).not_to be_requires_approval
+      expect(approval_only_args_job).to be_requires_approval
+      expect(approval_no_hash_args_job).to be_requires_approval
+      expect(approval_hash_args_job).to be_requires_approval
+      expect(approval_all_args_job).to be_requires_approval
+
+      job = Resque::Plugins::Approve::PendingJob.new(SecureRandom.uuid,
+                                                     class_name: job_class,
+                                                     args:       [1,
+                                                                  "fred",
+                                                                  "something else",
+                                                                  888,
+                                                                  approval_queue:  "Another Queue",
+                                                                  approval_at:     2.hours.from_now,
+                                                                  other_arg:       1,
+                                                                  "something else" => "something"])
+
+      expect(job).not_to be_requires_approval
+    end
+  end
+
+  describe "enqueue_job" do
+    it "enqueues the job without any parameters" do
+      no_args_job.enqueue_job
+
+      expect(Resque).to have_received(:enqueue_to).with("Some_Queue", BasicJob)
+    end
+
+    it "enqueues the job without any parameters" do
+      key_list.add_job(no_args_job)
+
+      no_args_job.enqueue_job
+    end
+
+    it "delay enqueues a job" do
+      allow(Resque).to receive(:enqueue_at_with_queue).and_call_original
+
+      Timecop.freeze do
+        approval_all_args_job.enqueue_job
+
+        expect(Resque).
+            to have_received(:enqueue_at_with_queue).
+                with("Another Queue",
+                     2.hours.from_now,
+                     BasicJob,
+                     1,
+                     "fred",
+                     "something else",
+                     888,
+                     "other_arg"      => 1,
+                     "something else" => "something")
+      end
+    end
+  end
+
+  describe "delete" do
+    it "works with an already deleted job" do
+      no_args_job.delete
+
+      expect { Resque::Plugins::Approve::PendingJob.new(no_args_job.id).delete }.not_to raise_exception
+    end
+
+    it "deletes the job" do
+      no_args_job.delete
+
+      expect(Resque::Plugins::Approve::PendingJob.new(no_args_job.id).class_name).not_to be
+    end
+
+    it "removes the job from the queue" do
+      no_args_job.delete
+
+      expect(Resque::Plugins::Approve::PendingJobQueue.new(key).num_jobs).to be_zero
+    end
+
+    it "does not remoe the queue" do
+      no_args_job.delete
+
+      expect(key_list.num_queues).to eq 1
+    end
+
+    it "does delete the queue if the class says to" do
+      job = Resque::Plugins::Approve::PendingJob.new SecureRandom.uuid,
+                                                     class_name: AutoDeleteApprovalKeyJob,
+                                                     args:       [approval_key: key]
+
+      key_list.add_job(job)
+
+      expect(Resque::Plugins::Approve::ApprovalKeyList.new.num_queues).to eq 1
+      expect(Resque::Plugins::Approve::PendingJobQueue.new(key).num_jobs).to eq 1
+
+      job.delete
+
+      expect(Resque::Plugins::Approve::PendingJobQueue.new(key).num_jobs).to eq 0
+      expect(Resque::Plugins::Approve::ApprovalKeyList.new.num_queues).to eq 0
+    end
+  end
+end
+# rubocop:enable Layout/AlignHash