Clean up tests

Author: francisco-videira-nhs

lambdas/api-handler/src/handlers/__tests__/letter-status-update.test.ts

@@ -99,8 +99,12 @@ describe('createLetterStatusUpdateHandler', () => {
     await letterStatusUpdateHandler(buildEvent(letterToUpdate), context, callback);
 
     expect(mockedDeps.letterRepo.updateLetterStatus).toHaveBeenCalledWith(letterToUpdate[0]);
-    expect(mockedDeps.logger.error).toHaveBeenCalledWith({ err: mockError},
-      'Error processing update: messageId=mid-id1 correlationId=correlationId-id1');
+    expect(mockedDeps.logger.error).toHaveBeenCalledWith({
+      err: mockError,
+      messageId: 'mid-id1',
+      correlationId: 'correlationId-id1',
+      messageBody: '{\"id\":\"id1\",\"status\":\"ACCEPTED\",\"supplierId\":\"s1\"}',
+    }, 'Error processing letter status update');
   });
 });
 

lambdas/api-handler/src/handlers/letter-status-update.ts

@@ -16,8 +16,12 @@ async function processMessageAsync(message: SQSRecord, deps: Deps): Promise<any>
   try {
     const letterToUpdate: LetterDto = LetterDtoSchema.parse(JSON.parse(message.body));
     await deps.letterRepo.updateLetterStatus(letterToUpdate);
-    deps.logger.info(`Processed update to letterId=${letterToUpdate.id} supplierId=${letterToUpdate.supplierId} correlationId=${message.messageAttributes["CorrelationId"].stringValue}`);
   } catch (error) {
-    deps.logger.error({ err: error }, `Error processing update: messageId=${message.messageId} correlationId=${message.messageAttributes["CorrelationId"].stringValue}`);
+    deps.logger.error({
+      err: error,
+      messageId: message.messageId,
+      correlationId: message.messageAttributes['CorrelationId'].stringValue,
+      messageBody: message.body
+    }, 'Error processing letter status update');
   }
 }

lambdas/api-handler/src/services/__tests__/letter-operations.test.ts

@@ -266,6 +266,8 @@ describe('enqueueLetterUpdateRequests function', () => {
 
     const result = await enqueueLetterUpdateRequests(updateLettersRequest, 'supplier1', 'correlationId1', deps);
 
+    expect(result).toBeUndefined();
+
     expect(deps.sqsClient.send).toHaveBeenNthCalledWith(1, expect.objectContaining({
       input: {
         QueueUrl: deps.env.QUEUE_URL,
@@ -313,23 +315,55 @@ describe('enqueueLetterUpdateRequests function', () => {
           id: 'id1',
           type: 'Letter',
           attributes: {
-            status: 'REJECTED',
-            reasonCode: 123,
-            reasonText: 'Reason text',
+            status: 'ACCEPTED'
+          }
+        },
+        {
+          id: 'id2',
+          type: 'Letter',
+          attributes: {
+            status: 'REJECTED'
           }
         }
       ]
     };
-    const sqsClient = { send: jest.fn().mockRejectedValue(mockError) } as unknown as SQSClient;
+    const sqsClient = { send: jest.fn()
+      .mockRejectedValue(mockError)
+      .mockResolvedValueOnce({ MessageId: 'm1' })
+    } as unknown as SQSClient;
     const logger = { error: jest.fn() } as unknown as pino.Logger;
     const env = {
       QUEUE_URL: 'sqsUrl'
     };
     const deps: Deps = { sqsClient, logger, env } as Deps;
 
-    await enqueueLetterUpdateRequests(updateLettersRequest, 'supplier1', 'correlationId1', deps);
+    const result = await enqueueLetterUpdateRequests(updateLettersRequest, 'supplier1', 'correlationId1', deps);
+
+    expect(result).toBeUndefined();
+
+    expect(deps.sqsClient.send).toHaveBeenNthCalledWith(2, expect.objectContaining({
+      input: {
+        QueueUrl: deps.env.QUEUE_URL,
+        MessageAttributes: {
+          CorrelationId: {
+            DataType: 'String',
+            StringValue: 'correlationId1',
+          }
+        },
+        MessageBody: JSON.stringify({
+            id: updateLettersRequest.data[1].id,
+            supplierId: 'supplier1',
+            status: updateLettersRequest.data[1].attributes.status
+        })
+      }
+    }));
 
-    expect(deps.logger.error).toHaveBeenCalledWith({ err: mockError},
-          'Error queuing letterId=id1 supplierId=supplier1 correlationId=correlationId1 for update');
+    expect(deps.logger.error).toHaveBeenCalledWith({
+      err: mockError,
+      correlationId: 'correlationId1',
+      letterId: 'id2',
+      letterStatus: 'REJECTED',
+      supplierId: 'supplier1'
+    }, 'Error enqueuing letter status update');
   });
 });

lambdas/api-handler/src/services/letter-operations.ts

@@ -91,13 +91,18 @@ export async function enqueueLetterUpdateRequests(postLettersRequest: PostLetter
         MessageBody: JSON.stringify(mapPostLetterResourceToDto(request, supplierId)),
       });
       await deps.sqsClient.send(command);
-      deps.logger.info(`Enqueued letter update: url=${command.input.QueueUrl}, message=${command.input.MessageBody}, correlationId=${correlationId}`)
     } catch (err) {
-      deps.logger.error({ err }, `Error queuing letterId=${request.id} supplierId=${supplierId} correlationId=${correlationId} for update`);
+      deps.logger.error({
+        err,
+        correlationId: correlationId,
+        letterId: request.id,
+        letterStatus: request.attributes.status,
+        supplierId: supplierId
+      }, 'Error enqueuing letter status update');
     }
   });
 
-  await Promise.allSettled(tasks);
+  await Promise.all(tasks);
 }
 
 function isNotFoundError(error: any) {