resque-stages 0.0.1

data/spec/resque/plugins/stages/staged_group_stage_spec.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Resque::Plugins::Stages::StagedGroupStage do
+  let(:group) do
+    instance_double(Resque::Plugins::Stages::StagedGroup,
+                    add_stage:       nil,
+                    remove_stage:    nil,
+                    stage_completed: nil,
+                    group_id:        SecureRandom.uuid)
+  end
+  let(:stage) { Resque::Plugins::Stages::StagedGroupStage.new SecureRandom.uuid }
+  let(:load_stage) { Resque::Plugins::Stages::StagedGroupStage.new stage.group_stage_id }
+
+  RSpec.shared_examples("enqueues new jobs") do |enqueue_method, enqueue_method_parameters|
+    describe enqueue_method do
+      let(:enqueue_parameters) { [*enqueue_method_parameters, BasicJob, "This", 1, "is", "an" => "arglist"] }
+      let(:job) { load_stage.jobs.first }
+      let(:enqueued_parameters) { [*enqueue_method_parameters, BasicJob, { staged_job_id: job.job_id }, "This", 1, "is", "an" => "arglist"] }
+
+      before(:each) do
+        allow(Resque).to receive(enqueue_method).and_return nil
+      end
+
+      it "creates the job" do
+        stage.public_send(enqueue_method, *enqueue_parameters)
+
+        expect(load_stage.num_jobs).to eq 1
+
+        expect(job.args).to eq ["This", 1, "is", "an" => "arglist"]
+        expect(job.class_name).to eq "BasicJob"
+      end
+
+      it "does not enqueue the job is the status is pending" do
+        stage.public_send(enqueue_method, *enqueue_parameters)
+
+        expect(Resque).not_to have_received(enqueue_method)
+      end
+
+      it "enqueues the job if the status is running" do
+        stage.status = :running
+
+        stage.public_send(enqueue_method, *enqueue_parameters)
+
+        expect(Resque).to have_received(enqueue_method).with(*enqueued_parameters)
+      end
+
+      it "marks the job as queued if the status is running" do
+        stage.status = :running
+
+        stage.public_send(enqueue_method, *enqueue_parameters)
+
+        expect(load_stage.jobs.first.status).to eq :queued
+      end
+
+      it "enqueues the job and changes status to running if status is completed" do
+        stage.status = :complete
+
+        stage.public_send(enqueue_method, *enqueue_parameters)
+
+        expect(Resque).to have_received(enqueue_method).with(*enqueued_parameters)
+        expect(stage.status).to eq :running
+      end
+
+      it "marks the job as queued and changes status to running if status is completed" do
+        stage.status = :complete
+
+        stage.public_send(enqueue_method, *enqueue_parameters)
+
+        expect(load_stage.jobs.first.status).to eq :queued
+        expect(stage.status).to eq :running
+      end
+    end
+  end
+
+  describe "enqueuing jobs" do
+    it_behaves_like "enqueues new jobs", :enqueue, []
+    it_behaves_like "enqueues new jobs", :enqueue_to, ["queue"]
+    it_behaves_like "enqueues new jobs", :enqueue_at, [Time.now]
+    it_behaves_like "enqueues new jobs", :enqueue_at_with_queue, ["queue", Time.now]
+    it_behaves_like "enqueues new jobs", :enqueue_in, [12.seconds]
+    it_behaves_like "enqueues new jobs", :enqueue_in_with_queue, ["queue", 12.seconds]
+  end
+
+  describe "status" do
+    it "defaults to pending" do
+      expect(stage.status).to eq :pending
+    end
+
+    it "saves when set" do
+      stage.status = :running
+      expect(load_stage.status).to eq :running
+    end
+  end
+
+  describe "number" do
+    it "defaults to 1" do
+      expect(stage.number).to eq 1
+    end
+
+    it "saves when set" do
+      stage.number = 8
+      expect(load_stage.number).to eq 8
+    end
+  end
+
+  describe "staged_group" do
+    it "returns nil if staged_group_id is nil" do
+      expect(stage.staged_group).to be_nil
+    end
+
+    it "saves the staged_group_id" do
+      stage.staged_group = group
+
+      expect(load_stage.staged_group.group_id).to eq group.group_id
+    end
+
+    it "adds the stage to the group" do
+      stage.staged_group = group
+
+      expect(group).to have_received(:add_stage).with(stage)
+    end
+  end
+
+  context "with jobs" do
+    let(:jobs) do
+      build_jobs = [travel_to(5.hours.ago) { stage.enqueue(BasicJob, "a pending") },
+                    travel_to(2.hours.ago) { stage.enqueue(BasicJob, "z queued") },
+                    travel_to(4.hours.ago) { stage.enqueue(BasicJob, "h running") },
+                    travel_to(1.hours.ago) { stage.enqueue(BasicJob, "c pending_re_run") },
+                    travel_to(3.hours.ago) { stage.enqueue(BasicJob, "m failed") },
+                    travel_to(0.hours.ago) { stage.enqueue(BasicJob, "i successful") }]
+
+      build_jobs[0].status = :pending
+      build_jobs[1].status = :queued
+      build_jobs[2].status = :running
+      build_jobs[3].status = :pending_re_run
+      build_jobs[4].status = :failed
+      build_jobs[5].status = :successful
+
+      build_jobs[0].status_message = "y"
+      build_jobs[1].status_message = "g"
+      build_jobs[2].status_message = "l"
+      build_jobs[3].status_message = "q"
+      build_jobs[4].status_message = "r"
+      build_jobs[5].status_message = "b"
+
+      build_jobs
+    end
+
+    before(:each) do
+      allow(Resque).to receive(:enqueue).and_return nil
+    end
+
+    describe "paginated_jobs" do
+      it "paginates by class_name" do
+        jobs
+
+        expect(load_stage.paginated_jobs("class_name", "asc", 2, 2)).to eq [jobs[2], jobs[3]]
+      end
+
+      it "paginates by status" do
+        jobs
+
+        expect(load_stage.paginated_jobs("status", "asc", 2, 2)).to eq [jobs[3], jobs[1]]
+      end
+
+      it "paginates by status_message" do
+        jobs
+
+        expect(load_stage.paginated_jobs("status_message", "asc", 2, 2)).to eq [jobs[2], jobs[3]]
+      end
+
+      it "paginates by queue_time" do
+        jobs
+
+        expect(load_stage.paginated_jobs("queue_time", "asc", 2, 2)).to eq [jobs[4], jobs[1]]
+      end
+    end
+
+    describe "jobs" do
+      it "returns all jobs" do
+        jobs
+
+        expect(load_stage.jobs.length).to eq jobs.length
+        expect(load_stage.num_jobs).to eq jobs.length
+      end
+
+      %i[pending queued running pending_re_run failed successful].each.with_index do |status, index|
+        it "returns jobs based on status #{status}" do
+          jobs
+          expect(load_stage.jobs_by_status(status)).to eq [jobs[index]]
+        end
+
+        it "removes a job when it is deleted" do
+          jobs.sample.delete
+
+          expect(load_stage.jobs.length).to eq jobs.length - 1
+          expect(load_stage.num_jobs).to eq jobs.length - 1
+        end
+
+        it "deletes all jobs when deleted" do
+          jobs
+
+          stage.delete
+
+          expect(load_stage.jobs.length).to eq 0
+          expect(load_stage.num_jobs).to eq 0
+        end
+
+        it "removes the stage from the group when deleted" do
+          jobs
+
+          stage.staged_group = group
+          stage.delete
+
+          expect(group).to have_received(:remove_stage).with(stage)
+        end
+      end
+    end
+
+    describe "initiate" do
+      it "queues all pending jobs" do
+        allow(Resque).to receive(:enqueue).and_return nil
+
+        jobs
+
+        stage.initiate
+
+        expect(Resque).to have_received(:enqueue).with(BasicJob, { staged_job_id: jobs[0].job_id }, anything)
+        expect(Resque).not_to have_received(:enqueue).with(BasicJob, { staged_job_id: jobs[1].job_id }, anything)
+        expect(Resque).not_to have_received(:enqueue).with(BasicJob, { staged_job_id: jobs[2].job_id }, anything)
+        expect(Resque).not_to have_received(:enqueue).with(BasicJob, { staged_job_id: jobs[3].job_id }, anything)
+        expect(Resque).not_to have_received(:enqueue).with(BasicJob, { staged_job_id: jobs[4].job_id }, anything)
+        expect(Resque).not_to have_received(:enqueue).with(BasicJob, { staged_job_id: jobs[5].job_id }, anything)
+      end
+
+      it "changes the status to running" do
+        allow(Resque).to receive(:enqueue).and_return nil
+
+        jobs
+        stage.initiate
+
+        expect(stage.status).to eq :running
+      end
+    end
+
+    describe "job_completed" do
+      it "does nothing if not all jobs are completed" do
+        jobs
+
+        stage.job_completed
+
+        expect(group).not_to have_received(:stage_completed)
+        expect(stage.status).to eq :running
+      end
+
+      it "changes the status to complete if all jobs are completed" do
+        jobs.each { |job| job.status = :failed unless job.completed? }
+
+        expect(stage.status).to eq :complete
+      end
+
+      it "notifies the group if all jobs are completed" do
+        stage.staged_group = group
+
+        jobs.each do |job|
+          allow(job).to receive(:staged_group_stage).and_return(stage)
+        end
+        jobs.each { |job| job.status = :successful unless job.completed? }
+
+        expect(group).to have_received(:stage_completed)
+      end
+    end
+  end
+
+  describe "#order_param" do
+    it "returns asc for any column other than the current one" do
+      expect(load_stage.order_param("sort_option",
+                                    "current_sort",
+                                    %w[asc desc].sample)).to eq "asc"
+    end
+
+    it "returns desc for the current column if it is asc" do
+      expect(load_stage.order_param("sort_option", "sort_option", "asc")).to eq "desc"
+    end
+
+    it "returns asc for the current column if it is desc" do
+      expect(load_stage.order_param("sort_option", "sort_option", "desc")).to eq "asc"
+    end
+  end
+end

data/spec/resque/plugins/stages/staged_job_spec.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Resque::Plugins::Stages::StagedJob do
+  let(:stage) do
+    instance_double(Resque::Plugins::Stages::StagedGroupStage,
+                    add_job:        nil,
+                    remove_job:     nil,
+                    group_stage_id: SecureRandom.uuid,
+                    status:         :pending,
+                    "status=":      nil,
+                    job_completed:  nil)
+  end
+  let(:job) { Resque::Plugins::Stages::StagedJob.create_job(stage, BasicJob, "This", 1, :is, an: "arglist") }
+  let(:load_job) { Resque::Plugins::Stages::StagedJob.new(job.job_id) }
+
+  context "compressed job" do
+    let(:job) { Resque::Plugins::Stages::StagedJob.create_job(stage, CompressedJob, "This", 1, :is, an: "arglist") }
+    let(:enqueue_args) do
+      [{ resque_compressed: true,
+         payload:           CompressedJob.compressed_args([{ "staged_job_id" => job.job_id }, "This", 1, :is, an: "arglist"]),
+         staged_job_id:     job.job_id }]
+    end
+
+    describe "create" do
+      it "creates a new job" do
+        travel_to(Time.now) do
+          job
+          load_job
+
+          expect(load_job.class_name).to eq "CompressedJob"
+          expect(load_job.staged_group_stage.group_stage_id).to eq stage.group_stage_id
+          expect(load_job.enqueue_args).to eq [CompressedJob, *enqueue_args]
+          expect(load_job.args).to eq ["This", 1, "is", "an" => "arglist"]
+          expect(load_job.uncompressed_args).to eq ["This", 1, "is", "an" => "arglist"]
+          expect(load_job.status).to eq :pending
+          expect(load_job.queue_time).to eq Time.now
+        end
+      end
+    end
+
+    describe "enqueue_job" do
+      it "enqueues a job with the staging parameters" do
+        allow(Resque).to receive(:enqueue)
+
+        load_job.enqueue_job
+
+        expect(Resque).to have_received(:enqueue).with(CompressedJob, *enqueue_args)
+      end
+    end
+
+    describe "enqueue_args" do
+      it "returns the args for enqueing the job" do
+        expect(load_job.enqueue_args).to eq [CompressedJob, *enqueue_args]
+      end
+    end
+
+    describe "args" do
+      it "returns the args for the job" do
+        expect(load_job.args).to eq ["This", 1, "is", "an" => "arglist"]
+      end
+
+      it "returns the uncompressed args for the job" do
+        expect(load_job.uncompressed_args).to eq ["This", 1, "is", "an" => "arglist"]
+      end
+
+      it "defaults args to a blank array if nil" do
+        job.args = nil
+        job.save!
+
+        expect(load_job.args).to eq []
+      end
+    end
+  end
+
+  describe "create" do
+    it "creates a new job" do
+      travel_to(Time.now) do
+        job
+        load_job
+
+        expect(load_job.class_name).to eq "BasicJob"
+        expect(load_job.staged_group_stage.group_stage_id).to eq stage.group_stage_id
+        expect(load_job.args).to eq ["This", 1, "is", "an" => "arglist"]
+        expect(load_job.uncompressed_args).to eq ["This", 1, "is", "an" => "arglist"]
+        expect(load_job.status).to eq :pending
+        expect(load_job.queue_time).to eq Time.now
+      end
+    end
+
+    it "adds the job to the staged_group_stage" do
+      job
+      expect(stage).to have_received(:add_job).with(job)
+    end
+  end
+
+  describe "<=>" do
+    it "returns true for identical IDs" do
+      expect(job <=> load_job).to be_zero
+    end
+
+    it "returns false for different IDs" do
+      expect(Resque::Plugins::Stages::StagedJob.new(SecureRandom.uuid) <=> job).not_to be_zero
+    end
+
+    it "returns false for different objects" do
+      expect(job <=> job.job_id).to be_nil
+    end
+  end
+
+  describe "status" do
+    it "saves upon setting" do
+      job.status = :successful
+
+      expect(load_job.status).to eq :successful
+    end
+
+    it "pending sets the group to pending if the stage is completed" do
+      allow(stage).to receive(:status).and_return :complete
+
+      job.status = :pending
+
+      expect(stage).to have_received(:status=).with(:pending)
+    end
+
+    it "pending does nothing if the stage is pending" do
+      allow(stage).to receive(:status).and_return :pending
+
+      job.status = :pending
+
+      expect(stage).not_to have_received(:status=)
+    end
+
+    it "pending does nothing if the stage is running" do
+      allow(stage).to receive(:status).and_return :running
+
+      job.status = :pending
+
+      expect(stage).not_to have_received(:status=)
+    end
+
+    it "queued? changes the stage to running if stage is pending" do
+      allow(stage).to receive(:status).and_return :pending
+
+      job.status = :queued
+
+      expect(stage).to have_received(:status=).with(:running)
+    end
+
+    it "queued? does nothing if stage is running" do
+      allow(stage).to receive(:status).and_return :running
+
+      job.status = :queued
+
+      expect(stage).not_to have_received(:status=)
+    end
+
+    it "queued? changes the stage to running if stage is completed" do
+      allow(stage).to receive(:status).and_return :complete
+
+      job.status = :queued
+
+      expect(stage).to have_received(:status=).with(:running)
+    end
+
+    it "complete? changes notifies the stage" do
+      job.status = :failed
+
+      expect(stage).to have_received(:job_completed)
+    end
+  end
+
+  describe "status_message" do
+    it "saves upon setting" do
+      job.status_message = "This is a large status that we're just telling you about"
+
+      expect(load_job.status_message).to eq "This is a large status that we're just telling you about"
+    end
+  end
+
+  describe "delete" do
+    it "deletes the object" do
+      job.delete
+      expect(load_job.args).to be_empty
+    end
+
+    it "removes the object from the group stage" do
+      job.delete
+      expect(stage).to have_received(:remove_job).with(job)
+    end
+  end
+
+  describe "enqueue_job" do
+    it "enqueues a job with the staging parameters" do
+      allow(Resque).to receive(:enqueue)
+
+      load_job.enqueue_job
+
+      expect(Resque).to have_received(:enqueue).with(BasicJob, { staged_job_id: load_job.job_id }, "This", 1, "is", "an" => "arglist")
+    end
+
+    it "sets the jobs status to queued" do
+      allow(Resque).to receive(:enqueue)
+
+      load_job.enqueue_job
+
+      expect(load_job.status).to eq :queued
+    end
+
+    it "enqueues delayed jobs" do
+      allow(Resque).to receive(:enqueue_delayed_selection)
+
+      job.status = :pending_re_run
+
+      load_job.enqueue_job
+
+      expect(Resque).to have_received(:enqueue_delayed_selection)
+    end
+  end
+
+  describe "enqueue_args" do
+    it "returns the args for enqueing the job" do
+      expect(load_job.enqueue_args).to eq [BasicJob, { staged_job_id: job.job_id }, "This", 1, "is", "an" => "arglist"]
+    end
+  end
+
+  describe "args" do
+    it "returns the args for the job" do
+      expect(load_job.args).to eq ["This", 1, "is", "an" => "arglist"]
+    end
+
+    it "returns the uncompressed_args for the job" do
+      expect(load_job.uncompressed_args).to eq ["This", 1, "is", "an" => "arglist"]
+    end
+
+    it "defaults args to a blank array if nil" do
+      job.args = nil
+      job.save!
+
+      expect(load_job.args).to eq []
+    end
+  end
+
+  describe "staged_group_stage" do
+    it "returns a staged_group_stage object" do
+      expect(load_job.staged_group_stage).to be_a(Resque::Plugins::Stages::StagedGroupStage)
+    end
+
+    it "returns nil if the job does not exist" do
+      job.delete
+
+      expect(load_job.staged_group_stage).to be_nil
+    end
+  end
+
+  describe "completed?" do
+    %i[pending queued running pending_re_run].each do |status|
+      it "is not completed if status #{status}" do
+        job.status = status
+
+        expect(job.completed?).to be_falsey
+      end
+    end
+
+    %i[failed successful].each do |status|
+      it "is not completed if status #{status}" do
+        job.status = status
+
+        expect(job.completed?).to be_truthy
+      end
+    end
+  end
+
+  describe "queued?" do
+    %i[pending failed successful].each do |status|
+      it "is not completed if status #{status}" do
+        job.status = status
+
+        expect(job.queued?).to be_falsey
+      end
+    end
+
+    %i[queued running pending_re_run].each do |status|
+      it "is not completed if status #{status}" do
+        job.status = status
+
+        expect(job.queued?).to be_truthy
+      end
+    end
+  end
+
+  describe "pending?" do
+    %i[queued running failed successful].each do |status|
+      it "is not completed if status #{status}" do
+        job.status = status
+
+        expect(job.pending?).to be_falsey
+      end
+    end
+
+    %i[pending pending_re_run].each do |status|
+      it "is not completed if status #{status}" do
+        job.status = status
+
+        expect(job.pending?).to be_truthy
+      end
+    end
+  end
+
+  describe "blank?" do
+    it "is not blank if the job key exists" do
+      job
+
+      expect(load_job).to be_present
+    end
+
+    it "is blank if the job key is missing" do
+      job.delete
+
+      expect(load_job).to be_blank
+    end
+  end
+end