remise des fichier au bon endroit

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/AvisDTO.java

@@ -0,0 +1,11 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis;
+
+import java.util.UUID;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@Getter
+public class AvisDTO {
+  private final UUID avisId;
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/AvisInfo.java

@@ -0,0 +1,13 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis;
+
+import java.time.LocalDate;
+import java.util.UUID;
+
+public record AvisInfo(
+    UUID clientId,
+    UUID livreId,
+    int note,
+    String commentaire,
+    LocalDate dateAchat
+) {
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/converter/AvisConverter.java

@@ -0,0 +1,27 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.converter;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.entity.Avis;
+
+public final class AvisConverter {
+
+  private AvisConverter() {
+  }
+
+  public static Avis toDomain(AvisInfo avisInfo) {
+    return Avis.builder()
+        .clientId(avisInfo.clientId())
+        .livreId(avisInfo.livreId())
+        .note(avisInfo.note())
+        .commentaire(avisInfo.commentaire())
+        .dateAchat(avisInfo.dateAchat())
+        .build();
+  }
+
+  public static AvisDTO toDTO(Avis avis) {
+    return AvisDTO.builder()
+        .avisId(avis.getId())
+        .build();
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/entity/Avis.java

@@ -0,0 +1,21 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.entity;
+
+import java.time.LocalDate;
+import java.util.UUID;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@Getter
+public class Avis {
+  private UUID id;
+  private UUID clientId;
+  private UUID livreId;
+  private int note;
+  private String commentaire;
+  private LocalDate dateAchat;
+
+  public void setRandomUUID() {
+    this.id = UUID.randomUUID();
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/exception/AvisNotFoundException.java

@@ -0,0 +1,13 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.exception;
+
+import java.text.MessageFormat;
+import java.util.UUID;
+
+public class AvisNotFoundException extends Exception {
+
+  public static final String THE_AVIS_WITH_ID_DOES_NOT_EXIST_MESSAGE = "The avis with id {0} does not exist";
+
+  public AvisNotFoundException(UUID uuid) {
+    super(MessageFormat.format(THE_AVIS_WITH_ID_DOES_NOT_EXIST_MESSAGE, uuid));
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/exception/NotValidAvisException.java

@@ -0,0 +1,8 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.exception;
+
+public class NotValidAvisException extends Exception {
+
+  public NotValidAvisException(String message) {
+    super(message);
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/repository/AvisRepository.java

@@ -0,0 +1,56 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.repository;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.entity.Avis;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor
+public final class AvisRepository {
+
+  private final List<Avis> avisList = new ArrayList<>();
+
+  public List<Avis> findAll() {
+    return avisList;
+  }
+
+  public void deleteAll() {
+    avisList.clear();
+  }
+
+  public Avis save(Avis newAvis) {
+    Optional<Avis> existing = this.findById(newAvis.getId());
+    existing.ifPresentOrElse(avisList::remove, newAvis::setRandomUUID);
+    this.avisList.add(newAvis);
+    return newAvis;
+  }
+
+  public Optional<Avis> findById(UUID uuid) {
+    return this.avisList.stream()
+        .filter(avis -> avis.getId().equals(uuid))
+        .findFirst();
+  }
+
+  public boolean existsById(UUID uuid) {
+    return this.avisList.stream()
+        .anyMatch(avis -> avis.getId().equals(uuid));
+  }
+
+  public List<Avis> findByLivreId(UUID livreId) {
+    return this.avisList.stream()
+        .filter(avis -> avis.getLivreId().equals(livreId))
+        .toList();
+  }
+
+  public List<Avis> findByClientId(UUID clientId) {
+    return this.avisList.stream()
+        .filter(avis -> avis.getClientId().equals(clientId))
+        .toList();
+  }
+
+  public void delete(Avis avis) {
+    avisList.remove(avis);
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/usecase/AvisUseCase.java

@@ -0,0 +1,40 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.usecase;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.converter.AvisConverter;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.entity.Avis;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.exception.NotValidAvisException;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.repository.AvisRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.validator.AvisValidator;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.CustomerNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
+import java.util.Optional;
+import java.util.UUID;
+
+public final class AvisUseCase {
+
+  private final AvisRepository avisRepository;
+  private final CustomerRepository customerRepository;
+
+  public AvisUseCase(AvisRepository avisRepository, CustomerRepository customerRepository) {
+    this.avisRepository = avisRepository;
+    this.customerRepository = customerRepository;
+  }
+
+  public AvisDTO gererAvis(AvisInfo avisInfo) throws NotValidAvisException, CustomerNotFoundException {
+    AvisValidator.validate(avisInfo);
+
+    customerRepository.findById(avisInfo.clientId())
+        .orElseThrow(() -> new CustomerNotFoundException(avisInfo.clientId()));
+
+    Avis avis = AvisConverter.toDomain(avisInfo);
+    Avis savedAvis = avisRepository.save(avis);
+
+    return AvisConverter.toDTO(savedAvis);
+  }
+
+  public Optional<AvisDTO> findAvisById(UUID uuid) {
+    return avisRepository.findById(uuid).map(AvisConverter::toDTO);
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/validator/AvisValidator.java

@@ -0,0 +1,54 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.validator;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.exception.NotValidAvisException;
+
+public final class AvisValidator {
+
+  public static final String CLIENT_ID_CANNOT_BE_NULL = "Client id cannot be null";
+  public static final String LIVRE_ID_CANNOT_BE_NULL = "Livre id cannot be null";
+  public static final String NOTE_MUST_BE_BETWEEN_1_AND_5 = "Note must be between 1 and 5";
+  public static final String COMMENTAIRE_CANNOT_BE_BLANK = "Commentaire cannot be blank";
+  public static final String DATE_ACHAT_CANNOT_BE_NULL = "Date achat cannot be null";
+
+  private AvisValidator() {
+  }
+
+  public static void validate(AvisInfo avisInfo) throws NotValidAvisException {
+    validateClientId(avisInfo);
+    validateLivreId(avisInfo);
+    validateNote(avisInfo);
+    validateCommentaire(avisInfo);
+    validateDateAchat(avisInfo);
+  }
+
+  private static void validateClientId(AvisInfo avisInfo) throws NotValidAvisException {
+    if (avisInfo.clientId() == null) {
+      throw new NotValidAvisException(CLIENT_ID_CANNOT_BE_NULL);
+    }
+  }
+
+  private static void validateLivreId(AvisInfo avisInfo) throws NotValidAvisException {
+    if (avisInfo.livreId() == null) {
+      throw new NotValidAvisException(LIVRE_ID_CANNOT_BE_NULL);
+    }
+  }
+
+  private static void validateNote(AvisInfo avisInfo) throws NotValidAvisException {
+    if (avisInfo.note() < 1 || avisInfo.note() > 5) {
+      throw new NotValidAvisException(NOTE_MUST_BE_BETWEEN_1_AND_5);
+    }
+  }
+
+  private static void validateCommentaire(AvisInfo avisInfo) throws NotValidAvisException {
+    if (avisInfo.commentaire() == null || avisInfo.commentaire().isBlank()) {
+      throw new NotValidAvisException(COMMENTAIRE_CANNOT_BE_BLANK);
+    }
+  }
+
+  private static void validateDateAchat(AvisInfo avisInfo) throws NotValidAvisException {
+    if (avisInfo.dateAchat() == null) {
+      throw new NotValidAvisException(DATE_ACHAT_CANNOT_BE_NULL);
+    }
+  }
+}

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

@@ -0,0 +1,24 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.UUID;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@Getter
+public class BookDTO {
+  private final UUID id;
+  private final String isbn;
+  private final String title;
+  private final String author;
+  private final String publisher;
+  private final LocalDate publicationDate;
+  private final BigDecimal price;
+  private final int stock;
+  private final List<String> categories;
+  private final String description;
+  private final String language;
+}

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

@@ -0,0 +1,19 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+
+public record BookInfo(
+    String isbn,
+    String title,
+    String author,
+    String publisher,
+    LocalDate publicationDate,
+    BigDecimal price,
+    int initialStock,
+    List<String> categories,
+    String description,
+    String language
+) {
+}

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.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+ 
+public final class BookConverter {
+ 
+  private BookConverter() {
+  }
+ 
+  public static Book toDomain(BookInfo bookInfo) {
+    return Book.builder()
+        .isbn(bookInfo.isbn())
+        .title(bookInfo.title())
+        .author(bookInfo.author())
+        .publisher(bookInfo.publisher())
+        .publicationDate(bookInfo.publicationDate())
+        .price(bookInfo.price())
+        .stock(bookInfo.initialStock())
+        .categories(bookInfo.categories())
+        .description(bookInfo.description())
+        .language(bookInfo.language())
+        .build();
+  }
+ 
+  public static BookDTO toDTO(Book book) {
+    return BookDTO.builder()
+        .id(book.getId())
+        .isbn(book.getIsbn())
+        .title(book.getTitle())
+        .author(book.getAuthor())
+        .publisher(book.getPublisher())
+        .publicationDate(book.getPublicationDate())
+        .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,30 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.entity;
+ 
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.UUID;
+import lombok.Builder;
+import lombok.Getter;
+ 
+@Builder
+@Getter
+public class Book {
+ 
+  private UUID id;
+  private String isbn;
+  private String title;
+  private String author;
+  private String publisher;
+  private LocalDate publicationDate;
+  private BigDecimal price;
+  private int stock;
+  private List<String> categories;
+  private String description;
+  private String language;
+ 
+  public void setRandomUUID() {
+    this.id = UUID.randomUUID();
+  }
+}
+ 

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

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

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

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

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

@@ -0,0 +1,51 @@
+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;
+import java.util.UUID;
+import lombok.NoArgsConstructor;
+ 
+@NoArgsConstructor
+public final 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> optionalBookWithSameId = this.findById(newBook.getId());
+    optionalBookWithSameId.ifPresentOrElse(books::remove, newBook::setRandomUUID);
+    this.books.add(newBook);
+    return newBook;
+  }
+ 
+  public Optional<Book> findById(UUID uuid) {
+    return this.books.stream()
+        .filter(book -> book.getId().equals(uuid))
+        .findFirst();
+  }
+ 
+  public boolean existsById(UUID uuid) {
+    return this.books.stream()
+        .anyMatch(book -> book.getId().equals(uuid));
+  }
+ 
+  public Optional<Book> findByIsbn(String isbn) {
+    return this.books.stream()
+        .filter(book -> book.getIsbn().equals(isbn))
+        .findFirst();
+  }
+ 
+  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,67 @@
+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.BookInfo;
+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.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;
+import java.util.UUID;
+ 
+public final class BookUseCase {
+ 
+  private final BookRepository bookRepository;
+ 
+  public BookUseCase(BookRepository bookRepository) {
+    this.bookRepository = bookRepository;
+  }
+ 
+  public String registerBook(BookInfo bookInfo) throws NotValidBookException {
+    BookValidator.validate(bookInfo);
+    Book bookToRegister = BookConverter.toDomain(bookInfo);
+    Book registeredBook = bookRepository.save(bookToRegister);
+    return registeredBook.getIsbn();
+  }
+ 
+  public Optional<BookDTO> findBookByIsbn(String isbn) {
+    Optional<Book> optionalBook = bookRepository.findByIsbn(isbn);
+    return optionalBook.map(BookConverter::toDTO);
+  }
+ 
+  public BookDTO updateBook(UUID uuid, BookInfo bookInfo) throws BookNotFoundException, NotValidBookException {
+    BookValidator.validate(bookInfo);
+    Book existingBook = getBookIfNotFoundThrowException(uuid);
+    Book updatedBook = Book.builder()
+        .id(uuid)
+        .isbn(bookInfo.isbn())
+        .title(bookInfo.title())
+        .author(bookInfo.author())
+        .publisher(bookInfo.publisher())
+        .publicationDate(bookInfo.publicationDate())
+        .price(bookInfo.price())
+        .stock(existingBook.getStock())
+        .categories(bookInfo.categories())
+        .description(bookInfo.description())
+        .language(bookInfo.language())
+        .build();
+    Book saved = bookRepository.save(updatedBook);
+    return BookConverter.toDTO(saved);
+  }
+ 
+  public void deleteBook(UUID uuid) throws BookNotFoundException {
+    Book bookToDelete = getBookIfNotFoundThrowException(uuid);
+    bookRepository.delete(bookToDelete);
+  }
+ 
+  private Book getBookIfNotFoundThrowException(UUID uuid) throws BookNotFoundException {
+    Optional<Book> optionalBook = bookRepository.findById(uuid);
+    if (optionalBook.isEmpty()) {
+      throw new BookNotFoundException(uuid);
+    }
+    return optionalBook.get();
+  }
+}
+ 

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/validator/BookValidator.java

@@ -0,0 +1,59 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.validator;
+ 
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
+import java.math.BigDecimal;
+ 
+public final class BookValidator {
+ 
+  public static final String ISBN_IS_NOT_VALID = "ISBN is not valid";
+  public static final String PRICE_MUST_BE_POSITIVE = "Price must be positive";
+  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 PUBLISHER_CANNOT_BE_BLANK = "Publisher cannot be blank";
+  public static final String ISBN_REGEX = "\\d{13}";
+ 
+  private BookValidator() {
+  }
+ 
+  public static void validate(BookInfo bookInfo) throws NotValidBookException {
+    validateIsbn(bookInfo);
+    validateTitle(bookInfo);
+    validateAuthor(bookInfo);
+    validatePublisher(bookInfo);
+    validatePrice(bookInfo);
+  }
+ 
+  private static void validateIsbn(BookInfo bookInfo) throws NotValidBookException {
+    if (bookInfo.isbn() == null || bookInfo.isbn().isBlank()) {
+      throw new NotValidBookException(ISBN_IS_NOT_VALID);
+    }
+    if (!bookInfo.isbn().matches(ISBN_REGEX)) {
+      throw new NotValidBookException(ISBN_IS_NOT_VALID);
+    }
+  }
+ 
+  private static void validateTitle(BookInfo bookInfo) throws NotValidBookException {
+    if (bookInfo.title() == null || bookInfo.title().isBlank()) {
+      throw new NotValidBookException(TITLE_CANNOT_BE_BLANK);
+    }
+  }
+ 
+  private static void validateAuthor(BookInfo bookInfo) throws NotValidBookException {
+    if (bookInfo.author() == null || bookInfo.author().isBlank()) {
+      throw new NotValidBookException(AUTHOR_CANNOT_BE_BLANK);
+    }
+  }
+ 
+  private static void validatePublisher(BookInfo bookInfo) throws NotValidBookException {
+    if (bookInfo.publisher() == null || bookInfo.publisher().isBlank()) {
+      throw new NotValidBookException(PUBLISHER_CANNOT_BE_BLANK);
+    }
+  }
+ 
+  private static void validatePrice(BookInfo bookInfo) throws NotValidBookException {
+    if (bookInfo.price() == null || bookInfo.price().compareTo(BigDecimal.ZERO) <= 0) {
+      throw new NotValidBookException(PRICE_MUST_BE_POSITIVE);
+    }
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/order/AdresseLivraison.java

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

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

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

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

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

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/order/OrderDTO.java

@@ -0,0 +1,15 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order;
+ 
+import java.math.BigDecimal;
+import java.util.UUID;
+import lombok.Builder;
+import lombok.Getter;
+ 
+@Builder
+@Getter
+public class OrderDTO {
+  private final UUID commandeId;
+  private final BigDecimal montantTotal;
+  private final int pointsFideliteGagnes;
+}
+ 

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/order/OrderInfo.java

@@ -0,0 +1,13 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order;
+ 
+import java.util.List;
+import java.util.UUID;
+ 
+public record OrderInfo(
+    UUID clientId,
+    List<LigneCommandeInfo> lignesCommande,
+    AdresseLivraison adresseLivraison,
+    ModePaiement modePaiement
+) {
+}
+ 

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/order/converter/OrderConverter.java

@@ -0,0 +1,34 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.converter;
+ 
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.LigneCommande;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.Order;
+import java.math.BigDecimal;
+import java.util.List;
+ 
+public final class OrderConverter {
+ 
+  private OrderConverter() {
+  }
+ 
+  public static Order toDomain(OrderInfo orderInfo, List<LigneCommande> lignes,
+      BigDecimal montantTotal, int pointsFideliteGagnes) {
+    return Order.builder()
+        .clientId(orderInfo.clientId())
+        .lignesCommande(lignes)
+        .adresseLivraison(orderInfo.adresseLivraison())
+        .modePaiement(orderInfo.modePaiement())
+        .montantTotal(montantTotal)
+        .pointsFideliteGagnes(pointsFideliteGagnes)
+        .build();
+  }
+ 
+  public static OrderDTO toDTO(Order order) {
+    return OrderDTO.builder()
+        .commandeId(order.getId())
+        .montantTotal(order.getMontantTotal())
+        .pointsFideliteGagnes(order.getPointsFideliteGagnes())
+        .build();
+  }
+}

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

@@ -0,0 +1,15 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.entity;
+ 
+import java.math.BigDecimal;
+import java.util.UUID;
+import lombok.Builder;
+import lombok.Getter;
+ 
+@Builder
+@Getter
+public class LigneCommande {
+  private UUID livreId;
+  private int quantite;
+  private BigDecimal prixUnitaire;
+}
+ 

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/order/entity/Order.java

@@ -0,0 +1,26 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.entity;
+ 
+import fr.iut_fbleau.but3.dev62.mylibrary.order.AdresseLivraison;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.ModePaiement;
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.UUID;
+import lombok.Builder;
+import lombok.Getter;
+ 
+@Builder
+@Getter
+public class Order {
+  private UUID id;
+  private UUID clientId;
+  private List<LigneCommande> lignesCommande;
+  private AdresseLivraison adresseLivraison;
+  private ModePaiement modePaiement;
+  private BigDecimal montantTotal;
+  private int pointsFideliteGagnes;
+ 
+  public void setRandomUUID() {
+    this.id = UUID.randomUUID();
+  }
+}
+ 

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/order/exception/NotValidOrderException.java

@@ -0,0 +1,9 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.exception;
+ 
+public class NotValidOrderException extends Exception {
+ 
+  public NotValidOrderException(String message) {
+    super(message);
+  }
+}
+ 

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/order/exception/OrderNotFoundException.java

@@ -0,0 +1,14 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.exception;
+ 
+import java.text.MessageFormat;
+import java.util.UUID;
+ 
+public class OrderNotFoundException extends Exception {
+ 
+  public static final String THE_ORDER_WITH_ID_DOES_NOT_EXIST_MESSAGE = "The order with id {0} does not exist";
+ 
+  public OrderNotFoundException(UUID uuid) {
+    super(MessageFormat.format(THE_ORDER_WITH_ID_DOES_NOT_EXIST_MESSAGE, uuid));
+  }
+}
+ 

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/order/repository/OrderRepository.java

@@ -0,0 +1,50 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.repository;
+ 
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.Order;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import lombok.NoArgsConstructor;
+ 
+@NoArgsConstructor
+public final class OrderRepository {
+ 
+  private final List<Order> orders = new ArrayList<>();
+ 
+  public List<Order> findAll() {
+    return orders;
+  }
+ 
+  public void deleteAll() {
+    orders.clear();
+  }
+ 
+  public Order save(Order newOrder) {
+    Optional<Order> existing = this.findById(newOrder.getId());
+    existing.ifPresentOrElse(orders::remove, newOrder::setRandomUUID);
+    this.orders.add(newOrder);
+    return newOrder;
+  }
+ 
+  public Optional<Order> findById(UUID uuid) {
+    return this.orders.stream()
+        .filter(order -> order.getId().equals(uuid))
+        .findFirst();
+  }
+ 
+  public boolean existsById(UUID uuid) {
+    return this.orders.stream()
+        .anyMatch(order -> order.getId().equals(uuid));
+  }
+ 
+  public List<Order> findByClientId(UUID clientId) {
+    return this.orders.stream()
+        .filter(order -> order.getClientId().equals(clientId))
+        .toList();
+  }
+ 
+  public void delete(Order order) {
+    this.orders.remove(order);
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/order/usecase/OrderUseCase.java

@@ -0,0 +1,79 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.usecase;
+ 
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.CustomerNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.ModePaiement;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.converter.OrderConverter;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.LigneCommande;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.Order;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.exception.NotValidOrderException;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.repository.OrderRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.validator.OrderValidator;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+ 
+public final class OrderUseCase {
+ 
+  private final OrderRepository orderRepository;
+  private final CustomerRepository customerRepository;
+  private final BookRepository bookRepository;
+ 
+  public OrderUseCase(OrderRepository orderRepository, CustomerRepository customerRepository,
+      BookRepository bookRepository) {
+    this.orderRepository = orderRepository;
+    this.customerRepository = customerRepository;
+    this.bookRepository = bookRepository;
+  }
+ 
+  public OrderDTO passerCommande(OrderInfo orderInfo)
+      throws NotValidOrderException, CustomerNotFoundException {
+    OrderValidator.validate(orderInfo);
+ 
+    Customer customer = customerRepository.findById(orderInfo.clientId())
+        .orElseThrow(() -> new CustomerNotFoundException(orderInfo.clientId()));
+ 
+    List<LigneCommande> lignes = new ArrayList<>();
+    BigDecimal montantTotal = BigDecimal.ZERO;
+ 
+    for (LigneCommandeInfo ligneInfo : orderInfo.lignesCommande()) {
+      Book book = bookRepository.findById(ligneInfo.livreId())
+          .orElseThrow(() -> new NotValidOrderException("Book not found: " + ligneInfo.livreId()));
+ 
+      BigDecimal prixLigne = book.getPrice().multiply(BigDecimal.valueOf(ligneInfo.quantite()));
+      montantTotal = montantTotal.add(prixLigne);
+ 
+      lignes.add(LigneCommande.builder()
+          .livreId(ligneInfo.livreId())
+          .quantite(ligneInfo.quantite())
+          .prixUnitaire(book.getPrice())
+          .build());
+    }
+ 
+    int pointsGagnes = montantTotal.intValue();
+ 
+    if (orderInfo.modePaiement() == ModePaiement.POINTS_FIDELITE) {
+      customer.addLoyaltyPoints(-montantTotal.intValue());
+    } else {
+      customer.addLoyaltyPoints(pointsGagnes);
+    }
+    customerRepository.save(customer);
+ 
+    Order order = OrderConverter.toDomain(orderInfo, lignes, montantTotal, pointsGagnes);
+    Order savedOrder = orderRepository.save(order);
+ 
+    return OrderConverter.toDTO(savedOrder);
+  }
+ 
+  public Optional<OrderDTO> findOrderById(UUID uuid) {
+    return orderRepository.findById(uuid).map(OrderConverter::toDTO);
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/order/validator/OrderValidator.java

@@ -0,0 +1,53 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.validator;
+ 
+import fr.iut_fbleau.but3.dev62.mylibrary.order.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.exception.NotValidOrderException;
+ 
+public final class OrderValidator {
+ 
+  public static final String CLIENT_ID_CANNOT_BE_NULL = "Client id cannot be null";
+  public static final String LIGNES_COMMANDE_CANNOT_BE_EMPTY = "Order must have at least one item";
+  public static final String QUANTITE_MUST_BE_POSITIVE = "Quantity must be positive";
+  public static final String MODE_PAIEMENT_CANNOT_BE_NULL = "Payment method cannot be null";
+  public static final String ADRESSE_LIVRAISON_CANNOT_BE_NULL = "Delivery address cannot be null";
+ 
+  private OrderValidator() {
+  }
+ 
+  public static void validate(OrderInfo orderInfo) throws NotValidOrderException {
+    validateClientId(orderInfo);
+    validateLignesCommande(orderInfo);
+    validateAdresseLivraison(orderInfo);
+    validateModePaiement(orderInfo);
+  }
+ 
+  private static void validateClientId(OrderInfo orderInfo) throws NotValidOrderException {
+    if (orderInfo.clientId() == null) {
+      throw new NotValidOrderException(CLIENT_ID_CANNOT_BE_NULL);
+    }
+  }
+ 
+  private static void validateLignesCommande(OrderInfo orderInfo) throws NotValidOrderException {
+    if (orderInfo.lignesCommande() == null || orderInfo.lignesCommande().isEmpty()) {
+      throw new NotValidOrderException(LIGNES_COMMANDE_CANNOT_BE_EMPTY);
+    }
+    for (LigneCommandeInfo ligne : orderInfo.lignesCommande()) {
+      if (ligne.quantite() <= 0) {
+        throw new NotValidOrderException(QUANTITE_MUST_BE_POSITIVE);
+      }
+    }
+  }
+ 
+  private static void validateAdresseLivraison(OrderInfo orderInfo) throws NotValidOrderException {
+    if (orderInfo.adresseLivraison() == null) {
+      throw new NotValidOrderException(ADRESSE_LIVRAISON_CANNOT_BE_NULL);
+    }
+  }
+ 
+  private static void validateModePaiement(OrderInfo orderInfo) throws NotValidOrderException {
+    if (orderInfo.modePaiement() == null) {
+      throw new NotValidOrderException(MODE_PAIEMENT_CANNOT_BE_NULL);
+    }
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/converter/AvisConverterTest.java

@@ -0,0 +1,76 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.converter;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.entity.Avis;
+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.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("AvisConverter Unit Tests")
+class AvisConverterTest {
+
+  private final UUID clientId = UUID.randomUUID();
+  private final UUID livreId = UUID.randomUUID();
+
+  @Nested
+  @DisplayName("toDomain() method tests")
+  class ToDomainTests {
+
+    @Test
+    @DisplayName("Should convert AvisInfo to Avis domain object")
+    void shouldConvertAvisInfoToDomain() {
+      AvisInfo avisInfo = new AvisInfo(
+          clientId, livreId, 5, "Excellent livre !", LocalDate.of(2024, 1, 15)
+      );
+
+      Avis result = AvisConverter.toDomain(avisInfo);
+
+      assertNotNull(result);
+      assertEquals(clientId, result.getClientId());
+      assertEquals(livreId, result.getLivreId());
+      assertEquals(5, result.getNote());
+      assertEquals("Excellent livre !", result.getCommentaire());
+      assertEquals(LocalDate.of(2024, 1, 15), result.getDateAchat());
+    }
+
+    @Test
+    @DisplayName("Should have null ID after toDomain (set by repository)")
+    void shouldHaveNullIdAfterToDomain() {
+      AvisInfo avisInfo = new AvisInfo(clientId, livreId, 3, "Commentaire", LocalDate.now());
+
+      Avis result = AvisConverter.toDomain(avisInfo);
+
+      assertNull(result.getId());
+    }
+  }
+
+  @Nested
+  @DisplayName("toDTO() method tests")
+  class ToDTOTests {
+
+    @Test
+    @DisplayName("Should convert Avis domain object to AvisDTO")
+    void shouldConvertAvisToDTO() {
+      UUID avisId = UUID.randomUUID();
+      Avis avis = Avis.builder()
+          .id(avisId)
+          .clientId(clientId)
+          .livreId(livreId)
+          .note(5)
+          .commentaire("Excellent !")
+          .dateAchat(LocalDate.of(2024, 1, 15))
+          .build();
+
+      AvisDTO result = AvisConverter.toDTO(avis);
+
+      assertNotNull(result);
+      assertEquals(avisId, result.getAvisId());
+    }
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/entity/AvisNotFoundExceptionTest.java

@@ -0,0 +1,46 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.exception;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class AvisNotFoundExceptionTest {
+
+  @Test
+  @DisplayName("Exception message should contain the UUID provided")
+  void testExceptionMessageContainsUUID() {
+    UUID uuid = UUID.randomUUID();
+
+    AvisNotFoundException exception = new AvisNotFoundException(uuid);
+
+    String expectedMessage = String.format("The avis with id %s does not exist", uuid);
+    assertEquals(expectedMessage, exception.getMessage());
+  }
+
+  @Test
+  @DisplayName("Exception should use the correct constant message format")
+  void testExceptionUsesConstantMessageFormat() {
+    UUID uuid = UUID.randomUUID();
+
+    AvisNotFoundException exception = new AvisNotFoundException(uuid);
+
+    assertEquals("The avis with id {0} does not exist",
+        AvisNotFoundException.THE_AVIS_WITH_ID_DOES_NOT_EXIST_MESSAGE);
+    assertTrue(exception.getMessage().contains(uuid.toString()));
+  }
+
+  @Test
+  @DisplayName("Exception should be properly thrown and caught")
+  void testExceptionCanBeThrownAndCaught() {
+    UUID uuid = UUID.randomUUID();
+
+    try {
+      throw new AvisNotFoundException(uuid);
+    } catch (AvisNotFoundException e) {
+      assertTrue(e.getMessage().contains(uuid.toString()));
+    }
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/entity/AvisTest.java

@@ -0,0 +1,60 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.entity;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class AvisTest {
+
+  @Test
+  @DisplayName("Builder should create a valid Avis instance")
+  void testAvisBuilder() {
+    UUID id = UUID.randomUUID();
+    UUID clientId = UUID.randomUUID();
+    UUID livreId = UUID.randomUUID();
+
+    Avis avis = Avis.builder()
+        .id(id)
+        .clientId(clientId)
+        .livreId(livreId)
+        .note(5)
+        .commentaire("Excellent livre !")
+        .dateAchat(LocalDate.of(2024, 1, 15))
+        .build();
+
+    assertEquals(id, avis.getId());
+    assertEquals(clientId, avis.getClientId());
+    assertEquals(livreId, avis.getLivreId());
+    assertEquals(5, avis.getNote());
+    assertEquals("Excellent livre !", avis.getCommentaire());
+    assertEquals(LocalDate.of(2024, 1, 15), avis.getDateAchat());
+  }
+
+  @Test
+  @DisplayName("setRandomUUID should set a new non-null UUID")
+  void testSetRandomUUID() {
+    Avis avis = Avis.builder().build();
+    UUID originalId = avis.getId();
+
+    avis.setRandomUUID();
+
+    assertNotNull(avis.getId());
+    assertNotEquals(originalId, avis.getId());
+  }
+
+  @Test
+  @DisplayName("Two setRandomUUID calls should produce different UUIDs")
+  void testSetRandomUUIDTwice() {
+    Avis avis = Avis.builder().build();
+    avis.setRandomUUID();
+    UUID firstId = avis.getId();
+
+    avis.setRandomUUID();
+
+    assertNotEquals(firstId, avis.getId());
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/exception/NotValidAvisExceptionTest.java

@@ -0,0 +1,61 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.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.*;
+
+class NotValidAvisExceptionTest {
+
+  @Test
+  @DisplayName("Exception should be created with the provided message")
+  void testExceptionCreation() {
+    String errorMessage = "Note must be between 1 and 5";
+
+    NotValidAvisException exception = new NotValidAvisException(errorMessage);
+
+    assertEquals(errorMessage, exception.getMessage());
+  }
+
+  @ParameterizedTest
+  @ValueSource(strings = {
+      "Note must be between 1 and 5",
+      "Commentaire cannot be blank",
+      "Client id cannot be null",
+      "Livre id cannot be null",
+      "Date achat cannot be null"
+  })
+  @DisplayName("Exception should handle different validation messages")
+  void testExceptionWithDifferentMessages(String errorMessage) {
+    NotValidAvisException exception = new NotValidAvisException(errorMessage);
+
+    assertEquals(errorMessage, exception.getMessage());
+  }
+
+  @Test
+  @DisplayName("Exception should be properly thrown and caught")
+  void testExceptionCanBeThrownAndCaught() {
+    String errorMessage = "Note must be between 1 and 5";
+
+    Exception exception = assertThrows(NotValidAvisException.class, () -> {
+      throw new NotValidAvisException(errorMessage);
+    });
+
+    assertEquals(errorMessage, exception.getMessage());
+  }
+
+  @Test
+  @DisplayName("Exception should be catchable as a general Exception")
+  void testExceptionInheritance() {
+    String errorMessage = "Commentaire cannot be blank";
+
+    try {
+      throw new NotValidAvisException(errorMessage);
+    } catch (Exception e) {
+      assertEquals(NotValidAvisException.class, e.getClass());
+      assertEquals(errorMessage, e.getMessage());
+    }
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/repository/AvisRepositoryTest.java

@@ -0,0 +1,184 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.repository;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.entity.Avis;
+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.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class AvisRepositoryTest {
+
+  private AvisRepository repository;
+  private Avis avis1;
+  private Avis avis2;
+  private UUID clientId1;
+  private UUID livreId1;
+
+  @BeforeEach
+  void setUp() {
+    repository = new AvisRepository();
+    clientId1 = UUID.randomUUID();
+    livreId1 = UUID.randomUUID();
+
+    avis1 = Avis.builder()
+        .clientId(clientId1)
+        .livreId(livreId1)
+        .note(5)
+        .commentaire("Excellent livre !")
+        .dateAchat(LocalDate.of(2024, 1, 15))
+        .build();
+    avis1.setRandomUUID();
+
+    avis2 = Avis.builder()
+        .clientId(UUID.randomUUID())
+        .livreId(livreId1)
+        .note(3)
+        .commentaire("Pas mal")
+        .dateAchat(LocalDate.of(2024, 2, 10))
+        .build();
+    avis2.setRandomUUID();
+  }
+
+  @Test
+  @DisplayName("New repository should be empty")
+  void testNewRepositoryIsEmpty() {
+    assertTrue(repository.findAll().isEmpty());
+  }
+
+  @Nested
+  @DisplayName("Save operations")
+  class SaveOperations {
+
+    @Test
+    @DisplayName("Save should add a new avis")
+    void testSaveNewAvis() {
+      Avis saved = repository.save(avis1);
+
+      assertEquals(1, repository.findAll().size());
+      assertEquals(avis1.getId(), saved.getId());
+    }
+
+    @Test
+    @DisplayName("Save should update existing avis with same ID")
+    void testSaveUpdatesExistingAvis() {
+      repository.save(avis1);
+      UUID id = avis1.getId();
+
+      Avis updated = Avis.builder()
+          .id(id)
+          .clientId(clientId1)
+          .livreId(livreId1)
+          .note(3)
+          .commentaire("Finalement moyen")
+          .dateAchat(LocalDate.of(2024, 1, 15))
+          .build();
+
+      Avis saved = repository.save(updated);
+
+      assertEquals(1, repository.findAll().size());
+      assertEquals(id, saved.getId());
+      assertEquals(3, saved.getNote());
+    }
+
+    @Test
+    @DisplayName("Save multiple avis should add all of them")
+    void testSaveMultipleAvis() {
+      repository.save(avis1);
+      repository.save(avis2);
+
+      assertEquals(2, repository.findAll().size());
+    }
+  }
+
+  @Nested
+  @DisplayName("Find operations")
+  class FindOperations {
+
+    @BeforeEach
+    void setUpAvis() {
+      repository.save(avis1);
+      repository.save(avis2);
+    }
+
+    @Test
+    @DisplayName("FindById should return avis with matching ID")
+    void testFindById() {
+      Optional<Avis> found = repository.findById(avis1.getId());
+
+      assertTrue(found.isPresent());
+      assertEquals(avis1.getId(), found.get().getId());
+    }
+
+    @Test
+    @DisplayName("FindById should return empty Optional when ID doesn't exist")
+    void testFindByIdNotFound() {
+      Optional<Avis> found = repository.findById(UUID.randomUUID());
+
+      assertTrue(found.isEmpty());
+    }
+
+    @Test
+    @DisplayName("FindByLivreId should return all avis for a book")
+    void testFindByLivreId() {
+      List<Avis> found = repository.findByLivreId(livreId1);
+
+      assertEquals(2, found.size());
+    }
+
+    @Test
+    @DisplayName("FindByClientId should return all avis for a client")
+    void testFindByClientId() {
+      List<Avis> found = repository.findByClientId(clientId1);
+
+      assertEquals(1, found.size());
+      assertEquals(avis1.getId(), found.getFirst().getId());
+    }
+
+    @Test
+    @DisplayName("ExistsById should return true when ID exists")
+    void testExistsByIdExists() {
+      assertTrue(repository.existsById(avis1.getId()));
+    }
+
+    @Test
+    @DisplayName("ExistsById should return false when ID doesn't exist")
+    void testExistsByIdNotExists() {
+      assertFalse(repository.existsById(UUID.randomUUID()));
+    }
+  }
+
+  @Nested
+  @DisplayName("Delete operations")
+  class DeleteOperations {
+
+    @BeforeEach
+    void setUpAvis() {
+      repository.save(avis1);
+      repository.save(avis2);
+    }
+
+    @Test
+    @DisplayName("Delete should remove the specified avis")
+    void testDelete() {
+      repository.delete(avis1);
+
+      assertEquals(1, repository.findAll().size());
+      assertFalse(repository.findAll().contains(avis1));
+    }
+
+    @Test
+    @DisplayName("DeleteAll should remove all avis")
+    void testDeleteAll() {
+      repository.deleteAll();
+
+      assertTrue(repository.findAll().isEmpty());
+    }
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/usecase/AvisUseCaseTest.java

@@ -0,0 +1,169 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.usecase;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.entity.Avis;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.exception.NotValidAvisException;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.repository.AvisRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.CustomerNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
+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.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class AvisUseCaseTest {
+
+  @Mock
+  private AvisRepository avisRepository;
+
+  @Mock
+  private CustomerRepository customerRepository;
+
+  @InjectMocks
+  private AvisUseCase avisUseCase;
+
+  private UUID clientId;
+  private UUID livreId;
+  private Customer testCustomer;
+  private AvisInfo validAvisInfo;
+
+  @BeforeEach
+  void setUp() {
+    clientId = UUID.randomUUID();
+    livreId = UUID.randomUUID();
+
+    testCustomer = Customer.builder()
+        .id(clientId)
+        .firstName("Marie")
+        .lastName("Dupont")
+        .phoneNumber("0612345678")
+        .loyaltyPoints(100)
+        .build();
+
+    validAvisInfo = new AvisInfo(clientId, livreId, 5, "Excellent livre !", LocalDate.of(2024, 1, 15));
+  }
+
+  @Nested
+  @DisplayName("GererAvis tests")
+  class GererAvisTests {
+
+    @Test
+    @DisplayName("Should create avis when valid data is provided")
+    void testGererAvisWithValidData() throws NotValidAvisException, CustomerNotFoundException {
+      when(customerRepository.findById(clientId)).thenReturn(Optional.of(testCustomer));
+
+      UUID avisId = UUID.randomUUID();
+      Avis savedAvis = Avis.builder()
+          .id(avisId)
+          .clientId(clientId)
+          .livreId(livreId)
+          .note(5)
+          .commentaire("Excellent livre !")
+          .dateAchat(LocalDate.of(2024, 1, 15))
+          .build();
+      when(avisRepository.save(any(Avis.class))).thenReturn(savedAvis);
+
+      AvisDTO result = avisUseCase.gererAvis(validAvisInfo);
+
+      assertNotNull(result);
+      assertEquals(avisId, result.getAvisId());
+      verify(avisRepository, times(1)).save(any(Avis.class));
+    }
+
+    @Test
+    @DisplayName("Should throw exception when customer does not exist")
+    void testGererAvisWithUnknownCustomer() {
+      when(customerRepository.findById(clientId)).thenReturn(Optional.empty());
+
+      assertThrows(CustomerNotFoundException.class,
+          () -> avisUseCase.gererAvis(validAvisInfo));
+
+      verify(avisRepository, never()).save(any(Avis.class));
+    }
+
+    @Test
+    @DisplayName("Should throw exception when note is invalid")
+    void testGererAvisWithInvalidNote() {
+      AvisInfo invalidAvis = new AvisInfo(clientId, livreId, 6, "Commentaire", LocalDate.now());
+
+      assertThrows(NotValidAvisException.class,
+          () -> avisUseCase.gererAvis(invalidAvis));
+
+      verify(avisRepository, never()).save(any(Avis.class));
+    }
+
+    @Test
+    @DisplayName("Should throw exception when commentaire is blank")
+    void testGererAvisWithBlankCommentaire() {
+      AvisInfo invalidAvis = new AvisInfo(clientId, livreId, 5, "", LocalDate.now());
+
+      assertThrows(NotValidAvisException.class,
+          () -> avisUseCase.gererAvis(invalidAvis));
+
+      verify(avisRepository, never()).save(any(Avis.class));
+    }
+
+    @Test
+    @DisplayName("Should throw exception when clientId is null")
+    void testGererAvisWithNullClientId() {
+      AvisInfo invalidAvis = new AvisInfo(null, livreId, 5, "Commentaire", LocalDate.now());
+
+      assertThrows(NotValidAvisException.class,
+          () -> avisUseCase.gererAvis(invalidAvis));
+
+      verify(avisRepository, never()).save(any(Avis.class));
+    }
+  }
+
+  @Nested
+  @DisplayName("FindAvis tests")
+  class FindAvisTests {
+
+    @Test
+    @DisplayName("Should return avis when ID exists")
+    void testFindAvisById() {
+      UUID avisId = UUID.randomUUID();
+      Avis avis = Avis.builder()
+          .id(avisId)
+          .clientId(clientId)
+          .livreId(livreId)
+          .note(5)
+          .commentaire("Excellent !")
+          .dateAchat(LocalDate.now())
+          .build();
+
+      when(avisRepository.findById(avisId)).thenReturn(Optional.of(avis));
+
+      Optional<AvisDTO> result = avisUseCase.findAvisById(avisId);
+
+      assertTrue(result.isPresent());
+      assertEquals(avisId, result.get().getAvisId());
+    }
+
+    @Test
+    @DisplayName("Should return empty Optional when ID does not exist")
+    void testFindAvisByIdNotFound() {
+      UUID nonExistentId = UUID.randomUUID();
+      when(avisRepository.findById(nonExistentId)).thenReturn(Optional.empty());
+
+      Optional<AvisDTO> result = avisUseCase.findAvisById(nonExistentId);
+
+      assertTrue(result.isEmpty());
+    }
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/avis/validator/AvisValidatorTest.java

@@ -0,0 +1,131 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.avis.validator;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.exception.NotValidAvisException;
+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.ValueSource;
+
+import java.time.LocalDate;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class AvisValidatorTest {
+
+  private final UUID clientId = UUID.randomUUID();
+  private final UUID livreId = UUID.randomUUID();
+
+  private AvisInfo validAvis() {
+    return new AvisInfo(clientId, livreId, 5, "Excellent livre !", LocalDate.of(2024, 1, 15));
+  }
+
+  @Test
+  @DisplayName("Should validate avis with valid data")
+  void testValidateValidAvis() {
+    assertDoesNotThrow(() -> AvisValidator.validate(validAvis()));
+  }
+
+  @Nested
+  @DisplayName("ClientId validation tests")
+  class ClientIdValidationTests {
+
+    @Test
+    @DisplayName("Should throw exception when clientId is null")
+    void testValidateNullClientId() {
+      AvisInfo avis = new AvisInfo(null, livreId, 5, "Commentaire", LocalDate.now());
+
+      NotValidAvisException exception = assertThrows(NotValidAvisException.class,
+          () -> AvisValidator.validate(avis));
+
+      assertEquals(AvisValidator.CLIENT_ID_CANNOT_BE_NULL, exception.getMessage());
+    }
+  }
+
+  @Nested
+  @DisplayName("LivreId validation tests")
+  class LivreIdValidationTests {
+
+    @Test
+    @DisplayName("Should throw exception when livreId is null")
+    void testValidateNullLivreId() {
+      AvisInfo avis = new AvisInfo(clientId, null, 5, "Commentaire", LocalDate.now());
+
+      NotValidAvisException exception = assertThrows(NotValidAvisException.class,
+          () -> AvisValidator.validate(avis));
+
+      assertEquals(AvisValidator.LIVRE_ID_CANNOT_BE_NULL, exception.getMessage());
+    }
+  }
+
+  @Nested
+  @DisplayName("Note validation tests")
+  class NoteValidationTests {
+
+    @ParameterizedTest
+    @ValueSource(ints = {1, 2, 3, 4, 5})
+    @DisplayName("Should validate when note is between 1 and 5")
+    void testValidateValidNote(int validNote) {
+      AvisInfo avis = new AvisInfo(clientId, livreId, validNote, "Commentaire", LocalDate.now());
+      assertDoesNotThrow(() -> AvisValidator.validate(avis));
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, -1, 6, 10})
+    @DisplayName("Should throw exception when note is out of range")
+    void testValidateInvalidNote(int invalidNote) {
+      AvisInfo avis = new AvisInfo(clientId, livreId, invalidNote, "Commentaire", LocalDate.now());
+
+      NotValidAvisException exception = assertThrows(NotValidAvisException.class,
+          () -> AvisValidator.validate(avis));
+
+      assertEquals(AvisValidator.NOTE_MUST_BE_BETWEEN_1_AND_5, exception.getMessage());
+    }
+  }
+
+  @Nested
+  @DisplayName("Commentaire validation tests")
+  class CommentaireValidationTests {
+
+    @Test
+    @DisplayName("Should throw exception when commentaire is blank")
+    void testValidateBlankCommentaire() {
+      AvisInfo avis = new AvisInfo(clientId, livreId, 5, "", LocalDate.now());
+
+      NotValidAvisException exception = assertThrows(NotValidAvisException.class,
+          () -> AvisValidator.validate(avis));
+
+      assertEquals(AvisValidator.COMMENTAIRE_CANNOT_BE_BLANK, exception.getMessage());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {" ", "  ", "\t", "\n"})
+    @DisplayName("Should throw exception when commentaire contains only whitespace")
+    void testValidateWhitespaceCommentaire(String whitespace) {
+      AvisInfo avis = new AvisInfo(clientId, livreId, 5, whitespace, LocalDate.now());
+
+      NotValidAvisException exception = assertThrows(NotValidAvisException.class,
+          () -> AvisValidator.validate(avis));
+
+      assertEquals(AvisValidator.COMMENTAIRE_CANNOT_BE_BLANK, exception.getMessage());
+    }
+  }
+
+  @Nested
+  @DisplayName("DateAchat validation tests")
+  class DateAchatValidationTests {
+
+    @Test
+    @DisplayName("Should throw exception when dateAchat is null")
+    void testValidateNullDateAchat() {
+      AvisInfo avis = new AvisInfo(clientId, livreId, 5, "Commentaire", null);
+
+      NotValidAvisException exception = assertThrows(NotValidAvisException.class,
+          () -> AvisValidator.validate(avis));
+
+      assertEquals(AvisValidator.DATE_ACHAT_CANNOT_BE_NULL, exception.getMessage());
+    }
+  }
+}

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

@@ -0,0 +1,108 @@
+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.entity.Book;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("BookConverter Unit Tests")
+class BookConverterTest {
+
+  @Nested
+  @DisplayName("toDomain() method tests")
+  class ToDomainTests {
+
+    @Test
+    @DisplayName("Should convert BookInfo to Book domain object")
+    void shouldConvertBookInfoToDomain() {
+      BookInfo bookInfo = new BookInfo(
+          "9782016289308",
+          "Le Petit Prince",
+          "Antoine de Saint-Exupéry",
+          "Gallimard",
+          LocalDate.of(1943, 4, 6),
+          new BigDecimal("12.90"),
+          10,
+          List.of("Roman", "Jeunesse"),
+          "Un classique",
+          "FR"
+      );
+
+      Book result = BookConverter.toDomain(bookInfo);
+
+      assertNotNull(result);
+      assertEquals(bookInfo.isbn(), result.getIsbn());
+      assertEquals(bookInfo.title(), result.getTitle());
+      assertEquals(bookInfo.author(), result.getAuthor());
+      assertEquals(bookInfo.publisher(), result.getPublisher());
+      assertEquals(bookInfo.publicationDate(), result.getPublicationDate());
+      assertEquals(bookInfo.price(), result.getPrice());
+      assertEquals(bookInfo.initialStock(), result.getStock());
+      assertEquals(bookInfo.categories(), result.getCategories());
+      assertEquals(bookInfo.description(), result.getDescription());
+      assertEquals(bookInfo.language(), result.getLanguage());
+    }
+
+    @Test
+    @DisplayName("Should have null ID after toDomain (set by repository)")
+    void shouldHaveNullIdAfterToDomain() {
+      BookInfo bookInfo = new BookInfo(
+          "9782016289308", "Titre", "Auteur", "Editeur",
+          LocalDate.now(), new BigDecimal("10.00"), 5,
+          List.of("Roman"), "Description", "FR"
+      );
+
+      Book result = BookConverter.toDomain(bookInfo);
+
+      assertNull(result.getId());
+    }
+  }
+
+  @Nested
+  @DisplayName("toDTO() method tests")
+  class ToDTOTests {
+
+    @Test
+    @DisplayName("Should convert Book domain object to BookDTO with all fields mapped correctly")
+    void shouldConvertBookToDTO() {
+      UUID id = UUID.randomUUID();
+      Book book = Book.builder()
+          .id(id)
+          .isbn("9782016289308")
+          .title("Le Petit Prince")
+          .author("Antoine de Saint-Exupéry")
+          .publisher("Gallimard")
+          .publicationDate(LocalDate.of(1943, 4, 6))
+          .price(new BigDecimal("12.90"))
+          .stock(10)
+          .categories(List.of("Roman", "Jeunesse"))
+          .description("Un classique")
+          .language("FR")
+          .build();
+
+      BookDTO result = BookConverter.toDTO(book);
+
+      assertNotNull(result);
+      assertEquals(book.getId(), result.getId());
+      assertEquals(book.getIsbn(), result.getIsbn());
+      assertEquals(book.getTitle(), result.getTitle());
+      assertEquals(book.getAuthor(), result.getAuthor());
+      assertEquals(book.getPublisher(), result.getPublisher());
+      assertEquals(book.getPublicationDate(), result.getPublicationDate());
+      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());
+    }
+  }
+}

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

@@ -0,0 +1,71 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.entity;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BookTest {
+
+  @Test
+  @DisplayName("Builder should create a valid Book instance")
+  void testBookBuilder() {
+    UUID id = UUID.randomUUID();
+
+    Book book = Book.builder()
+        .id(id)
+        .isbn("9782016289308")
+        .title("Le Petit Prince")
+        .author("Antoine de Saint-Exupéry")
+        .publisher("Gallimard")
+        .publicationDate(LocalDate.of(1943, 4, 6))
+        .price(new BigDecimal("12.90"))
+        .stock(10)
+        .categories(List.of("Roman", "Jeunesse"))
+        .description("Un classique")
+        .language("FR")
+        .build();
+
+    assertEquals(id, book.getId());
+    assertEquals("9782016289308", book.getIsbn());
+    assertEquals("Le Petit Prince", book.getTitle());
+    assertEquals("Antoine de Saint-Exupéry", book.getAuthor());
+    assertEquals("Gallimard", book.getPublisher());
+    assertEquals(LocalDate.of(1943, 4, 6), book.getPublicationDate());
+    assertEquals(new BigDecimal("12.90"), book.getPrice());
+    assertEquals(10, book.getStock());
+    assertEquals(List.of("Roman", "Jeunesse"), book.getCategories());
+    assertEquals("Un classique", book.getDescription());
+    assertEquals("FR", book.getLanguage());
+  }
+
+  @Test
+  @DisplayName("setRandomUUID should set a new non-null UUID")
+  void testSetRandomUUID() {
+    Book book = Book.builder().build();
+    UUID originalId = book.getId();
+
+    book.setRandomUUID();
+
+    assertNotNull(book.getId());
+    assertNotEquals(originalId, book.getId());
+  }
+
+  @Test
+  @DisplayName("Two setRandomUUID calls should produce different UUIDs")
+  void testSetRandomUUIDTwice() {
+    Book book = Book.builder().build();
+    book.setRandomUUID();
+    UUID firstId = book.getId();
+
+    book.setRandomUUID();
+    UUID secondId = book.getId();
+
+    assertNotEquals(firstId, secondId);
+  }
+}

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

@@ -0,0 +1,47 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BookNotFoundExceptionTest {
+
+  @Test
+  @DisplayName("Exception message should contain the UUID provided")
+  void testExceptionMessageContainsUUID() {
+    UUID uuid = UUID.randomUUID();
+
+    BookNotFoundException exception = new BookNotFoundException(uuid);
+
+    String expectedMessage = String.format("The book with id %s does not exist", uuid);
+    assertEquals(expectedMessage, exception.getMessage());
+  }
+
+  @Test
+  @DisplayName("Exception should use the correct constant message format")
+  void testExceptionUsesConstantMessageFormat() {
+    UUID uuid = UUID.randomUUID();
+
+    BookNotFoundException exception = new BookNotFoundException(uuid);
+
+    assertEquals("The book with id {0} does not exist",
+        BookNotFoundException.THE_BOOK_WITH_ID_DOES_NOT_EXIST_MESSAGE);
+    assertTrue(exception.getMessage().contains(uuid.toString()));
+  }
+
+  @Test
+  @DisplayName("Exception should be properly thrown and caught")
+  void testExceptionCanBeThrownAndCaught() {
+    UUID uuid = UUID.randomUUID();
+
+    try {
+      throw new BookNotFoundException(uuid);
+    } catch (BookNotFoundException e) {
+      String expectedMessage = String.format("The book with id %s does not exist", uuid);
+      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.*;
+
+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 not valid",
+      "Title cannot be blank",
+      "Author cannot be blank",
+      "Publisher cannot be blank",
+      "Price must be positive"
+  })
+  @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 = "ISBN is not valid";
+
+    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 = "Price must be positive";
+
+    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,219 @@
+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.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BookRepositoryTest {
+
+  private BookRepository repository;
+  private Book book1;
+  private Book book2;
+
+  @BeforeEach
+  void setUp() {
+    repository = new BookRepository();
+
+    book1 = Book.builder()
+        .isbn("9782016289308")
+        .title("Le Petit Prince")
+        .author("Antoine de Saint-Exupéry")
+        .publisher("Gallimard")
+        .publicationDate(LocalDate.of(1943, 4, 6))
+        .price(new BigDecimal("12.90"))
+        .stock(10)
+        .categories(List.of("Roman"))
+        .description("Un classique")
+        .language("FR")
+        .build();
+    book1.setRandomUUID();
+
+    book2 = Book.builder()
+        .isbn("9782070409189")
+        .title("L'Étranger")
+        .author("Albert Camus")
+        .publisher("Gallimard")
+        .publicationDate(LocalDate.of(1942, 5, 19))
+        .price(new BigDecimal("9.50"))
+        .stock(5)
+        .categories(List.of("Roman"))
+        .description("Roman philosophique")
+        .language("FR")
+        .build();
+    book2.setRandomUUID();
+  }
+
+  @Test
+  @DisplayName("New repository should be empty")
+  void testNewRepositoryIsEmpty() {
+    assertTrue(repository.findAll().isEmpty());
+    assertEquals(0, repository.findAll().size());
+  }
+
+  @Nested
+  @DisplayName("Save operations")
+  class SaveOperations {
+
+    @Test
+    @DisplayName("Save should add a new book")
+    void testSaveNewBook() {
+      Book saved = repository.save(book1);
+
+      assertEquals(1, repository.findAll().size());
+      assertEquals(book1.getId(), saved.getId());
+      assertEquals(book1.getIsbn(), saved.getIsbn());
+    }
+
+    @Test
+    @DisplayName("Save should update existing book with same ID")
+    void testSaveUpdatesExistingBook() {
+      repository.save(book1);
+      UUID id = book1.getId();
+
+      Book updatedBook = Book.builder()
+          .id(id)
+          .isbn("9782016289308")
+          .title("Le Petit Prince - Edition collector")
+          .author("Antoine de Saint-Exupéry")
+          .publisher("Gallimard")
+          .publicationDate(LocalDate.of(1943, 4, 6))
+          .price(new BigDecimal("19.90"))
+          .stock(3)
+          .categories(List.of("Roman"))
+          .description("Edition collector")
+          .language("FR")
+          .build();
+
+      Book saved = repository.save(updatedBook);
+
+      assertEquals(1, repository.findAll().size());
+      assertEquals(id, saved.getId());
+      assertEquals("Le Petit Prince - Edition collector", saved.getTitle());
+      assertEquals(new BigDecimal("19.90"), saved.getPrice());
+    }
+
+    @Test
+    @DisplayName("Save multiple books should add all of them")
+    void testSaveMultipleBooks() {
+      repository.save(book1);
+      repository.save(book2);
+
+      assertEquals(2, repository.findAll().size());
+      assertTrue(repository.findAll().contains(book1));
+      assertTrue(repository.findAll().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() {
+      assertEquals(2, repository.findAll().size());
+    }
+
+    @Test
+    @DisplayName("FindById should return book with matching ID")
+    void testFindById() {
+      Optional<Book> found = repository.findById(book1.getId());
+
+      assertTrue(found.isPresent());
+      assertEquals(book1.getIsbn(), found.get().getIsbn());
+      assertEquals(book1.getTitle(), found.get().getTitle());
+    }
+
+    @Test
+    @DisplayName("FindById should return empty Optional when ID doesn't exist")
+    void testFindByIdNotFound() {
+      Optional<Book> found = repository.findById(UUID.randomUUID());
+
+      assertTrue(found.isEmpty());
+    }
+
+    @Test
+    @DisplayName("FindByIsbn should return book with matching ISBN")
+    void testFindByIsbn() {
+      Optional<Book> found = repository.findByIsbn("9782016289308");
+
+      assertTrue(found.isPresent());
+      assertEquals(book1.getId(), found.get().getId());
+    }
+
+    @Test
+    @DisplayName("FindByIsbn should return empty Optional when ISBN doesn't exist")
+    void testFindByIsbnNotFound() {
+      Optional<Book> found = repository.findByIsbn("0000000000000");
+
+      assertTrue(found.isEmpty());
+    }
+
+    @Test
+    @DisplayName("ExistsById should return true when ID exists")
+    void testExistsByIdExists() {
+      assertTrue(repository.existsById(book1.getId()));
+    }
+
+    @Test
+    @DisplayName("ExistsById should return false when ID doesn't exist")
+    void testExistsByIdNotExists() {
+      assertFalse(repository.existsById(UUID.randomUUID()));
+    }
+  }
+
+  @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);
+
+      assertEquals(1, repository.findAll().size());
+      assertFalse(repository.findAll().contains(book1));
+      assertTrue(repository.findAll().contains(book2));
+    }
+
+    @Test
+    @DisplayName("DeleteAll should remove all books")
+    void testDeleteAll() {
+      repository.deleteAll();
+
+      assertTrue(repository.findAll().isEmpty());
+    }
+
+    @Test
+    @DisplayName("Delete should not throw exception when book doesn't exist")
+    void testDeleteNonExistentBook() {
+      Book nonExistent = Book.builder().isbn("0000000000000").build();
+      nonExistent.setRandomUUID();
+
+      assertDoesNotThrow(() -> repository.delete(nonExistent));
+      assertEquals(2, repository.findAll().size());
+    }
+  }
+}

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

@@ -0,0 +1,230 @@
+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.BookInfo;
+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.NotValidBookException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+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 static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class BookUseCaseTest {
+
+  @Mock
+  private BookRepository bookRepository;
+
+  @InjectMocks
+  private BookUseCase bookUseCase;
+
+  private UUID bookId;
+  private Book testBook;
+  private BookInfo validBookInfo;
+
+  @BeforeEach
+  void setUp() {
+    bookId = UUID.randomUUID();
+    testBook = Book.builder()
+        .id(bookId)
+        .isbn("9782016289308")
+        .title("Le Petit Prince")
+        .author("Antoine de Saint-Exupéry")
+        .publisher("Gallimard")
+        .publicationDate(LocalDate.of(1943, 4, 6))
+        .price(new BigDecimal("12.90"))
+        .stock(10)
+        .categories(List.of("Roman", "Jeunesse"))
+        .description("Un classique")
+        .language("FR")
+        .build();
+
+    validBookInfo = new BookInfo(
+        "9782016289308",
+        "Le Petit Prince",
+        "Antoine de Saint-Exupéry",
+        "Gallimard",
+        LocalDate.of(1943, 4, 6),
+        new BigDecimal("12.90"),
+        10,
+        List.of("Roman", "Jeunesse"),
+        "Un classique",
+        "FR"
+    );
+  }
+
+  @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);
+
+      assertNotNull(registeredIsbn);
+      assertEquals("9782016289308", 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(
+          "",
+          "",
+          "",
+          "",
+          null,
+          BigDecimal.ZERO,
+          -1,
+          null,
+          "",
+          ""
+      );
+
+      assertThrows(NotValidBookException.class,
+          () -> bookUseCase.registerBook(invalidBookInfo));
+
+      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("9782016289308")).thenReturn(Optional.of(testBook));
+
+      Optional<BookDTO> foundBook = bookUseCase.findBookByIsbn("9782016289308");
+
+      assertTrue(foundBook.isPresent());
+      assertEquals(testBook.getId(), foundBook.get().getId());
+      assertEquals(testBook.getTitle(), foundBook.get().getTitle());
+      verify(bookRepository, times(1)).findByIsbn("9782016289308");
+    }
+
+    @Test
+    @DisplayName("Should return empty Optional when ISBN doesn't exist")
+    void testFindBookByIsbnNotFound() {
+      when(bookRepository.findByIsbn("9999999999999")).thenReturn(Optional.empty());
+
+      Optional<BookDTO> foundBook = bookUseCase.findBookByIsbn("9999999999999");
+
+      assertTrue(foundBook.isEmpty());
+      verify(bookRepository, times(1)).findByIsbn("9999999999999");
+    }
+  }
+
+  @Nested
+  @DisplayName("Update book tests")
+  class UpdateBookTests {
+
+    @Test
+    @DisplayName("Should update book when valid data is provided")
+    void testUpdateBookWithValidData() throws BookNotFoundException, NotValidBookException {
+      when(bookRepository.findById(bookId)).thenReturn(Optional.of(testBook));
+
+      Book updatedBook = Book.builder()
+          .id(bookId)
+          .isbn("9782070409189")
+          .title("L'Étranger")
+          .author("Albert Camus")
+          .publisher("Gallimard")
+          .publicationDate(LocalDate.of(1942, 5, 19))
+          .price(new BigDecimal("9.50"))
+          .stock(10)
+          .categories(List.of("Roman"))
+          .description("Roman philosophique")
+          .language("FR")
+          .build();
+
+      when(bookRepository.save(any(Book.class))).thenReturn(updatedBook);
+
+      BookInfo updateInfo = new BookInfo(
+          "9782070409189",
+          "L'Étranger",
+          "Albert Camus",
+          "Gallimard",
+          LocalDate.of(1942, 5, 19),
+          new BigDecimal("9.50"),
+          99,
+          List.of("Roman"),
+          "Roman philosophique",
+          "FR"
+      );
+
+      BookDTO result = bookUseCase.updateBook(bookId, updateInfo);
+
+      assertNotNull(result);
+      assertEquals(bookId, result.getId());
+      assertEquals("L'Étranger", result.getTitle());
+      assertEquals("9782070409189", result.getIsbn());
+      assertEquals(10, result.getStock());
+      verify(bookRepository, times(1)).findById(bookId);
+      verify(bookRepository, times(1)).save(any(Book.class));
+    }
+
+    @Test
+    @DisplayName("Should throw exception when book ID doesn't exist")
+    void testUpdateBookNotFound() {
+      UUID nonExistentId = UUID.randomUUID();
+      when(bookRepository.findById(nonExistentId)).thenReturn(Optional.empty());
+
+      assertThrows(BookNotFoundException.class,
+          () -> bookUseCase.updateBook(nonExistentId, validBookInfo));
+
+      verify(bookRepository, times(1)).findById(nonExistentId);
+      verify(bookRepository, never()).save(any(Book.class));
+    }
+  }
+
+  @Nested
+  @DisplayName("Delete book tests")
+  class DeleteBookTests {
+
+    @Test
+    @DisplayName("Should delete book when ID exists")
+    void testDeleteBook() throws BookNotFoundException {
+      when(bookRepository.findById(bookId)).thenReturn(Optional.of(testBook));
+
+      assertDoesNotThrow(() -> bookUseCase.deleteBook(bookId));
+
+      verify(bookRepository, times(1)).findById(bookId);
+      verify(bookRepository, times(1)).delete(testBook);
+    }
+
+    @Test
+    @DisplayName("Should throw exception when deleting unknown book")
+    void testDeleteBookNotFound() {
+      UUID nonExistentId = UUID.randomUUID();
+      when(bookRepository.findById(nonExistentId)).thenReturn(Optional.empty());
+
+      assertThrows(BookNotFoundException.class,
+          () -> bookUseCase.deleteBook(nonExistentId));
+
+      verify(bookRepository, times(1)).findById(nonExistentId);
+      verify(bookRepository, never()).delete(any(Book.class));
+    }
+  }
+}

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

@@ -0,0 +1,184 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.validator;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+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.ValueSource;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BookValidatorTest {
+
+  private BookInfo validBook() {
+    return new BookInfo(
+        "9782016289308",
+        "Le Petit Prince",
+        "Antoine de Saint-Exupéry",
+        "Gallimard",
+        LocalDate.of(1943, 4, 6),
+        new BigDecimal("12.90"),
+        10,
+        List.of("Roman"),
+        "Un classique",
+        "FR"
+    );
+  }
+
+  @Test
+  @DisplayName("Should validate book with valid data")
+  void testValidateValidBook() {
+    assertDoesNotThrow(() -> BookValidator.validate(validBook()));
+  }
+
+  @Nested
+  @DisplayName("ISBN validation tests")
+  class IsbnValidationTests {
+
+    @Test
+    @DisplayName("Should throw exception when ISBN is blank")
+    void testValidateBlankIsbn() {
+      BookInfo book = new BookInfo("", "Titre", "Auteur", "Editeur",
+          LocalDate.now(), new BigDecimal("10.00"), 1, List.of("Roman"), "Desc", "FR");
+
+      NotValidBookException exception = assertThrows(NotValidBookException.class,
+          () -> BookValidator.validate(book));
+
+      assertEquals(BookValidator.ISBN_IS_NOT_VALID, exception.getMessage());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"123456", "978201628930", "97820162893088", "abcdefghijklm", "978-016289308"})
+    @DisplayName("Should throw exception when ISBN format is invalid")
+    void testValidateInvalidIsbnFormat(String invalidIsbn) {
+      BookInfo book = new BookInfo(invalidIsbn, "Titre", "Auteur", "Editeur",
+          LocalDate.now(), new BigDecimal("10.00"), 1, List.of("Roman"), "Desc", "FR");
+
+      NotValidBookException exception = assertThrows(NotValidBookException.class,
+          () -> BookValidator.validate(book));
+
+      assertEquals(BookValidator.ISBN_IS_NOT_VALID, exception.getMessage());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"9782016289308", "9782070409189", "9782253006329"})
+    @DisplayName("Should validate when ISBN has exactly 13 digits")
+    void testValidateValidIsbn(String validIsbn) {
+      BookInfo book = new BookInfo(validIsbn, "Titre", "Auteur", "Editeur",
+          LocalDate.now(), new BigDecimal("10.00"), 1, List.of("Roman"), "Desc", "FR");
+
+      assertDoesNotThrow(() -> BookValidator.validate(book));
+    }
+  }
+
+  @Nested
+  @DisplayName("Title validation tests")
+  class TitleValidationTests {
+
+    @Test
+    @DisplayName("Should throw exception when title is blank")
+    void testValidateBlankTitle() {
+      BookInfo book = new BookInfo("9782016289308", "", "Auteur", "Editeur",
+          LocalDate.now(), new BigDecimal("10.00"), 1, List.of("Roman"), "Desc", "FR");
+
+      NotValidBookException exception = assertThrows(NotValidBookException.class,
+          () -> BookValidator.validate(book));
+
+      assertEquals(BookValidator.TITLE_CANNOT_BE_BLANK, exception.getMessage());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {" ", "  ", "\t", "\n"})
+    @DisplayName("Should throw exception when title contains only whitespace")
+    void testValidateWhitespaceTitle(String whitespace) {
+      BookInfo book = new BookInfo("9782016289308", whitespace, "Auteur", "Editeur",
+          LocalDate.now(), new BigDecimal("10.00"), 1, List.of("Roman"), "Desc", "FR");
+
+      NotValidBookException exception = assertThrows(NotValidBookException.class,
+          () -> BookValidator.validate(book));
+
+      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() {
+      BookInfo book = new BookInfo("9782016289308", "Titre", "", "Editeur",
+          LocalDate.now(), new BigDecimal("10.00"), 1, List.of("Roman"), "Desc", "FR");
+
+      NotValidBookException exception = assertThrows(NotValidBookException.class,
+          () -> BookValidator.validate(book));
+
+      assertEquals(BookValidator.AUTHOR_CANNOT_BE_BLANK, exception.getMessage());
+    }
+  }
+
+  @Nested
+  @DisplayName("Publisher validation tests")
+  class PublisherValidationTests {
+
+    @Test
+    @DisplayName("Should throw exception when publisher is blank")
+    void testValidateBlankPublisher() {
+      BookInfo book = new BookInfo("9782016289308", "Titre", "Auteur", "",
+          LocalDate.now(), new BigDecimal("10.00"), 1, List.of("Roman"), "Desc", "FR");
+
+      NotValidBookException exception = assertThrows(NotValidBookException.class,
+          () -> BookValidator.validate(book));
+
+      assertEquals(BookValidator.PUBLISHER_CANNOT_BE_BLANK, exception.getMessage());
+    }
+  }
+
+  @Nested
+  @DisplayName("Price validation tests")
+  class PriceValidationTests {
+
+    @Test
+    @DisplayName("Should throw exception when price is negative")
+    void testValidateNegativePrice() {
+      BookInfo book = new BookInfo("9782016289308", "Titre", "Auteur", "Editeur",
+          LocalDate.now(), new BigDecimal("-5.00"), 1, List.of("Roman"), "Desc", "FR");
+
+      NotValidBookException exception = assertThrows(NotValidBookException.class,
+          () -> BookValidator.validate(book));
+
+      assertEquals(BookValidator.PRICE_MUST_BE_POSITIVE, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Should throw exception when price is zero")
+    void testValidateZeroPrice() {
+      BookInfo book = new BookInfo("9782016289308", "Titre", "Auteur", "Editeur",
+          LocalDate.now(), BigDecimal.ZERO, 1, List.of("Roman"), "Desc", "FR");
+
+      NotValidBookException exception = assertThrows(NotValidBookException.class,
+          () -> BookValidator.validate(book));
+
+      assertEquals(BookValidator.PRICE_MUST_BE_POSITIVE, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Should throw exception when price is null")
+    void testValidateNullPrice() {
+      BookInfo book = new BookInfo("9782016289308", "Titre", "Auteur", "Editeur",
+          LocalDate.now(), null, 1, List.of("Roman"), "Desc", "FR");
+
+      NotValidBookException exception = assertThrows(NotValidBookException.class,
+          () -> BookValidator.validate(book));
+
+      assertEquals(BookValidator.PRICE_MUST_BE_POSITIVE, exception.getMessage());
+    }
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/avis/AvisSteps.java

@@ -0,0 +1,185 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.features.avis;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.AvisInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.exception.NotValidAvisException;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.repository.AvisRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.avis.usecase.AvisUseCase;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.CustomerNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.Before;
+import io.cucumber.java.en.And;
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+public class AvisSteps {
+
+  private final CustomerRepository customerRepository = new CustomerRepository();
+  private final BookRepository bookRepository = new BookRepository();
+  private final AvisRepository avisRepository = new AvisRepository();
+  private final AvisUseCase avisUseCase = new AvisUseCase(avisRepository, customerRepository);
+
+  private final Map<String, UUID> customerPhoneUUID = new HashMap<>();
+  private final Map<String, UUID> bookIsbnUUID = new HashMap<>();
+
+  private AvisDTO avisResult;
+  private NotValidAvisException notValidAvisException;
+  private boolean customerNotFoundThrown = false;
+
+  @Before
+  public void setUp() {
+    customerRepository.deleteAll();
+    bookRepository.deleteAll();
+    avisRepository.deleteAll();
+    customerPhoneUUID.clear();
+    bookIsbnUUID.clear();
+    avisResult = null;
+    notValidAvisException = null;
+    customerNotFoundThrown = false;
+  }
+
+  @Given("the system has the following customers for avis:")
+  public void theSystemHasTheFollowingCustomersForAvis(DataTable dataTable) {
+    List<Map<String, String>> customers = dataTable.asMaps(String.class, String.class);
+
+    for (Map<String, String> customer : customers) {
+      String phone = customer.get("numeroTelephone");
+      Customer newCustomer = Customer.builder()
+          .firstName(customer.get("prenom"))
+          .lastName(customer.get("nom"))
+          .phoneNumber(phone)
+          .loyaltyPoints(Integer.parseInt(customer.get("pointsFidelite")))
+          .build();
+      Customer saved = customerRepository.save(newCustomer);
+      customerPhoneUUID.put(phone, saved.getId());
+    }
+
+    assertEquals(customers.size(), customerRepository.findAll().size());
+  }
+
+  @And("the catalog has the following books for avis:")
+  public void theCatalogHasTheFollowingBooksForAvis(DataTable dataTable) {
+    List<Map<String, String>> books = dataTable.asMaps(String.class, String.class);
+
+    for (Map<String, String> book : books) {
+      String isbn = book.get("isbn");
+      Book newBook = Book.builder()
+          .isbn(isbn)
+          .title(book.get("titre"))
+          .author(book.get("auteur"))
+          .publisher(book.get("editeur"))
+          .publicationDate(LocalDate.parse(book.get("datePublication")))
+          .price(new BigDecimal(book.get("prix")))
+          .stock(Integer.parseInt(book.get("stockInitial")))
+          .categories(List.of(book.get("categories").split(";")))
+          .description(book.get("description"))
+          .language(book.get("langue"))
+          .build();
+      Book saved = bookRepository.save(newBook);
+      bookIsbnUUID.put(isbn, saved.getId());
+    }
+
+    assertEquals(books.size(), bookRepository.findAll().size());
+  }
+
+  @When("customer {string} submits a review for book {string} with:")
+  public void customerSubmitsAReviewForBookWith(String phoneNumber, String isbn, DataTable dataTable)
+      throws NotValidAvisException, CustomerNotFoundException {
+    Map<String, String> row = dataTable.asMaps(String.class, String.class).getFirst();
+
+    UUID customerId = customerPhoneUUID.get(phoneNumber);
+    UUID livreId = bookIsbnUUID.get(isbn);
+
+    AvisInfo avisInfo = new AvisInfo(
+        customerId,
+        livreId,
+        Integer.parseInt(row.get("note")),
+        row.get("commentaire"),
+        LocalDate.parse(row.get("dateAchat"))
+    );
+
+    avisResult = avisUseCase.gererAvis(avisInfo);
+  }
+
+  @Then("a new review is created")
+  public void aNewReviewIsCreated() {
+    assertNotNull(avisResult);
+    assertNotNull(avisResult.getAvisId());
+  }
+
+  @And("the system now has {int} reviews")
+  public void theSystemNowHasReviews(int expectedCount) {
+    assertEquals(expectedCount, avisRepository.findAll().size());
+  }
+
+  @When("customer {string} tries to submit a review for book {string} with:")
+  public void customerTriesToSubmitAReviewForBookWith(String phoneNumber, String isbn, DataTable dataTable) {
+    Map<String, String> row = dataTable.asMaps(String.class, String.class).getFirst();
+
+    UUID customerId = customerPhoneUUID.get(phoneNumber);
+    UUID livreId = bookIsbnUUID.get(isbn);
+
+    AvisInfo avisInfo = new AvisInfo(
+        customerId,
+        livreId,
+        Integer.parseInt(row.get("note")),
+        row.get("commentaire"),
+        LocalDate.parse(row.get("dateAchat"))
+    );
+
+    notValidAvisException = assertThrows(NotValidAvisException.class,
+        () -> avisUseCase.gererAvis(avisInfo));
+  }
+
+  @When("an unknown customer tries to submit a review for book {string} with:")
+  public void anUnknownCustomerTriesToSubmitAReviewForBookWith(String isbn, DataTable dataTable) {
+    Map<String, String> row = dataTable.asMaps(String.class, String.class).getFirst();
+
+    UUID unknownId = UUID.randomUUID();
+    UUID livreId = bookIsbnUUID.get(isbn);
+
+    AvisInfo avisInfo = new AvisInfo(
+        unknownId,
+        livreId,
+        Integer.parseInt(row.get("note")),
+        row.get("commentaire"),
+        LocalDate.parse(row.get("dateAchat"))
+    );
+
+    try {
+      avisUseCase.gererAvis(avisInfo);
+    } catch (CustomerNotFoundException e) {
+      customerNotFoundThrown = true;
+    } catch (NotValidAvisException e) {
+      notValidAvisException = e;
+    }
+  }
+
+  @Then("the review creation fails")
+  public void theReviewCreationFails() {
+    assertNotNull(notValidAvisException);
+  }
+
+  @Then("the review creation fails with customer not found")
+  public void theReviewCreationFailsWithCustomerNotFound() {
+    assertTrue(customerNotFoundThrown);
+  }
+
+  @And("I receive a validation avis error containing {string}")
+  public void iReceiveAValidationAvisErrorContaining(String errorMessage) {
+    assertEquals(errorMessage, notValidAvisException.getMessage());
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/book/BookSteps.java

@@ -0,0 +1,212 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.features.book;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+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.entity.Book;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundException;
+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.usecase.BookUseCase;
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.Before;
+import io.cucumber.java.en.And;
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+public class BookSteps {
+
+  private final BookRepository bookRepository = new BookRepository();
+  private final BookUseCase bookUseCase = new BookUseCase(bookRepository);
+  private final Map<String, UUID> bookIsbnUUID = new HashMap<>();
+
+  private String bookRegistration;
+  private Optional<BookDTO> bookByIsbn;
+  private Book updatedBook;
+  private NotValidBookException notValidBookException;
+
+  @Before
+  public void setUp() {
+    bookRepository.deleteAll();
+    bookIsbnUUID.clear();
+    bookRegistration = null;
+    bookByIsbn = null;
+    updatedBook = null;
+    notValidBookException = null;
+  }
+
+  @Given("the catalog has the following books:")
+  public void theCatalogHasTheFollowingBooks(DataTable dataTable) {
+    List<Map<String, String>> books = dataTable.asMaps(String.class, String.class);
+
+    for (Map<String, String> book : books) {
+      String isbn = book.get("isbn");
+      Book newBook = Book.builder()
+          .isbn(isbn)
+          .title(book.get("titre"))
+          .author(book.get("auteur"))
+          .publisher(book.get("editeur"))
+          .publicationDate(LocalDate.parse(book.get("datePublication")))
+          .price(new BigDecimal(book.get("prix")))
+          .stock(Integer.parseInt(book.get("stockInitial")))
+          .categories(List.of(book.get("categories").split(";")))
+          .description(book.get("description"))
+          .language(book.get("langue"))
+          .build();
+      Book save = bookRepository.save(newBook);
+      bookIsbnUUID.put(isbn, save.getId());
+    }
+
+    assertEquals(books.size(), bookRepository.findAll().size());
+  }
+
+  @When("I register a new book with the following information:")
+  public void iRegisterANewBookWithTheFollowingInformation(DataTable dataTable) throws NotValidBookException {
+    Map<String, String> bookInfo = dataTable.asMaps(String.class, String.class).getFirst();
+
+    BookInfo newBook = new BookInfo(
+        bookInfo.get("isbn"),
+        bookInfo.get("titre"),
+        bookInfo.get("auteur"),
+        bookInfo.get("editeur"),
+        LocalDate.parse(bookInfo.get("datePublication")),
+        new BigDecimal(bookInfo.get("prix")),
+        Integer.parseInt(bookInfo.get("stockInitial")),
+        List.of(bookInfo.get("categories").split(";")),
+        bookInfo.get("description"),
+        bookInfo.get("langue")
+    );
+
+    bookRegistration = bookUseCase.registerBook(newBook);
+  }
+
+  @Then("a new book is created")
+  public void aNewBookIsCreated() {
+    assertNotNull(bookRegistration);
+  }
+
+  @And("the catalog now has {int} books")
+  public void theCatalogNowHasBooks(int numberOfBooks) {
+    assertEquals(numberOfBooks, bookRepository.findAll().size());
+  }
+
+  @And("the book {string} has a stock of {int}")
+  public void theBookHasAStockOf(String isbn, int stock) {
+    Book book = bookRepository.findByIsbn(isbn).orElseThrow();
+    assertEquals(stock, book.getStock());
+  }
+
+  @When("I request the book with ISBN {string}")
+  public void iRequestTheBookWithISBN(String isbn) {
+    bookByIsbn = bookUseCase.findBookByIsbn(isbn);
+  }
+
+  @Then("I receive the following book information:")
+  public void iReceiveTheFollowingBookInformation(DataTable dataTable) {
+    Map<String, String> bookInfo = dataTable.asMaps(String.class, String.class).getFirst();
+    assertTrue(bookByIsbn.isPresent());
+    BookDTO bookDTO = bookByIsbn.get();
+    assertEquals(bookInfo.get("isbn"), bookDTO.getIsbn());
+    assertEquals(bookInfo.get("titre"), bookDTO.getTitle());
+    assertEquals(bookInfo.get("auteur"), bookDTO.getAuthor());
+    assertEquals(bookInfo.get("editeur"), bookDTO.getPublisher());
+    assertEquals(LocalDate.parse(bookInfo.get("datePublication")), bookDTO.getPublicationDate());
+    assertEquals(new BigDecimal(bookInfo.get("prix")), bookDTO.getPrice());
+    assertEquals(Integer.parseInt(bookInfo.get("stockInitial")), bookDTO.getStock());
+    assertEquals(bookInfo.get("description"), bookDTO.getDescription());
+    assertEquals(bookInfo.get("langue"), bookDTO.getLanguage());
+  }
+
+  @When("I update book {string} with the following information:")
+  public void iUpdateBookWithTheFollowingInformation(String isbn, DataTable dataTable)
+      throws BookNotFoundException, NotValidBookException {
+    Map<String, String> bookData = dataTable.asMaps(String.class, String.class).getFirst();
+    BookInfo bookInfo = new BookInfo(
+        bookData.get("isbn"),
+        bookData.get("titre"),
+        bookData.get("auteur"),
+        bookData.get("editeur"),
+        LocalDate.parse(bookData.get("datePublication")),
+        new BigDecimal(bookData.get("prix")),
+        Integer.parseInt(bookData.get("stockInitial")),
+        List.of(bookData.get("categories").split(";")),
+        bookData.get("description"),
+        bookData.get("langue")
+    );
+    UUID uuid = bookIsbnUUID.get(isbn);
+    bookUseCase.updateBook(uuid, bookInfo);
+  }
+
+  @Then("the book {string} has the following updated information:")
+  public void theBookHasTheFollowingUpdatedInformation(String previousIsbn, DataTable dataTable) {
+    Map<String, String> updatedData = dataTable.asMaps(String.class, String.class).getFirst();
+
+    UUID uuid = bookIsbnUUID.get(previousIsbn);
+    updatedBook = bookRepository.findById(uuid).orElseThrow();
+    assertEquals(updatedData.get("isbn"), updatedBook.getIsbn());
+    assertEquals(updatedData.get("titre"), updatedBook.getTitle());
+    assertEquals(updatedData.get("auteur"), updatedBook.getAuthor());
+    assertEquals(updatedData.get("editeur"), updatedBook.getPublisher());
+    assertEquals(LocalDate.parse(updatedData.get("datePublication")), updatedBook.getPublicationDate());
+    assertEquals(new BigDecimal(updatedData.get("prix")), updatedBook.getPrice());
+    assertEquals(updatedData.get("description"), updatedBook.getDescription());
+    assertEquals(updatedData.get("langue"), updatedBook.getLanguage());
+  }
+
+  @And("the stock remains unchanged at {int}")
+  public void theStockRemainsUnchangedAt(int expectedStock) {
+    assertEquals(expectedStock, updatedBook.getStock());
+  }
+
+  @When("I delete the book with ISBN {string}")
+  public void iDeleteTheBookWithISBN(String isbn) throws BookNotFoundException {
+    UUID uuid = bookIsbnUUID.get(isbn);
+    bookUseCase.deleteBook(uuid);
+  }
+
+  @Then("the book {string} is removed from the catalog")
+  public void theBookIsRemovedFromTheCatalog(String isbn) {
+    UUID uuid = bookIsbnUUID.get(isbn);
+    assertFalse(bookRepository.existsById(uuid));
+  }
+
+  @When("I try to register a new book with the following information:")
+  public void iTryToRegisterANewBookWithTheFollowingInformation(DataTable dataTable) {
+    Map<String, String> bookInfo = dataTable.asMaps(String.class, String.class).getFirst();
+
+    BookInfo newBook = new BookInfo(
+        bookInfo.get("isbn"),
+        bookInfo.get("titre"),
+        bookInfo.get("auteur"),
+        bookInfo.get("editeur"),
+        LocalDate.parse(bookInfo.get("datePublication")),
+        new BigDecimal(bookInfo.get("prix")),
+        Integer.parseInt(bookInfo.get("stockInitial")),
+        List.of(bookInfo.get("categories").split(";")),
+        bookInfo.get("description"),
+        bookInfo.get("langue")
+    );
+
+    notValidBookException = assertThrows(NotValidBookException.class,
+        () -> bookUseCase.registerBook(newBook));
+  }
+
+  @Then("the book registration fails")
+  public void theBookRegistrationFails() {
+    assertNotNull(notValidBookException);
+  }
+
+  @And("I receive a validation book error message containing {string}")
+  public void iReceiveAValidationBookErrorMessageContaining(String errorMessage) {
+    assertEquals(errorMessage, notValidBookException.getMessage());
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/order/OrderSteps.java

@@ -0,0 +1,223 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.features.order;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+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 fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.CustomerNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.AdresseLivraison;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.ModePaiement;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.exception.NotValidOrderException;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.repository.OrderRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.usecase.OrderUseCase;
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.Before;
+import io.cucumber.java.en.And;
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+public class OrderSteps {
+
+  private final CustomerRepository customerRepository = new CustomerRepository();
+  private final BookRepository bookRepository = new BookRepository();
+  private final OrderRepository orderRepository = new OrderRepository();
+  private final OrderUseCase orderUseCase = new OrderUseCase(orderRepository, customerRepository, bookRepository);
+
+  private final Map<String, UUID> customerPhoneUUID = new HashMap<>();
+  private final Map<String, UUID> bookIsbnUUID = new HashMap<>();
+
+  private OrderDTO orderResult;
+  private NotValidOrderException notValidOrderException;
+  private boolean customerNotFoundThrown = false;
+
+  @Before
+  public void setUp() {
+    customerRepository.deleteAll();
+    bookRepository.deleteAll();
+    orderRepository.deleteAll();
+    customerPhoneUUID.clear();
+    bookIsbnUUID.clear();
+    orderResult = null;
+    notValidOrderException = null;
+    customerNotFoundThrown = false;
+  }
+
+  @Given("the system has the following customers for order:")
+  public void theSystemHasTheFollowingCustomersForOrder(DataTable dataTable) {
+    List<Map<String, String>> customers = dataTable.asMaps(String.class, String.class);
+
+    for (Map<String, String> customer : customers) {
+      String phone = customer.get("numeroTelephone");
+      Customer newCustomer = Customer.builder()
+          .firstName(customer.get("prenom"))
+          .lastName(customer.get("nom"))
+          .phoneNumber(phone)
+          .loyaltyPoints(Integer.parseInt(customer.get("pointsFidelite")))
+          .build();
+      Customer saved = customerRepository.save(newCustomer);
+      customerPhoneUUID.put(phone, saved.getId());
+    }
+
+    assertEquals(customers.size(), customerRepository.findAll().size());
+  }
+
+  @And("the catalog has the following books for order:")
+  public void theCatalogHasTheFollowingBooksForOrder(DataTable dataTable) {
+    List<Map<String, String>> books = dataTable.asMaps(String.class, String.class);
+
+    for (Map<String, String> book : books) {
+      String isbn = book.get("isbn");
+      Book newBook = Book.builder()
+          .isbn(isbn)
+          .title(book.get("titre"))
+          .author(book.get("auteur"))
+          .publisher(book.get("editeur"))
+          .publicationDate(LocalDate.parse(book.get("datePublication")))
+          .price(new BigDecimal(book.get("prix")))
+          .stock(Integer.parseInt(book.get("stockInitial")))
+          .categories(List.of(book.get("categories").split(";")))
+          .description(book.get("description"))
+          .language(book.get("langue"))
+          .build();
+      Book saved = bookRepository.save(newBook);
+      bookIsbnUUID.put(isbn, saved.getId());
+    }
+
+    assertEquals(books.size(), bookRepository.findAll().size());
+  }
+
+  @When("I place an order for customer {string} with:")
+  public void iPlaceAnOrderForCustomerWith(String phoneNumber, DataTable dataTable)
+      throws NotValidOrderException, CustomerNotFoundException {
+    Map<String, String> row = dataTable.asMaps(String.class, String.class).getFirst();
+
+    UUID customerId = customerPhoneUUID.get(phoneNumber);
+    UUID livreId = bookIsbnUUID.get(row.get("livreIsbn"));
+
+    AdresseLivraison adresse = new AdresseLivraison(
+        row.get("rue"), row.get("ville"), row.get("codePostal"), row.get("pays")
+    );
+
+    OrderInfo orderInfo = new OrderInfo(
+        customerId,
+        List.of(new LigneCommandeInfo(livreId, Integer.parseInt(row.get("quantite")))),
+        adresse,
+        ModePaiement.valueOf(row.get("modePaiement"))
+    );
+
+    orderResult = orderUseCase.passerCommande(orderInfo);
+  }
+
+  @Then("a new order is created")
+  public void aNewOrderIsCreated() {
+    assertNotNull(orderResult);
+    assertNotNull(orderResult.getCommandeId());
+  }
+
+  @And("the order total is {double}")
+  public void theOrderTotalIs(double expectedTotal) {
+    assertEquals(0, new BigDecimal(String.valueOf(expectedTotal)).compareTo(orderResult.getMontantTotal()));
+  }
+
+  @And("the customer {string} now has {int} loyalty points")
+  public void theCustomerNowHasLoyaltyPoints(String phoneNumber, int expectedPoints) {
+    UUID customerId = customerPhoneUUID.get(phoneNumber);
+    Customer customer = customerRepository.findById(customerId).orElseThrow();
+    assertEquals(expectedPoints, customer.getLoyaltyPoints());
+  }
+
+  @When("I try to place an order for customer {string} with no items:")
+  public void iTryToPlaceAnOrderForCustomerWithNoItems(String phoneNumber, DataTable dataTable) {
+    Map<String, String> row = dataTable.asMaps(String.class, String.class).getFirst();
+    UUID customerId = customerPhoneUUID.get(phoneNumber);
+
+    AdresseLivraison adresse = new AdresseLivraison(
+        row.get("rue"), row.get("ville"), row.get("codePostal"), row.get("pays")
+    );
+
+    OrderInfo orderInfo = new OrderInfo(
+        customerId, List.of(), adresse, ModePaiement.valueOf(row.get("modePaiement"))
+    );
+
+    notValidOrderException = assertThrows(NotValidOrderException.class,
+        () -> orderUseCase.passerCommande(orderInfo));
+  }
+
+  @When("I try to place an order for customer {string} with invalid quantity:")
+  public void iTryToPlaceAnOrderForCustomerWithInvalidQuantity(String phoneNumber, DataTable dataTable) {
+    Map<String, String> row = dataTable.asMaps(String.class, String.class).getFirst();
+    UUID customerId = customerPhoneUUID.get(phoneNumber);
+    UUID livreId = bookIsbnUUID.get(row.get("livreIsbn"));
+
+    AdresseLivraison adresse = new AdresseLivraison(
+        row.get("rue"), row.get("ville"), row.get("codePostal"), row.get("pays")
+    );
+
+    OrderInfo orderInfo = new OrderInfo(
+        customerId,
+        List.of(new LigneCommandeInfo(livreId, Integer.parseInt(row.get("quantite")))),
+        adresse,
+        ModePaiement.valueOf(row.get("modePaiement"))
+    );
+
+    notValidOrderException = assertThrows(NotValidOrderException.class,
+        () -> orderUseCase.passerCommande(orderInfo));
+  }
+
+  @When("I try to place an order for an unknown customer with:")
+  public void iTryToPlaceAnOrderForAnUnknownCustomerWith(DataTable dataTable) {
+    Map<String, String> row = dataTable.asMaps(String.class, String.class).getFirst();
+    UUID unknownId = UUID.randomUUID();
+    UUID livreId = bookIsbnUUID.get(row.get("livreIsbn"));
+
+    AdresseLivraison adresse = new AdresseLivraison(
+        row.get("rue"), row.get("ville"), row.get("codePostal"), row.get("pays")
+    );
+
+    OrderInfo orderInfo = new OrderInfo(
+        unknownId,
+        List.of(new LigneCommandeInfo(livreId, Integer.parseInt(row.get("quantite")))),
+        adresse,
+        ModePaiement.valueOf(row.get("modePaiement"))
+    );
+
+    try {
+      orderUseCase.passerCommande(orderInfo);
+    } catch (CustomerNotFoundException e) {
+      customerNotFoundThrown = true;
+    } catch (NotValidOrderException e) {
+      notValidOrderException = e;
+    }
+  }
+
+  @Then("the order placement fails")
+  public void theOrderPlacementFails() {
+    assertNotNull(notValidOrderException);
+  }
+
+  @Then("the order placement fails with customer not found")
+  public void theOrderPlacementFailsWithCustomerNotFound() {
+    assertTrue(customerNotFoundThrown);
+  }
+
+  @And("I receive a validation order error containing {string}")
+  public void iReceiveAValidationOrderErrorContaining(String errorMessage) {
+    assertEquals(errorMessage, notValidOrderException.getMessage());
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/order/converter/OrderConverterTest.java

@@ -0,0 +1,94 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.converter;
+ 
+import fr.iut_fbleau.but3.dev62.mylibrary.order.AdresseLivraison;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.LigneCommandeInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.ModePaiement;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.LigneCommande;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.Order;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+ 
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.UUID;
+ 
+import static org.junit.jupiter.api.Assertions.*;
+ 
+@DisplayName("OrderConverter Unit Tests")
+class OrderConverterTest {
+ 
+  private final UUID clientId = UUID.randomUUID();
+  private final UUID livreId = UUID.randomUUID();
+  private final AdresseLivraison adresse = new AdresseLivraison("1 rue de Paris", "Paris", "75001", "France");
+ 
+  @Nested
+  @DisplayName("toDomain() method tests")
+  class ToDomainTests {
+ 
+    @Test
+    @DisplayName("Should convert OrderInfo to Order domain object")
+    void shouldConvertOrderInfoToDomain() {
+      OrderInfo orderInfo = new OrderInfo(
+          clientId,
+          List.of(new LigneCommandeInfo(livreId, 2)),
+          adresse,
+          ModePaiement.CB
+      );
+ 
+      List<LigneCommande> lignes = List.of(
+          LigneCommande.builder()
+              .livreId(livreId)
+              .quantite(2)
+              .prixUnitaire(new BigDecimal("12.90"))
+              .build()
+      );
+ 
+      Order result = OrderConverter.toDomain(orderInfo, lignes, new BigDecimal("25.80"), 25);
+ 
+      assertNotNull(result);
+      assertEquals(clientId, result.getClientId());
+      assertEquals(adresse, result.getAdresseLivraison());
+      assertEquals(ModePaiement.CB, result.getModePaiement());
+      assertEquals(new BigDecimal("25.80"), result.getMontantTotal());
+      assertEquals(25, result.getPointsFideliteGagnes());
+      assertEquals(1, result.getLignesCommande().size());
+    }
+ 
+    @Test
+    @DisplayName("Should have null ID after toDomain (set by repository)")
+    void shouldHaveNullIdAfterToDomain() {
+      OrderInfo orderInfo = new OrderInfo(clientId, List.of(new LigneCommandeInfo(livreId, 1)), adresse, ModePaiement.CB);
+ 
+      Order result = OrderConverter.toDomain(orderInfo, List.of(), BigDecimal.ZERO, 0);
+ 
+      assertNull(result.getId());
+    }
+  }
+ 
+  @Nested
+  @DisplayName("toDTO() method tests")
+  class ToDTOTests {
+ 
+    @Test
+    @DisplayName("Should convert Order domain object to OrderDTO with all fields mapped correctly")
+    void shouldConvertOrderToDTO() {
+      UUID orderId = UUID.randomUUID();
+      Order order = Order.builder()
+          .id(orderId)
+          .clientId(clientId)
+          .montantTotal(new BigDecimal("25.80"))
+          .pointsFideliteGagnes(25)
+          .build();
+ 
+      OrderDTO result = OrderConverter.toDTO(order);
+ 
+      assertNotNull(result);
+      assertEquals(orderId, result.getCommandeId());
+      assertEquals(new BigDecimal("25.80"), result.getMontantTotal());
+      assertEquals(25, result.getPointsFideliteGagnes());
+    }
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/order/entity/OrderTest.java

@@ -0,0 +1,81 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.entity;
+ 
+import fr.iut_fbleau.but3.dev62.mylibrary.order.AdresseLivraison;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.ModePaiement;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+ 
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.UUID;
+ 
+import static org.junit.jupiter.api.Assertions.*;
+ 
+class OrderTest {
+ 
+  @Test
+  @DisplayName("Builder should create a valid Order instance")
+  void testOrderBuilder() {
+    UUID id = UUID.randomUUID();
+    UUID clientId = UUID.randomUUID();
+    AdresseLivraison adresse = new AdresseLivraison("1 rue de Paris", "Paris", "75001", "France");
+ 
+    Order order = Order.builder()
+        .id(id)
+        .clientId(clientId)
+        .adresseLivraison(adresse)
+        .modePaiement(ModePaiement.CB)
+        .montantTotal(new BigDecimal("25.80"))
+        .pointsFideliteGagnes(25)
+        .lignesCommande(List.of())
+        .build();
+ 
+    assertEquals(id, order.getId());
+    assertEquals(clientId, order.getClientId());
+    assertEquals(adresse, order.getAdresseLivraison());
+    assertEquals(ModePaiement.CB, order.getModePaiement());
+    assertEquals(new BigDecimal("25.80"), order.getMontantTotal());
+    assertEquals(25, order.getPointsFideliteGagnes());
+  }
+ 
+  @Test
+  @DisplayName("setRandomUUID should set a new non-null UUID")
+  void testSetRandomUUID() {
+    Order order = Order.builder().build();
+    UUID originalId = order.getId();
+ 
+    order.setRandomUUID();
+ 
+    assertNotNull(order.getId());
+    assertNotEquals(originalId, order.getId());
+  }
+ 
+  @Test
+  @DisplayName("Two setRandomUUID calls should produce different UUIDs")
+  void testSetRandomUUIDTwice() {
+    Order order = Order.builder().build();
+    order.setRandomUUID();
+    UUID firstId = order.getId();
+ 
+    order.setRandomUUID();
+    UUID secondId = order.getId();
+ 
+    assertNotEquals(firstId, secondId);
+  }
+ 
+  @Test
+  @DisplayName("Builder should create a valid LigneCommande instance")
+  void testLigneCommandeBuilder() {
+    UUID livreId = UUID.randomUUID();
+ 
+    LigneCommande ligne = LigneCommande.builder()
+        .livreId(livreId)
+        .quantite(3)
+        .prixUnitaire(new BigDecimal("12.90"))
+        .build();
+ 
+    assertEquals(livreId, ligne.getLivreId());
+    assertEquals(3, ligne.getQuantite());
+    assertEquals(new BigDecimal("12.90"), ligne.getPrixUnitaire());
+  }
+}