✅ réussite des test des usecase

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/usecase/BookUseCase.java

@@ -0,0 +1,90 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.usecase;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDetails;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.converter.BookConverter;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.IllegalBookStockException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.validator.BookValidator;
+
+import java.util.Optional;
+
+public class BookUseCase {
+
+    private final BookRepository bookRepository;
+
+    public BookUseCase(BookRepository bookRepository) {
+
+        this.bookRepository = bookRepository;
+    }
+
+    public String registerBook(BookInfo newbook, BookSalesInfo newbooksalesinfo, BookDetails newbookdetails) throws NotValidBookException {
+        BookValidator.validate(newbook);
+        BookValidator.validate(newbooksalesinfo);
+        BookValidator.validate(newbookdetails);
+        Book bookToRegister = BookConverter.ToDomain(newbook, newbooksalesinfo, newbookdetails);
+        Book bookToRegistered = bookRepository.save(bookToRegister);
+        return bookToRegistered.getIsbn();
+    }
+
+    public Optional<BookDTO> findBookByIsbn(String isbn) {
+        Optional<Book> optionalBook = bookRepository.findByIsbn(isbn);
+        return optionalBook.map(BookConverter::ToDTO);
+    }
+
+    public BookDTO updateBook(String isbn, BookInfo bookinfo, BookSalesInfo booksalesinfo, BookDetails bookdetails)
+            throws BookNotFoundException, NotValidBookException {
+        BookValidator.validate(bookinfo);
+        BookValidator.validate(booksalesinfo);
+        BookValidator.validate(bookdetails);
+        Book bookByIsbn = getBookIfDoesNotExistThrowBookNotFoundException(isbn);
+        Book book = Book.builder()
+                .isbn(isbn)
+                .title(bookinfo.title())
+                .author(bookinfo.author())
+                .editor(bookinfo.editor())
+                .date(bookByIsbn.getDate())
+                .price(booksalesinfo.getPrice())
+                .stock(booksalesinfo.getStock())
+                .categories(bookdetails.getCategories())
+                .description(bookdetails.getDescription())
+                .language(bookByIsbn.getLanguage())
+                .build();
+        Book updatedBook = bookRepository.save(book);
+        return BookConverter.ToDTO(updatedBook);
+    }
+
+    public void deleteBook(String isbn) throws BookNotFoundException {
+        Book bookToDelete = getBookIfDoesNotExistThrowBookNotFoundException(isbn);
+        this.bookRepository.delete(bookToDelete);
+    }
+
+    public int addStockCopies(String isbn, int stockCopiesToAdd) throws BookNotFoundException {
+        Book bookToAddStockCopies = getBookIfDoesNotExistThrowBookNotFoundException(isbn);
+        bookToAddStockCopies.addStock(stockCopiesToAdd);
+        bookRepository.save(bookToAddStockCopies);
+        return bookToAddStockCopies.getStock();
+    }
+
+    public int subtractStockCopies(String isbn, int stockCopiesToRemove)
+            throws BookNotFoundException, IllegalBookStockException {
+        Book bookToSubtractStockCopies = getBookIfDoesNotExistThrowBookNotFoundException(isbn);
+        bookToSubtractStockCopies.removeStock(stockCopiesToRemove);
+        bookRepository.save(bookToSubtractStockCopies);
+        return bookToSubtractStockCopies.getStock();
+    }
+
+    private Book getBookIfDoesNotExistThrowBookNotFoundException(String isbn)
+            throws BookNotFoundException {
+        Optional<Book> optionalBookByIsbn = bookRepository.findByIsbn(isbn);
+        if (optionalBookByIsbn.isEmpty()) {
+            throw new BookNotFoundException(isbn);
+        }
+        return optionalBookByIsbn.get();
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/usecase/BookUseCaseTest.java

@@ -5,6 +5,8 @@ import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDetails;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.IllegalBookStockException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
 import org.junit.jupiter.api.BeforeEach;
@@ -87,7 +89,7 @@ public class BookUseCaseTest {
         void testRegisterBookWithValidData() throws NotValidBookException {
             when(bookRepository.save(any(Book.class))).thenReturn(testBook);
 
-            String registeredIsbn = bookUseCase.registerBook(validBookInfo);
+            String registeredIsbn = bookUseCase.registerBook(validBookInfo, validBookSalesInfo, validBookDetails);
 
             assertNotNull(registeredIsbn);
             assertEquals(bookIsbn, registeredIsbn);
@@ -98,9 +100,17 @@ public class BookUseCaseTest {
         @DisplayName("Should throw exception when book data is not valid")
         void testRegisterBookWithInvalidData() {
             BookInfo invalidBookInfo = new BookInfo(bookIsbn,"", "", "", date);
-
+            BookSalesInfo invalidUpdateSalesInfo = BookSalesInfo.builder()
+                    .price(0)
+                    .stock(-3)
+                    .build();
+            BookDetails invalidUpdateDetails = BookDetails.builder()
+                    .categories(categories)
+                    .description("")
+                    .language("")
+                    .build();
             assertThrows(NotValidBookException.class,
-                    () -> bookUseCase.registerBook(invalidBookInfo));
+                    () -> bookUseCase.registerBook(invalidBookInfo, invalidUpdateSalesInfo, invalidUpdateDetails));
 
             verify(bookRepository, never()).save(any(Book.class));
         }
@@ -125,7 +135,7 @@ public class BookUseCaseTest {
 
         @Test
         @DisplayName("Should return empty Optional when isbn doesn't exist")
-        void testFindBookByIsbn() {
+        void testFindBookByIsbnNotFound() {
             when(bookRepository.findByIsbn("1656546262516")).thenReturn(Optional.empty());
 
             Optional<BookDTO> foundBook = bookUseCase.findBookByIsbn("1656546262516");
@@ -166,10 +176,10 @@ public class BookUseCaseTest {
                     .build();
             BookDetails updateDetails = BookDetails.builder()
                     .categories(categories)
-                    .description("C'était un brave partit trop tôt")
+                    .description("C'était un brave partit trop tôt beaucoup trop tôt")
                     .language("Français")
                     .build();
-            BookDTO result = BookUseCase.updateBook(updateInfo, updateSalesInfo, updateDetails);
+            BookDTO result = bookUseCase.updateBook(bookIsbn, updateInfo, updateSalesInfo, updateDetails);
 
             assertNotNull(result);
             assertEquals(bookIsbn, result.getIsbn());
@@ -204,7 +214,7 @@ public class BookUseCaseTest {
                     .build();
 
             assertThrows(BookNotFoundException.class,
-                    () -> bookUseCase.updateBook(updateInfo, updateSalesInfo, updateDetails));
+                    () -> bookUseCase.updateBook(nonExistentIsbn, updateInfo, updateSalesInfo, updateDetails));
 
             verify(bookRepository, times(1)).findByIsbn(nonExistentIsbn);
             verify(bookRepository, never()).save(any(Book.class));
@@ -225,7 +235,7 @@ public class BookUseCaseTest {
                     .build();
 
             assertThrows(NotValidBookException.class,
-                    () -> bookUseCase.updateBook(invalidUpdateInfo, invalidUpdateSalesInfo, invalidUpdateDetails));
+                    () -> bookUseCase.updateBook(bookIsbn, invalidUpdateInfo, invalidUpdateSalesInfo, invalidUpdateDetails));
 
             verify(bookRepository, never()).findByIsbn(any(String.class));
             verify(bookRepository, never()).save(any(Book.class));
@@ -299,7 +309,7 @@ public class BookUseCaseTest {
 
         @Test
         @DisplayName("Should subtract stock copies from book")
-        void testSubtractStockCopies() throws BookNotFoundException, IllegalBookCpoiesException {
+        void testSubtractStockCopies() throws BookNotFoundException, IllegalBookStockException {
             when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
             when(bookRepository.save(testBook)).thenReturn(testBook);
 
@@ -322,7 +332,7 @@ public class BookUseCaseTest {
 
             int copiesToRemove = 200;
 
-            assertThrows(IllegalBookCpoiesException.class,
+            assertThrows(IllegalBookStockException.class,
                     () -> bookUseCase.subtractStockCopies(bookIsbn, copiesToRemove));
 
             verify(bookRepository, times(1)).findByIsbn(bookIsbn);