Effective Testing of Cloud Components with Quarkus and LocalStack

      You also need to add one HTTP client library as a dependency, let’s use url-connection-client.

     ```


      <dependency>
         <groupId>software.amazon.awssdk</groupId>
         <artifactId>url-connection-client</artifactId>
      </dependency>

     You just received a connection error because quarkus did not run a localstack container before running your tests. Let’s fix that with a S3 integration.

3. **Java implementation S3 integration**

     Now that we understand the environment of our AWS S3 local integration, we can go to the Java code. How quarkinverse extension helps coding and S3 integration?
With this extension, you can use the @Inject annotation from jakarta CDI, to get a S3 client and do whatever you want with your bucket, either in production or test code:


     ```java


       @Inject
       private S3Client s3;

 To isolate the interaction with external aws library, I created one interface to abstract this process:

 ```java

   public interface ImageDataRepository {
      public void save(Path file,
                     Image image);
      public byte [] find(Image image);
      public void delete(Image image);
      public String createPresignedGetUrl(Image image);       
      public String getBucketName();
   }

     And the S3Client is injected into a concrete class called S3BucketImage, that invokes the API services.

     To make transfers to S3 safer, we can use pre-signed urls. Those are temporary addresses that lets your application securely share a link with clients and transfer content directly to them.
In our application, there are three rest services (JAX-RS resources) where it is possible to save, get and generate a presigned URL to your S3 object:

     ```java


        @Path("/image")
        public class ImageResource {
           @Inject
           private ImageDataRepository imageDataRepository;

           @POST
           @Consumes(MediaType.MULTIPART_FORM_DATA)
           @Transactional
           public void saveImage(ImageFormData imageFormData){
                Image image = ImageBuilder.newInstance()                                 .withBucket(imageDataRepository.getBucketName())
               .withFileName(imageFormData.fileName)
               .withMimeType(imageFormData.mimeType)
               .addTag("fileName",  imageFormData.fileName).build();
               image.persist();
           imageDataRepository.save(imageFormData.file.toPath(), image);
           }

           @Path("/{id}")
           @GET
           @Produces(MediaType.APPLICATION_OCTET_STREAM)
           public byte[] getImage(@PathParam("id") Long id){
              return imageDataRepository.find(Image.findById(id));
           }

           @Path("/{id}/presignedGetUrl")
           @GET
           public String createPresignedGetUrl(@PathParam("id") Long id){
              return imageDataRepository.createPresignedGetUrl(Image.findById(id));
           }
         } 

 The ImageDataRepository implementation provides the S3 operations:

 ```java

    @ApplicationScoped
    public class S3BucketImage implements ImageDataRepository {
      @ConfigProperty(name = "bucket.name")
      private String bucketName;
      @ConfigProperty(name = "presigned.url.duration.in.minutes")
      private Integer presignedUrlDurationInMinutes;
      @Inject
      private S3Client s3;
      @Inject
      private S3Presigner presigner;

      public String getBucketName(){
         return this.bucketName;
      }

      public void save(Path file,
                Image productImage) {
         List<Tag> tagsS3 = getTags(productImage);
         s3.putObject(
         PutObjectRequest.builder()
           .bucket(productImage.bucket())
           .key(productImage.key())
           .contentType(productImage.mimeType())
          .tagging(Tagging.builder().tagSet(tagsS3).build())
           .build(),
           RequestBody.fromFile(file));
      }

      public void delete(Image productImage) {
           DeleteObjectRequest deleteRequest = DeleteObjectRequest.builder()
           .bucket(productImage.bucket())
           .key(productImage.key())
           .build();

           s3.deleteObject(deleteRequest);
      }

      public byte[] find(Image productImage) {
         try {
             return s3.getObject(GetObjectRequest.builder()
                  .bucket(productImage.bucket())
                  .key(productImage.key())
                  .build()).readAllBytes();
          } catch (IOException e) {
               throw new RuntimeException(e);
          }
      }

      public String createPresignedGetUrl(Image productImage) {
          GetObjectRequest objectRequest = GetObjectRequest.builder()
           .bucket(productImage.bucket())
           .key(productImage.key())
           .build();

          GetObjectPresignRequest presignRequest =  GetObjectPresignRequest.builder()
         .signatureDuration(Duration.ofMinutes(presignedUrlDurationInMinutes))
           .getObjectRequest(objectRequest)
           .build();

          PresignedGetObjectRequest presignedRequest = presigner.presignGetObject(presignRequest);


          return presignedRequest.url().toExternalForm();
      }

      private List<Tag> getTags(Image productImage) {
          List<Tag> tagsS3 = productImage.tags().stream().map(
           t -> parseTagS3(t)
           ).collect(Collectors.toList());
             return tagsS3;
      }

      private Tag parseTagS3(s3sample.domain.Tag t) {
          return Tag.builder().key(t.key()).value(t.value()).build();
      }

      @PostConstruct
      private void createBucket() {
          try {
             try {
                 HeadBucketRequest headBucketRequest = HeadBucketRequest.builder()
                   .bucket(bucketName)
                   .build();
           s3.headBucket(headBucketRequest);
           } catch (NoSuchBucketException e) {
                CreateBucketRequest bucketRequest = CreateBucketRequest.builder()
                   .bucket(bucketName)
                   .build();
                s3.createBucket(bucketRequest);
           }
         } catch (Exception e) {
            //FIXME add log
         }
    }
  }

     Notice that the method createBucket() creates the bucket only if does not already exists.

4. **Tests**

     The tests were created using REST Assured to POST and GET the image, and to GET a  pre-signed URL to the image. The tests were separated into two classes, one for get operations, and another to save the image.

     ```java


        @QuarkusTest
        public class ImageGetTest extends ImageTest {
             Image productImage;

             @BeforeEach
             @Transactional
             void startProductFixture(){
                  productImage = ImageBuilder.newInstance()
                    .withFileName(fileName)
                    .withBucket(bucketName)
                    .withMimeType(mimetype)
                    .addTag("fileName", fileName)
                    .addTag("city", "Vitoria")
                    .addTag("country", "Brasil")
                    .build();
                  productImage.persist();
                  imageDataRepository.save(file, productImage);
             }

             @Test
             public void testGetS3ProductImage() {
                    byte [] file = given()
                      .when()
                      .get("/api/image/" + productImage.id)
                      .then()
                      .statusCode(HttpStatus.SC_OK)
                      .extract()
                      .body()
                      .asByteArray(); // Adjust the expected     status code as needed
                    assertThat(file, notNullValue());

                   //saveFileLocalToVerifyManually(file);
             }

             @Test
             public void testPresignedGetUrlS3() {
                  String preAssignedUrl = given()
                     .when()
                     .get("/api/image/%d/presignedGetUrl".formatted(productImage.id))
                     .then()
                     .statusCode(HttpStatus.SC_OK)
                     .extract()
                     .body()
                     .asString();

                  byte [] file = given()
                     .baseUri(preAssignedUrl)
                     .get()
                     .then()
                     .statusCode(HttpStatus.SC_OK)
                     .extract()
                     .body()
                     .asByteArray();

                 assertThat(file, notNullValue());

                //   saveFileLocalToVerifyManually(file);
            }


            private void saveFileLocalToVerifyManually(byte [] file){
                String localFilePath = "/tmp/test.jpg";

                try (FileOutputStream fos = new  FileOutputStream(localFilePath)) {
                    fos.write(file);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

          }

 Test to upload the image to S3:

 ```java

     @QuarkusTest
     public class ImagePostTest extends ImageTest {
         @Test
         public void testUpdateS3ProductImage() {
              Integer id = given()
              .multiPart("file", file)
              .multiPart("fileName", fileName)
              .multiPart("mimeType", mimetype)
              .when()
              .post("/api/image")
              .then()
              .statusCode(HttpStatus.SC_OK)
              .extract().path("id");

              Image img = Image.findById(id);
              assertThat(img, notNullValue());
              assertThat(img.bucket(), equalTo(bucketName));
              assertThat(img.id, notNullValue());
              assertThat(img.fileName(), equalTo(fileName));
              assertThat(img.mimeType(), equalTo(mimetype));

              byte [] imageFileData = imageDataRepository.find(img);
              assertThat(imageFileData, notNullValue());

              imageDataRepository.delete(img);
         }
     }

     The abstract superclass supply common resources to the tests:

     ```Java


        public abstract class ImageTest {
             String fileName = "Vitoria_ES_Brasil.jpg";
             String mimetype = "image/jpeg";
             Path file = Paths.get("src/test/resources/s3sample/domain/core/product/" + fileName);
             @ConfigProperty(name = "bucket.name")
             String bucketName;
             @Inject
             ImageDataRepository imageDataRepository;
        }

 As you can see, the interface ImageDataRepository provides the implementation to operate on S3. In the end, quarkus will inject an S3Client pointing to the local services running in a docker container.