From 4dedf7ef4966d2405e91de34c99947f751ca75ef Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 12:20:12 -0700
Subject: [PATCH 01/12] updated doc upload evss to set error_message,
 failed_date, and acknowledgement_date for failed uploads

---
 app/sidekiq/evss/document_upload.rb       |  3 +++
 spec/sidekiq/evss/document_upload_spec.rb | 10 +++++++++-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/app/sidekiq/evss/document_upload.rb b/app/sidekiq/evss/document_upload.rb
index 41248cb05f3..b1fff1c861a 100644
--- a/app/sidekiq/evss/document_upload.rb
+++ b/app/sidekiq/evss/document_upload.rb
@@ -80,6 +80,9 @@ def self.update_evidence_submission(msg)
     current_personalisation = JSON.parse(evidence_submission.template_metadata)['personalisation']
     evidence_submission.update(
       upload_status: BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED],
+      failed_date: DateTime.now.utc,
+      acknowledgement_date: (DateTime.current + 30.days).utc,
+      error_message: 'EVSS::DocumentUpload document upload failure',
       template_metadata: {
         personalisation: update_personalisation(current_personalisation, msg['failed_at'])
       }.to_json
diff --git a/spec/sidekiq/evss/document_upload_spec.rb b/spec/sidekiq/evss/document_upload_spec.rb
index 99d563f5ac9..324a75a69a2 100644
--- a/spec/sidekiq/evss/document_upload_spec.rb
+++ b/spec/sidekiq/evss/document_upload_spec.rb
@@ -40,6 +40,8 @@
   let(:client_stub) { instance_double(EVSS::DocumentsService) }
   let(:notify_client_stub) { instance_double(VaNotify::Service) }
   let(:issue_instant) { Time.now.to_i }
+  let(:current_date_time) { DateTime.now.utc }
+
   let(:msg) do
     {
       'jid' => job_id,
@@ -103,7 +105,7 @@
     end
 
     context 'when upload fails' do
-      let(:evidence_submission_failed) { create(:bd_evidence_submission_failed) }
+      let(:evidence_submission_failed) { create(:bd_evidence_submission_failed, job_class: EVSSClaimService) }
       let!(:evidence_submission_pending) do
         create(:bd_evidence_submission_pending,
                tracked_item_id:,
@@ -133,7 +135,13 @@
         evidence_submission = EvidenceSubmission.find_by(job_id: job_id)
         current_personalisation = JSON.parse(evidence_submission.template_metadata)['personalisation']
         expect(evidence_submission.upload_status).to eql(BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED])
+        expect(evidence_submission.error_message).to eql('EVSS::DocumentUpload document upload failure')
         expect(current_personalisation['date_failed']).to eql(failed_date)
+
+        Timecop.freeze(current_date_time) do
+          expect(evidence_submission.failed_date).to be_within(1.second).of(current_date_time.utc)
+          expect(evidence_submission.acknowledgement_date).to be_within(1.second).of((current_date_time + 30.days).utc)
+        end
       end
 
       it 'fails to create a failed evidence submission record when args malformed' do

From d34309fda2688cb96dfa212d513f1a1b047db54d Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 12:30:20 -0700
Subject: [PATCH 02/12] updated doc upload lighthouse to set error_message,
 failed_date, and acknowledgement_date for failed uploads

---
 .../evidence_submissions/document_upload.rb       |  3 +++
 .../evidence_submissions/document_upload_spec.rb  | 15 +++++++++++++--
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/app/sidekiq/lighthouse/evidence_submissions/document_upload.rb b/app/sidekiq/lighthouse/evidence_submissions/document_upload.rb
index 559e9b82ce0..04d869d5d60 100644
--- a/app/sidekiq/lighthouse/evidence_submissions/document_upload.rb
+++ b/app/sidekiq/lighthouse/evidence_submissions/document_upload.rb
@@ -58,6 +58,9 @@ def self.update_evidence_submission_for_failure(msg)
         current_personalisation = JSON.parse(evidence_submission.template_metadata)['personalisation']
         evidence_submission.update(
           upload_status: BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED],
+          failed_date: DateTime.now.utc,
+          acknowledgement_date: (DateTime.current + 30.days).utc,
+          error_message: 'Lighthouse::EvidenceSubmissions::DocumentUpload document upload failure',
           template_metadata: {
             personalisation: update_personalisation(current_personalisation, msg['failed_at'])
           }.to_json
diff --git a/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb b/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
index 266017f90be..d684a2399c1 100644
--- a/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
+++ b/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
@@ -35,10 +35,10 @@
   end
   let(:user_account) { create(:user_account) }
   let(:job_id) { job }
-
   let(:client_stub) { instance_double(BenefitsDocuments::WorkerService) }
   let(:job_class) { 'Lighthouse::EvidenceSubmissions::DocumentUpload' }
   let(:issue_instant) { Time.now.to_i }
+  let(:current_date_time) { DateTime.now.utc }
   let(:msg) do
     {
       'jid' => job_id,
@@ -58,7 +58,9 @@
   end
 
   # Create Evidence Submission records from factory
-  let(:evidence_submission_failed) { create(:bd_evidence_submission_failed) }
+  let(:evidence_submission_failed) do
+    create(:bd_evidence_submission_failed, job_class: described_class)
+  end
   let(:evidence_submission_pending) do
     create(:bd_evidence_submission_pending,
            tracked_item_id: tracked_item_ids,
@@ -90,6 +92,9 @@ def mock_response(status:, body:)
           }
         )
       end
+      let(:failed_date) do
+        BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(issue_instant)
+      end
 
       it 'retrieves the file, uploads to Lighthouse and returns a success response' do
         allow(LighthouseDocumentUploader).to receive(:new) { uploader_stub }
@@ -153,7 +158,13 @@ def mock_response(status:, body:)
         evidence_submission = EvidenceSubmission.find_by(job_id: job_id)
         current_personalisation = JSON.parse(evidence_submission.template_metadata)['personalisation']
         expect(evidence_submission.upload_status).to eql(BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED])
+        expect(evidence_submission.error_message).to eql('Lighthouse::EvidenceSubmissions::DocumentUpload document upload failure')
         expect(current_personalisation['date_failed']).to eql(failed_date)
+
+        Timecop.freeze(current_date_time) do
+          expect(evidence_submission.failed_date).to be_within(1.second).of(current_date_time.utc)
+          expect(evidence_submission.acknowledgement_date).to be_within(1.second).of((current_date_time + 30.days).utc)
+        end
       end
 
       it 'fails to create a failed evidence submission record when args malformed' do

From 93f8b4fb607084c139ee6d04455b66b2938505ac Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 12:30:54 -0700
Subject: [PATCH 03/12] update evss test

---
 spec/sidekiq/evss/document_upload_spec.rb | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/spec/sidekiq/evss/document_upload_spec.rb b/spec/sidekiq/evss/document_upload_spec.rb
index 324a75a69a2..54408ec1121 100644
--- a/spec/sidekiq/evss/document_upload_spec.rb
+++ b/spec/sidekiq/evss/document_upload_spec.rb
@@ -36,12 +36,10 @@
   end
   let(:job_class) { 'EVSS::DocumentUpload' }
   let(:job_id) { job }
-
   let(:client_stub) { instance_double(EVSS::DocumentsService) }
   let(:notify_client_stub) { instance_double(VaNotify::Service) }
   let(:issue_instant) { Time.now.to_i }
   let(:current_date_time) { DateTime.now.utc }
-
   let(:msg) do
     {
       'jid' => job_id,
@@ -105,7 +103,7 @@
     end
 
     context 'when upload fails' do
-      let(:evidence_submission_failed) { create(:bd_evidence_submission_failed, job_class: EVSSClaimService) }
+      let(:evidence_submission_failed) { create(:bd_evidence_submission_failed, job_class: described_class) }
       let!(:evidence_submission_pending) do
         create(:bd_evidence_submission_pending,
                tracked_item_id:,

From 3fa71328ad343a746decbedf403a7cadc50f5afc Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 12:38:35 -0700
Subject: [PATCH 04/12] update factory for evss and lighthouse

---
 .../benefits_documents/evidence_submission.rb | 27 +++++++++++++++++--
 spec/sidekiq/evss/document_upload_spec.rb     |  4 ++-
 .../document_upload_spec.rb                   |  2 +-
 3 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/spec/factories/lighthouse/benefits_documents/evidence_submission.rb b/spec/factories/lighthouse/benefits_documents/evidence_submission.rb
index 9facda6cb9b..2ad998b1ed7 100644
--- a/spec/factories/lighthouse/benefits_documents/evidence_submission.rb
+++ b/spec/factories/lighthouse/benefits_documents/evidence_submission.rb
@@ -43,11 +43,34 @@
     end
   end
 
-  factory :bd_evidence_submission_failed, class: 'EvidenceSubmission' do
+  factory :bd_lh_evidence_submission_failed_type1_error, class: 'EvidenceSubmission' do
     association :user_account, factory: :user_account
     created_at { DateTime.now.utc }
+    job_class { Lighthouse::BenefitsDocuments::DocumentUpload }
     upload_status { BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED] }
-    job_class { 'Lighthouse::EvidenceSubmissions::DocumentUpload' }
+    failed_date { DateTime.now.utc }
+    acknowledgement_date { DateTime.now.utc + 30.days }
+    error_message { 'Lighthouse::EvidenceSubmissions::DocumentUpload document upload failure' }
+    template_metadata do
+      { 'personalisation' => {
+        'first_name' => 'test',
+        'document_type' => 'Birth Certificate',
+        'file_name' => 'test.txt',
+        'obfuscated_file_name' => 'tesXXile.txt',
+        'date_submitted' => DateTime.now.utc.to_s,
+        'date_failed' => DateTime.now.utc.to_s
+      } }.to_json
+    end
+  end
+
+  factory :bd_evss_evidence_submission_failed_type1_error, class: 'EvidenceSubmission' do
+    association :user_account, factory: :user_account
+    created_at { DateTime.now.utc }
+    job_class { EVSS::DocumentUpload }
+    upload_status { BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED] }
+    failed_date { DateTime.now.utc }
+    acknowledgement_date { DateTime.now.utc + 30.days }
+    error_message { 'EVSS::DocumentUpload document upload failure' }
     template_metadata do
       { 'personalisation' => {
         'first_name' => 'test',
diff --git a/spec/sidekiq/evss/document_upload_spec.rb b/spec/sidekiq/evss/document_upload_spec.rb
index 54408ec1121..3284e8fb49d 100644
--- a/spec/sidekiq/evss/document_upload_spec.rb
+++ b/spec/sidekiq/evss/document_upload_spec.rb
@@ -103,7 +103,9 @@
     end
 
     context 'when upload fails' do
-      let(:evidence_submission_failed) { create(:bd_evidence_submission_failed, job_class: described_class) }
+      let(:evidence_submission_failed) do
+        create(:bd_evss_evidence_submission_failed_type1_error)
+      end
       let!(:evidence_submission_pending) do
         create(:bd_evidence_submission_pending,
                tracked_item_id:,
diff --git a/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb b/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
index d684a2399c1..66be4c24d86 100644
--- a/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
+++ b/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
@@ -59,7 +59,7 @@
 
   # Create Evidence Submission records from factory
   let(:evidence_submission_failed) do
-    create(:bd_evidence_submission_failed, job_class: described_class)
+    create(:bd_lh_evidence_submission_failed_type1_error)
   end
   let(:evidence_submission_pending) do
     create(:bd_evidence_submission_pending,

From f86b8e40a4ab45df2ba541cf4de8cfe06ecfa00f Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 13:30:01 -0700
Subject: [PATCH 05/12] added tests to failure_notification_email_job_spec.rb
 for each of the 3 error types

---
 .../failure_notification_email_job_spec.rb    | 203 ++++++++++++++----
 1 file changed, 159 insertions(+), 44 deletions(-)

diff --git a/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb b/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
index 9cbc123d629..6005de60126 100644
--- a/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
+++ b/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
@@ -40,82 +40,197 @@
     end
   end
 
-  context 'when there is a FAILED record without a va_notify_date and an error occurs' do
-    before do
-      allow(VaNotify::Service).to receive(:new).and_raise(StandardError)
-      allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
-      allow(Rails.logger).to receive(:error)
-      allow(StatsD).to receive(:increment)
+  context 'when the FAILED record is for EVSS and doesnt have a va_notify_date' do
+    context 'when an error occurs' do
+      before do
+        allow(VaNotify::Service).to receive(:new).and_raise(StandardError)
+        allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
+        allow(Rails.logger).to receive(:error)
+        allow(StatsD).to receive(:increment)
+      end
+
+      let!(:evidence_submission_failed) { create(:bd_evss_evidence_submission_failed_type1_error) }
+      let(:error_message) { "#{evidence_submission_failed.job_class} va notify failure email errored" }
+      let(:tags) { ['service:claim-status', "function: #{error_message}"] }
+
+      it 'handles the error and increments the statsd metric' do
+        expect(EvidenceSubmission.count).to eq(1)
+        expect(EvidenceSubmission.va_notify_email_queued.length).to eq(0)
+        expect(vanotify_service).not_to receive(:send_email)
+        expect(Rails.logger)
+          .to receive(:error)
+          .with(error_message, { message: 'StandardError' })
+        expect(StatsD).to receive(:increment).with('silent_failure', tags: tags)
+        subject.new.perform
+      end
     end
 
-    let!(:evidence_submission_failed) { create(:bd_evidence_submission_failed) }
-    let(:error_message) { "#{evidence_submission_failed.job_class} va notify failure email errored" }
-    let(:tags) { ['service:claim-status', "function: #{error_message}"] }
-
-    it 'handles the error and increments the statsd metric' do
-      expect(EvidenceSubmission.count).to eq(1)
-      expect(EvidenceSubmission.va_notify_email_queued.length).to eq(0)
-      expect(vanotify_service).not_to receive(:send_email)
-      expect(Rails.logger)
-        .to receive(:error)
-        .with(error_message, { message: 'StandardError' })
-      expect(StatsD).to receive(:increment).with('silent_failure', tags: tags)
-      subject.new.perform
+    context 'when no error occurs' do
+      let(:tags) { ['service:claim-status', "function: #{message}"] }
+      let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
+      let!(:evidence_submission_failed) { create(:bd_evss_evidence_submission_failed_type1_error) }
+
+      before do
+        allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
+        allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
+        allow(Rails.logger).to receive(:info)
+        allow(StatsD).to receive(:increment)
+      end
+
+      it 'successfully enqueues a failure notification mailer to send to the veteran' do
+        expect(EvidenceSubmission.count).to eq(1)
+        expect(EvidenceSubmission.va_notify_email_not_queued.length).to eq(1)
+        expect(vanotify_service).to receive(:send_email)
+        expect(evidence_submission_failed).to receive(:update).and_call_original
+        expect(Rails.logger).to receive(:info).with(message)
+        expect(StatsD).to receive(:increment).with('silent_failure_avoided_no_confirmation', tags: tags)
+        subject.new.perform
+        expect(EvidenceSubmission.va_notify_email_queued.length).to eq(1)
+      end
     end
   end
 
-  context 'when there is 1 FAILED record without a va_notify_date' do
-    let(:tags) { ['service:claim-status', "function: #{message}"] }
-    let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
-    let!(:evidence_submission_failed) { create(:bd_evidence_submission_failed) }
+  context 'when the FAILED record is for Lighthouse type 1 error and doesnt have a va_notify_date' do
+    context 'when an error occurs' do
+      before do
+        allow(VaNotify::Service).to receive(:new).and_raise(StandardError)
+        allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
+        allow(Rails.logger).to receive(:error)
+        allow(StatsD).to receive(:increment)
+      end
+
+      let!(:evidence_submission_failed) { create(:bd_lh_evidence_submission_failed_type1_error) }
+      let(:error_message) { "#{evidence_submission_failed.job_class} va notify failure email errored" }
+      let(:tags) { ['service:claim-status', "function: #{error_message}"] }
+
+      it 'handles the error and increments the statsd metric' do
+        expect(EvidenceSubmission.count).to eq(1)
+        expect(EvidenceSubmission.va_notify_email_queued.length).to eq(0)
+        expect(vanotify_service).not_to receive(:send_email)
+        expect(Rails.logger)
+          .to receive(:error)
+          .with(error_message, { message: 'StandardError' })
+        expect(StatsD).to receive(:increment).with('silent_failure', tags: tags)
+        subject.new.perform
+      end
+    end
 
-    before do
-      allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
-      allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
-      allow(Rails.logger).to receive(:info)
-      allow(StatsD).to receive(:increment)
+    context 'when no error occurs' do
+      let(:tags) { ['service:claim-status', "function: #{message}"] }
+      let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
+      let!(:evidence_submission_failed) { create(:bd_lh_evidence_submission_failed_type1_error) }
+
+      before do
+        allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
+        allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
+        allow(Rails.logger).to receive(:info)
+        allow(StatsD).to receive(:increment)
+      end
+
+      it 'successfully enqueues a failure notification mailer to send to the veteran' do
+        expect(EvidenceSubmission.count).to eq(1)
+        expect(EvidenceSubmission.va_notify_email_not_queued.length).to eq(1)
+        expect(vanotify_service).to receive(:send_email)
+        expect(evidence_submission_failed).to receive(:update).and_call_original
+        expect(Rails.logger).to receive(:info).with(message)
+        expect(StatsD).to receive(:increment).with('silent_failure_avoided_no_confirmation', tags: tags)
+        subject.new.perform
+        expect(EvidenceSubmission.va_notify_email_queued.length).to eq(1)
+      end
     end
+  end
 
-    it 'successfully enqueues a failure notification mailer to send to the veteran' do
-      expect(EvidenceSubmission.count).to eq(1)
-      expect(EvidenceSubmission.va_notify_email_not_queued.length).to eq(1)
-      expect(vanotify_service).to receive(:send_email)
-      expect(evidence_submission_failed).to receive(:update).and_call_original
-      expect(Rails.logger).to receive(:info).with(message)
-      expect(StatsD).to receive(:increment).with('silent_failure_avoided_no_confirmation', tags: tags)
-      subject.new.perform
-      expect(EvidenceSubmission.va_notify_email_queued.length).to eq(1)
+  context 'when the FAILED record is for Lighthouse type 2 error and doesnt have a va_notify_date' do
+    context 'when an error occurs' do
+      before do
+        allow(VaNotify::Service).to receive(:new).and_raise(StandardError)
+        allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
+        allow(Rails.logger).to receive(:error)
+        allow(StatsD).to receive(:increment)
+      end
+
+      let!(:evidence_submission_failed) { create(:bd_lh_evidence_submission_failed_type2_error) }
+      let(:error_message) { "#{evidence_submission_failed.job_class} va notify failure email errored" }
+      let(:tags) { ['service:claim-status', "function: #{error_message}"] }
+
+      it 'handles the error and increments the statsd metric' do
+        expect(EvidenceSubmission.count).to eq(1)
+        expect(EvidenceSubmission.va_notify_email_queued.length).to eq(0)
+        expect(vanotify_service).not_to receive(:send_email)
+        expect(Rails.logger)
+          .to receive(:error)
+          .with(error_message, { message: 'StandardError' })
+        expect(StatsD).to receive(:increment).with('silent_failure', tags: tags)
+        subject.new.perform
+      end
+    end
+
+    context 'when no error occurs' do
+      let(:tags) { ['service:claim-status', "function: #{message}"] }
+      let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
+      let!(:evidence_submission_failed) { create(:bd_lh_evidence_submission_failed_type2_error) }
+
+      before do
+        allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
+        allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
+        allow(Rails.logger).to receive(:info)
+        allow(StatsD).to receive(:increment)
+      end
+
+      it 'successfully enqueues a failure notification mailer to send to the veteran' do
+        expect(EvidenceSubmission.count).to eq(1)
+        expect(EvidenceSubmission.va_notify_email_not_queued.length).to eq(1)
+        expect(vanotify_service).to receive(:send_email)
+        expect(evidence_submission_failed).to receive(:update).and_call_original
+        expect(Rails.logger).to receive(:info).with(message)
+        expect(StatsD).to receive(:increment).with('silent_failure_avoided_no_confirmation', tags: tags)
+        subject.new.perform
+        expect(EvidenceSubmission.va_notify_email_queued.length).to eq(1)
+      end
     end
   end
 
   context 'when there are multiple FAILED records without a va_notify_date' do
     let(:message1) { "#{evidence_submission_failed1.job_class} va notify failure email queued" }
     let(:message2) { "#{evidence_submission_failed2.job_class} va notify failure email queued" }
+    let(:message3) { "#{evidence_submission_failed3.job_class} va notify failure email queued" }
+
     let(:tags1) { ['service:claim-status', "function: #{message1}"] }
-    let(:tags2) { ['service:claim-status', "function: #{message1}"] }
-    let!(:evidence_submission_failed1) { create(:bd_evidence_submission_failed) }
-    let!(:evidence_submission_failed2) { create(:bd_evidence_submission_failed) }
+    let(:tags2) { ['service:claim-status', "function: #{message2}"] }
+    let(:tags3) { ['service:claim-status', "function: #{message3}"] }
+
+    let!(:evidence_submission_failed1) { create(:bd_lh_evidence_submission_failed_type1_error) }
+    let!(:evidence_submission_failed2) { create(:bd_lh_evidence_submission_failed_type2_error) }
+    let!(:evidence_submission_failed3) { create(:bd_evss_evidence_submission_failed_type1_error) }
 
     before do
       allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
       allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed1,
-                                                                                    evidence_submission_failed2])
+                                                                                    evidence_submission_failed2,
+                                                                                    evidence_submission_failed3])
       allow(Rails.logger).to receive(:info)
       allow(StatsD).to receive(:increment)
     end
 
     it 'successfully enqueues a failure notification mailer to send to the veteran' do
-      expect(EvidenceSubmission.count).to eq(2)
-      expect(EvidenceSubmission.va_notify_email_not_queued.length).to eq(2)
+      expect(EvidenceSubmission.count).to eq(3)
+      expect(EvidenceSubmission.va_notify_email_not_queued.length).to eq(3)
       expect(vanotify_service).to receive(:send_email)
+
       expect(evidence_submission_failed1).to receive(:update).and_call_original
       expect(evidence_submission_failed2).to receive(:update).and_call_original
+      expect(evidence_submission_failed3).to receive(:update).and_call_original
+
       expect(Rails.logger).to receive(:info).with(message1)
       expect(Rails.logger).to receive(:info).with(message2)
+      expect(Rails.logger).to receive(:info).with(message3)
+
       expect(StatsD).to receive(:increment).with('silent_failure_avoided_no_confirmation', tags: tags1)
       expect(StatsD).to receive(:increment).with('silent_failure_avoided_no_confirmation', tags: tags2)
+      expect(StatsD).to receive(:increment).with('silent_failure_avoided_no_confirmation', tags: tags3)
+
       subject.new.perform
-      expect(EvidenceSubmission.va_notify_email_queued.length).to eq(2)
+      expect(EvidenceSubmission.va_notify_email_queued.length).to eq(3)
     end
   end
 end

From cc10f964c48d15d25713ec56b577b938d5511ea5 Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 13:38:27 -0700
Subject: [PATCH 06/12] updated factory to have more realistic dates, added
 more fields to be set in the upload_status_updater code, udpated tests

---
 .../upload_status_updater.rb                  | 13 +++++-
 .../benefits_documents/evidence_submission.rb | 42 +++++++++++++++----
 .../upload_status_updater_spec.rb             | 20 ++++++++-
 3 files changed, 66 insertions(+), 9 deletions(-)

diff --git a/lib/lighthouse/benefits_documents/upload_status_updater.rb b/lib/lighthouse/benefits_documents/upload_status_updater.rb
index 26e4461ad9c..562ed487126 100644
--- a/lib/lighthouse/benefits_documents/upload_status_updater.rb
+++ b/lib/lighthouse/benefits_documents/upload_status_updater.rb
@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'lighthouse/benefits_documents/constants'
+require 'lighthouse/benefits_documents/utilities/helpers'
 
 module BenefitsDocuments
   class UploadStatusUpdater
@@ -95,10 +96,20 @@ def process_failure
         upload_status: BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED],
         failed_date: DateTime.now.utc,
         acknowledgement_date: (DateTime.current + 30.days).utc,
-        error_message: @lighthouse_document_status_response['error']
+        error_message: @lighthouse_document_status_response['error'],
+        template_metadata: {
+          personalisation: update_personalisation
+        }.to_json
       )
     end
 
+    # Update personalisation here since an evidence submission record was previously created
+    def update_personalisation
+      personalisation = JSON.parse(@pending_evidence_submission.template_metadata)['personalisation'].clone
+      personalisation['date_failed'] = BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(DateTime.current)
+      personalisation
+    end
+
     def process_upload
       @pending_evidence_submission.update!(
         upload_status: BenefitsDocuments::Constants::UPLOAD_STATUS[:SUCCESS],
diff --git a/spec/factories/lighthouse/benefits_documents/evidence_submission.rb b/spec/factories/lighthouse/benefits_documents/evidence_submission.rb
index 2ad998b1ed7..bed8a4fd2b6 100644
--- a/spec/factories/lighthouse/benefits_documents/evidence_submission.rb
+++ b/spec/factories/lighthouse/benefits_documents/evidence_submission.rb
@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'lighthouse/benefits_documents/constants'
+require 'lighthouse/benefits_documents/utilities/helpers'
 
 FactoryBot.define do
   factory :bd_evidence_submission, class: 'EvidenceSubmission' do
@@ -37,16 +38,18 @@
         'document_type' => 'Birth Certificate',
         'file_name' => 'testfile.txt',
         'obfuscated_file_name' => 'tesXXile.txt',
-        'date_submitted' => DateTime.now.utc.to_s,
+        'date_submitted' => BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(DateTime.now),
         'date_failed' => nil
       } }.to_json
     end
   end
 
+  # Document Upload Failures for Type 1 errors occur in app/sidekiq/lighthouse/evidence_submissions/document_upload.rb
+  # when a error happens before the document upload is sent to lighthouse
   factory :bd_lh_evidence_submission_failed_type1_error, class: 'EvidenceSubmission' do
     association :user_account, factory: :user_account
     created_at { DateTime.now.utc }
-    job_class { Lighthouse::BenefitsDocuments::DocumentUpload }
+    job_class { 'Lighthouse::BenefitsDocuments::Service' }
     upload_status { BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED] }
     failed_date { DateTime.now.utc }
     acknowledgement_date { DateTime.now.utc + 30.days }
@@ -57,16 +60,41 @@
         'document_type' => 'Birth Certificate',
         'file_name' => 'test.txt',
         'obfuscated_file_name' => 'tesXXile.txt',
-        'date_submitted' => DateTime.now.utc.to_s,
-        'date_failed' => DateTime.now.utc.to_s
+        'date_submitted' => BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(DateTime.now),
+        'date_failed' => BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(DateTime.now)
       } }.to_json
     end
   end
 
+  # Document Upload Failures for Type 2 errors occur in lib/lighthouse/benefits_documents/upload_status_updater.rb
+  # when the polling job to grab the upload status from lighthouse occurs and there is a failure processing
+  # the upload on lighthouses side
+  factory :bd_lh_evidence_submission_failed_type2_error, class: 'EvidenceSubmission' do
+    association :user_account, factory: :user_account
+    created_at { DateTime.now.utc }
+    job_class { 'Lighthouse::BenefitsDocuments::Service' }
+    upload_status { BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED] }
+    failed_date { DateTime.now.utc }
+    acknowledgement_date { DateTime.now.utc + 30.days }
+    error_message { 'test - there was an error returned from lh api' }
+    template_metadata do
+      { 'personalisation' => {
+        'first_name' => 'test',
+        'document_type' => 'Birth Certificate',
+        'file_name' => 'test.txt',
+        'obfuscated_file_name' => 'tesXXile.txt',
+        'date_submitted' => BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(DateTime.now),
+        'date_failed' => BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(DateTime.now)
+      } }.to_json
+    end
+  end
+
+  # Document Upload Failures for Type 1 errors occur in app/sidekiq/evss/document_upload.rb
+  # when a error happens before or when we send the upload to evss
   factory :bd_evss_evidence_submission_failed_type1_error, class: 'EvidenceSubmission' do
     association :user_account, factory: :user_account
     created_at { DateTime.now.utc }
-    job_class { EVSS::DocumentUpload }
+    job_class { 'EVSS::DocumentUpload' }
     upload_status { BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED] }
     failed_date { DateTime.now.utc }
     acknowledgement_date { DateTime.now.utc + 30.days }
@@ -77,8 +105,8 @@
         'document_type' => 'Birth Certificate',
         'file_name' => 'test.txt',
         'obfuscated_file_name' => 'tesXXile.txt',
-        'date_submitted' => DateTime.now.utc.to_s,
-        'date_failed' => DateTime.now.utc.to_s
+        'date_submitted' => BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(DateTime.now),
+        'date_failed' => BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(DateTime.now)
       } }.to_json
     end
   end
diff --git a/spec/lib/lighthouse/benefits_documents/upload_status_updater_spec.rb b/spec/lib/lighthouse/benefits_documents/upload_status_updater_spec.rb
index f6681541bf8..1e4157e02a7 100644
--- a/spec/lib/lighthouse/benefits_documents/upload_status_updater_spec.rb
+++ b/spec/lib/lighthouse/benefits_documents/upload_status_updater_spec.rb
@@ -3,12 +3,14 @@
 require 'rails_helper'
 require 'lighthouse/benefits_documents/upload_status_updater'
 require 'lighthouse/benefits_documents/constants'
+require 'lighthouse/benefits_documents/utilities/helpers'
 
 RSpec.describe BenefitsDocuments::UploadStatusUpdater do
   let(:lighthouse_document_upload) { create(:bd_evidence_submission_pending, job_class: 'BenefitsDocuments::Service') }
   let(:lighthouse_document_upload_timeout) { create(:bd_evidence_submission_timeout) }
   let(:past_date_time) { DateTime.new(1985, 10, 26) }
   let(:current_date_time) { DateTime.now.utc }
+  let(:issue_instant) { Time.now.to_i }
 
   describe '#update_status' do
     shared_examples 'status updater' do |status, error_message = nil|
@@ -19,6 +21,19 @@
         }.compact
       end
       let(:status_updater) { described_class.new(document_status_response, lighthouse_document_upload) }
+      let(:date) do
+        BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(issue_instant)
+      end
+      let(:updated_template_metadata) do
+        { 'personalisation' => {
+          'first_name' => 'test',
+          'document_type' => 'Birth Certificate',
+          'file_name' => 'testfile.txt',
+          'obfuscated_file_name' => 'tesXXile.txt',
+          'date_submitted' => date,
+          'date_failed' => date
+        } }.to_json
+      end
 
       it 'logs the document_status_response to the Rails logger' do
         Timecop.freeze(past_date_time) do
@@ -42,7 +57,7 @@
             end
           end
 
-          it 'updates status, failed_date, and acknowledgement_date' do
+          it 'updates status, failed_date, acknowledgement_date and template_metadata' do
             Timecop.freeze(current_date_time) do
               expect { status_updater.update_status }
                 .to change(lighthouse_document_upload, :acknowledgement_date)
@@ -54,6 +69,9 @@
                 .and change(lighthouse_document_upload, :upload_status)
                 .from(BenefitsDocuments::Constants::UPLOAD_STATUS[:PENDING])
                 .to(BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED])
+                .and change(lighthouse_document_upload, :template_metadata)
+                .from(lighthouse_document_upload.template_metadata)
+                .to(updated_template_metadata)
             end
           end
         end

From 99a864e5a3c4879bd0b2d604a61b26f16332c230 Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 13:50:13 -0700
Subject: [PATCH 07/12] fixed linting errors

---
 .../lighthouse/evidence_submissions/document_upload_spec.rb    | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb b/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
index 66be4c24d86..cc27219838a 100644
--- a/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
+++ b/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
@@ -158,7 +158,8 @@ def mock_response(status:, body:)
         evidence_submission = EvidenceSubmission.find_by(job_id: job_id)
         current_personalisation = JSON.parse(evidence_submission.template_metadata)['personalisation']
         expect(evidence_submission.upload_status).to eql(BenefitsDocuments::Constants::UPLOAD_STATUS[:FAILED])
-        expect(evidence_submission.error_message).to eql('Lighthouse::EvidenceSubmissions::DocumentUpload document upload failure')
+        expect(evidence_submission.error_message)
+          .to eql('Lighthouse::EvidenceSubmissions::DocumentUpload document upload failure')
         expect(current_personalisation['date_failed']).to eql(failed_date)
 
         Timecop.freeze(current_date_time) do

From 3b58ad1777de3be2b3f16bdaae0184084558b9d7 Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 14:47:07 -0700
Subject: [PATCH 08/12] update polling job tests

---
 ...ission_document_upload_polling_job_spec.rb | 54 +++++++++----------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/spec/sidekiq/lighthouse/evidence_submissions/evidence_submission_document_upload_polling_job_spec.rb b/spec/sidekiq/lighthouse/evidence_submissions/evidence_submission_document_upload_polling_job_spec.rb
index be58c6b52a8..a4c0ac6f233 100644
--- a/spec/sidekiq/lighthouse/evidence_submissions/evidence_submission_document_upload_polling_job_spec.rb
+++ b/spec/sidekiq/lighthouse/evidence_submissions/evidence_submission_document_upload_polling_job_spec.rb
@@ -2,54 +2,49 @@
 
 require 'rails_helper'
 require 'lighthouse/benefits_documents/constants'
+require 'lighthouse/benefits_documents/utilities/helpers'
 
 RSpec.describe Lighthouse::EvidenceSubmissions::EvidenceSubmissionDocumentUploadPollingJob, type: :job do
   let(:job) { described_class.perform_async }
   let(:user_account) { create(:user_account) }
   let(:user_account_uuid) { user_account.id }
   let(:current_date_time) { DateTime.current.utc }
-  let(:pending_params) do
-    {
-      claim_id: 'claim-id1',
-      tracked_item_id: 'tracked-item-id1',
-      job_id: job,
-      job_class: '',
-      upload_status: BenefitsDocuments::Constants::UPLOAD_STATUS[:PENDING],
-      user_account_id: user_account_uuid
-    }
+  let!(:pending_lighthouse_document_upload1) do
+    create(:bd_evidence_submission_pending, job_class: 'BenefitsDocuments::Service', request_id: 1)
+  end
+  let!(:pending_lighthouse_document_upload2) do
+    create(:bd_evidence_submission_pending, job_class: 'BenefitsDocuments::Service', request_id: 2)
   end
-  let(:pending_params2) do
+
+  let(:error_message) do
     {
-      claim_id: 'claim-id2',
-      tracked_item_id: 'tracked-item-id2',
-      job_id: job,
-      job_class: '',
-      upload_status: BenefitsDocuments::Constants::UPLOAD_STATUS[:PENDING],
-      user_account_id: user_account_uuid
+      'detail' => 'string',
+      'step' => 'BENEFITS_GATEWAY_SERVICE'
     }
   end
+  let(:issue_instant) { Time.now.to_i }
+  let(:date_failed) do
+    BenefitsDocuments::Utilities::Helpers.format_date_for_mailers(issue_instant)
+  end
 
   context 'when there are EvidenceSubmission records' do
     before do
       allow_any_instance_of(Auth::ClientCredentials::Service).to receive(:get_token).and_return('fake_access_token')
-      pending_es = EvidenceSubmission.find_or_create_by(**pending_params)
-      pending_es.request_id = 1
-      pending_es.save!
-      pending_es2 = EvidenceSubmission.find_or_create_by(**pending_params2)
-      pending_es2.request_id = 2
-      pending_es2.save!
     end
 
     it 'polls and updates status for each EvidenceSubmission record that is still pending to "complete"' do
       VCR.use_cassette('lighthouse/benefits_claims/documents/lighthouse_document_upload_status_polling_success') do
-        job
-        described_class.drain
+        Timecop.freeze(current_date_time) do
+          job
+          described_class.drain
+        end
       end
       pending_es = EvidenceSubmission.where(request_id: 1).first
       pending_es2 = EvidenceSubmission.where(request_id: 2).first
       expect(pending_es.completed?).to be(true)
-      expect(pending_es2.completed?).to be(true)
       expect(pending_es.delete_date).to be_within(1.second).of((current_date_time + 60.days).utc)
+
+      expect(pending_es2.completed?).to be(true)
       expect(pending_es2.delete_date).to be_within(1.second).of((current_date_time + 60.days).utc)
     end
 
@@ -63,11 +58,16 @@
       pending_es = EvidenceSubmission.where(request_id: 1).first
       pending_es2 = EvidenceSubmission.where(request_id: 2).first
       expect(pending_es.failed?).to be(true)
-      expect(pending_es2.failed?).to be(true)
       expect(pending_es.acknowledgement_date).to be_within(1.second).of((current_date_time + 30.days).utc)
-      expect(pending_es2.acknowledgement_date).to be_within(1.second).of((current_date_time + 30.days).utc)
       expect(pending_es.failed_date).to be_within(1.second).of(current_date_time.utc)
+      expect(pending_es.error_message).to eq(error_message.to_s)
+      expect(JSON.parse(pending_es.template_metadata)['personalisation']['date_failed']).to eq(date_failed)
+
+      expect(pending_es2.failed?).to be(true)
+      expect(pending_es2.acknowledgement_date).to be_within(1.second).of((current_date_time + 30.days).utc)
       expect(pending_es2.failed_date).to be_within(1.second).of(current_date_time.utc)
+      expect(pending_es2.error_message).to eq(error_message.to_s)
+      expect(JSON.parse(pending_es2.template_metadata)['personalisation']['date_failed']).to eq(date_failed)
     end
   end
 end

From 115b78ad487643b44871d9c61a8e4942c0b25a1b Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 17:52:23 -0700
Subject: [PATCH 09/12] update tests

---
 .../failure_notification_email_job.rb         | 13 +----
 .../benefits_documents/utilities/helpers.rb   | 11 +++++
 .../failure_notification_email_job_spec.rb    | 48 ++++++++++++++++---
 3 files changed, 54 insertions(+), 18 deletions(-)

diff --git a/app/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job.rb b/app/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job.rb
index 350816b6f2d..76470d2316f 100644
--- a/app/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job.rb
+++ b/app/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job.rb
@@ -39,8 +39,7 @@ def notify_client
 
       def send_failed_evidence_submissions
         failed_uploads.each do |upload|
-          personalisation = create_personalisation_from_upload(upload)
-
+          personalisation = BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(upload)
           # NOTE: The file_name in the personalisation that is passed in is obscured
           response = notify_client.send_email(
             recipient_identifier: { id_value: upload.user_account.icn, id_type: 'ICN' },
@@ -55,16 +54,6 @@ def send_failed_evidence_submissions
         nil
       end
 
-      # This will be used to send an upload failure email
-      # We created a new personalisation with the obfuscated_file_name so the filename is hidden in the email
-      def create_personalisation_from_upload(upload)
-        personalisation = JSON.parse(upload.template_metadata)['personalisation']
-        personalisation['file_name'] = personalisation['obfuscated_filename']
-        personalisation.delete('obfuscated_filename')
-
-        personalisation
-      end
-
       def record_email_send_success(upload, response)
         # Update evidence_submissions table record with the va_notify_id and va_notify_date
         upload.update(va_notify_id: response.id, va_notify_date: DateTime.now)
diff --git a/lib/lighthouse/benefits_documents/utilities/helpers.rb b/lib/lighthouse/benefits_documents/utilities/helpers.rb
index 9d4f5609c59..0f7c5b7d5ee 100644
--- a/lib/lighthouse/benefits_documents/utilities/helpers.rb
+++ b/lib/lighthouse/benefits_documents/utilities/helpers.rb
@@ -28,6 +28,17 @@ def self.format_date_for_mailers(date)
         # We display dates in mailers in the format "May 1, 2024 3:01 p.m. EDT"
         timestamp.strftime('%B %-d, %Y %-l:%M %P %Z').sub(/([ap])m/, '\1.m.')
       end
+
+      # Used to take the current personalisation from an evidence_submission records template_metadata
+      # and return a new personalisation with a file_name field that is obscured and doesnt have the field
+      # obfuscated_file_name. This will be used in the failed notification email template.
+      def self.create_personalisation_from_upload(upload)
+        personalisation = JSON.parse(upload.template_metadata)['personalisation']
+        personalisation['file_name'] = personalisation['obfuscated_file_name']
+        personalisation.delete('obfuscated_file_name')
+
+        personalisation
+      end
     end
   end
 end
diff --git a/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb b/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
index 6005de60126..de26248cd73 100644
--- a/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
+++ b/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
@@ -2,6 +2,8 @@
 
 require 'rails_helper'
 require 'va_notify/service'
+require 'lighthouse/benefits_documents/utilities/helpers'
+
 
 RSpec.describe Lighthouse::EvidenceSubmissions::FailureNotificationEmailJob, type: :job do
   subject { described_class }
@@ -69,7 +71,18 @@
       let(:tags) { ['service:claim-status', "function: #{message}"] }
       let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
       let!(:evidence_submission_failed) { create(:bd_evss_evidence_submission_failed_type1_error) }
-
+      let(:personalisation) {BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)}
+
+      let(:send_email_params) do 
+        {
+          recipient_identifier: {
+            id_value: evidence_submission_failed.user_account.icn,
+            id_type: 'ICN'
+          },
+          template_id: Settings.vanotify.services.benefits_management_tools.template_id.evidence_submission_failure_email,
+          personalisation: 
+        }
+      end
       before do
         allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
         allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
@@ -80,7 +93,7 @@
       it 'successfully enqueues a failure notification mailer to send to the veteran' do
         expect(EvidenceSubmission.count).to eq(1)
         expect(EvidenceSubmission.va_notify_email_not_queued.length).to eq(1)
-        expect(vanotify_service).to receive(:send_email)
+        expect(vanotify_service).to receive(:send_email).with(send_email_params)
         expect(evidence_submission_failed).to receive(:update).and_call_original
         expect(Rails.logger).to receive(:info).with(message)
         expect(StatsD).to receive(:increment).with('silent_failure_avoided_no_confirmation', tags: tags)
@@ -119,7 +132,19 @@
       let(:tags) { ['service:claim-status', "function: #{message}"] }
       let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
       let!(:evidence_submission_failed) { create(:bd_lh_evidence_submission_failed_type1_error) }
-
+      let(:personalisation) {BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)}
+
+      let(:send_email_params) do 
+        {
+          recipient_identifier: {
+            id_value: evidence_submission_failed.user_account.icn,
+            id_type: 'ICN'
+          },
+          template_id: Settings.vanotify.services.benefits_management_tools.template_id.evidence_submission_failure_email,
+          personalisation: 
+        }
+      end
+    
       before do
         allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
         allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
@@ -130,7 +155,7 @@
       it 'successfully enqueues a failure notification mailer to send to the veteran' do
         expect(EvidenceSubmission.count).to eq(1)
         expect(EvidenceSubmission.va_notify_email_not_queued.length).to eq(1)
-        expect(vanotify_service).to receive(:send_email)
+        expect(vanotify_service).to receive(:send_email).with(send_email_params)
         expect(evidence_submission_failed).to receive(:update).and_call_original
         expect(Rails.logger).to receive(:info).with(message)
         expect(StatsD).to receive(:increment).with('silent_failure_avoided_no_confirmation', tags: tags)
@@ -169,7 +194,18 @@
       let(:tags) { ['service:claim-status', "function: #{message}"] }
       let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
       let!(:evidence_submission_failed) { create(:bd_lh_evidence_submission_failed_type2_error) }
-
+      let(:personalisation) {BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)}
+
+      let(:send_email_params) do 
+        {
+          recipient_identifier: {
+            id_value: evidence_submission_failed.user_account.icn,
+            id_type: 'ICN'
+          },
+          template_id: Settings.vanotify.services.benefits_management_tools.template_id.evidence_submission_failure_email,
+          personalisation: 
+        }
+      end
       before do
         allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
         allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
@@ -180,7 +216,7 @@
       it 'successfully enqueues a failure notification mailer to send to the veteran' do
         expect(EvidenceSubmission.count).to eq(1)
         expect(EvidenceSubmission.va_notify_email_not_queued.length).to eq(1)
-        expect(vanotify_service).to receive(:send_email)
+        expect(vanotify_service).to receive(:send_email).with(send_email_params)
         expect(evidence_submission_failed).to receive(:update).and_call_original
         expect(Rails.logger).to receive(:info).with(message)
         expect(StatsD).to receive(:increment).with('silent_failure_avoided_no_confirmation', tags: tags)

From 2177a94b98378425f2ac9d44a9144f77a728bc1b Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 18:10:21 -0700
Subject: [PATCH 10/12] try to fix linting issues

---
 .../failure_notification_email_job_spec.rb        | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb b/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
index de26248cd73..c3f4aa234e9 100644
--- a/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
+++ b/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
@@ -4,7 +4,6 @@
 require 'va_notify/service'
 require 'lighthouse/benefits_documents/utilities/helpers'
 
-
 RSpec.describe Lighthouse::EvidenceSubmissions::FailureNotificationEmailJob, type: :job do
   subject { described_class }
 
@@ -71,8 +70,11 @@
       let(:tags) { ['service:claim-status', "function: #{message}"] }
       let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
       let!(:evidence_submission_failed) { create(:bd_evss_evidence_submission_failed_type1_error) }
-      let(:personalisation) {BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)}
-
+      let(:personalisation) do
+        {
+          BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)
+        }
+      end
       let(:send_email_params) do 
         {
           recipient_identifier: {
@@ -83,6 +85,7 @@
           personalisation: 
         }
       end
+
       before do
         allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
         allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
@@ -132,8 +135,7 @@
       let(:tags) { ['service:claim-status', "function: #{message}"] }
       let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
       let!(:evidence_submission_failed) { create(:bd_lh_evidence_submission_failed_type1_error) }
-      let(:personalisation) {BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)}
-
+      let(:personalisation) { BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed) }
       let(:send_email_params) do 
         {
           recipient_identifier: {
@@ -194,8 +196,7 @@
       let(:tags) { ['service:claim-status', "function: #{message}"] }
       let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
       let!(:evidence_submission_failed) { create(:bd_lh_evidence_submission_failed_type2_error) }
-      let(:personalisation) {BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)}
-
+      let(:personalisation) { BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed) }
       let(:send_email_params) do 
         {
           recipient_identifier: {

From 69f282b4f3da6136ca85a57545a5c5dccbe96bb4 Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Fri, 14 Feb 2025 18:23:53 -0700
Subject: [PATCH 11/12] fix linting issues

---
 .../failure_notification_email_job_spec.rb    | 36 +++++++++++--------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb b/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
index c3f4aa234e9..dde6a98cf05 100644
--- a/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
+++ b/spec/sidekiq/lighthouse/evidence_submissions/failure_notification_email_job_spec.rb
@@ -71,18 +71,17 @@
       let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
       let!(:evidence_submission_failed) { create(:bd_evss_evidence_submission_failed_type1_error) }
       let(:personalisation) do
-        {
-          BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)
-        }
+        BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)
       end
-      let(:send_email_params) do 
+      let(:send_email_params) do
         {
           recipient_identifier: {
             id_value: evidence_submission_failed.user_account.icn,
             id_type: 'ICN'
           },
-          template_id: Settings.vanotify.services.benefits_management_tools.template_id.evidence_submission_failure_email,
-          personalisation: 
+          template_id: Settings.vanotify.services.benefits_management_tools
+                               .template_id.evidence_submission_failure_email,
+          personalisation:
         }
       end
 
@@ -135,18 +134,21 @@
       let(:tags) { ['service:claim-status', "function: #{message}"] }
       let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
       let!(:evidence_submission_failed) { create(:bd_lh_evidence_submission_failed_type1_error) }
-      let(:personalisation) { BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed) }
-      let(:send_email_params) do 
+      let(:personalisation) do
+        BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)
+      end
+      let(:send_email_params) do
         {
           recipient_identifier: {
             id_value: evidence_submission_failed.user_account.icn,
             id_type: 'ICN'
           },
-          template_id: Settings.vanotify.services.benefits_management_tools.template_id.evidence_submission_failure_email,
-          personalisation: 
+          template_id: Settings.vanotify.services.benefits_management_tools
+                               .template_id.evidence_submission_failure_email,
+          personalisation:
         }
       end
-    
+
       before do
         allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
         allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])
@@ -196,17 +198,21 @@
       let(:tags) { ['service:claim-status', "function: #{message}"] }
       let(:message) { "#{evidence_submission_failed.job_class} va notify failure email queued" }
       let!(:evidence_submission_failed) { create(:bd_lh_evidence_submission_failed_type2_error) }
-      let(:personalisation) { BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed) }
-      let(:send_email_params) do 
+      let(:personalisation) do
+        BenefitsDocuments::Utilities::Helpers.create_personalisation_from_upload(evidence_submission_failed)
+      end
+      let(:send_email_params) do
         {
           recipient_identifier: {
             id_value: evidence_submission_failed.user_account.icn,
             id_type: 'ICN'
           },
-          template_id: Settings.vanotify.services.benefits_management_tools.template_id.evidence_submission_failure_email,
-          personalisation: 
+          template_id: Settings.vanotify.services.benefits_management_tools
+                               .template_id.evidence_submission_failure_email,
+          personalisation:
         }
       end
+
       before do
         allow(VaNotify::Service).to receive(:new).and_return(vanotify_service)
         allow(EvidenceSubmission).to receive(:va_notify_email_not_queued).and_return([evidence_submission_failed])

From a1f7cee1d36f3aceeaafdf9dc54430208df00b96 Mon Sep 17 00:00:00 2001
From: Peri McLaren <141954992+pmclaren19@users.noreply.github.com>
Date: Tue, 18 Feb 2025 11:55:19 -0700
Subject: [PATCH 12/12] added Timecop.unfreeze

---
 .../benefits_documents/upload_status_updater_spec.rb          | 4 ++++
 spec/sidekiq/evss/document_upload_spec.rb                     | 1 +
 .../lighthouse/evidence_submissions/document_upload_spec.rb   | 1 +
 3 files changed, 6 insertions(+)

diff --git a/spec/lib/lighthouse/benefits_documents/upload_status_updater_spec.rb b/spec/lib/lighthouse/benefits_documents/upload_status_updater_spec.rb
index 1e4157e02a7..38574092f6f 100644
--- a/spec/lib/lighthouse/benefits_documents/upload_status_updater_spec.rb
+++ b/spec/lib/lighthouse/benefits_documents/upload_status_updater_spec.rb
@@ -46,6 +46,7 @@
 
           status_updater.update_status
         end
+        Timecop.unfreeze
       end
 
       if error_message
@@ -55,6 +56,7 @@
               expect { status_updater.update_status }.to change(lighthouse_document_upload, :error_message)
                 .to(error_message.to_s)
             end
+            Timecop.unfreeze
           end
 
           it 'updates status, failed_date, acknowledgement_date and template_metadata' do
@@ -73,6 +75,7 @@
                 .from(lighthouse_document_upload.template_metadata)
                 .to(updated_template_metadata)
             end
+            Timecop.unfreeze
           end
         end
       else # testing success status
@@ -87,6 +90,7 @@
                 .from(BenefitsDocuments::Constants::UPLOAD_STATUS[:PENDING])
                 .to(BenefitsDocuments::Constants::UPLOAD_STATUS[:SUCCESS])
             end
+            Timecop.unfreeze
           end
         end
       end
diff --git a/spec/sidekiq/evss/document_upload_spec.rb b/spec/sidekiq/evss/document_upload_spec.rb
index 3284e8fb49d..e80ed2e4d58 100644
--- a/spec/sidekiq/evss/document_upload_spec.rb
+++ b/spec/sidekiq/evss/document_upload_spec.rb
@@ -142,6 +142,7 @@
           expect(evidence_submission.failed_date).to be_within(1.second).of(current_date_time.utc)
           expect(evidence_submission.acknowledgement_date).to be_within(1.second).of((current_date_time + 30.days).utc)
         end
+        Timecop.unfreeze
       end
 
       it 'fails to create a failed evidence submission record when args malformed' do
diff --git a/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb b/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
index cc27219838a..c98ffc9e591 100644
--- a/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
+++ b/spec/sidekiq/lighthouse/evidence_submissions/document_upload_spec.rb
@@ -166,6 +166,7 @@ def mock_response(status:, body:)
           expect(evidence_submission.failed_date).to be_within(1.second).of(current_date_time.utc)
           expect(evidence_submission.acknowledgement_date).to be_within(1.second).of((current_date_time + 30.days).utc)
         end
+        Timecop.unfreeze
       end
 
       it 'fails to create a failed evidence submission record when args malformed' do