refactor(book): extract S3 upload logic into BookMediaService

erichiroshi · erichiroshi · commit d2e64031ccab · 2026-03-05T10:58:20.000-04:00
BookService was mixing domain logic with storage infrastructure.
Upload responsibility now lives in a dedicated service.

- Create BookMediaService with uploadCover(Long, MultipartFile)
- Remove S3Service, prefix and S3_FOLDER_NAME from BookService
- Update BookController to inject and delegate to BookMediaService
- Rename uploadFile to uploadCover for semantic clarity
- Make find() package-private to support same-package access
diff --git a/src/main/java/com/example/library/book/BookController.java b/src/main/java/com/example/library/book/BookController.java
@@ -27,19 +27,18 @@
 import com.example.library.common.dto.PageResponseDTO;
 
 import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
 
 @Tag(name = "Books", description = "Endpoints para gerenciamento de livros")
+@RequiredArgsConstructor
 @RestController
 @RequestMapping("/api/v1/books")
 public class BookController {
 
 	private static final Logger log = LoggerFactory.getLogger(BookController.class);
 
 	private final BookService bookService;
-
-	public BookController(BookService bookService) {
-		this.bookService = bookService;
-	}
+	private final BookMediaService bookMediaService;
 
 	@Operation(
 		    summary = "Criar novo livro",
@@ -89,10 +88,10 @@ public ResponseEntity<Void> deleteById(@PathVariable Long id) {
 		return ResponseEntity.noContent().build();
 	}
 	
-	@PostMapping("/{bookId}/picture")
-    public ResponseEntity<Void> uploadPicture(@PathVariable Long bookId, @RequestPart("file") MultipartFile file) {
-		URI uri = bookService.uploadFile(bookId, file);
-		return ResponseEntity.created(uri).build();
-	}
+	@PostMapping("/{id}/cover")
+	public ResponseEntity<URI> uploadCover(@PathVariable Long id, @RequestPart	("file") MultipartFile file) {
+		URI uri = bookMediaService.uploadCover(id, file);
+		return ResponseEntity.ok(uri);
+	}	
 
 }
diff --git a/src/main/java/com/example/library/book/BookMediaService.java b/src/main/java/com/example/library/book/BookMediaService.java
@@ -0,0 +1,45 @@
+package com.example.library.book;
+
+import java.net.URI;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.example.library.aws.S3Service;
+import com.example.library.book.exception.BookNotFoundException;
+
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class BookMediaService {
+
+    private static final Logger log = LoggerFactory.getLogger(BookMediaService.class);
+    private static final String S3_FOLDER_NAME = "books/";
+
+    private final BookRepository repository;
+    private final S3Service s3Service;
+
+    @Value("${img.prefix.book}")
+    private String prefix;
+
+    @Transactional
+    public URI uploadCover(Long bookId, MultipartFile file) {
+        Book book = repository.findById(bookId).orElseThrow(() -> {
+            log.warn("Book not found for cover upload: {}", bookId);
+            return new BookNotFoundException(bookId);
+        });
+
+        String fileName = prefix + book.getId();
+        URI uri = s3Service.uploadFile(file, S3_FOLDER_NAME, fileName);
+        book.setCoverImageUrl(uri.toString());
+        repository.save(book);
+
+        log.info("Cover uploaded for bookId={} uri={}", bookId, uri);
+        return uri;
+    }
+}
diff --git a/src/main/java/com/example/library/book/BookService.java b/src/main/java/com/example/library/book/BookService.java
@@ -1,27 +1,23 @@
 package com.example.library.book;
 
-import java.net.URI;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.cache.annotation.Caching;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.web.multipart.MultipartFile;
 
 import io.micrometer.core.instrument.Counter;
 
 import com.example.library.author.Author;
 import com.example.library.author.AuthorLookupService;
-import com.example.library.aws.S3Service;
 import com.example.library.book.dto.BookCreateDTO;
 import com.example.library.book.dto.BookResponseDTO;
 import com.example.library.book.exception.BookAlreadyExistsException;
@@ -41,20 +37,15 @@
 public class BookService {
 	
     private static final Logger log = LoggerFactory.getLogger(BookService.class);
-    private static final String S3_FOLDER_NAME = "books/";
 
 	private final BookRepository repository;
 	private final AuthorLookupService authorPort;
 	private final CategoryLookupService categoryPort;
 	private final BookMapper mapper;
-	private final S3Service s3Service;
 	
 	private final ArtificialDelayService delayService;
 	private final Counter bookCreatedCounter;
 	
-	@Value("${img.prefix.book}")
-	private String prefix;
-
 	@CacheEvict(value = "books", allEntries = true)
 	@Transactional
 	public BookResponseDTO create(BookCreateDTO dto) {
@@ -130,18 +121,7 @@ public void deleteById(Long id) {
 		repository.deleteById(id);
 	}
 
-	//	@CacheEvict(value = "bookById", key = "#id")
-	@Transactional
-	public URI uploadFile(Long bookId, MultipartFile file) {
-		Book book = find(bookId);
-		String fileName = prefix + book.getId();
-		URI uri = s3Service.uploadFile(file, S3_FOLDER_NAME, fileName);
-		book.setCoverImageUrl(uri.toString());
-		repository.save(book);
-		return uri;
-	}
-
-	private Book find(Long id) {
+	Book find(Long id) {
 		return repository.findById(id).orElseThrow(() -> {
 			log.warn("Book not found: {}", id);
 			return new BookNotFoundException(id);
diff --git a/src/test/java/com/example/library/book/BookServiceS3UploadTest.java b/src/test/java/com/example/library/book/BookServiceS3UploadTest.java
@@ -9,6 +9,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.mock.web.MockMultipartFile;
@@ -31,7 +32,6 @@
 /**
  * Testes para a funcionalidade de upload de imagem de capa do livro com S3
  * 
- * VERSÃO ATUALIZADA: Inclui mock do ImageProcessingService
  */
 @ExtendWith(MockitoExtension.class)
 @DisplayName("BookService - Upload S3 Tests (Updated)")
@@ -43,7 +43,8 @@ class BookServiceS3UploadTest {
     @Mock
     private S3Service s3Service;
 
-    private BookService bookService;
+    @InjectMocks
+    private BookMediaService mediaService;
 
     private Book book;
     private Category category;
@@ -52,19 +53,8 @@ class BookServiceS3UploadTest {
 
     @BeforeEach
     void setUp() {
-        // Inicializar BookService
-        bookService = new BookService(
-            bookRepository,
-            null, // authorRepository
-            null, // categoryRepository
-            null, // bookMapper
-            s3Service,
-            null,  // delayService
-            null   // bookCreatedCounter
-        );
-        
         // Inject prefix via ReflectionTestUtils (config mudou para estrutura aninhada)
-        ReflectionTestUtils.setField(bookService, "prefix", "book-");
+        ReflectionTestUtils.setField(mediaService, "prefix", "book-");
 
         // Setup category
         category = new Category();
@@ -107,7 +97,7 @@ void shouldUploadPngImageSuccessfully() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            URI result = bookService.uploadFile(1L, validImage);
+            URI result = mediaService.uploadCover(1L, validImage);
 
             // Assert
             assertThat(result).isEqualTo(expectedS3Uri);
@@ -142,7 +132,7 @@ void shouldUploadJpegImageSuccessfully() {
                 .thenReturn(jpegUri);
 
             // Act
-            URI result = bookService.uploadFile(1L, jpegImage);
+            URI result = mediaService.uploadCover(1L, jpegImage);
 
             // Assert
             assertThat(result).isEqualTo(jpegUri);
@@ -160,7 +150,7 @@ void shouldReplaceExistingUrlOnNewUpload() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            bookService.uploadFile(1L, validImage);
+            mediaService.uploadCover(1L, validImage);
 
             // Assert
             ArgumentCaptor<Book> bookCaptor = ArgumentCaptor.forClass(Book.class);
@@ -180,7 +170,7 @@ void shouldUseCorrectFilenamePrefix() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            bookService.uploadFile(1L, validImage);
+            mediaService.uploadCover(1L, validImage);
 
             // Assert
             // Verifica que o prefixo "book-" + ID está correto
@@ -196,7 +186,7 @@ void shouldUseCorrectS3Folder() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            bookService.uploadFile(1L, validImage);
+            mediaService.uploadCover(1L, validImage);
 
             // Assert
             verify(s3Service).uploadFile(validImage, "books/", "book-1");
@@ -211,7 +201,7 @@ void shouldSaveBookWithUrlAfterSuccessfulUpload() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            bookService.uploadFile(1L, validImage);
+            mediaService.uploadCover(1L, validImage);
 
             // Assert
             verify(bookRepository).save(book);
@@ -232,7 +222,7 @@ void shouldUseExistingBookIdInFilename() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            bookService.uploadFile(12345L, validImage);
+            mediaService.uploadCover(12345L, validImage);
 
             // Assert
             verify(s3Service).uploadFile(validImage, "books/", "book-12345");
@@ -254,7 +244,7 @@ void shouldThrowBookNotFoundExceptionWhenBookDoesNotExist() {
             when(bookRepository.findById(999L)).thenReturn(Optional.empty());
 
             // Act & Assert
-            assertThatThrownBy(() -> bookService.uploadFile(999L, validImage))
+            assertThatThrownBy(() -> mediaService.uploadCover(999L, validImage))
                 .isInstanceOf(BookNotFoundException.class);
 
             // Verifica que S3Service não foi chamado
@@ -271,7 +261,7 @@ void shouldPropagateAmazonClientExceptionOnS3Failure() {
                 .thenThrow(new AmazonClientException());
 
             // Act & Assert
-            assertThatThrownBy(() -> bookService.uploadFile(1L, validImage))
+            assertThatThrownBy(() -> mediaService.uploadCover(1L, validImage))
                 .isInstanceOf(AmazonClientException.class);
 
             // Verifica que o livro NÃO foi salvo
@@ -287,7 +277,7 @@ void shouldNotSaveBookWhenS3ServiceThrowsException() {
                 .thenThrow(new RuntimeException("S3 connection failed"));
 
             // Act & Assert
-            assertThatThrownBy(() -> bookService.uploadFile(1L, validImage))
+            assertThatThrownBy(() -> mediaService.uploadCover(1L, validImage))
                 .isInstanceOf(RuntimeException.class)
                 .hasMessageContaining("S3 connection failed");
 
@@ -311,7 +301,7 @@ void shouldThrowIllegalArgumentExceptionWhenInvalidContentType() {
                 .thenThrow(new IllegalArgumentException("Invalid content type: application/pdf"));
 
             // Act & Assert
-            assertThatThrownBy(() -> bookService.uploadFile(1L, invalidFile))
+            assertThatThrownBy(() -> mediaService.uploadCover(1L, invalidFile))
                 .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("Invalid content type");
 
@@ -335,7 +325,7 @@ void shouldThrowIllegalArgumentExceptionWhenFileTooLarge() {
                 .thenThrow(new IllegalArgumentException("File too large"));
 
             // Act & Assert
-            assertThatThrownBy(() -> bookService.uploadFile(1L, largeFile))
+            assertThatThrownBy(() -> mediaService.uploadCover(1L, largeFile))
                 .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("File too large");
 
@@ -358,7 +348,7 @@ void shouldThrowIllegalArgumentExceptionWhenFileTooSmall() {
                 .thenThrow(new IllegalArgumentException("File too small"));
 
             // Act & Assert
-            assertThatThrownBy(() -> bookService.uploadFile(1L, tinyFile))
+            assertThatThrownBy(() -> mediaService.uploadCover(1L, tinyFile))
                 .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("File too small");
 
@@ -388,7 +378,7 @@ void shouldHandleVeryLargeBookId() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            bookService.uploadFile(largeId, validImage);
+            mediaService.uploadCover(largeId, validImage);
 
             // Assert
             verify(s3Service).uploadFile(validImage, "books/", "book-" + largeId);
@@ -410,7 +400,7 @@ void shouldHandleDifferentAllowedImageTypes() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            bookService.uploadFile(1L, webpImage);
+            mediaService.uploadCover(1L, webpImage);
 
             // Assert
             verify(s3Service).uploadFile(webpImage, "books/", "book-1");
@@ -430,14 +420,14 @@ void shouldHandleMultipleUploadsForSameBook() {
                 .thenReturn(secondUri);
 
             // Act - Primeiro upload
-            URI result1 = bookService.uploadFile(1L, validImage);
+            URI result1 = mediaService.uploadCover(1L, validImage);
             
             // Assert - Primeiro upload
             assertThat(result1).isEqualTo(firstUri);
             assertThat(book.getCoverImageUrl()).isEqualTo(firstUri.toString());
 
             // Act - Segundo upload
-            URI result2 = bookService.uploadFile(1L, validImage);
+            URI result2 = mediaService.uploadCover(1L, validImage);
             
             // Assert - Segundo upload substitui
             assertThat(result2).isEqualTo(secondUri);
@@ -465,7 +455,7 @@ void shouldFetchBookBeforeUpload() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            bookService.uploadFile(1L, validImage);
+            mediaService.uploadCover(1L, validImage);
 
             // Assert
             // Verifica ordem de chamadas
@@ -486,7 +476,7 @@ void shouldReturnUriFromS3Service() {
                 .thenReturn(customUri);
 
             // Act
-            URI result = bookService.uploadFile(1L, validImage);
+            URI result = mediaService.uploadCover(1L, validImage);
 
             // Assert
             assertThat(result).isEqualTo(customUri);
@@ -501,7 +491,7 @@ void shouldSaveBookWithSameUriReturned() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            URI returnedUri = bookService.uploadFile(1L, validImage);
+            URI returnedUri = mediaService.uploadCover(1L, validImage);
 
             // Assert
             ArgumentCaptor<Book> bookCaptor = ArgumentCaptor.forClass(Book.class);
@@ -524,7 +514,7 @@ void shouldKeepOtherBookFieldsUnchanged() {
                 .thenReturn(expectedS3Uri);
 
             // Act
-            bookService.uploadFile(1L, validImage);
+            mediaService.uploadCover(1L, validImage);
 
             // Assert
             ArgumentCaptor<Book> bookCaptor = ArgumentCaptor.forClass(Book.class);
