Feature/appeals 44915.uat 4.4.0

app/jobs/return_legacy_appeals_to_board_job.rb

@@ -7,15 +7,20 @@ class ReturnLegacyAppealsToBoardJob < CaseflowJob
 
   queue_as :low_priority
   application_attr :queue
-  NO_RECORDS_MOVED_MESSAGE = [Constants.DISTRIBUTION.no_records_moved_message].freeze
+
+  def initialize
+    @no_records_found_message = [Constants.DISTRIBUTION.no_records_moved_message].freeze
+    @nonsscavlj_number_of_appeals_limit = CaseDistributionLever.nonsscavlj_number_of_appeals_to_move || 0
+    @nonsscavlj_number_of_appeals_to_move = @nonsscavlj_number_of_appeals_limit - 1
+  end
 
   def perform
     begin
       returned_appeal_job = create_returned_appeal_job
 
       appeals, moved_appeals = eligible_and_moved_appeals
 
-      return send_job_slack_report(NO_RECORDS_MOVED_MESSAGE) if moved_appeals.nil?
+      return send_job_slack_report(@no_records_found_message) if moved_appeals.nil?
 
       complete_returned_appeal_job(returned_appeal_job, "Job completed successfully", moved_appeals)
 
@@ -74,10 +79,6 @@ def count_unique_bfkeys(appeals)
 
   private
 
-  def max_appeals_to_move
-    CaseDistributionLever.nonsscavlj_number_of_appeals_to_move
-  end
-
   def move_qualifying_appeals(appeals)
     qualifying_appeals_bfkeys = []
 
@@ -113,13 +114,11 @@ def get_tied_appeal_bfkeys(tied_appeals)
   end
 
   def update_qualifying_appeals_bfkeys(tied_appeals_bfkeys, qualifying_appeals_bfkeys)
-    max_appeals = max_appeals_to_move
-
     if tied_appeals_bfkeys.any?
-      if tied_appeals_bfkeys.count < max_appeals
+      if tied_appeals_bfkeys.count < @nonsscavlj_number_of_appeals_limit
         qualifying_appeals_bfkeys.push(tied_appeals_bfkeys)
       else
-        qualifying_appeals_bfkeys.push(tied_appeals_bfkeys[0..max_appeals])
+        qualifying_appeals_bfkeys.push(tied_appeals_bfkeys[0..@nonsscavlj_number_of_appeals_to_move])
       end
     end
 

spec/factories/case_distribution_lever.rb

@@ -500,5 +500,16 @@
       lever_group_order { 103 }
       control_group { "priority" }
     end
+
+    trait :nonsscavlj_number_of_appeals_to_move do
+      item { "nonsscavlj_number_of_appeals_to_move" }
+      title { "Non-SSC/AVLJ Number of Appeals to Move" }
+      data_type { "number" }
+      value { 2 }
+      unit { "" }
+      algorithms_used { [] }
+      lever_group { "internal" }
+      lever_group_order { 999 }
+    end
   end
 end

spec/jobs/push_priority_appeals_to_judges_job_spec.rb

@@ -13,6 +13,7 @@
     create(:case_distribution_lever, :ama_hearing_case_aod_affinity_days)
     create(:case_distribution_lever, :ama_direct_review_start_distribution_prior_to_goals)
     create(:case_distribution_lever, :disable_legacy_non_priority)
+    create(:case_distribution_lever, :nonsscavlj_number_of_appeals_to_move)
   end
 
   def to_judge_hash(arr)
@@ -230,7 +231,7 @@
         allow_any_instance_of(PushPriorityAppealsToJudgesJob).to receive(:eligible_judges).and_return(eligible_judges)
       end
 
       xit "should only distribute the ready priority cases tied to a judge" do
         expect(subject.count).to eq eligible_judges.count
         expect(subject.map { |dist| dist.statistics["batch_size"] }).to match_array [2, 2, 0, 0]
 
@@ -262,7 +263,7 @@
           create(:case_distribution_lever, :disable_legacy_priority, value: "false")
         end
 
         xit "should only distribute the ready priority cases tied to a judge" do
           expect(subject.count).to eq eligible_judges.count
           expect(subject.map { |dist| dist.statistics["batch_size"] }).to match_array [2, 2, 0, 0]
 
@@ -288,7 +289,7 @@
             create(:case_distribution_lever, :disable_ama_priority_evidence_submission, value: "false")
           end
 
           xit "should distribute the ready priority cases" do
             expect(subject.count).to eq eligible_judges.count
             expect(subject.map { |dist| dist.statistics["batch_size"] }).to match_array [2, 2, 0, 0]
 
@@ -312,7 +313,7 @@
             create(:case_distribution_lever, :disable_ama_priority_evidence_submission, value: "true")
           end
 
           xit "should not distribute the ready priority cases" do
             expect(subject.count).to eq eligible_judges.count
             expect(subject.map { |dist| dist.statistics["batch_size"] }).to match_array [0, 0, 0, 0]
 

spec/jobs/return_legacy_appeals_to_board_job_spec.rb

@@ -3,61 +3,75 @@
 describe ReturnLegacyAppealsToBoardJob, :all_dbs do
   describe "#perform" do
     let(:job) { described_class.new }
-    context "when successful" do
-      it "creates a ReturnedAppealJob instance and updates its status" do
-        expect do
-          job.perform
-        end.to change { ReturnedAppealJob.count }.by(1)
+    let(:returned_appeal_job) { instance_double("ReturnedAppealJob", id: 1) }
+    let(:appeals) { [{ "bfkey" => "1", "priority" => 1 }, { "bfkey" => "2", "priority" => 0 }] }
+    let(:moved_appeals) { [{ "bfkey" => "1", "priority" => 1 }] }
 
-        returned_appeal_job = ReturnedAppealJob.last
-        expect(returned_appeal_job.started_at).to be_present
+    before do
+      allow(CaseDistributionLever).to receive(:nonsscavlj_number_of_appeals_to_move).and_return(2)
 
-        if returned_appeal_job.errored_at
-          expect(JSON.parse(returned_appeal_job.stats)["message"]).to include("Job failed with error")
-        else
-          expect(returned_appeal_job.completed_at).to be_present
-          expect(JSON.parse(returned_appeal_job.stats)["message"]).to eq("Job completed successfully")
-        end
-      end
+      allow(job).to receive(:create_returned_appeal_job).and_return(returned_appeal_job)
+      allow(returned_appeal_job).to receive(:update!)
+      allow(job).to receive(:eligible_and_moved_appeals).and_return([appeals, moved_appeals])
+      allow(job).to receive(:filter_appeals).and_return({})
+      allow(job).to receive(:send_job_slack_report)
+      allow(job).to receive(:complete_returned_appeal_job)
+      allow(job).to receive(:metrics_service_report_runtime)
+    end
+
+    context "when the job completes successfully" do
+      it "creates a ReturnedAppealJob instance, processes appeals, and sends a report" do
+        allow(job).to receive(:slack_report).and_return(["Job completed successfully"])
+
+        job.perform
 
-      it "records runtime metrics" do
-        allow(MetricsService).to receive(:record_runtime)
-        expect do
-          job.perform
-        end.to change { ReturnedAppealJob.count }.by(1)
-        expect(MetricsService).to have_received(:record_runtime).with(
-          hash_including(metric_group: "return_legacy_appeals_to_board_job")
-        )
+        expect(job).to have_received(:create_returned_appeal_job).once
+        expect(job).to have_received(:eligible_and_moved_appeals).once
+        expect(job).to have_received(:complete_returned_appeal_job)
+          .with(returned_appeal_job, "Job completed successfully", moved_appeals).once
+        expect(job).to have_received(:send_job_slack_report).with(["Job completed successfully"]).once
+        expect(job).to have_received(:metrics_service_report_runtime)
+          .with(metric_group_name: "return_legacy_appeals_to_board_job").once
       end
     end
 
-    context "when an error occurs" do
-      let(:error_message) { "Something went wrong" }
-
+    context "when no appeals are moved" do
       before do
-        allow(job).to receive(:send_job_slack_report).and_raise(StandardError, error_message)
+        allow(job).to receive(:eligible_and_moved_appeals).and_return([appeals, nil])
+        allow(job).to receive(:slack_report).and_return(["Job Ran Successfully, No Records Moved"])
       end
 
-      it "updates the ReturnedAppealJob with error details" do
-        expect do
-          job.perform
-        end.to change { ReturnedAppealJob.count }.by(1)
+      it "sends a no records moved Slack report" do
+        job.perform
 
-        returned_appeal_job = ReturnedAppealJob.last
-        expect(returned_appeal_job.errored_at).to be_present
-        expect(JSON.parse(returned_appeal_job.stats)["message"]).to include("Job failed with error")
+        expect(job).to have_received(:send_job_slack_report).with(["Job Ran Successfully, No Records Moved"]).once
+        expect(job).to have_received(:metrics_service_report_runtime).once
       end
+    end
 
-      it "sends an error notification via Slack" do
-        expect_any_instance_of(SlackService).to receive(:send_notification).with(
-          a_string_matching(/<!here>\n \[ERROR\]/), job.class.name
-        )
-        job.perform
+    context "when an error occurs" do
+      let(:error_message) { "Unexpected error" }
+      let(:slack_service_instance) { instance_double(SlackService) }
+
+      before do
+        allow(job).to receive(:eligible_and_moved_appeals).and_raise(StandardError, error_message)
+        allow(job).to receive(:log_error)
+        allow(returned_appeal_job).to receive(:update!)
+        allow(SlackService).to receive(:new).and_return(slack_service_instance)
+        allow(slack_service_instance).to receive(:send_notification)
       end
 
-      it "logs the error" do
-        expect(job).to receive(:log_error).with(anything)
+      it "handles the error, logs it, and sends a Slack notification" do
         job.perform
+
+        expect(job).to have_received(:log_error).with(instance_of(StandardError))
+        expect(returned_appeal_job).to have_received(:update!)
+          .with(hash_including(errored_at: kind_of(Time),
+                               stats: "{\"message\":\"Job failed with error: #{error_message}\"}")).once
+        expect(slack_service_instance).to have_received(:send_notification).with(
+          a_string_matching(/<!here>\n \[ERROR\]/), job.class.name
+        ).once
+        expect(job).to have_received(:metrics_service_report_runtime).once
       end
     end
   end