Fix tests

Author: RanVaknin

services/s3/src/test/java/software/amazon/awssdk/services/s3/internal/extensions/DefaultS3AsyncClientSdkExtensionTest.java

@@ -18,8 +18,8 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
@@ -35,82 +35,106 @@
 
 class DefaultS3AsyncClientSdkExtensionTest {
 
-    private S3AsyncClient s3;
-    private DefaultS3AsyncClientSdkExtension extension;
+    S3AsyncClient s3;
 
     @BeforeEach
     void setUp() {
-        s3 = mock(S3AsyncClient.class);
-        extension = new DefaultS3AsyncClientSdkExtension(s3);
+        s3 = spy(S3AsyncClient.class);
     }
 
     @Test
-    void doesObjectExist_objectExists_returnsTrue() {
-        when(s3.headObject(any(Consumer.class)))
-            .thenReturn(CompletableFuture.completedFuture(HeadObjectResponse.builder().build()));
-        assertThat(extension.doesObjectExist("bucket", "key").join()).isTrue();
+    void doesObjectExist_200_returnsTrue() {
+        stubHeadObject(CompletableFuture.completedFuture(HeadObjectResponse.builder().build()));
+        assertThat(s3.doesObjectExist("foo", "bar").join()).isTrue();
     }
 
     @Test
-    void doesObjectExist_noSuchKey_returnsFalse() {
+    void doesObjectExist_404_returnsFalse() {
         CompletableFuture<HeadObjectResponse> future = new CompletableFuture<>();
         future.completeExceptionally(NoSuchKeyException.builder().build());
-        when(s3.headObject(any(Consumer.class))).thenReturn(future);
-        assertThat(extension.doesObjectExist("bucket", "key").join()).isFalse();
+        stubHeadObject(future);
+        assertThat(s3.doesObjectExist("foo", "bar").join()).isFalse();
     }
 
     @Test
-    void doesObjectExist_otherException_propagates() {
+    void doesObjectExist_403_propagatesException() {
         S3Exception forbidden = (S3Exception) S3Exception.builder().statusCode(403).message("Forbidden").build();
         CompletableFuture<HeadObjectResponse> future = new CompletableFuture<>();
         future.completeExceptionally(forbidden);
-        when(s3.headObject(any(Consumer.class))).thenReturn(future);
-        assertThatThrownBy(() -> extension.doesObjectExist("bucket", "key").join())
+        stubHeadObject(future);
+        assertThatThrownBy(() -> s3.doesObjectExist("foo", "bar").join())
             .isInstanceOf(CompletionException.class)
             .hasCause(forbidden);
     }
 
     @Test
-    void doesBucketExist_bucketExists_returnsTrue() {
-        when(s3.headBucket(any(Consumer.class)))
-            .thenReturn(CompletableFuture.completedFuture(HeadBucketResponse.builder().build()));
-        assertThat(extension.doesBucketExist("bucket").join()).isTrue();
+    void doesBucketExist_200_returnsTrue() {
+        stubHeadBucket(CompletableFuture.completedFuture(HeadBucketResponse.builder().build()));
+        assertThat(s3.doesBucketExist("foo").join()).isTrue();
     }
 
     @Test
-    void doesBucketExist_noSuchBucket_returnsFalse() {
+    void doesBucketExist_404_returnsFalse() {
         CompletableFuture<HeadBucketResponse> future = new CompletableFuture<>();
         future.completeExceptionally(NoSuchBucketException.builder().build());
-        when(s3.headBucket(any(Consumer.class))).thenReturn(future);
-        assertThat(extension.doesBucketExist("bucket").join()).isFalse();
+        stubHeadBucket(future);
+        assertThat(s3.doesBucketExist("foo").join()).isFalse();
     }
 
     @Test
-    void doesBucketExist_otherException_propagates() {
+    void doesBucketExist_403_propagatesException() {
         S3Exception forbidden = (S3Exception) S3Exception.builder().statusCode(403).message("Forbidden").build();
         CompletableFuture<HeadBucketResponse> future = new CompletableFuture<>();
         future.completeExceptionally(forbidden);
-        when(s3.headBucket(any(Consumer.class))).thenReturn(future);
-        assertThatThrownBy(() -> extension.doesBucketExist("bucket").join())
+        stubHeadBucket(future);
+        assertThatThrownBy(() -> s3.doesBucketExist("foo").join())
             .isInstanceOf(CompletionException.class)
             .hasCause(forbidden);
     }
 
+    // Validation tests
+
+    @Test
+    void doesBucketExist_nullBucket_fails() {
+        assertThatThrownBy(() -> s3.doesBucketExist(null).join())
+            .hasCauseInstanceOf(NullPointerException.class);
+    }
+
+    @Test
+    void doesBucketExist_emptyBucket_fails() {
+        assertThatThrownBy(() -> s3.doesBucketExist("").join())
+            .hasCauseInstanceOf(IllegalArgumentException.class);
+    }
+
     @Test
-    void doesBucketExist_nullBucket_failsFuture() {
-        CompletableFuture<Boolean> result = extension.doesBucketExist(null);
-        assertThatThrownBy(result::join).hasCauseInstanceOf(NullPointerException.class);
+    void doesObjectExist_nullBucket_fails() {
+        assertThatThrownBy(() -> s3.doesObjectExist(null, "key").join())
+            .hasCauseInstanceOf(NullPointerException.class);
     }
 
     @Test
-    void doesObjectExist_nullBucket_failsFuture() {
-        CompletableFuture<Boolean> result = extension.doesObjectExist(null, "key");
-        assertThatThrownBy(result::join).hasCauseInstanceOf(NullPointerException.class);
+    void doesObjectExist_emptyBucket_fails() {
+        assertThatThrownBy(() -> s3.doesObjectExist("", "key").join())
+            .hasCauseInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
-    void doesObjectExist_nullKey_failsFuture() {
-        CompletableFuture<Boolean> result = extension.doesObjectExist("bucket", null);
-        assertThatThrownBy(result::join).hasCauseInstanceOf(NullPointerException.class);
+    void doesObjectExist_nullKey_fails() {
+        assertThatThrownBy(() -> s3.doesObjectExist("bucket", null).join())
+            .hasCauseInstanceOf(NullPointerException.class);
+    }
+
+    @Test
+    void doesObjectExist_emptyKey_fails() {
+        assertThatThrownBy(() -> s3.doesObjectExist("bucket", "").join())
+            .hasCauseInstanceOf(IllegalArgumentException.class);
+    }
+
+    private void stubHeadBucket(CompletableFuture<HeadBucketResponse> result) {
+        doReturn(result).when(s3).headBucket(any(Consumer.class));
+    }
+
+    private void stubHeadObject(CompletableFuture<HeadObjectResponse> result) {
+        doReturn(result).when(s3).headObject(any(Consumer.class));
     }
 }