refactorr d'un nom de fichier

interface-contracts.json

@@ -14,10 +14,17 @@
         "langue": "string"
       },
       "output": {
+        "_comment": "c'est ce qui affiche quand tu crée avec la usecase (regarde register de customer)",
         "isbn": "string(13)"
       }
     },
 
+
+
+
+
+
+
     "PasserCommande": {
       "input": {
         "clientId": "uuid",
@@ -39,6 +46,12 @@
         "pointsFideliteGagnes": "integer"
       }
     },
+
+
+
+
+
+
     "GererAvis": {
       "input": {
         "clientId": "uuid",

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/BookDTO.java

@@ -0,0 +1,23 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book;
+
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+
+@Getter
+@Builder
+public class BookDTO {
+    private String isbn;
+    private String title;
+    private String author;
+    private String editor;
+    private LocalDate date;
+    private double price;
+    private Integer stock;
+    private ArrayList<String> categories = new ArrayList<>();
+    private String description ;
+    private String language;
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/BookDetails.java

@@ -0,0 +1,17 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book;
+
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.ArrayList;
+
+@Builder
+@Getter
+public class BookDetails {
+    private ArrayList<String> categories = new ArrayList<>();
+    private  String description ;
+    private  String language;
+
+
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/BookInfo.java

@@ -0,0 +1,6 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book;
+
+import java.time.LocalDate;
+
+public record BookInfo(String isbn, String title, String author, String editor, LocalDate date) {
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/BookSalesInfo.java

@@ -0,0 +1,11 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@Getter
+public class BookSalesInfo {
+    private double price;
+    private Integer stock;
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/converter/BookConverter.java

@@ -0,0 +1,42 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.converter;
+
+
+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.entity.Book;
+
+public final class BookConverter {
+    private BookConverter(){}
+
+    public static Book ToDomain(BookInfo bookinfo, BookSalesInfo booksalesinfo, BookDetails bookdetails){
+        return Book.builder()
+                .isbn(bookinfo.isbn())
+                .title(bookinfo.title())
+                .author(bookinfo.author())
+                .editor(bookinfo.editor())
+                .date(bookinfo.date())
+                .price(booksalesinfo.getPrice())
+                .stock(booksalesinfo.getStock())
+                .categories(bookdetails.getCategories())
+                .description(bookdetails.getDescription())
+                .language(bookdetails.getLanguage())
+                .build();
+    }
+
+    public static BookDTO ToDTO(Book book){
+        return BookDTO.builder()
+                .isbn(book.getIsbn())
+                .title(book.getTitle())
+                .author(book.getAuthor())
+                .editor(book.getEditor())
+                .date(book.getDate())
+                .price(book.getPrice())
+                .stock(book.getStock())
+                .categories(book.getCategories())
+                .description(book.getDescription())
+                .language(book.getLanguage())
+                .build();
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/entity/Book.java

@@ -0,0 +1,35 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.entity;
+
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.IllegalBookStockException;
+import lombok.Builder;
+import lombok.Getter;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+
+@Getter
+@Builder
+public class Book {
+    private String isbn;
+    private String title;
+    private String author;
+    private String editor;
+    private LocalDate date;
+    private double price;
+    private Integer stock;
+    private ArrayList<String> categories = new ArrayList<>();
+    private String description ;
+    private String language;
+
+    public void addStock(Integer copyToAdd){
+        this.stock += copyToAdd;
+    }
+
+    public void removeStock(Integer copyToRemomve) throws IllegalBookStockException {
+        if (copyToRemomve > this.stock){
+            throw new IllegalBookStockException(copyToRemomve, this.stock);
+        }
+        this.stock -= copyToRemomve;
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/BookNotFoundException.java

@@ -0,0 +1,11 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
+
+import java.text.MessageFormat;
+
+public class BookNotFoundException extends RuntimeException {
+    public static final String THE_BOOK_WITH_ID_DOES_NOT_EXIST_MESSAGE = "The book with isbn {0} does not exist";
+
+    public BookNotFoundException(String isbn) {
+        super(MessageFormat.format(THE_BOOK_WITH_ID_DOES_NOT_EXIST_MESSAGE, isbn));
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/IllegalBookStockException.java

@@ -0,0 +1,13 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
+
+import java.text.MessageFormat;
+
+public class IllegalBookStockException extends Exception {
+    public static final String CANNOT_REMOVE_COPY = "Cannot remove {0} copy from {1} copy";
+
+    public IllegalBookStockException(Integer toremove, Integer actual ) {
+
+        super(MessageFormat.format(CANNOT_REMOVE_COPY, toremove,
+                actual));
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/NotValidBookException.java

@@ -0,0 +1,7 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
+
+public class NotValidBookException extends RuntimeException {
+    public NotValidBookException(String message) {
+        super(message);
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/repository/BookRepository.java

@@ -0,0 +1,43 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.repository;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public class BookRepository {
+
+    private final List<Book> books = new ArrayList<>();
+
+    public List<Book> findAll() {
+        return books;
+    }
+
+    public void deleteAll() {
+        books.clear();
+    }
+
+    public Book save(Book newBook) {
+        Optional<Book> optionalBookWithSameIsbn = this.findByIsbn(newBook.getIsbn());
+        optionalBookWithSameIsbn.ifPresent(books::remove);
+        this.books.add(newBook);
+        return newBook;
+    }
+
+    public Optional<Book> findByIsbn(String isbn) {
+        return this.books.stream()
+                .filter(book -> book.getIsbn().equals(isbn))
+                .findFirst();
+    }
+
+    public boolean existsByIsbn(String isbn) {
+        return this.books.stream()
+                .anyMatch(book -> book.getIsbn().equals(isbn));
+    }
+
+    public void delete(Book book) {
+
+        this.books.remove(book);
+    }
+}

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/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/validator/BookValidator.java

@@ -0,0 +1,110 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.validator;
+
+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.exception.NotValidBookException;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+
+public class BookValidator {
+
+    public static final String ISBN_IS_NOT_VALID = "Isbn is not valid";
+    public static final String TITLE_CANNOT_BE_BLANK = "Title cannot be blank";
+    public static final String AUTHOR_CANNOT_BE_BLANK = "Author cannot be blank";
+    public static final String EDITOR_CANNOT_BE_BLANK = "Editor cannot be blank";
+    public static final String DATE_IS_NOT_VALID = "Date is not valid";
+    public static final String PRICE_IS_NOT_VALID = "Price is not valid";
+    public static final String STOCK_IS_NOT_VALID = "Stock is not valid";
+    public static final String CATEGORIES_IS_NOT_VALID = "Categories is not valid";
+    public static final String LANGUAGE_CANNOT_BE_BLANK = "Language cannot be blank";
+
+    private BookValidator() {
+    }
+
+    public static void validate(BookInfo newBook) throws NotValidBookException {
+        validateISBN(newBook);
+        validateTitle(newBook);
+        validateAuthor(newBook);
+        validateEditor(newBook);
+        validateDate(newBook);
+    }
+
+    public static void validate(BookSalesInfo newBook) throws NotValidBookException {
+        validatePrice(newBook);
+        validateStock(newBook);
+    }
+
+    public static void validate(BookDetails newBook) throws NotValidBookException {
+        validateCategories(newBook);
+        validateLanguage(newBook);
+    }
+
+    private static void validateISBN(BookInfo newBook) throws NotValidBookException {
+        if (newBook.isbn().isBlank()) {
+            throw new NotValidBookException(ISBN_IS_NOT_VALID);
+        } else if (newBook.isbn().length() != 13) {
+            throw new NotValidBookException(ISBN_IS_NOT_VALID);
+        }
+    }
+
+    private static void validateTitle(BookInfo newBook) throws NotValidBookException {
+        if (newBook.title().isBlank()) {
+            throw new NotValidBookException(TITLE_CANNOT_BE_BLANK);
+        }
+    }
+
+    private static void validateAuthor(BookInfo newBook) throws NotValidBookException {
+        if (newBook.author().isBlank()) {
+            throw new NotValidBookException(AUTHOR_CANNOT_BE_BLANK);
+        }
+    }
+
+    private static void validateEditor(BookInfo newBook) throws NotValidBookException {
+        if (newBook.editor().isBlank()) {
+            throw new NotValidBookException(EDITOR_CANNOT_BE_BLANK);
+        }
+    }
+
+    private static void validateDate(BookInfo newBook) throws NotValidBookException {
+        if (newBook.date().isAfter(LocalDate.now())) {
+            throw new NotValidBookException(DATE_IS_NOT_VALID);
+        }
+    }
+
+    private static void validatePrice(BookSalesInfo newBook) throws NotValidBookException {
+        if (newBook.getPrice() <= 0) {
+            throw new NotValidBookException(PRICE_IS_NOT_VALID);
+        }
+    }
+
+    private static void validateStock(BookSalesInfo newBook) throws NotValidBookException {
+        if (newBook.getStock() < 0) {
+            throw new NotValidBookException(STOCK_IS_NOT_VALID);
+        }
+    }
+
+    private static void validateCategories(BookDetails newBook) throws NotValidBookException {
+        if (newBook.getCategories().isEmpty()) {
+            throw new NotValidBookException(CATEGORIES_IS_NOT_VALID);
+        }else if (CategoriesNotBlank(newBook.getCategories())) {
+            throw new NotValidBookException(CATEGORIES_IS_NOT_VALID);
+        }
+    }
+
+    private static boolean CategoriesNotBlank(ArrayList<String> categories){
+        for (String categorie : categories) {
+            if (categorie.isBlank()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static void validateLanguage(BookDetails newBook) throws NotValidBookException {
+        if (newBook.getLanguage().isBlank()) {
+            throw new NotValidBookException(LANGUAGE_CANNOT_BE_BLANK);
+        }
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/AdresseInfo.java

@@ -0,0 +1,3 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande;
+
+public record AdresseInfo(String rue, String ville, String codePostal, String pays) {}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/CommandeDTO.java

@@ -0,0 +1,25 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande;
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.List;
+import java.util.UUID;
+
+@Getter
+@Builder
+public class CommandeDTO {
+    private UUID clientId;
+    private List<LigneCommandeInfo> lignesCommande;
+    private String rue;
+    private String ville;
+    private String codePostal;
+    private String pays;
+    private String modePaiement;
+
+
+    private UUID commandeId ;
+   private  double  montantTotal ;
+    private  Integer  pointsFideliteGagnes ;
+
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/CommandeInfo.java

@@ -0,0 +1,6 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande;
+
+import java.util.List;
+
+public record CommandeInfo(List<LigneCommandeInfo> listeLigne , String modePayement) {
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/LigneCommandeDTO.java

@@ -0,0 +1,15 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande;
+
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.UUID;
+
+@Getter
+@Builder
+public class LigneCommandeDTO {
+
+    int quantite;
+    UUID id;
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/LigneCommandeInfo.java

@@ -0,0 +1,6 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande;
+
+import java.util.UUID;
+
+public record LigneCommandeInfo(int quantite) {
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/ModePaiement.java

@@ -0,0 +1,7 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande;
+
+public enum ModePaiement {
+    CB,
+    PAYPAL,
+    POINTS_FIDELITE,
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/CommandeConverter.java

@@ -0,0 +1,33 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.converter;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.AdresseInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande;
+
+public final class CommandeConverter {
+
+
+   public static Commande toDomain(CommandeInfo commandeInfo, AdresseInfo adressInfo, String modePaiement) {
+        return Commande.builder()
+                .lignesCommande(commandeInfo.listeLigne())
+                .rue(adressInfo.rue())
+                .ville(adressInfo.ville())
+                .codePostal(adressInfo.codePostal())
+                .pays(adressInfo.pays())
+                .modePaiement(modePaiement)
+                .build();
+    }
+
+    public static CommandeDTO toDTO(CommandeInfo commandeInfo, AdresseInfo adressInfo, String modePaiement) {
+        return CommandeDTO.builder()
+                .lignesCommande(commandeInfo.listeLigne())
+                .rue(adressInfo.rue())
+                .ville(adressInfo.ville())
+                .codePostal(adressInfo.codePostal())
+                .pays(adressInfo.pays())
+                .modePaiement(modePaiement)
+                .build();
+    }
+
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/LigneCommandeConverter.java

@@ -0,0 +1,22 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.converter;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.LigneCommande;
+
+public final class LigneCommandeConverter {
+
+    public static LigneCommande toDomain(LigneCommandeInfo ligneCommandeInfo) {
+        return LigneCommande.builder()
+                .quantite(ligneCommandeInfo.quantite())
+                .build();
+    }
+
+    public static LigneCommandeDTO toDTO(LigneCommandeInfo ligneCommandeInfo) {
+        return LigneCommandeDTO.builder()
+                .quantite(ligneCommandeInfo.quantite())
+                .build();
+    }
+
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/Commande.java

@@ -0,0 +1,44 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.entity;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.ModePaiement;
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.List;
+import java.util.UUID;
+
+@Getter
+@Builder
+public class Commande {
+    private UUID clientId;
+    private List<LigneCommandeInfo> lignesCommande;
+    private String rue;
+    private String ville;
+    private String codePostal;
+    private String pays;
+    private String modePaiement;
+
+    private UUID commandeId ;
+    private  double  montantTotal ;
+    private  Integer  pointsFideliteGagnes ;
+
+    public void setRandomUUID() {
+        this.clientId = UUID.randomUUID();
+    }
+
+    public void setRandomUUIDCommande() {
+        this.commandeId = UUID.randomUUID();
+    }
+
+    public int convertPointsFidelite(){
+        if (this.montantTotal==0|| this.montantTotal<=0){
+            return 0;
+        }
+        return (int) Math.ceil(this.getMontantTotal());
+    }
+
+
+    // conversion point de fidéliter
+
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/LigneCommande.java

@@ -0,0 +1,20 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.entity;
+
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.UUID;
+
+@Getter
+@Builder
+public class LigneCommande {
+
+    int quantite;
+    UUID livreId;
+
+    public void setRandomUUID() {
+        this.livreId = UUID.randomUUID();
+    }
+
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidAdressException.java

@@ -0,0 +1,7 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception;
+
+public class NotValidAdressException extends RuntimeException {
+    public NotValidAdressException(String message) {
+        super(message);
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidCommandeException.java

@@ -0,0 +1,7 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception;
+
+public class NotValidCommandeException extends RuntimeException {
+    public NotValidCommandeException(String message) {
+        super(message);
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidLigneCommandeException.java

@@ -0,0 +1,7 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception;
+
+public class NotValidLigneCommandeException extends RuntimeException {
+    public NotValidLigneCommandeException(String message) {
+        super(message);
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/repository/ComandeRepository.java

@@ -0,0 +1,49 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.repository;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+public class ComandeRepository {
+
+    private final List<Commande> commande = new ArrayList<>();
+
+    public List<Commande> findAll(){return commande;}
+
+
+    public void deleteAll() {
+        commande.clear();
+    }
+
+    public Commande save(Commande newCommande){
+        Optional<Commande> optionalCommandeWithSameIsbn = this.findById(newCommande.getCommandeId());
+        optionalCommandeWithSameIsbn.ifPresent(commande::remove);
+        this.commande.add(newCommande);
+        return newCommande;
+    }
+
+    public Optional<Commande> findById(UUID uuid){
+        return this.commande.stream()
+                .filter(customer -> customer.getCommandeId().equals(uuid))
+                .findFirst();
+    }
+
+    public boolean existsById(UUID uuid) {
+        return this.commande.stream()
+                .anyMatch(customer -> customer.getCommandeId().equals(uuid));
+    }
+
+    public void delete(Commande commande) {
+        this.commande.remove(commande);
+    }
+
+
+    public void deleteById(UUID uuid) {
+        this.commande.removeIf(commande -> commande.getClientId().equals(uuid));
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/validator/CommandeValidator.java

@@ -0,0 +1,87 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.validator;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.AdresseInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidAdressException;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidCommandeException;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidLigneCommandeException;
+
+import java.util.Objects;
+
+public final class CommandeValidator {
+
+    public static final String LIGNE_COMMANDE_IS_NOT_VALIDE = "Ligne commande is not valide";
+    public static final String MODE_PAIEMENT_IS_NOT_VALIDE = "Mode Paiement is not valide";
+    public static final String LIST_LIGNE_COMANDE_IS_NOT_VALIDE = "List ligne commande is not valide";
+    public static final String STREET_IS_NOT_VALIDE = "rue is not valide";
+
+    public static final String CITY_IS_NOT_VALIDE = "city is not valide";
+    public static final String CODE_POSTAL_IS_NOT_VALIDE = "code postal is not valide";
+    public static final String COUNTRY_IS_NOT_VALIDE = "Country is not valide";
+
+
+    public static void validate(LigneCommandeInfo ligneCommandeInfo) {
+        if (ligneCommandeInfo.quantite()<=0){
+            throw new NotValidLigneCommandeException(LIGNE_COMMANDE_IS_NOT_VALIDE);
+        }
+    }
+
+    public static void validate(CommandeInfo commandeInfo) {
+
+        validateModePaiement(commandeInfo);
+        validateListLigneCommande(commandeInfo);
+    }
+
+    public static void validate(AdresseInfo adresseInfo) {
+        validateStreet(adresseInfo);
+        validateCity(adresseInfo);
+        validateCodePostal(adresseInfo);
+        validateCountry(adresseInfo);
+    }
+
+
+
+    private static void validateModePaiement(CommandeInfo commandeInfo) {
+        if(commandeInfo.modePayement()!="CB"&& commandeInfo.modePayement()!="PAYPAL"&& commandeInfo.modePayement()!="POINTS_FIDELITE"){
+            throw new NotValidCommandeException(MODE_PAIEMENT_IS_NOT_VALIDE);
+        }
+    }
+
+    private static void validateListLigneCommande(CommandeInfo commandeInfo) {
+        if (commandeInfo.listeLigne() == null
+                || commandeInfo.listeLigne().isEmpty()
+                || commandeInfo.listeLigne().stream().anyMatch(Objects::isNull)){
+            throw new NotValidCommandeException(LIST_LIGNE_COMANDE_IS_NOT_VALIDE);
+        }
+
+    }
+
+    private static void validateStreet(AdresseInfo adresseInfo) {
+        if (adresseInfo.rue() == null || adresseInfo.rue().isBlank()){
+            throw new NotValidAdressException(STREET_IS_NOT_VALIDE);
+        }
+    }
+    private static void validateCity(AdresseInfo adresseInfo) {
+        if (adresseInfo.ville() == null || adresseInfo.ville().isBlank()){
+            throw new NotValidAdressException(CITY_IS_NOT_VALIDE);
+        }
+    }
+
+    private static void validateCodePostal(AdresseInfo adresseInfo) {
+        if (adresseInfo.codePostal() == null || adresseInfo.codePostal().isBlank()){
+            throw new NotValidAdressException(CODE_POSTAL_IS_NOT_VALIDE);
+        }
+    }
+
+    private static void validateCountry(AdresseInfo adresseInfo) {
+        if (adresseInfo.pays() == null || adresseInfo.pays().isBlank()){
+            throw new NotValidAdressException(COUNTRY_IS_NOT_VALIDE);
+        }
+    }
+
+
+
+
+
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/converter/BookConverterTest.java

@@ -0,0 +1,118 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.converter;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDetails;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@DisplayName("BookConverterTest Unit Tests")
+public class BookConverterTest {
+
+    @Nested
+    @DisplayName("toDomain() method tests")
+    class ToDomainTests {
+
+        @Test
+        void ShouldConvertBookToDomain(){
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookinfo = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", "Kioon", date);
+            BookSalesInfo booksalesinfo = BookSalesInfo.builder()
+                    .price(12)
+                    .stock(10)
+                    .build();
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+            BookDetails bookdetails = BookDetails.builder()
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt")
+                    .language("Français")
+                    .build();
+
+            Book result = BookConverter.ToDomain(bookinfo, booksalesinfo, bookdetails);
+
+            assertEquals(bookinfo.isbn(), result.getIsbn());
+            assertEquals(bookinfo.title(), result.getTitle());
+            assertEquals(bookinfo.author(), result.getAuthor());
+            assertEquals(bookinfo.editor(), result.getEditor());
+            assertEquals(bookinfo.date(), result.getDate());
+            assertEquals(booksalesinfo.getPrice(), result.getPrice());
+            assertEquals(booksalesinfo.getStock(), result.getStock());
+            assertEquals(bookdetails.getCategories(), result.getCategories());
+            assertEquals(bookdetails.getDescription(), result.getDescription());
+            assertEquals(bookdetails.getLanguage(), result.getLanguage());
+        }
+    }
+
+    @Nested
+    @DisplayName("toDTO() method tests")
+    class ToDTOTests {
+
+        @Test
+        void ShouldConvertBookToDTO() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+            Book book = Book.builder()
+                    .isbn("1234567891012")
+                    .title("La vie de Maxime")
+                    .author("Marvin Aubert")
+                    .editor("Kioon")
+                    .date(date)
+                    .price(12.99)
+                    .stock(50)
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt")
+                    .language("Français")
+                    .build();
+
+            BookDTO result = BookConverter.ToDTO(book);
+
+            assertEquals(book.getIsbn(), result.getIsbn());
+            assertEquals(book.getTitle(), result.getTitle());
+            assertEquals(book.getAuthor(), result.getAuthor());
+            assertEquals(book.getEditor(), result.getEditor());
+            assertEquals(book.getDate(), result.getDate());
+            assertEquals(book.getPrice(), result.getPrice());
+            assertEquals(book.getStock(), result.getStock());
+            assertEquals(book.getCategories(), result.getCategories());
+            assertEquals(book.getDescription(), result.getDescription());
+            assertEquals(book.getLanguage(), result.getLanguage());
+        }
+    }
+
+    @Test
+    @DisplayName("Should preserve empty string values during conversion")
+    void shouldPreserveEmptyStrings() {
+        LocalDate date = LocalDate.of(2026, 3, 24);
+        BookInfo bookinfo = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", "Kioon", date);
+        BookSalesInfo booksalesinfo = BookSalesInfo.builder()
+                .price(12)
+                .stock(10)
+                .build();
+        ArrayList<String> categories = new ArrayList<>();
+        categories.add("Thriller");
+        categories.add("Biographie");
+        BookDetails bookdetails = BookDetails.builder()
+                .categories(categories)
+                .description("")
+                .language("Français")
+                .build();
+
+        Book book = BookConverter.ToDomain(bookinfo, booksalesinfo, bookdetails);
+        BookDTO result = BookConverter.ToDTO(book);
+
+        assertEquals("", result.getDescription());
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/entity/BookTest.java

@@ -0,0 +1,168 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.entity;
+
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.IllegalBookStockException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class BookTest {
+
+    @Test
+    @DisplayName("Builder should create a valid Book instance")
+    void testBookBuilder() {
+        String isbn = "1234567891012";
+        String title = "La vie de Maxime";
+        String author = "Marvin Aubert";
+        String editor = "Kioon";
+        LocalDate date = LocalDate.of(2026, 3, 24);
+        double price = 12.99;
+        Integer stock = 50;
+        ArrayList<String> categories = new ArrayList<>();
+        categories.add("Thriller");
+        categories.add("Biographie");
+        String description = "C'était un brave partit trop tôt";
+        String language = "Français";
+        Book book = Book.builder()
+                .isbn(isbn)
+                .title(title)
+                .author(author)
+                .editor(editor)
+                .date(date)
+                .price(price)
+                .stock(stock)
+                .categories(categories)
+                .description(description)
+                .language(language)
+                .build();
+
+        assertEquals(isbn, book.getIsbn());
+        assertEquals(title, book.getTitle());
+        assertEquals(author, book.getAuthor());
+        assertEquals(editor, book.getEditor());
+        assertEquals(date, book.getDate());
+        assertEquals(price, book.getPrice());
+        assertEquals(stock, book.getStock());
+        assertEquals(categories, book.getCategories());
+        assertEquals(description, book.getDescription());
+        assertEquals(language, book.getLanguage());
+    }
+
+    @Nested
+    @DisplayName("Stock Tests")
+    class StockTests {
+
+        @Test
+        @DisplayName("addCopy should correctly increment stocks")
+        void testAddCopy() {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToAdd = 5;
+            Integer copyExpected = 10;
+
+            book.addStock(copyToAdd);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+
+        @Test
+        @DisplayName("addCopy should correctly increment zero points correctly")
+        void testAddZeroToCopy() {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToAdd = 0;
+            Integer copyExpected = 5;
+
+            book.addStock(copyToAdd);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+
+        @Test
+        @DisplayName("removeLoyaltyPoints should correctly decrement loyalty points")
+        void testRemoveCopy() throws IllegalBookStockException {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToRemove = 2;
+            Integer copyExpected = 3;
+
+            book.removeStock(copyToRemove);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+
+        @Test
+        @DisplayName("removeLoyaltyPoints should correctly decrement loyalty points")
+        void testRemoveZeroToCopy() throws IllegalBookStockException {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToRemove = 0;
+            Integer copyExpected = 5;
+
+            book.removeStock(copyToRemove);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+
+        @Test
+        @DisplayName("removeLoyaltyPoints should correctly decrement loyalty points")
+        void testRemoveAllToCopy() throws IllegalBookStockException {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToRemove = 5;
+            Integer copyExpected = 0;
+
+            book.removeStock(copyToRemove);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+
+        @Test
+        @DisplayName("removeSTock should throw exception when trying to remove more copy than available")
+        void testRemoveTooManyCopy() {
+            Book book = Book.builder()
+                    .stock(50)
+                    .build();
+            int copyToRemove = 75;
+
+            IllegalBookStockException exception = assertThrows(
+                    IllegalBookStockException.class,
+                    () -> book.removeStock(copyToRemove)
+            );
+
+            assertEquals(50, book.getStock());
+
+            assertTrue(exception.getMessage().contains(String.valueOf(copyToRemove)));
+            assertTrue(exception.getMessage().contains(String.valueOf(book.getStock())));
+        }
+    }
+
+    @Nested
+    @DisplayName("Price Tests")
+    class PriceTests {
+        @Test
+        @DisplayName("addCopy should correctly increment stocks")
+        void testAddCopy() {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToAdd = 5;
+            Integer copyExpected = 10;
+
+            book.addStock(copyToAdd);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/BookNotFoundExceptionTest.java

@@ -0,0 +1,48 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class BookNotFoundExceptionTest {
+
+    @Test
+    @DisplayName("Exception message should contain the isbn provided")
+    void testExceptionMessageContainsIsbn() {
+        String isbn = "1234567891012";
+
+        BookNotFoundException exception = new BookNotFoundException(isbn);
+
+        String expectedMessage = String.format("The book with isbn %s does not exist", isbn);
+        assertEquals(expectedMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should use the correct constant message format")
+    void testExceptionUsesConstantMessageFormat() {
+        String isbn = "1234567891012";
+
+        BookNotFoundException exception = new BookNotFoundException(isbn);
+
+        String expectedFormatWithPlaceholder = "The book with isbn {0} does not exist";
+        assertEquals(BookNotFoundException.THE_BOOK_WITH_ID_DOES_NOT_EXIST_MESSAGE,
+                expectedFormatWithPlaceholder);
+        assertTrue(exception.getMessage().contains(isbn.toString()));
+    }
+
+    @Test
+    @DisplayName("Exception should be properly thrown and caught")
+    void testExceptionCanBeThrownAndCaught() {
+        String isbn = "1234567891012";
+
+        try {
+            throw new BookNotFoundException(isbn);
+        } catch (BookNotFoundException e) {
+            String expectedMessage = String.format("The book with isbn %s does not exist", isbn);
+            assertEquals(expectedMessage, e.getMessage());
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/IllegalBookStockExceptionTest.java

@@ -0,0 +1,70 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import java.text.MessageFormat;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class IllegalBookStockExceptionTest {
+
+    @Test
+    @DisplayName("Exception message should contain the needed and actual stock")
+    void testExceptionMessageContainsStock() {
+        int neededStock = 100;
+        int actualStock = 50;
+
+        IllegalBookStockException exception = new IllegalBookStockException(neededStock, actualStock);
+
+        String expectedMessage = "Cannot remove 100 copy from 50 copy";
+        assertEquals(expectedMessage, exception.getMessage());
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            "100, 50",
+            "75, 25",
+            "200, 150",
+            "1000, 750"
+    })
+    @DisplayName("Exception message should be formatted correctly for different stock values")
+    void testExceptionMessageForDifferentStockValues(int neededStock, int actualStock) {
+        IllegalBookStockException exception = new IllegalBookStockException(neededStock, actualStock);
+
+        String expectedMessage = MessageFormat.format(IllegalBookStockException.CANNOT_REMOVE_COPY, neededStock, actualStock);
+        assertEquals(expectedMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should use the correct constant message format")
+    void testExceptionUsesConstantMessageFormat() {
+        int neededStock = 100;
+        int actualStock = 50;
+
+        IllegalBookStockException exception = new IllegalBookStockException(neededStock, actualStock);
+
+        String expectedFormatWithPlaceholder = "Cannot remove {0} copy from {1} copy";
+        assertEquals(IllegalBookStockException.CANNOT_REMOVE_COPY,
+                expectedFormatWithPlaceholder);
+        assertTrue(exception.getMessage().contains(String.valueOf(neededStock)));
+        assertTrue(exception.getMessage().contains(String.valueOf(actualStock)));
+    }
+
+    @Test
+    @DisplayName("Exception should be properly thrown and caught")
+    void testExceptionCanBeThrownAndCaught() {
+        int neededStock = 100;
+        int actualStock = 50;
+
+        try {
+            throw new IllegalBookStockException(neededStock, actualStock);
+        } catch (IllegalBookStockException e) {
+            String expectedMessage = String.format("Cannot remove %d copy from %d copy", neededStock, actualStock);
+            assertEquals(expectedMessage, e.getMessage());
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/NotValidBookExceptionTest.java

@@ -0,0 +1,61 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class NotValidBookExceptionTest {
+
+    @Test
+    @DisplayName("Exception should be created with the provided message")
+    void testExceptionCreation() {
+        String errorMessage = "Book data is not valid";
+
+        NotValidBookException exception = new NotValidBookException(errorMessage);
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "Isbn is required",
+            "Title cannot be empty",
+            "Date format is invalid",
+            "Price must be above 0"
+    })
+    @DisplayName("Exception should handle different validation messages")
+    void testExceptionWithDifferentMessages(String errorMessage) {
+        NotValidBookException exception = new NotValidBookException(errorMessage);
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should be properly thrown and caught")
+    void testExceptionCanBeThrownAndCaught() {
+        String errorMessage = "Required field is missing";
+
+        Exception exception = assertThrows(NotValidBookException.class, () -> {
+            throw new NotValidBookException(errorMessage);
+        });
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should be catchable as a general Exception")
+    void testExceptionInheritance() {
+        String errorMessage = "Invalid book data";
+
+        try {
+            throw new NotValidBookException(errorMessage);
+        } catch (Exception e) {
+            assertEquals(NotValidBookException.class, e.getClass());
+            assertEquals(errorMessage, e.getMessage());
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/repository/BookRepositoryTest.java

@@ -0,0 +1,255 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.repository;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class BookRepositoryTest {
+
+    private BookRepository repository;
+    private Book book1;
+    private Book book2;
+
+    @BeforeEach
+    void setUp() {
+        repository = new BookRepository();
+
+        LocalDate date = LocalDate.of(2026, 3, 24);
+        ArrayList<String> categories = new ArrayList<>();
+        categories.add("Thriller");
+        categories.add("Biographie");
+
+        book1 = Book.builder()
+                .isbn("1234567891012")
+                .title("La vie de Maxime")
+                .author("Marvin Aubert")
+                .editor("Kioon")
+                .date(date)
+                .price(12.99)
+                .stock(50)
+                .categories(categories)
+                .description("C'était un brave partit trop tôt")
+                .language("Français")
+                .build();
+
+        book2 = Book.builder()
+                .isbn("1234567891015")
+                .title("La vie de Marvin")
+                .author("Maxime Lebreton")
+                .editor("Kioon")
+                .date(date)
+                .price(12.99)
+                .stock(50)
+                .categories(categories)
+                .description("C'était un brave partit trop tôt")
+                .language("Français")
+                .build();
+    }
+
+    @Test
+    @DisplayName("New repository should be empty")
+    void testNewRepositoryIsEmpty() {
+        List<Book> books = repository.findAll();
+
+        assertTrue(books.isEmpty());
+        assertEquals(0, books.size());
+    }
+
+    @Nested
+    @DisplayName("Save operations")
+    class SaveOperations {
+
+        @Test
+        @DisplayName("Save should add a new book")
+        void testSaveNewBook() {
+            Book savedBook = repository.save(book1);
+
+            assertEquals(1, repository.findAll().size());
+            assertEquals(book1.getIsbn(), savedBook.getIsbn());
+            assertEquals(book1.getTitle(), savedBook.getTitle());
+        }
+
+        @Test
+        @DisplayName("Save should update existing book with same isbn")
+        void testSaveUpdatesExistingBook() {
+            repository.save(book1);
+
+            String isbn = "1234567891012";
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+
+            Book updatedBook = Book.builder()
+                    .isbn(isbn)
+                    .title("La vie de Maxime")
+                    .author("Updated")
+                    .editor("Kioon")
+                    .date(date)
+                    .price(12.99)
+                    .stock(50)
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt beaucoup trop tôt")
+                    .language("Français")
+                    .build();
+
+            Book savedBook = repository.save(updatedBook);
+
+            assertEquals(1, repository.findAll().size());
+            assertEquals(isbn, savedBook.getIsbn());
+            assertEquals("La vie de Maxime", savedBook.getTitle());
+            assertEquals("Updated", savedBook.getAuthor());
+            assertEquals("Kioon", savedBook.getEditor());
+            assertEquals(date, savedBook.getDate());
+            assertEquals(12.99, savedBook.getPrice());
+            assertEquals(50, savedBook.getStock());
+            assertEquals(categories, savedBook.getCategories());
+            assertEquals("C'était un brave partit trop tôt beaucoup trop tôt", savedBook.getDescription());
+            assertEquals("Français", savedBook.getLanguage());
+        }
+
+        @Test
+        @DisplayName("Save multiple books should add all of them")
+        void testSaveMultipleBooks() {
+            repository.save(book1);
+            repository.save(book2);
+
+            List<Book> books = repository.findAll();
+
+            assertEquals(2, books.size());
+            assertTrue(books.contains(book1));
+            assertTrue(books.contains(book2));
+        }
+    }
+
+    @Nested
+    @DisplayName("Find operations")
+    class FindOperations {
+
+        @BeforeEach
+        void setUpBooks() {
+            repository.save(book1);
+            repository.save(book2);
+        }
+
+        @Test
+        @DisplayName("FindAll should return all books")
+        void testFindAll() {
+            List<Book> books = repository.findAll();
+
+            assertEquals(2, books.size());
+            assertTrue(books.contains(book1));
+            assertTrue(books.contains(book2));
+        }
+
+        @Test
+        @DisplayName("FindByIsbn should return book with matching isbn")
+        void testFindByIsbn() {
+            Optional<Book> foundBook = repository.findByIsbn(book1.getIsbn());
+
+            assertTrue(foundBook.isPresent());
+            assertEquals(book1.getTitle(), foundBook.get().getTitle());
+            assertEquals(book1.getAuthor(), foundBook.get().getAuthor());
+        }
+
+        @Test
+        @DisplayName("FindByIsbn should return empty Optional when isbn doesn't exist")
+        void testFindByIsbnNotFound() {
+            String nonExistedisbn = "1515265522652";
+
+            Optional<Book> foundBook = repository.findByIsbn(nonExistedisbn);
+
+            assertTrue(foundBook.isEmpty());
+        }
+
+        @Test
+        @DisplayName("ExistsByIsbn should return true when isbn exists")
+        void testExistsByIsbnExists() {
+            boolean exists = repository.existsByIsbn(book1.getIsbn());
+
+            assertTrue(exists);
+        }
+
+        @Test
+        @DisplayName("ExistsByIsbn should return false when isbn doesn't exist")
+        void testExistsByIsbnNotExists() {
+            String nonExistedisbn = "1515265522652";
+
+            boolean exists = repository.existsByIsbn(nonExistedisbn);
+
+            assertFalse(exists);
+        }
+    }
+
+    @Nested
+    @DisplayName("Delete operations")
+    class DeleteOperations {
+
+        @BeforeEach
+        void setUpBooks() {
+            repository.save(book1);
+            repository.save(book2);
+        }
+
+        @Test
+        @DisplayName("Delete should remove the specified book")
+        void testDelete() {
+            repository.delete(book1);
+
+            List<Book> books = repository.findAll();
+
+            assertEquals(1, books.size());
+            assertFalse(books.contains(book1));
+            assertTrue(books.contains(book2));
+        }
+
+        @Test
+        @DisplayName("DeleteAll should remove all books")
+        void testDeleteAll() {
+            repository.deleteAll();
+
+            List<Book> books = repository.findAll();
+
+            assertTrue(books.isEmpty());
+            assertEquals(0, books.size());
+        }
+
+        @Test
+        @DisplayName("Delete should not throw exception when book doesn't exist")
+        void testDeleteNonExistentBook() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+            Book nonExistentBook = Book.builder()
+                    .isbn("1515466461319")
+                    .title("La vie de Patrick")
+                    .author("Updated")
+                    .editor("Kioon")
+                    .date(date)
+                    .price(12.99)
+                    .stock(50)
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt")
+                    .language("Français")
+                    .build();
+
+            assertDoesNotThrow(() -> repository.delete(nonExistentBook));
+
+            assertEquals(2, repository.findAll().size());
+        }
+    }
+}

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

@@ -0,0 +1,356 @@
+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.entity.Book;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundExceptionTest;
+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;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.never;
+
+@ExtendWith(MockitoExtension.class)
+public class BookUseCaseTest {
+
+    @Mock
+    private BookRepository bookRepository;
+
+    @InjectMocks
+    private BookUseCase bookUseCase;
+
+    private String bookIsbn;
+    private ArrayList<String> categories;
+    private LocalDate date;
+    private Book testBook;
+    private BookInfo validBookInfo;
+    private BookDetails validBookDetails;
+    private BookSalesInfo validBookSalesInfo;
+
+    @BeforeEach
+    void setUp() {
+        bookIsbn = "1234567891012";
+        date = LocalDate.of(2026, 3, 24);
+        categories = new ArrayList<>();
+        categories.add("Thriller");
+        categories.add("Biographie");
+
+        testBook = Book.builder()
+                .isbn(bookIsbn)
+                .title("La vie de Maxime")
+                .author("Marvin AUbert")
+                .editor("Kioon")
+                .date(date)
+                .price(12.99)
+                .stock(50)
+                .categories(categories)
+                .description("C'était un brave partit trop tôt")
+                .language("Français")
+                .build();
+
+        validBookInfo = new BookInfo(bookIsbn,"La vie de Maxime", "Marvin AUbert", "Kioon", date);
+        validBookSalesInfo = BookSalesInfo.builder()
+                .price(12.99)
+                .stock(50)
+                .build();
+        validBookDetails = BookDetails.builder()
+                .categories(categories)
+                .description("C'était un brave partit trop tôt")
+                .language("Français")
+                .build();
+    }
+
+    @Nested
+    @DisplayName("Register Book tests")
+    class RegisterBookTests {
+
+        @Test
+        @DisplayName("Should register book when valid data is provided")
+        void testRegisterBookWithValidData() throws NotValidBookException {
+            when(bookRepository.save(any(Book.class))).thenReturn(testBook);
+
+            String registeredIsbn = bookUseCase.registerBook(validBookInfo, validBookSalesInfo, validBookDetails);
+
+            assertNotNull(registeredIsbn);
+            assertEquals(bookIsbn, registeredIsbn);
+            verify(bookRepository, times(1)).save(any(Book.class));
+        }
+
+        @Test
+        @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, invalidUpdateSalesInfo, invalidUpdateDetails));
+
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+    }
+
+    @Nested
+    @DisplayName("Find book tests")
+    class FindBookTests {
+
+        @Test
+        @DisplayName("Should return book when isbn exists")
+        void testFindBookByIsbn() {
+            when(bookRepository.findByIsbn("1234567891012")).thenReturn(Optional.of(testBook));
+
+            Optional<BookDTO> foundBook = bookUseCase.findBookByIsbn("1234567891012");
+
+            assertTrue(foundBook.isPresent());
+            assertEquals(testBook.getIsbn(), foundBook.get().getIsbn());
+            assertEquals(testBook.getTitle(), foundBook.get().getTitle());
+            verify(bookRepository, times(1)).findByIsbn("1234567891012");
+        }
+
+        @Test
+        @DisplayName("Should return empty Optional when isbn doesn't exist")
+        void testFindBookByIsbnNotFound() {
+            when(bookRepository.findByIsbn("1656546262516")).thenReturn(Optional.empty());
+
+            Optional<BookDTO> foundBook = bookUseCase.findBookByIsbn("1656546262516");
+
+            assertTrue(foundBook.isEmpty());
+            verify(bookRepository, times(1)).findByIsbn("1656546262516");
+        }
+    }
+
+    @Nested
+    @DisplayName("Update book tests")
+    class UpdateBookTests {
+
+        @Test
+        @DisplayName("Should update book when valid data is provided")
+        void testUpdateBookWithValidData() throws BookNotFoundException, NotValidBookException {
+            when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
+
+            Book updatedBook = Book.builder()
+                    .isbn(bookIsbn)
+                    .title("La vie de Maxime")
+                    .author("Updated")
+                    .editor("Kioon")
+                    .date(date)
+                    .price(12.99)
+                    .stock(50)
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt")
+                    .language("Français")
+                    .build();
+
+            when(bookRepository.save(any(Book.class))).thenReturn(updatedBook);
+
+            BookInfo updateInfo = new BookInfo(bookIsbn, "La vie de Maxime", "Updated", "Kioon", date);
+            BookSalesInfo updateSalesInfo = BookSalesInfo.builder()
+                    .price(12.99)
+                    .stock(50)
+                    .build();
+            BookDetails updateDetails = BookDetails.builder()
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt beaucoup trop tôt")
+                    .language("Français")
+                    .build();
+            BookDTO result = bookUseCase.updateBook(bookIsbn, updateInfo, updateSalesInfo, updateDetails);
+
+            assertNotNull(result);
+            assertEquals(bookIsbn, result.getIsbn());
+            assertEquals("La vie de Maxime", result.getTitle());
+            assertEquals("Updated", result.getAuthor());
+            assertEquals("Kioon", result.getEditor());
+            assertEquals(date, result.getDate());
+            assertEquals(12.99, result.getPrice());
+            assertEquals(50, result.getStock());
+            assertEquals(categories, result.getCategories());
+            assertEquals("C'était un brave partit trop tôt", result.getDescription());
+            assertEquals("Français", result.getLanguage());
+            verify(bookRepository, times(1)).findByIsbn(bookIsbn);
+            verify(bookRepository, times(1)).save(any(Book.class));
+        }
+
+        @Test
+        @DisplayName("Should throw exception when book isbn doesn't exist")
+        void testUpdateBookNotFound() {
+            String nonExistentIsbn = "1656546262516";
+            when(bookRepository.findByIsbn(nonExistentIsbn)).thenReturn(Optional.empty());
+
+            BookInfo updateInfo = new BookInfo(nonExistentIsbn, "La vie de Maxime", "Updated", "Kioon", date);
+            BookSalesInfo updateSalesInfo = BookSalesInfo.builder()
+                    .price(12.99)
+                    .stock(50)
+                    .build();
+            BookDetails updateDetails = BookDetails.builder()
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt")
+                    .language("Français")
+                    .build();
+
+            assertThrows(BookNotFoundException.class,
+                    () -> bookUseCase.updateBook(nonExistentIsbn, updateInfo, updateSalesInfo, updateDetails));
+
+            verify(bookRepository, times(1)).findByIsbn(nonExistentIsbn);
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+
+        @Test
+        @DisplayName("Should throw exception when update data is not valid")
+        void testUpdateBookWithInvalidData() {
+            BookInfo invalidUpdateInfo = 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.updateBook(bookIsbn, invalidUpdateInfo, invalidUpdateSalesInfo, invalidUpdateDetails));
+
+            verify(bookRepository, never()).findByIsbn(any(String.class));
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+    }
+
+    @Nested
+    @DisplayName("Delete book tests")
+    class DeleteBookTests {
+
+        @Test
+        @DisplayName("Should delete book when isbn exists")
+        void testDeleteBook() throws BookNotFoundException {
+            when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
+            doNothing().when(bookRepository).delete(testBook);
+
+            bookUseCase.deleteBook(bookIsbn);
+
+            verify(bookRepository, times(1)).findByIsbn(bookIsbn);
+            verify(bookRepository, times(1)).delete(testBook);
+        }
+
+        @Test
+        @DisplayName("Should throw exception when book isbn doesn't exist")
+        void testDeleteBookNotFound() {
+            String nonExistentIsbn = "1656546262516";
+            when(bookRepository.findByIsbn(nonExistentIsbn)).thenReturn(Optional.empty());
+
+            assertThrows(BookNotFoundException.class,
+                    () -> bookUseCase.deleteBook(nonExistentIsbn));
+
+            verify(bookRepository, times(1)).findByIsbn(nonExistentIsbn);
+            verify(bookRepository, never()).delete(any(Book.class));
+        }
+    }
+
+    @Nested
+    @DisplayName("Stock copies tests")
+    class StockCopiesTests {
+
+        @Test
+        @DisplayName("Should add stock copies to book")
+        void testAddStockCopies() throws BookNotFoundException {
+            when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
+            when(bookRepository.save(testBook)).thenReturn(testBook);
+
+            int initialCopies = testBook.getStock();
+            int copiesToAdd = 50;
+            int expectedCopies = initialCopies + copiesToAdd;
+
+            int newCopies = bookUseCase.addStockCopies(bookIsbn, copiesToAdd);
+
+            assertEquals(expectedCopies, newCopies);
+            assertEquals(expectedCopies, testBook.getStock());
+            verify(bookRepository, times(1)).findByIsbn(bookIsbn);
+            verify(bookRepository, times(1)).save(testBook);
+        }
+
+        @Test
+        @DisplayName("Should throw exception when adding copies to non-existent book")
+        void testAddStockCopiesToNonExistentBook() {
+            String nonExistentIsbn = "1656546262516";
+            when(bookRepository.findByIsbn(nonExistentIsbn)).thenReturn(Optional.empty());
+
+            assertThrows(BookNotFoundException.class,
+                    () -> bookUseCase.addStockCopies(nonExistentIsbn, 50));
+
+            verify(bookRepository, times(1)).findByIsbn(nonExistentIsbn);
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+
+        @Test
+        @DisplayName("Should subtract stock copies from book")
+        void testSubtractStockCopies() throws BookNotFoundException, IllegalBookStockException {
+            when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
+            when(bookRepository.save(testBook)).thenReturn(testBook);
+
+            int initialCopies = testBook.getStock();
+            int copiesToRemove = 30;
+            int expectedCopies = initialCopies - copiesToRemove;
+
+            int newCopies = bookUseCase.subtractStockCopies(bookIsbn, copiesToRemove);
+
+            assertEquals(expectedCopies, newCopies);
+            assertEquals(expectedCopies, testBook.getStock());
+            verify(bookRepository, times(1)).findByIsbn(bookIsbn);
+            verify(bookRepository, times(1)).save(testBook);
+        }
+
+        @Test
+        @DisplayName("Should throw exception when trying to remove more copies than available")
+        void testSubtractTooManyStockCopies() {
+            when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
+
+            int copiesToRemove = 200;
+
+            assertThrows(IllegalBookStockException.class,
+                    () -> bookUseCase.subtractStockCopies(bookIsbn, copiesToRemove));
+
+            verify(bookRepository, times(1)).findByIsbn(bookIsbn);
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+
+        @Test
+        @DisplayName("Should throw exception when subtracting copies from non-existent book")
+        void testSubtractStockCopiesFromNonExistentBook() {
+            String nonExistentIsbn = "1656546262516";
+            when(bookRepository.findByIsbn(nonExistentIsbn)).thenReturn(Optional.empty());
+
+            assertThrows(BookNotFoundException.class,
+                    () -> bookUseCase.subtractStockCopies(nonExistentIsbn, 50));
+
+            verify(bookRepository, times(1)).findByIsbn(nonExistentIsbn);
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/validator/BookValidatorTest.java

@@ -0,0 +1,379 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.validator;
+
+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.exception.NotValidBookException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BookValidatorTest {
+
+    @Test
+    @DisplayName("Should validate book with valid data")
+    void testValidateValidBook() {
+        LocalDate date = LocalDate.of(2026, 3, 24);
+        BookInfo validBook = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", "Kioon", date);
+
+        assertDoesNotThrow(() -> BookValidator.validate(validBook));
+    }
+
+    @Test
+    @DisplayName("Should validate book details with valid data")
+    void testValidateValidBookDetails() {
+        ArrayList<String> categories = new ArrayList<>();
+        categories.add("Thriller");
+        categories.add("Biographie");
+        BookDetails validBookDetails = BookDetails.builder()
+                .categories(categories)
+                .description("C'était un brave partit trop tôt")
+                .language("Français")
+                .build();
+
+        assertDoesNotThrow(() -> BookValidator.validate(validBookDetails));
+    }
+
+    @Test
+    @DisplayName("Should validate book sales informations with valid data")
+    void testValidateValidBookSalesInfo() {
+        BookSalesInfo validBookSalesInfo = BookSalesInfo.builder()
+                .price(15)
+                .stock(10)
+                .build();
+
+        assertDoesNotThrow(() -> BookValidator.validate(validBookSalesInfo));
+    }
+
+    @Nested
+    @DisplayName("ISBN validation tests")
+    class ISBNValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when isbn is blank")
+        void testValidateBlankISBN() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithBlankISBN = new BookInfo("", "La vie de Maxime", "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithBlankISBN)
+            );
+
+            assertEquals(BookValidator.ISBN_IS_NOT_VALID, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        @DisplayName("Should throw exception when isbn contains only whitespace")
+        void testValidateWhitespaceISBN(String whitespace) {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithWhitespaceISBN = new BookInfo(whitespace, "La vie de Maxime", "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceISBN)
+            );
+
+            assertEquals(BookValidator.ISBN_IS_NOT_VALID, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"00000", "0000000000", "0000000000000000"})
+        @DisplayName("Should throw exception when isbn contains only thriteen character")
+        void testValidateThirteenCharacterISBN(String number) {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithNotExactCharacterISBN = new BookInfo(number, "La vie de Maxime", "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithNotExactCharacterISBN)
+            );
+
+            assertEquals(BookValidator.ISBN_IS_NOT_VALID, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("Title validation tests")
+    class TitleValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when title is blank")
+        void testValidateBlankTitle() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithBlankTitle = new BookInfo("0000000000000","", "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithBlankTitle)
+            );
+
+            assertEquals(BookValidator.TITLE_CANNOT_BE_BLANK, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        @DisplayName("Should throw exception when title contains only whitespace")
+        void testValidateWhitespaceFirstName(String whitespace) {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithWhitespaceTitle = new BookInfo("0000000000000",whitespace, "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceTitle)
+            );
+
+            assertEquals(BookValidator.TITLE_CANNOT_BE_BLANK, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("author validation tests")
+    class AuthorValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when author is blank")
+        void testValidateBlankAuthor() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithBlankAuthor = new BookInfo("0000000000000","La vie de Maxime", "", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithBlankAuthor)
+            );
+
+            assertEquals(BookValidator.AUTHOR_CANNOT_BE_BLANK, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        @DisplayName("Should throw exception when author contains only whitespace")
+        void testValidateWhitespaceAuthor(String whitespace) {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithWhitespaceAuthor = new BookInfo("0000000000000","La vie de Maxime", whitespace, "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceAuthor)
+            );
+
+            assertEquals(BookValidator.AUTHOR_CANNOT_BE_BLANK, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("editor validation tests")
+    class EditorValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when editor is blank")
+        void testValidateBlankEditor() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithBlankEditor = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", "", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithBlankEditor)
+            );
+
+            assertEquals(BookValidator.EDITOR_CANNOT_BE_BLANK, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        @DisplayName("Should throw exception when editor contains only whitespace")
+        void testValidateWhitespaceEditor(String whitespace) {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithWhitespaceEditor = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", whitespace, date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceEditor)
+            );
+
+            assertEquals(BookValidator.EDITOR_CANNOT_BE_BLANK, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("date validation tests")
+    class DateValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when date is after the actual date")
+        void testValidateFuturDate() {
+            LocalDate date = LocalDate.of(2026, 5, 24);
+            BookInfo bookWithFuturDate = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithFuturDate)
+            );
+
+            assertEquals(BookValidator.DATE_IS_NOT_VALID, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("price validation tests")
+    class PriceValidationTests {
+
+        @ParameterizedTest
+        @ValueSource(doubles = {-3, -15, 0})
+        @DisplayName("Should throw exception when price is negative or equal to zero")
+        void testValidateNegativePrice(double invalidprice) {
+            BookSalesInfo bookWithNegativePrice = BookSalesInfo.builder()
+                    .price(invalidprice)
+                    .stock(10)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithNegativePrice)
+            );
+
+            assertEquals(BookValidator.PRICE_IS_NOT_VALID, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("stock validation tests")
+    class StockValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when stock is negative")
+        void testValidateNegativeSTock() {
+            BookSalesInfo bookWithNegativeStock = BookSalesInfo.builder()
+                    .price(3)
+                    .stock(-3)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithNegativeStock)
+            );
+
+            assertEquals(BookValidator.STOCK_IS_NOT_VALID, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("categories validation tests")
+    class CategoriesValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when categories is empty")
+        void testValidateBlankCategories() {
+            ArrayList<String> categories = new ArrayList<>();
+            String description = "C'était un brave partit trop tôt";
+            String language = "Français";
+            BookDetails bookWithEmptyCategories = BookDetails.builder()
+                    .categories(categories)
+                    .description(description)
+                    .language(language)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithEmptyCategories)
+            );
+
+            assertEquals(BookValidator.CATEGORIES_IS_NOT_VALID, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @MethodSource("provideLists")
+        @DisplayName("Should throw exception when categories contains an whitespace")
+        void testValidateWhitespaceCategories(ArrayList<String> invalidlist) {
+            String description = "C'était un brave partit trop tôt";
+            String language = "Français";
+            BookDetails bookWithWhitespaceCategories = BookDetails.builder()
+                    .categories(invalidlist)
+                    .description(description)
+                    .language(language)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceCategories)
+            );
+
+            assertEquals(BookValidator.CATEGORIES_IS_NOT_VALID, exception.getMessage());
+        }
+
+        static Stream<ArrayList<String>> provideLists() {
+            return Stream.of(
+                    new ArrayList<String>(java.util.List.of("")),
+                    new ArrayList<String>(java.util.List.of(" ")),
+                    new ArrayList<String>(java.util.List.of("  ")),
+                    new ArrayList<String>(java.util.List.of("\t")),
+                    new ArrayList<String>(java.util.List.of("\n")),
+                    new ArrayList<String>(java.util.List.of("A", "", "C"))
+            );
+        }
+    }
+
+    @Nested
+    @DisplayName("language validation tests")
+    class LanguageValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when language is blank")
+        void testValidateNegativeLanguage() {
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+            String description = "C'était un brave partit trop tôt";
+            String language = "";
+
+            BookDetails bookWithBlankLanguage = BookDetails.builder()
+                    .categories(categories)
+                    .description(description)
+                    .language(language)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithBlankLanguage)
+            );
+
+            assertEquals(BookValidator.LANGUAGE_CANNOT_BE_BLANK, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        @DisplayName("Should throw exception when language contains only whitespace")
+        void testValidateWhitespaceLanguage(String whitespace) {
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+            String description = "C'était un brave partit trop tôt";
+
+            BookDetails bookWithWhitespaceLanguage = BookDetails.builder()
+                    .categories(categories)
+                    .description(description)
+                    .language(whitespace)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceLanguage)
+            );
+
+            assertEquals(BookValidator.LANGUAGE_CANNOT_BE_BLANK, exception.getMessage());
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/CommandeConverterTest.java

@@ -0,0 +1,65 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.converter;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.*;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class CommandeConverterTest {
+
+
+    @Test
+    void TestConvertCommandeToDomain(){
+        String modePaiement = ModePaiement.CB.name();
+        List<LigneCommandeInfo> listLigne = new ArrayList<>();
+        LigneCommandeInfo ligne = new LigneCommandeInfo(12);
+        LigneCommandeInfo ligne2 = new LigneCommandeInfo(14);
+        listLigne.add(ligne);
+        listLigne.add(ligne2);
+        CommandeInfo commandeInfo = new CommandeInfo(listLigne,modePaiement);
+        AdresseInfo adressInfo = new AdresseInfo("rue du cheval","La Rochette","77000","France");
+
+
+        Commande result = CommandeConverter.toDomain(commandeInfo,adressInfo,modePaiement);
+
+
+        assertNotNull(result);
+        assertEquals(commandeInfo.listeLigne(), result.getLignesCommande());
+        assertEquals(adressInfo.rue() , result.getRue());
+        assertEquals(adressInfo.ville() , result.getVille());
+        assertEquals(adressInfo.codePostal() , result.getCodePostal());
+        assertEquals(adressInfo.pays() , result.getPays());
+        assertEquals(  modePaiement,result.getModePaiement());
+    }
+
+    @Test
+    void TestConvertCommandeToDTO(){
+        String modePaiement = ModePaiement.CB.name();
+        List<LigneCommandeInfo> listLigne = new ArrayList<>();
+        LigneCommandeInfo ligne = new LigneCommandeInfo(12);
+        LigneCommandeInfo ligne2 = new LigneCommandeInfo(14);
+        listLigne.add(ligne);
+        listLigne.add(ligne2);
+        CommandeInfo commandeInfo = new CommandeInfo(listLigne,modePaiement);
+        AdresseInfo adressInfo = new AdresseInfo("rue du cheval","La Rochette","77000","France");
+
+
+        CommandeDTO result = CommandeConverter.toDTO(commandeInfo,adressInfo,modePaiement);
+
+
+        assertNotNull(result);
+        assertEquals(commandeInfo.listeLigne(), result.getLignesCommande());
+        assertEquals(adressInfo.rue() , result.getRue());
+        assertEquals(adressInfo.ville() , result.getVille());
+        assertEquals(adressInfo.codePostal() , result.getCodePostal());
+        assertEquals(adressInfo.pays() , result.getPays());
+        assertEquals(  modePaiement,result.getModePaiement());
+    }
+
+
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/LigneCommandeConverterTest.java

@@ -0,0 +1,35 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.converter;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.LigneCommande;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class LigneCommandeConverterTest {
+
+
+    @Test
+    void TestConvertLigneCommandeToDomain(){
+        LigneCommandeInfo ligne = new LigneCommandeInfo(12);
+
+        LigneCommande result = LigneCommandeConverter.toDomain(ligne);
+
+
+        assertEquals(ligne.quantite(),result.getQuantite());
+
+    }
+
+    @Test
+    void TestConvertLigneCommandeToDTO(){
+        LigneCommandeInfo ligne = new LigneCommandeInfo(12);
+
+        LigneCommandeDTO result = LigneCommandeConverter.toDTO(ligne);
+
+
+        assertEquals(ligne.quantite(),result.getQuantite());
+
+    }
+
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/CommandeTest.java

@@ -0,0 +1,104 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.entity;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.ModePaiement;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class CommandeTest {
+    @Test
+    public void commandeTest(){
+
+        UUID clientId = UUID.randomUUID();
+        List<LigneCommandeInfo> lignesCommande =  new ArrayList<>();
+        LigneCommandeInfo commande1 = new LigneCommandeInfo(12);
+        LigneCommandeInfo commande2 = new LigneCommandeInfo(13);
+        lignesCommande.add(commande1);
+        lignesCommande.add(commande2);
+        String rue = "rue du chien" ;
+        String ville = "LKa Rochette" ;
+        String codePostal = "7700" ;
+        String pays = "France" ;
+        String modePayement = ModePaiement.CB.name() ;
+
+        Commande commande = Commande.builder()
+                .clientId(clientId)
+                .lignesCommande(lignesCommande)
+                .rue(rue)
+                .ville(ville)
+                .codePostal(codePostal)
+                .pays(pays)
+                .modePaiement(modePayement)
+                .build();
+
+        assertEquals(clientId, commande.getClientId());
+        assertEquals(lignesCommande, commande.getLignesCommande());
+        assertEquals(rue, commande.getRue());
+        assertEquals(ville, commande.getVille());
+        assertEquals(codePostal, commande.getCodePostal());
+        assertEquals(pays, commande.getPays());
+        assertEquals(modePayement, commande.getModePaiement());
+    }
+
+
+
+    @Test
+    @DisplayName("setRandomUUID should change the ID to a new random UUID")
+    void testSetRandomUUID() {
+        Commande commande = Commande.builder().build();
+        UUID originalId = commande.getClientId();
+
+        commande.setRandomUUID();
+
+        assertNotNull(commande.getClientId());
+        assertNotEquals(originalId, commande.getClientId());
+    }
+
+    @Test
+    @DisplayName("setRandomUUID should change the ID to a new random UUID")
+    void testSetRandomUUIDForCommande() {
+        Commande commande = Commande.builder().build();
+        UUID originalId = commande.getCommandeId();
+
+        commande.setRandomUUIDCommande();
+
+        assertNotNull(commande.getCommandeId());
+        assertNotEquals(originalId, commande.getCommandeId());
+    }
+
+
+    @Test
+    void testConvertPointsFideliteGagnes(){
+        Commande commande = Commande.builder()
+                .montantTotal(14.34)
+                .build();
+       Integer point =  commande.convertPointsFidelite();
+
+        assertEquals(point,(int) Math.ceil(commande.getMontantTotal()));
+    }
+
+    @ParameterizedTest
+    @ValueSource(doubles = {-1.9,0.0})
+    void testConvertPointsFideliteGagnesWhenMontantTotalIsNotGood(){
+        Commande commande = Commande.builder()
+                .montantTotal(14.34)
+                .build();
+        Integer point =  commande.convertPointsFidelite();
+
+        assertEquals(point,(int) Math.ceil(commande.getMontantTotal()));
+    }
+
+
+
+
+
+
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/LigneCommandeTest.java

@@ -0,0 +1,41 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.entity;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class LigneCommandeTest {
+
+    @Test
+    @DisplayName("Builder should create a valid LigneCommande instance")
+    void TestLigneCommande() {
+        UUID id = UUID.randomUUID();
+        int quantite = 12;
+
+
+        LigneCommande ligneCommande = LigneCommande.builder()
+                                                    .livreId(id)
+                                                    .quantite(quantite)
+                                                    .build();
+
+        assertEquals(id, ligneCommande.getLivreId());
+        assertEquals(quantite, ligneCommande.getQuantite());
+
+    }
+
+    @Test
+    @DisplayName("setRandomUUID should change the ID to a new random UUID")
+    void testSetRandomUUID() {
+        LigneCommande ligneCommande = LigneCommande.builder().build();
+        UUID originalId = ligneCommande.getLivreId();
+
+        ligneCommande.setRandomUUID();
+
+        assertNotNull(ligneCommande.getLivreId());
+        assertNotEquals(originalId, ligneCommande.getLivreId());
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidAdressExceptionTest.java

@@ -0,0 +1,67 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.valid;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidAdressException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class NotValidAdressExceptionTest {
+
+    @Test
+    @DisplayName("Exception should be created with the provided message")
+    void testExceptionCreation() {
+        String errorMessage = "Adresse is not valid";
+
+        NotValidAdressException exception = new NotValidAdressException(errorMessage);
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "rue is not valide",
+            "city is not valide",
+            "code postal is not valide",
+            "Country is not valide"
+    })
+    @DisplayName("Exception should handle different validation messages")
+    void testExceptionWithDifferentMessages(String errorMessage) {
+        NotValidAdressException exception = new NotValidAdressException(errorMessage);
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should be properly thrown and caught")
+    void testExceptionCanBeThrownAndCaught() {
+        String errorMessage = "Required field is missing";
+
+        Exception exception = assertThrows(NotValidAdressException.class, () -> {
+            throw new NotValidAdressException(errorMessage);
+        });
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should be catchable as a general Exception")
+    void testExceptionInheritance() {
+        String errorMessage = "Invalid Adresse ";
+
+        try {
+            throw new NotValidAdressException(errorMessage);
+        } catch (Exception e) {
+            assertEquals(NotValidAdressException.class, e.getClass());
+            assertEquals(errorMessage, e.getMessage());
+        }
+    }
+
+
+
+
+
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidCommandeExceptionTest.java

@@ -0,0 +1,61 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.valid;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidCommandeException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class NotValidCommandeExceptionTest {
+
+    @Test
+    @DisplayName("Exception should be created with the provided message")
+    void testExceptionCreation() {
+        String errorMessage = "Commande is not valid";
+
+        NotValidCommandeException exception = new NotValidCommandeException(errorMessage);
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "Mode Paiement is not valide",
+            "List ligne commande is not valide"
+    })
+    @DisplayName("Exception should handle different validation messages")
+    void testExceptionWithDifferentMessages(String errorMessage) {
+        NotValidCommandeException exception = new NotValidCommandeException(errorMessage);
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should be properly thrown and caught")
+    void testExceptionCanBeThrownAndCaught() {
+        String errorMessage = "Required field is missing";
+
+        Exception exception = assertThrows(NotValidCommandeException.class, () -> {
+            throw new NotValidCommandeException(errorMessage);
+        });
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should be catchable as a general Exception")
+    void testExceptionInheritance() {
+        String errorMessage = "Invalid Commande ";
+
+        try {
+            throw new NotValidCommandeException(errorMessage);
+        } catch (Exception e) {
+            assertEquals(NotValidCommandeException.class, e.getClass());
+            assertEquals(errorMessage, e.getMessage());
+        }
+    }
+
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidLigneCommandeExceptionTest.java

@@ -0,0 +1,47 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.valid;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidLigneCommandeException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class NotValidLigneCommandeExceptionTest {
+
+    @Test
+    @DisplayName("Exception should handle different validation messages")
+    void testExceptionCreation() {
+        String errorMessage = "Ligne commande is not valide";
+        NotValidLigneCommandeException exception = new NotValidLigneCommandeException(errorMessage);
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should be properly thrown and caught")
+    void testExceptionCanBeThrownAndCaught() {
+        String errorMessage = "Required field is missing";
+
+        Exception exception = assertThrows(NotValidLigneCommandeException.class, () -> {
+            throw new NotValidLigneCommandeException(errorMessage);
+        });
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should be catchable as a general Exception")
+    void testExceptionInheritance() {
+        String errorMessage = "Invalid Commande ";
+
+        try {
+            throw new NotValidLigneCommandeException(errorMessage);
+        } catch (Exception e) {
+            assertEquals(NotValidLigneCommandeException.class, e.getClass());
+            assertEquals(errorMessage, e.getMessage());
+        }
+    }
+
+
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/repository/CommandeRepositoryTest.java

@@ -0,0 +1,349 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.repository;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.ModePaiement;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class CommandeRepositoryTest {
+
+    private ComandeRepository repository;
+    private Commande commandeN1;
+    private Commande commandeN2;
+    private Commande commandeN3;
+
+    @BeforeEach
+    void setUp() {
+        repository = new ComandeRepository();
+
+        UUID clientId = UUID.randomUUID();
+        List<LigneCommandeInfo> lignesCommande = new ArrayList<>();
+        LigneCommandeInfo commande1 = new LigneCommandeInfo(12);
+        LigneCommandeInfo commande2 = new LigneCommandeInfo(13);
+        lignesCommande.add(commande1);
+        lignesCommande.add(commande2);
+        String rue = "rue du chien";
+        String ville = "LKa Rochette";
+        String codePostal = "7700";
+        String pays = "France";
+        String modePayement = ModePaiement.CB.name();
+
+        commandeN1 = Commande.builder()
+                .clientId(clientId)
+                .lignesCommande(lignesCommande)
+                .rue(rue)
+                .ville(ville)
+                .codePostal(codePostal)
+                .pays(pays)
+                .modePaiement(modePayement)
+                .build();
+        commandeN1.setRandomUUIDCommande();
+
+
+        List<LigneCommandeInfo> lignesCommande2 = new ArrayList<>();
+        LigneCommandeInfo commande3 = new LigneCommandeInfo(43);
+        LigneCommandeInfo commande4 = new LigneCommandeInfo(1);
+        lignesCommande2.add(commande3);
+        lignesCommande2.add(commande4);
+
+        commandeN2 = Commande.builder()
+                .clientId(clientId)
+                .lignesCommande(lignesCommande2)
+                .rue(rue)
+                .ville(ville)
+                .codePostal(codePostal)
+                .pays(pays)
+                .modePaiement(modePayement)
+                .build();
+        commandeN2.setRandomUUIDCommande();
+
+        List<LigneCommandeInfo> lignesCommande3 = new ArrayList<>();
+        LigneCommandeInfo commande6 = new LigneCommandeInfo(12);
+        LigneCommandeInfo commande7 = new LigneCommandeInfo(13);
+        lignesCommande3.add(commande6);
+        lignesCommande3.add(commande7);
+        String rue2 = "rue du chevre chaud ";
+        String ville2 = "jsp";
+        String codePostal2 = "77";
+        String pays2 = "Lune ";
+        String modePayement2 = ModePaiement.PAYPAL.name();
+
+        commandeN3 = Commande.builder()
+                .lignesCommande(lignesCommande3)
+                .rue(rue2)
+                .ville(ville2)
+                .codePostal(codePostal2)
+                .pays(pays2)
+                .modePaiement(modePayement2)
+                .build();
+        commandeN3.setRandomUUID();
+        commandeN3.setRandomUUIDCommande();
+
+    }
+
+    @Test
+    @DisplayName("New repository should be empty")
+    void testNewRepositoryIsEmpty() {
+        List<Commande> commande = repository.findAll();
+
+        assertTrue(commande.isEmpty());
+        assertEquals(0, commande.size());
+    }
+
+
+    @Nested
+    @DisplayName("Save operations")
+    class SaveOperations {
+        @Test
+        @DisplayName("Save should add a new comande")
+        void testSaveNewCommande() {
+            Commande savedCommande = repository.save(commandeN1);
+
+            assertEquals(1, repository.findAll().size());
+            assertEquals(commandeN1.getCommandeId(), savedCommande.getCommandeId());
+            assertEquals(commandeN1.getClientId(), savedCommande.getClientId());
+        }
+
+
+        @Test
+        @DisplayName("Save should update existing commande with same ID")
+        void testSaveUpdatesExistingCommande() {
+            repository.save(commandeN1);
+
+
+            List<LigneCommandeInfo> lignesCommande2 = new ArrayList<>();
+            LigneCommandeInfo commande3 = new LigneCommandeInfo(43);
+            LigneCommandeInfo commande4 = new LigneCommandeInfo(1);
+            lignesCommande2.add(commande3);
+            lignesCommande2.add(commande4);
+
+
+            UUID id = commandeN1.getCommandeId();
+            Commande updatedCommande = Commande.builder()
+                    .commandeId(id)
+                    .lignesCommande(lignesCommande2)
+                    .rue("rue")
+                    .ville("moi")
+                    .codePostal("1")
+                    .pays("Russie")
+                    .modePaiement(ModePaiement.POINTS_FIDELITE.name())
+                    .build();
+
+            Commande savedCommande = repository.save(updatedCommande);
+
+            assertEquals(1, repository.findAll().size());
+            assertEquals(id, savedCommande.getCommandeId());
+            assertEquals("rue", savedCommande.getRue());
+            assertEquals("moi", savedCommande.getVille());
+            assertEquals("1", savedCommande.getCodePostal());
+            assertEquals("Russie", savedCommande.getPays());
+            assertEquals(ModePaiement.POINTS_FIDELITE.name(), savedCommande.getModePaiement());
+        }
+
+        @Test
+        @DisplayName("Save multiple customers should add all of them")
+        void testSaveMultipleCommande() {
+            repository.save(commandeN1);
+            repository.save(commandeN2);
+
+            List<Commande> commande = repository.findAll();
+
+            assertEquals(2, commande.size());
+            assertTrue(commande.contains(commandeN1));
+            assertTrue(commande.contains(commandeN2));
+        }
+    }
+
+    @Nested
+    @DisplayName("Find operations")
+    class FindOperations {
+
+        @BeforeEach
+        void setUpCommande() {
+            repository.save(commandeN1);
+            repository.save(commandeN2);
+        }
+
+        @Test
+        @DisplayName("FindAll should return all commande")
+        void testFindAll() {
+            List<Commande> commande = repository.findAll();
+
+            assertEquals(2, commande.size());
+            assertTrue(commande.contains(commandeN1));
+            assertTrue(commande.contains(commandeN2));
+        }
+
+        @Test
+        @DisplayName("FindById should return commande with matching ID")
+        void testFindById() {
+            Optional<Commande> foundCommande = repository.findById(commandeN1.getCommandeId());
+
+            assertTrue(foundCommande.isPresent());
+            assertEquals(commandeN1.getCommandeId(), foundCommande.get().getCommandeId());
+            assertEquals(commandeN1.getClientId(), foundCommande.get().getClientId());
+        }
+
+        @Test
+        void testFindByIdNotFound(){
+            UUID nonExistentId = UUID.randomUUID();
+            Optional<Commande> foundCommande = repository.findById(nonExistentId);
+
+            assertTrue(foundCommande.isEmpty());
+        }
+
+
+        @Test
+        void testExistsByIdExists(){
+            boolean exists = repository.existsById(commandeN1.getCommandeId());
+
+            assertTrue(exists);
+
+        }
+
+        @Test
+        void testExistsByIdNotExists(){
+            UUID nonExistentId = UUID.randomUUID();
+            boolean exists = repository.existsById(nonExistentId);
+
+            assertFalse(exists);
+        }
+    }
+
+
+
+
+    @Nested
+    @DisplayName("Delete operations")
+    class DeleteOperations {
+
+
+        @BeforeEach
+        void setUpCustomers() {
+            repository.save(commandeN1);
+            repository.save(commandeN2);
+            repository.save(commandeN3);
+        }
+
+
+        @Test
+        @DisplayName("Delete should remove the specified customer")
+        void testDelete() {
+            repository.delete(commandeN1);
+
+            List<Commande> commande = repository.findAll();
+
+            assertEquals(2, commande.size());
+            assertFalse(commande.contains(commandeN1));
+            assertTrue(commande.contains(commandeN2));
+            assertTrue(commande.contains(commandeN3));
+        }
+
+        @Test
+        @DisplayName("DeleteAll should remove all customers")
+        void testDeleteAll() {
+            repository.deleteAll();
+
+            List<Commande> commande = repository.findAll();
+
+            assertTrue(commande.isEmpty());
+            assertEquals(0, commande.size());
+        }
+
+        @Test
+        @DisplayName("Delete should not throw exception when customer doesn't exist")
+        void testDeleteNonExistentCustomer() {
+
+            List<LigneCommandeInfo> lignesCommande = new ArrayList<>();
+            LigneCommandeInfo commande1 = new LigneCommandeInfo(321);
+            LigneCommandeInfo commande2 = new LigneCommandeInfo(3);
+            lignesCommande.add(commande1);
+            lignesCommande.add(commande2);
+
+
+            Commande nonExistentCommande = Commande.builder()
+                    .lignesCommande(lignesCommande)
+                    .rue("non")
+                    .ville("non")
+                    .codePostal("Existent")
+                    .pays("0000")
+                    .modePaiement(ModePaiement.PAYPAL.name())
+                    .build();
+            nonExistentCommande.setRandomUUIDCommande();
+
+            assertDoesNotThrow(() -> repository.delete(nonExistentCommande));
+
+            assertEquals(3, repository.findAll().size());
+        }
+
+
+        @Test
+        void TestDeleteAllCommandeByCustomerID() {
+            System.out.println(commandeN1.getClientId());
+            System.out.println(commandeN2.getClientId());
+            System.out.println(commandeN3.getClientId());
+            repository.deleteById(commandeN1.getClientId());
+
+
+            List<Commande> commande = repository.findAll();
+
+            assertEquals(1, commande.size());
+            assertFalse(commande.contains(commandeN1));
+            assertFalse(commande.contains(commandeN2));
+            assertTrue(commande.contains(commandeN3));
+
+
+        }
+
+
+        @Test
+        void TestDeleteAllCommandeByNonExistentCustomerID() {
+
+
+            List<LigneCommandeInfo> lignesCommande = new ArrayList<>();
+            LigneCommandeInfo commande1 = new LigneCommandeInfo(321);
+            LigneCommandeInfo commande2 = new LigneCommandeInfo(3);
+            lignesCommande.add(commande1);
+            lignesCommande.add(commande2);
+
+
+            Commande nonExistentCommande = Commande.builder()
+                    .lignesCommande(lignesCommande)
+                    .rue("non")
+                    .ville("non")
+                    .codePostal("Existent")
+                    .pays("0000")
+                    .modePaiement(ModePaiement.PAYPAL.name())
+                    .build();
+            nonExistentCommande.setRandomUUIDCommande();
+
+
+            repository.deleteById(nonExistentCommande.getClientId());
+
+
+            assertDoesNotThrow(() -> repository.findAll());
+
+            assertEquals(3, repository.findAll().size());
+
+
+        }
+
+
+    }
+
+
+
+
+}
+
+

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/usecase/CommandeUseCase.java

@@ -0,0 +1,74 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.usecase;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.AdresseInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.ModePaiement;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.repository.ComandeRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.usecase.CustomerUseCase;
+import org.junit.jupiter.api.BeforeEach;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+public class CommandeUseCase {
+
+    @Mock
+    private ComandeRepository comandeRepository;
+
+
+    @InjectMocks
+    private CommandeUseCase commandeUseCase;
+
+    private UUID commandeId;
+    private UUID clientId;
+    private Commande testCommande;
+    private CommandeInfo validCommandeInfo;
+    private LigneCommandeInfo validLigneCommandeInfo;
+    private AdresseInfo validAdresseInfo;
+
+    @BeforeEach
+    void setUp() {
+
+        clientId = UUID.randomUUID();
+        commandeId = UUID.randomUUID();
+        List<LigneCommandeInfo> lignesCommande = new ArrayList<>();
+        LigneCommandeInfo commande1 = new LigneCommandeInfo(12);
+        LigneCommandeInfo commande2 = new LigneCommandeInfo(13);
+        lignesCommande.add(commande1);
+        lignesCommande.add(commande2);
+        String rue = "rue du chien";
+        String ville = "LKa Rochette";
+        String codePostal = "7700";
+        String pays = "France";
+        String modePayement = ModePaiement.CB.name();
+
+        testCommande = Commande.builder()
+                .clientId(clientId)
+                .lignesCommande(lignesCommande)
+                .rue(rue)
+                .ville(ville)
+                .codePostal(codePostal)
+                .pays(pays)
+                .modePaiement(modePayement)
+                .commandeId(commandeId)
+                .build();
+
+
+        validCommandeInfo = new CommandeInfo(lignesCommande,ModePaiement.CB.name());
+        validLigneCommandeInfo= new LigneCommandeInfo(12);
+        validAdresseInfo = new AdresseInfo("rue du chien","LKa Rochette","7700","France");
+    }
+
+
+    @Nested
+
+
+
+
+
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/validator/CommandeValidatorTest.java

@@ -0,0 +1,165 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.commande.validator;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.AdresseInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.ModePaiement;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidAdressException;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidCommandeException;
+import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidLigneCommandeException;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.*;
+
+import java.util.*;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class CommandeValidatorTest {
+
+
+    @Test
+    void testValidateValideLigneCommande () {
+        LigneCommandeInfo ligneCommandeValide =  new LigneCommandeInfo(5);
+
+
+        assertDoesNotThrow(() -> CommandeValidator.validate(ligneCommandeValide));
+    }
+    @ParameterizedTest
+    @ValueSource(ints = {-5,0 })
+    void testValidateNotValideLigneCommande (int notValiteQuantite) {
+        LigneCommandeInfo ligneCommandeNotValide =  new LigneCommandeInfo(notValiteQuantite);
+        NotValidLigneCommandeException exception = assertThrows(
+                NotValidLigneCommandeException.class,
+                () -> CommandeValidator.validate(ligneCommandeNotValide)
+        );
+
+        assertEquals(CommandeValidator.LIGNE_COMMANDE_IS_NOT_VALIDE, exception.getMessage());
+    }
+
+
+    @ParameterizedTest
+    @EnumSource(value = ModePaiement.class, names = {"CB", "PAYPAL", "POINTS_FIDELITE"})
+    void testValidateValideCommande(ModePaiement modePaiement) {
+        LigneCommandeInfo ligneCommandeValide =  new LigneCommandeInfo(5);
+        List<LigneCommandeInfo> listeLigne = new ArrayList<>();
+        listeLigne.add(ligneCommandeValide);
+        String modePaiementValide = modePaiement.toString();
+        CommandeInfo commandeValid = new CommandeInfo(listeLigne, modePaiementValide);
+
+        assertDoesNotThrow(() -> CommandeValidator.validate(commandeValid));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings =  {"jambon", "    ", ""})
+    void testValidateNotValideModePaiement(String modePaiementError) {
+        LigneCommandeInfo ligneCommandeValide =  new LigneCommandeInfo(5);
+        List<LigneCommandeInfo> listeLigne = new ArrayList<>();
+        listeLigne.add(ligneCommandeValide);
+        String modePaiementValide = modePaiementError;
+        CommandeInfo commandeValid = new CommandeInfo(listeLigne, modePaiementValide);
+
+        NotValidCommandeException exception = assertThrows(
+                NotValidCommandeException.class,
+                () -> CommandeValidator.validate(commandeValid)
+        );
+        assertEquals(CommandeValidator.MODE_PAIEMENT_IS_NOT_VALIDE, exception.getMessage());
+    }
+
+        @ParameterizedTest
+        @MethodSource("provideInvalidOrderLists")
+        void testValidateNotValideListLigneCommande(List<LigneCommandeInfo> listeLigne) {
+            String modePaiementValide = ModePaiement.CB.toString();
+            CommandeInfo commandeValid = new CommandeInfo(listeLigne, modePaiementValide);
+            NotValidCommandeException exception = assertThrows(
+                    NotValidCommandeException.class,
+                    () -> CommandeValidator.validate(commandeValid)
+            );
+            assertEquals(CommandeValidator.LIST_LIGNE_COMANDE_IS_NOT_VALIDE, exception.getMessage());
+
+    }
+    static Stream<Arguments> provideInvalidOrderLists() {
+        return Stream.of(
+                Arguments.of(Collections.emptyList()),
+                Arguments.of(Arrays.asList(new LigneCommandeInfo(5), null, null, new LigneCommandeInfo(12))),
+                Arguments.of((List<LigneCommandeInfo>) null)
+        );
+    }
+
+    @Nested
+    class TestAdress{
+
+
+        @Test
+        void testValidateValideLigneCommande () {
+            AdresseInfo adress = new AdresseInfo("rue du chien","La Rochette","7700","France");
+
+            assertDoesNotThrow(() -> CommandeValidator.validate(adress));
+        }
+
+
+
+
+        @ParameterizedTest
+        @NullSource
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        void testValidateNotValideStreet(String  notvalideStreet) {
+            AdresseInfo adress = new AdresseInfo(notvalideStreet,"La Rochette","7700","France");
+            NotValidAdressException exception = assertThrows(
+                    NotValidAdressException.class,
+                    () -> CommandeValidator.validate(adress)
+            );
+            assertEquals(CommandeValidator.STREET_IS_NOT_VALIDE, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @NullSource
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        void testValidateNotValideCity(String  notvalideCity) {
+            AdresseInfo adress = new AdresseInfo("rue du chien",notvalideCity,"7700","France");
+            NotValidAdressException exception = assertThrows(
+                    NotValidAdressException.class,
+                    () -> CommandeValidator.validate(adress)
+            );
+            assertEquals(CommandeValidator.CITY_IS_NOT_VALIDE, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @NullSource
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        void testValidateNotValideCodePostal(String  notvalideCodePostal) {
+            AdresseInfo adress = new AdresseInfo("rue du chien","La Rochette",notvalideCodePostal,"France");
+            NotValidAdressException exception = assertThrows(
+                    NotValidAdressException.class,
+                    () -> CommandeValidator.validate(adress)
+            );
+            assertEquals(CommandeValidator.CODE_POSTAL_IS_NOT_VALIDE, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @NullSource
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        void testValidateNotValideCountry(String  notvalideCountry) {
+            AdresseInfo adress = new AdresseInfo("rue du chien","La Rochette","7700",notvalideCountry);
+            NotValidAdressException exception = assertThrows(
+                    NotValidAdressException.class,
+                    () -> CommandeValidator.validate(adress)
+            );
+            assertEquals(CommandeValidator.COUNTRY_IS_NOT_VALIDE, exception.getMessage());
+        }
+
+    }
+
+
+
+
+
+
+
+
+
+
+
+}