jcroteau/APPEALS-23894 - Close VeteranRecordRequest tasks for Veterans Readiness and Employment (VRE) business line

app/queries/veteran_record_requests_open_for_vre_query.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class VeteranRecordRequestsOpenForVREQuery
+  # @return [ActiveRecord::Relation] VeteranRecordRequest tasks that are
+  #   both open and assigned to the 'Veterans Readiness and Employment' business
+  #   line (f.k.a 'Vocational Rehabilitation and Employment')
+  def self.call
+    vre_business_line =
+      BusinessLine.where(name: Constants::BENEFIT_TYPES["voc_rehab"])
+
+    VeteranRecordRequest.open.where(assigned_to: vre_business_line)
+  end
+end

lib/helpers/cancel_tasks_and_descendants.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+class CancelTasksAndDescendants
+  LOG_TAG = "CancelTasksAndDescendants"
+
+  # Cancels all tasks and descendant tasks for given Task relation
+  #
+  # @param task_relation [ActiveRecord::Relation] tasks to be cancelled
+  # @return [NilClass]
+  def self.call(task_relation = Task.none)
+    new(task_relation).__send__(:call)
+  end
+
+  private
+
+  def initialize(task_relation)
+    @task_relation = task_relation
+    @request_id = SecureRandom.uuid
+    @logs = []
+  end
+
+  def call
+    RequestStore[:current_user] = User.system_user
+
+    with_paper_trail_options do
+      log_time_elapsed { log_task_count_before_and_after { cancel_tasks } }
+      print_logs_to_stdout
+    end
+  end
+
+  # @note Temporarily sets the PaperTrail request options and executes the given
+  #   block. The request options are only in effect on the current thread for
+  #   the duration of the block.
+  #   This is needed so that the PaperTrail `versions` records for cancelled
+  #   tasks reflect the appropriate `whodunnit` and `request_id`.
+  def with_paper_trail_options(&block)
+    options = { whodunnit: User.system_user.id,
+                controller_info: { request_id: @request_id } }
+
+    PaperTrail.request(options, &block)
+  end
+
+  def cancel_tasks
+    @task_relation.find_each do |task|
+      log_cancelled(task) { task.cancel_task_and_child_subtasks }
+    rescue StandardError => error
+      log_errored(task, error)
+    end
+  end
+
+  def log_cancelled(task, &block)
+    task_ids = cancellable_descendants_for(task).pluck(:id)
+    yield(block)
+    log("Task ids #{task_ids} cancelled successfully")
+  end
+
+  def log_errored(task, error)
+    task_ids = cancellable_descendants_for(task).pluck(:id)
+    log("Task ids #{task_ids} not cancelled due to error - #{error}",
+        level: :error)
+  end
+
+  def cancellable_descendants_for(task)
+    # Note: The result of `Task #descendants` also includes the instance itself
+    Task.open.where(id: task.descendants)
+  end
+
+  def log_task_count_before_and_after(&block)
+    initial_count = count_of_cancellable_tasks
+    log_total_tasks_for_cancellation(initial_count)
+    yield(block)
+    final_count = initial_count - count_of_cancellable_tasks
+    log_cancelled_successfully(final_count)
+  end
+
+  def count_of_cancellable_tasks
+    sum = 0
+    @task_relation.find_each do |task|
+      sum += cancellable_descendants_for(task).count
+    end
+    sum
+  end
+
+  def log_total_tasks_for_cancellation(count)
+    log("Total tasks for cancellation: #{count}")
+  end
+
+  def log_cancelled_successfully(count)
+    log("Tasks cancelled successfully: #{count}")
+  end
+
+  def log_time_elapsed(&block)
+    time_elapsed_in_seconds = Benchmark.realtime(&block)
+    log("Elapsed time (sec): #{time_elapsed_in_seconds}")
+  end
+
+  def log(message, level: :info)
+    append_to_application_logs(level, message)
+    append_to_logs_for_stdout(message)
+  end
+
+  def append_to_application_logs(level, message)
+    Rails.logger.tagged(LOG_TAG, @request_id) do
+      Rails.logger.public_send(level, message)
+    end
+  end
+
+  def append_to_logs_for_stdout(message)
+    @logs << "[#{LOG_TAG}] [#{@request_id}] #{message}"
+  end
+
+  def print_logs_to_stdout
+    puts @logs
+  end
+end

lib/tasks/remediations/cancel_vrr_tasks_open_for_vre.rake

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "../../../lib/helpers/cancel_tasks_and_descendants"
+
+namespace :remediations do
+  desc "Cancel VeteranRecordRequest tasks that are both open and assigned to " \
+       "the 'Veterans Readiness and Employment' business line"
+  task :cancel_vrr_tasks_open_for_vre => [:environment] do
+    CancelTasksAndDescendants.call(
+      VeteranRecordRequestsOpenForVREQuery.call
+    )
+  end
+end

spec/factories/organization.rb

@@ -70,6 +70,11 @@
       type { "BusinessLine" }
     end
 
+    factory :vre_business_line, class: BusinessLine do
+      type { "BusinessLine" }
+      name { Constants::BENEFIT_TYPES["voc_rehab"] }
+    end
+
     factory :hearings_management do
       type { "HearingsManagement" }
       name { "Hearings Management" }

spec/helpers/cancel_tasks_and_descendants_spec.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "helpers/cancel_tasks_and_descendants"
+require "securerandom"
+
+describe CancelTasksAndDescendants do
+  describe ".call" do
+    context "when task_relation is not given" do
+      subject(:call) { described_class.call }
+
+      it "assigns RequestStore[:current_user]" do
+        expect { call }.to change { RequestStore[:current_user] }.
+          from(nil).to(User.system_user)
+      end
+
+      it "appends appropriate logs to application logs" do
+        rails_logger = Rails.logger
+        allow(Rails).to receive(:logger).and_return(rails_logger)
+
+        aggregate_failures do
+          expect(rails_logger).to receive(:info)
+            .with("Total tasks for cancellation: 0").ordered
+
+          expect(rails_logger).not_to receive(:info)
+            .with(/Task ids \[.+\] cancelled successfully/)
+
+          expect(rails_logger).to receive(:info)
+            .with(/Tasks cancelled successfully: 0/).ordered
+
+          expect(rails_logger).to receive(:info)
+            .with(/Elapsed time \(sec\):/).ordered
+        end
+
+        call
+      end
+
+      it "appends appropriate logs to stdout" do
+        allow(SecureRandom).to receive(:uuid) { "dummy-request-id" }
+
+        expect { call }.to output(
+          match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Total tasks for cancellation: 0"))
+          .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Tasks cancelled successfully: 0"))
+          .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Elapsed time (sec):"))
+        ).to_stdout
+      end
+
+      it { is_expected.to be_nil }
+    end
+
+    context "when task_relation is given " do
+      subject(:call) { described_class.call(task_relation) }
+
+      let(:task_relation) { Task.where(id: [task_1, task_2, task_3]) }
+      let(:task_1) { create(:veteran_record_request_task) }
+      let(:task_2) { create(:veteran_record_request_task) }
+      let(:task_3) { create(:veteran_record_request_task) }
+
+      before do
+        expect(task_relation).to receive(:find_each).at_least(:once)
+          .and_yield(task_1)
+          .and_yield(task_2)
+          .and_yield(task_3)
+
+        allow(task_1).to receive(:self_and_descendants) { [task_1] }
+        allow(task_2).to receive(:self_and_descendants) { [task_2] }
+        allow(task_3).to receive(:self_and_descendants) { [task_3] }
+      end
+
+      it "cancels each task and its descendants" do
+        aggregate_failures do
+          expect(task_1).to receive(:cancel_task_and_child_subtasks)
+          expect(task_2).to receive(:cancel_task_and_child_subtasks)
+          expect(task_3).to receive(:cancel_task_and_child_subtasks)
+        end
+        call
+      end
+
+      it "sets PaperTrail versions data appropriately for cancelled tasks" do
+        request_id = SecureRandom.uuid
+        allow(SecureRandom).to receive(:uuid) { request_id }
+
+        call
+
+        task_1_version = task_1.versions.last
+        expect(task_1_version.whodunnit).to eq(User.system_user.id.to_s)
+        expect(task_1_version.request_id).to eq(request_id)
+      end
+
+      it "appends appropriate logs to application logs" do
+        rails_logger = Rails.logger
+        allow(Rails).to receive(:logger).and_return(rails_logger)
+
+        aggregate_failures do
+          expect(rails_logger).to receive(:info)
+            .with("Total tasks for cancellation: 3").ordered
+
+          expect(rails_logger).to receive(:info)
+            .with(/Task ids \[#{task_1.id}\] cancelled successfully/).ordered
+
+          expect(rails_logger).to receive(:info)
+            .with(/Task ids \[#{task_2.id}\] cancelled successfully/).ordered
+
+          expect(rails_logger).to receive(:info)
+            .with(/Task ids \[#{task_3.id}\] cancelled successfully/).ordered
+
+          expect(rails_logger).to receive(:info)
+            .with(/Tasks cancelled successfully: 3/).ordered
+
+          expect(rails_logger).to receive(:info)
+            .with(/Elapsed time \(sec\):/).ordered
+        end
+
+        call
+      end
+
+      it "appends appropriate logs to stdout" do
+        allow(SecureRandom).to receive(:uuid) { "dummy-request-id" }
+
+        expect { call }.to output(
+          match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Total tasks for cancellation: 3"))
+          .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Task ids [#{task_1.id}] cancelled successfully"))
+          .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Task ids [#{task_2.id}] cancelled successfully"))
+          .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Task ids [#{task_3.id}] cancelled successfully"))
+          .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Tasks cancelled successfully: 3"))
+          .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Elapsed time (sec):"))
+        ).to_stdout
+      end
+
+      context "when a task fails to cancel" do
+        before do
+          expect(task_2).to receive(:cancel_task_and_child_subtasks).
+            and_raise(ActiveModel::ValidationError.new(Task.new))
+        end
+
+        it "does not prevent cancellation of other tasks in the relation" do
+          aggregate_failures do
+            expect(task_1).to receive(:cancel_task_and_child_subtasks)
+            expect(task_3).to receive(:cancel_task_and_child_subtasks)
+          end
+          call
+        end
+
+        it "does not raise error" do
+          expect { call }.not_to raise_error
+        end
+
+        it "appends appropriate logs to application logs" do
+          rails_logger = Rails.logger
+          allow(Rails).to receive(:logger).and_return(rails_logger)
+
+          aggregate_failures do
+            expect(rails_logger).to receive(:info)
+              .with("Total tasks for cancellation: 3").ordered
+
+            expect(rails_logger).to receive(:info)
+              .with(/Task ids \[#{task_1.id}\] cancelled successfully/).ordered
+
+            expect(rails_logger).to receive(:error).with(
+              /Task ids \[#{task_2.id}\] not cancelled due to error - Validation failed/
+            ).ordered
+
+            expect(rails_logger).to receive(:info)
+              .with(/Task ids \[#{task_3.id}\] cancelled successfully/).ordered
+
+            expect(rails_logger).to receive(:info)
+              .with(/Tasks cancelled successfully: 2/).ordered
+
+            expect(rails_logger).to receive(:info)
+              .with(/Elapsed time \(sec\):/).ordered
+          end
+
+          call
+        end
+
+        it "appends appropriate logs to stdout" do
+          allow(SecureRandom).to receive(:uuid) { "dummy-request-id" }
+
+          expect { call }.to output(
+            match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Total tasks for cancellation: 3"))
+            .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Task ids [#{task_1.id}] cancelled successfully"))
+            .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Task ids [#{task_2.id}] not cancelled due to error - Validation failed"))
+            .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Task ids [#{task_3.id}] cancelled successfully"))
+            .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Tasks cancelled successfully: 2"))
+            .and match(Regexp.escape("[CancelTasksAndDescendants] [dummy-request-id] Elapsed time (sec):"))
+          ).to_stdout
+        end
+
+        it { is_expected.to be_nil }
+      end
+    end
+  end
+end

spec/lib/tasks/remediations/cancel_vrr_tasks_open_for_vre_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+describe "remediations/cancel_vrr_tasks_open_for_vre" do
+  include_context "rake"
+
+  describe "remediations:cancel_vrr_tasks_open_for_vre" do
+    it "delegates to CancelTasksAndDescendants" do
+      task_relation = double("task_relation")
+
+      expect(CancelTasksAndDescendants::VeteranRecordRequestsOpenForVREQuery).
+        to receive(:call).and_return(task_relation)
+
+      expect(CancelTasksAndDescendants).to receive(:call).with(task_relation)
+
+      Rake::Task["remediations:cancel_vrr_tasks_open_for_vre"].invoke
+    end
+  end
+end