feat: test that email still sent despite pdf gen failure

Author: kevin9foong

src/app/modules/submission/encrypt-submission/__tests__/encrypt-submission.service.spec.ts

@@ -2,13 +2,14 @@
 import dbHandler from '__tests__/unit/backend/helpers/jest-db'
 import { ObjectId } from 'bson'
 import mongoose from 'mongoose'
-import { ok, okAsync } from 'neverthrow'
+import { errAsync, ok, okAsync } from 'neverthrow'
 import {
   BasicField,
-  EmailResponse, FormAuthType,
+  EmailResponse,
+  FormAuthType,
   FormResponseMode,
   MyInfoAttribute,
-  PaymentChannel
+  PaymentChannel,
 } from 'shared/types'
 
 import { getEncryptSubmissionModel } from 'src/app/models/submission.server.model'
@@ -28,6 +29,7 @@ import {
   createEncryptSubmissionWithoutSave,
   performEncryptPostSubmissionActions,
 } from '../encrypt-submission.service'
+import { AutoreplyPdfGenerationError } from 'src/app/services/mail/mail.errors'
 
 const EncryptSubmission = getEncryptSubmissionModel(mongoose)
 
@@ -148,6 +150,53 @@ describe('encrypt-submission.service', () => {
         )
       })
 
+      it('should send email confirmations and sendSubmissionToAdmin without pdf attachment when pdf generation fails', async () => {
+        // Arrange
+        MockMailUtils.generateAutoreplyPdf.mockReturnValue(
+          errAsync(new AutoreplyPdfGenerationError()),
+        )
+        const mockSubmission = {
+          _id: new ObjectId(),
+          form: new ObjectId(),
+          created: new Date(),
+        } as IEncryptedSubmissionSchema
+        const mockResponses: ProcessedFieldResponse[] = [
+          {
+            _id: new ObjectId().toHexString(),
+            question: SgidFieldTitle.SgidNric,
+            answer: MOCK_NRIC,
+            fieldType: BasicField.Nric,
+          },
+        ]
+        MockFormService.retrieveFullFormById.mockReturnValue(
+          okAsync(MOCK_NON_PAYMENT_ENCRYPT_FORM),
+        )
+
+        // Act
+        await performEncryptPostSubmissionActions({
+          submission: mockSubmission,
+          responses: mockResponses,
+          emailFields: mockResponses,
+          submissionAttachments: MOCK_SUBMISSION_ATTACHMENTS,
+          respondentEmails: ['[email protected]', '[email protected]'], // presence of respondent emails means that form summary is enabled
+        })
+
+        // Assert
+        expect(MockMailUtils.generateAutoreplyPdf).toHaveBeenCalledOnce()
+        expect(MockMailService.sendSubmissionToAdmin).toHaveBeenCalledWith(
+          expect.objectContaining({
+            submissionAttachments: MOCK_SUBMISSION_ATTACHMENTS,
+            pdfAttachment: undefined,
+          }),
+        )
+        expect(MockMailService.sendAutoReplyEmails).toHaveBeenCalledWith(
+          expect.objectContaining({
+            submissionAttachments: MOCK_SUBMISSION_ATTACHMENTS,
+            pdfAttachment: undefined,
+          }),
+        )
+      })
+
       it('should not generate pdf attachment if payment is enabled and not pass to either sendSubmissionToAdmin or sendEmailConfirmations', async () => {
         // Arrange
         const mockSubmission = {

src/app/modules/submission/multirespondent-submission/__tests__/multirespondent-submission.service.spec.ts

@@ -1,6 +1,6 @@
 import dbHandler from '__tests__/unit/backend/helpers/jest-db'
 import { ObjectId } from 'bson'
-import { okAsync } from 'neverthrow'
+import { errAsync, okAsync } from 'neverthrow'
 import {
   BasicField,
   FieldResponsesV3,
@@ -29,6 +29,7 @@ import {
   performMultiRespondentPostSubmissionUpdateActions,
   sendNextStepReminderEmail,
 } from '../multirespondent-submission.service'
+import { AutoreplyPdfGenerationError } from 'src/app/services/mail/mail.errors'
 
 jest.mock('src/app/modules/datadog/datadog.utils')
 jest.mock('src/app/services/mail/mail.utils')
@@ -46,15 +47,18 @@ const MOCK_SUBMISSION_ATTACHMENTS = [
     fieldId: new ObjectId().toHexString(),
   },
 ]
-MockMailUtils.generateAutoreplyPdf.mockReturnValue(
-  okAsync(Buffer.from('mock pdf buffer')),
-)
 
 describe('multirespondent-submission.service', () => {
   beforeAll(async () => {
     await dbHandler.connect()
   })
 
+  beforeEach(() => {
+    MockMailUtils.generateAutoreplyPdf.mockReturnValue(
+      okAsync(Buffer.from('mock pdf buffer')),
+    )
+  })
+
   afterEach(async () => {
     jest.clearAllMocks()
     await dbHandler.clearDatabase()
@@ -706,6 +710,86 @@ describe('multirespondent-submission.service', () => {
         // Assert
         expect(sendMrfRespondentCopyEmailSpy).not.toHaveBeenCalled()
       })
+
+      it('sends respondent copy despite pdf generation error', async () => {
+        // Arrange
+        MockMailUtils.generateAutoreplyPdf.mockReturnValue(
+          errAsync(new AutoreplyPdfGenerationError()),
+        )
+        const sendMrfRespondentCopyEmailSpy = jest.spyOn(
+          MailService,
+          'sendMrfRespondentCopyEmail',
+        )
+        const emailFieldWithFormSummaryStep1 = {
+          _id: new ObjectId().toHexString(),
+          fieldType: BasicField.Email,
+          title: 'Step 1 Email Field',
+          autoReplyOptions: {
+            hasAutoReply: true,
+            includeFormSummary: true,
+            autoReplySubject: 'Test Subject',
+            autoReplyMessage: 'Test Message',
+            autoReplySender: 'Test Sender',
+          },
+        }
+
+        const workflow = [
+          {
+            _id: new ObjectId().toHexString(),
+            workflow_type: WorkflowType.Static,
+            emails: [],
+            edit: [emailFieldWithFormSummaryStep1._id],
+          },
+        ]
+
+        // Act
+        await performMultiRespondentPostSubmissionCreateActions({
+          submission: {
+            _id: mockSubmissionId,
+          } as unknown as IMultirespondentSubmissionSchema,
+          submissionId: mockSubmissionId,
+          form: {
+            _id: mockFormId,
+            title: 'Test Form',
+            form_fields: [emailFieldWithFormSummaryStep1],
+            stepsToNotify: [workflow[0]._id],
+            workflow,
+            admin: {
+              agency: {
+                fullName: 'Government Technology Agency',
+              },
+            },
+          } as unknown as IPopulatedMultirespondentForm,
+          encryptedPayload: {
+            encryptedContent: 'encryptedContent',
+            version: 1,
+            submissionPublicKey: 'submissionPublicKey',
+            encryptedSubmissionSecretKey: 'encryptedSubmissionSecretKey',
+            responses: {
+              [emailFieldWithFormSummaryStep1._id]: {
+                fieldType: BasicField.Email,
+                answer: {
+                  value: '[email protected]',
+                },
+              },
+            },
+          } as MultirespondentSubmissionDto,
+          logMeta: {} as any,
+          attachments: MOCK_SUBMISSION_ATTACHMENTS,
+        })
+
+        // Assert
+        // that sent to correct destination emails
+        expect(sendMrfRespondentCopyEmailSpy).toHaveBeenCalledTimes(1)
+        expect(
+          sendMrfRespondentCopyEmailSpy.mock.calls[0][0].autoReplyMailData
+            .email,
+        ).toEqual('[email protected]')
+        // still sends without pdf attachment
+        expect(
+          sendMrfRespondentCopyEmailSpy.mock.calls[0][0].attachments,
+        ).toEqual([...MOCK_SUBMISSION_ATTACHMENTS])
+      })
     })
 
     describe('subsequent steps', () => {
@@ -2101,6 +2185,62 @@ describe('multirespondent-submission.service', () => {
   })
 
   describe('mrf completion email notification when no approval step exists', () => {
+    it('sends completion email without pdf attachment when pdf generation fails', async () => {
+      // Arrange
+      MockMailUtils.generateAutoreplyPdf.mockReturnValue(
+        errAsync(new AutoreplyPdfGenerationError()),
+      )
+      const sendMrfWorkflowCompletionEmailSpy = jest.spyOn(
+        MailService,
+        'sendMrfWorkflowCompletionEmail',
+      )
+      const singleStepWorkflow: FormWorkflowStepDto[] = [
+        {
+          _id: new ObjectId().toHexString(),
+          workflow_type: WorkflowType.Static,
+          emails: [],
+          edit: [],
+        },
+      ]
+
+      // Act
+      await performMultiRespondentPostSubmissionCreateActions({
+        submission: {
+          _id: mockSubmissionId,
+        } as unknown as IMultirespondentSubmissionSchema,
+        submissionId: mockSubmissionId,
+        form: {
+          _id: mockFormId,
+          workflow: singleStepWorkflow,
+          emails: ['[email protected]'],
+        } as IPopulatedMultirespondentForm,
+        encryptedPayload: {
+          encryptedContent: 'encryptedContent',
+          version: 1,
+          submissionPublicKey: 'submissionPublicKey',
+          encryptedSubmissionSecretKey: 'encryptedSubmissionSecretKey',
+        } as MultirespondentSubmissionDto,
+        attachments: MOCK_SUBMISSION_ATTACHMENTS,
+        logMeta: {} as any,
+      })
+
+      // Assert
+      expect(sendMrfWorkflowCompletionEmailSpy).toHaveBeenCalledTimes(1)
+      // pdf generation is invoked
+      expect(MockMailUtils.generateAutoreplyPdf).toHaveBeenCalledTimes(1)
+      // submission attachments is sent without pdf attachment
+      expect(
+        sendMrfWorkflowCompletionEmailSpy.mock.calls[0][0].attachments,
+      ).toEqual([...MOCK_SUBMISSION_ATTACHMENTS])
+      // the correct destination emails are included
+      expect(
+        sendMrfWorkflowCompletionEmailSpy.mock.calls[0][0].emails,
+      ).toContainValues(['[email protected]'])
+      expect(
+        sendMrfWorkflowCompletionEmailSpy.mock.calls[0][0].emails.length,
+      ).toBe(1)
+    })
+    
     it('sends completion email with pdf attachment when single step mrf is completed', async () => {
       // Arrange
       const sendMrfWorkflowCompletionEmailSpy = jest.spyOn(