test refactoring

Author: ORybak5

service/build.gradle

@@ -73,6 +73,7 @@ dependencies {
 	testImplementation 'com.squareup.okhttp3:okhttp:4.12.0'
 	testImplementation 'com.squareup.okhttp3:mockwebserver:4.12.0'
 	testImplementation 'io.findify:s3mock_2.13:0.2.6'
+	testImplementation 'com.adobe.testing:s3mock-junit5:3.12.0'
 
 	pitest 'com.arcmutate:base:1.3.1'
 	pitest 'com.arcmutate:pitest-git-plugin:2.0.0'

service/src/test/java/uk/nhs/adaptors/gp2gp/common/storage/S3StorageConnectorTest.java

@@ -1,85 +1,90 @@
 package uk.nhs.adaptors.gp2gp.common.storage;
 
-import org.junit.jupiter.api.BeforeEach;
+import com.adobe.testing.s3mock.junit5.S3MockExtension;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.junit.jupiter.api.extension.RegisterExtension;
 import software.amazon.awssdk.core.ResponseInputStream;
 import software.amazon.awssdk.core.sync.RequestBody;
-import software.amazon.awssdk.regions.Region;
 import software.amazon.awssdk.services.s3.S3Client;
-import software.amazon.awssdk.services.s3.model.GetObjectRequest;
+import software.amazon.awssdk.services.s3.model.CreateBucketRequest;
 import software.amazon.awssdk.services.s3.model.GetObjectResponse;
+import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
+import software.amazon.awssdk.services.s3.model.HeadObjectResponse;
 import software.amazon.awssdk.services.s3.model.PutObjectRequest;
 
 import java.io.ByteArrayInputStream;
+import java.io.IOException;
 import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Optional;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+
 
 class S3StorageConnectorTest {
 
+    public static final int PORT = 9090;
+    private static final String BUCKET_NAME = "s3bucket";
     private static final String FILE_NAME = "test-file.txt";
-    private S3StorageConnector s3StorageConnector;
-    private StorageConnectorConfiguration config;
-    private static final long STREAM_LENGTH = 100L;
 
-    @Mock
-    private S3Client mockS3Client;
+    @RegisterExtension
+    static final S3MockExtension S3_MOCK = S3MockExtension.builder().withSecureConnection(false).build();
+
+    private static S3StorageConnector s3StorageConnector;
+    private static StorageConnectorConfiguration config;
+
+    private static S3Client s3Client;
 
-    @Mock
-    private InputStream is;
+    @BeforeAll
+    static void setUp() {
 
-    @BeforeEach
-    void setUp() {
-        MockitoAnnotations.openMocks(this);
+        s3Client = S3_MOCK.createS3ClientV2();
 
         config = new StorageConnectorConfiguration();
-        config.setContainerName("s3Bucket");
+        config.setContainerName(BUCKET_NAME);
 
-        s3StorageConnector = new S3StorageConnector(mockS3Client, config);
-    }
+        s3Client.createBucket(CreateBucketRequest.builder().bucket(BUCKET_NAME).build());
 
+        s3StorageConnector = new S3StorageConnector(s3Client, config);
+    }
 
     @Test
-    void expectExceptionWhenS3ClientCannotDeliverResponse() {
-        S3StorageConnector storageConnector = new S3StorageConnector(S3Client.builder().region(Region.EU_WEST_2).build(), config);
+    void expectExceptionWhenFileDoesNotExist() {
         Exception exception = assertThrows(StorageConnectorException.class,
-                                           () -> storageConnector.downloadFromStorage("s3File"));
+                                           () -> s3StorageConnector.downloadFromStorage("nonexistent-file.txt"));
 
         assertEquals("Error occurred downloading from S3 Bucket", exception.getMessage());
     }
 
     @Test
-    void downloadFromStorageTest() {
-        var mockResponse = mock(GetObjectResponse.class);
-        var mockInputStream = new ByteArrayInputStream("dummy-content".getBytes());
-        var mockResponseInputStream = new ResponseInputStream<>(mockResponse, mockInputStream);
-        final var request = GetObjectRequest.builder().bucket(config.getContainerName()).key(FILE_NAME).build();
+    void downloadFromStorageTest() throws IOException {
 
-        when(mockS3Client.getObject(request)).thenReturn(mockResponseInputStream);
+        String fileContent = "dummy-content";
+        s3Client.putObject(
+            PutObjectRequest.builder().bucket(BUCKET_NAME).key(FILE_NAME).build(),
+            RequestBody.fromString(fileContent));
 
-        var result = s3StorageConnector.downloadFromStorage(FILE_NAME);
+        ResponseInputStream<GetObjectResponse> response = s3StorageConnector.downloadFromStorage(FILE_NAME);
+        String downloadedContent = new String(response.readAllBytes(), StandardCharsets.UTF_8);
 
-        assertNotNull(result);
-        verify(mockS3Client).getObject(request);
+        assertNotNull(response);
+        assertEquals(fileContent, downloadedContent);
     }
 
     @Test
-    void uploadToStorageTest() {
-        final var expectedRequest = PutObjectRequest.builder().bucket(config.getContainerName()).key(FILE_NAME).build();
+    void uploadToStorageTest() throws IOException {
+        InputStream inputStream = new ByteArrayInputStream("upload-content".getBytes(StandardCharsets.UTF_8));
+        long streamLength = inputStream.available();
+
+        s3StorageConnector.uploadToStorage(inputStream, streamLength, FILE_NAME);
 
-        s3StorageConnector.uploadToStorage(is, STREAM_LENGTH, FILE_NAME);
+        HeadObjectResponse response = s3Client.headObject(HeadObjectRequest.builder().bucket(BUCKET_NAME).key(FILE_NAME).build());
 
-        verify(mockS3Client, times(1)).putObject(eq(expectedRequest), any(RequestBody.class));
+        assertNotNull(response);
+        assertEquals(Optional.of(streamLength).get(), response.contentLength());
     }
 
 }