Full Test cases coverage

Author: Pankaj Agrawal

powertools-sqs/src/main/java/software/amazon/lambda/powertools/sqs/PowertoolsSqs.java

@@ -97,6 +97,11 @@ public static SqsClient defaultSqsClient() {
         return client;
     }
 
+    public static <R> List<R> partialBatchProcessor(final SQSEvent event,
+                                                    final Class<? extends SqsMessageHandler<R>> handler) {
+        return partialBatchProcessor(event, false, handler);
+    }
+
     public static <R> List<R> partialBatchProcessor(final SQSEvent event,
                                                     final boolean suppressException,
                                                     final Class<? extends SqsMessageHandler<R>> handler) {
@@ -118,6 +123,11 @@ public static <R> List<R> partialBatchProcessor(final SQSEvent event,
         }
     }
 
+    public static <R> List<R> partialBatchProcessor(final SQSEvent event,
+                                                    final SqsMessageHandler<R> handler) {
+        return partialBatchProcessor(event, false, handler);
+    }
+
     public static <R> List<R> partialBatchProcessor(final SQSEvent event,
                                                     final boolean suppressException,
                                                     final SqsMessageHandler<R> handler) {

powertools-sqs/src/main/java/software/amazon/lambda/powertools/sqs/SQSBatchProcessingException.java

@@ -16,6 +16,10 @@ public class SQSBatchProcessingException extends RuntimeException {
     public <T> SQSBatchProcessingException(final List<Exception> exceptions,
                                            final List<SQSEvent.SQSMessage> failures,
                                            final List<T> successReturns) {
+        super(exceptions.stream()
+                .map(Throwable::toString)
+                .collect(joining("\n")));
+
         this.exceptions = new ArrayList<>(exceptions);
         this.failures = new ArrayList<>(failures);
         this.returnValues = new ArrayList<>(successReturns);
@@ -33,25 +37,13 @@ public List<SQSEvent.SQSMessage> getFailures() {
         return failures;
     }
 
-    @Override
-    public String getMessage() {
-        return exceptions.stream()
-                .map(Throwable::toString)
-                .collect(joining("\n"));
-    }
-
     @Override
     public void printStackTrace() {
         for (Exception exception : exceptions) {
             exception.printStackTrace();
         }
     }
 
-    @Override
-    public String toString() {
-        return getMessage();
-    }
-
     <T> void addSuccessMessageReturnValues(final List<T> returnValues) {
         this.returnValues.addAll(returnValues);
     }

powertools-sqs/src/test/java/software/amazon/lambda/powertools/sqs/PowertoolsSqsBatchProcessorTest.java

@@ -2,42 +2,53 @@
 
 import java.io.IOException;
 import java.util.List;
-import java.util.stream.Stream;
 
-import com.amazonaws.AmazonServiceException;
-import com.amazonaws.SdkClientException;
 import com.amazonaws.services.lambda.runtime.events.SQSEvent;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.ValueSource;
 import software.amazon.awssdk.services.sqs.SqsClient;
+import software.amazon.awssdk.services.sqs.model.DeleteMessageBatchRequest;
+import software.amazon.awssdk.services.sqs.model.GetQueueUrlRequest;
+import software.amazon.awssdk.services.sqs.model.GetQueueUrlResponse;
 
 import static com.amazonaws.services.lambda.runtime.events.SQSEvent.SQSMessage;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+import static software.amazon.lambda.powertools.sqs.PowertoolsSqs.defaultSqsClient;
+import static software.amazon.lambda.powertools.sqs.PowertoolsSqs.partialBatchProcessor;
 
 class PowertoolsSqsBatchProcessorTest {
 
-    private final SqsClient sqsClient = mock(SqsClient.class);
-    private final SqsClient interactionClient = mock(SqsClient.class);
+    private static final SqsClient sqsClient = mock(SqsClient.class);
+    private static final SqsClient interactionClient = mock(SqsClient.class);
     private static final ObjectMapper MAPPER = new ObjectMapper();
     private SQSEvent event;
 
     @BeforeEach
     void setUp() throws IOException {
+        reset(sqsClient, interactionClient);
         event = MAPPER.readValue(this.getClass().getResource("/sampleSqsBatchEvent.json"), SQSEvent.class);
-        PowertoolsSqs.defaultSqsClient(sqsClient);
+
+        when(sqsClient.getQueueUrl(any(GetQueueUrlRequest.class))).thenReturn(GetQueueUrlResponse.builder()
+                .queueUrl("test")
+                .build());
+
+        defaultSqsClient(sqsClient);
     }
 
     @Test
     void shouldBatchProcessAndNotDeleteMessagesWhenAllSuccess() {
-        List<String> returnValues = PowertoolsSqs.partialBatchProcessor(event, false, (message) -> {
+        List<String> returnValues = partialBatchProcessor(event, false, (message) -> {
             interactionClient.listQueues();
             return "Success";
         });
@@ -53,24 +64,159 @@ void shouldBatchProcessAndNotDeleteMessagesWhenAllSuccess() {
     @ParameterizedTest
     @ValueSource(classes = {SampleInnerSqsHandler.class, SampleSqsHandler.class})
     void shouldBatchProcessViaClassAndNotDeleteMessagesWhenAllSuccess(Class<? extends SqsMessageHandler<String>> handler) {
-        List<String> returnValues = PowertoolsSqs.partialBatchProcessor(event, false, handler);
+        List<String> returnValues = partialBatchProcessor(event, handler);
 
         assertThat(returnValues)
                 .hasSize(2)
                 .containsExactly("0", "1");
+
+        verifyNoInteractions(sqsClient);
+    }
+
+    @Test
+    void shouldBatchProcessAndDeleteSuccessMessageOnPartialFailures() {
+        String failedId = "2e1424d4-f796-459a-8184-9c92662be6da";
+
+        SqsMessageHandler<String> failedHandler = (message) -> {
+            if (failedId.equals(message.getMessageId())) {
+                throw new RuntimeException("Failed processing");
+            }
+
+            interactionClient.listQueues();
+            return "Success";
+        };
+
+        assertThatExceptionOfType(SQSBatchProcessingException.class)
+                .isThrownBy(() -> partialBatchProcessor(event, failedHandler))
+                .satisfies(e -> {
+
+                    assertThat(e.successMessageReturnValues())
+                            .hasSize(1)
+                            .contains("Success");
+
+                    assertThat(e.getFailures())
+                            .hasSize(1)
+                            .extracting("messageId")
+                            .contains(failedId);
+
+                    assertThat(e.getExceptions())
+                            .hasSize(1)
+                            .extracting("detailMessage")
+                            .contains("Failed processing");
+                });
+
+        verify(interactionClient).listQueues();
+        verify(sqsClient).deleteMessageBatch(any(DeleteMessageBatchRequest.class));
+    }
+
+    @Test
+    void shouldBatchProcessAndFullFailuresInBatch() {
+        SqsMessageHandler<String> failedHandler = (message) -> {
+            throw new RuntimeException(message.getMessageId());
+        };
+
+        assertThatExceptionOfType(SQSBatchProcessingException.class)
+                .isThrownBy(() -> partialBatchProcessor(event, failedHandler))
+                .satisfies(e -> {
+
+                    assertThat(e.successMessageReturnValues())
+                            .isEmpty();
+
+                    assertThat(e.getFailures())
+                            .hasSize(2)
+                            .extracting("messageId")
+                            .containsExactly("059f36b4-87a3-44ab-83d2-661975830a7d",
+                                    "2e1424d4-f796-459a-8184-9c92662be6da");
+
+                    assertThat(e.getExceptions())
+                            .hasSize(2)
+                            .extracting("detailMessage")
+                            .containsExactly("059f36b4-87a3-44ab-83d2-661975830a7d",
+                                    "2e1424d4-f796-459a-8184-9c92662be6da");
+                });
+
+        verifyNoInteractions(sqsClient);
+    }
+
+    @Test
+    void shouldBatchProcessViaClassAndDeleteSuccessMessageOnPartialFailures() {
+        assertThatExceptionOfType(SQSBatchProcessingException.class)
+                .isThrownBy(() -> partialBatchProcessor(event, FailureSampleInnerSqsHandler.class))
+                .satisfies(e -> {
+
+                    assertThat(e.successMessageReturnValues())
+                            .hasSize(1)
+                            .contains("Success");
+
+                    assertThat(e.getFailures())
+                            .hasSize(1)
+                            .extracting("messageId")
+                            .contains("2e1424d4-f796-459a-8184-9c92662be6da");
+
+                    assertThat(e.getExceptions())
+                            .hasSize(1)
+                            .extracting("detailMessage")
+                            .contains("Failed processing");
+                });
+
+        verify(sqsClient).deleteMessageBatch(any(DeleteMessageBatchRequest.class));
+    }
+
+
+    @Test
+    void shouldBatchProcessAndSuppressExceptions() {
+        String failedId = "2e1424d4-f796-459a-8184-9c92662be6da";
+
+        SqsMessageHandler<String> failedHandler = (message) -> {
+            if (failedId.equals(message.getMessageId())) {
+                throw new RuntimeException("Failed processing");
+            }
+
+            interactionClient.listQueues();
+            return "Success";
+        };
+
+        List<String> returnValues = partialBatchProcessor(event, true, failedHandler);
+
+        assertThat(returnValues)
+                .hasSize(1)
+                .contains("Success");
+
+        verify(interactionClient).listQueues();
+        verify(sqsClient).deleteMessageBatch(any(DeleteMessageBatchRequest.class));
     }
 
-    private static Stream<Arguments> exception() {
-        return Stream.of(Arguments.of(new AmazonServiceException("Service Exception")),
-                Arguments.of(new SdkClientException("Client Exception")));
+    @Test
+    void shouldBatchProcessViaClassAndSuppressExceptions() {
+        List<String> returnValues = partialBatchProcessor(event, true, FailureSampleInnerSqsHandler.class);
+
+        assertThat(returnValues)
+                .hasSize(1)
+                .contains("Success");
+
+        verify(interactionClient).listQueues();
+        verify(sqsClient).deleteMessageBatch(any(DeleteMessageBatchRequest.class));
     }
 
     public class SampleInnerSqsHandler implements SqsMessageHandler<String> {
         private int counter;
 
         @Override
         public String process(SQSMessage message) {
+            interactionClient.listQueues();
             return String.valueOf(counter++);
         }
     }
+
+    public class FailureSampleInnerSqsHandler implements SqsMessageHandler<String> {
+        @Override
+        public String process(SQSEvent.SQSMessage message) {
+            if ("2e1424d4-f796-459a-8184-9c92662be6da".equals(message.getMessageId())) {
+                throw new RuntimeException("Failed processing");
+            }
+
+            interactionClient.listQueues();
+            return "Success";
+        }
+    }
 }

powertools-sqs/src/test/java/software/amazon/lambda/powertools/sqs/handlers/PartialBatchFailureSuppressedHandler.java

@@ -0,0 +1,32 @@
+package software.amazon.lambda.powertools.sqs.handlers;
+
+import com.amazonaws.services.lambda.runtime.Context;
+import com.amazonaws.services.lambda.runtime.RequestHandler;
+import com.amazonaws.services.lambda.runtime.events.SQSEvent;
+import software.amazon.lambda.powertools.sqs.SqsBatchProcessor;
+import software.amazon.lambda.powertools.sqs.SqsMessageHandler;
+
+import static com.amazonaws.services.lambda.runtime.events.SQSEvent.SQSMessage;
+import static software.amazon.lambda.powertools.sqs.internal.SqsMessageBatchProcessorAspectTest.sqsClient;
+
+public class PartialBatchFailureSuppressedHandler implements RequestHandler<SQSEvent, String> {
+    @Override
+    @SqsBatchProcessor(value = InnerMessageHandler.class, suppressException = true)
+    public String handleRequest(final SQSEvent sqsEvent,
+                                final Context context) {
+        return "Success";
+    }
+
+    private class InnerMessageHandler implements SqsMessageHandler<Object> {
+
+        @Override
+        public String process(SQSMessage message) {
+            if ("2e1424d4-f796-459a-8184-9c92662be6da".equals(message.getMessageId())) {
+                throw new RuntimeException("2e1424d4-f796-459a-8184-9c92662be6da");
+            }
+
+            sqsClient.listQueues();
+            return "Success";
+        }
+    }
+}

powertools-sqs/src/test/java/software/amazon/lambda/powertools/sqs/handlers/PartialBatchHandler.java

@@ -0,0 +1,32 @@
+package software.amazon.lambda.powertools.sqs.handlers;
+
+import com.amazonaws.services.lambda.runtime.Context;
+import com.amazonaws.services.lambda.runtime.RequestHandler;
+import com.amazonaws.services.lambda.runtime.events.SQSEvent;
+import software.amazon.lambda.powertools.sqs.SqsBatchProcessor;
+import software.amazon.lambda.powertools.sqs.SqsMessageHandler;
+
+import static com.amazonaws.services.lambda.runtime.events.SQSEvent.SQSMessage;
+import static software.amazon.lambda.powertools.sqs.internal.SqsMessageBatchProcessorAspectTest.sqsClient;
+
+public class PartialBatchPartialFailureHandler implements RequestHandler<SQSEvent, String> {
+    @Override
+    @SqsBatchProcessor(InnerMessageHandler.class)
+    public String handleRequest(final SQSEvent sqsEvent,
+                                final Context context) {
+        return "Success";
+    }
+
+    private class InnerMessageHandler implements SqsMessageHandler<Object> {
+
+        @Override
+        public String process(SQSMessage message) {
+            if ("2e1424d4-f796-459a-8184-9c92662be6da".equals(message.getMessageId())) {
+                throw new RuntimeException("2e1424d4-f796-459a-8184-9c92662be6da");
+            }
+
+            sqsClient.listQueues();
+            return "Success";
+        }
+    }
+}