ajout de Order

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/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());
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/order/exception/NotValidOrderExceptionTest.java

@@ -0,0 +1,61 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.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 NotValidOrderExceptionTest {
+ 
+  @Test
+  @DisplayName("Exception should be created with the provided message")
+  void testExceptionCreation() {
+    String errorMessage = "Order data is not valid";
+ 
+    NotValidOrderException exception = new NotValidOrderException(errorMessage);
+ 
+    assertEquals(errorMessage, exception.getMessage());
+  }
+ 
+  @ParameterizedTest
+  @ValueSource(strings = {
+      "Client id cannot be null",
+      "Order must have at least one item",
+      "Quantity must be positive",
+      "Payment method cannot be null",
+      "Delivery address cannot be null"
+  })
+  @DisplayName("Exception should handle different validation messages")
+  void testExceptionWithDifferentMessages(String errorMessage) {
+    NotValidOrderException exception = new NotValidOrderException(errorMessage);
+ 
+    assertEquals(errorMessage, exception.getMessage());
+  }
+ 
+  @Test
+  @DisplayName("Exception should be properly thrown and caught")
+  void testExceptionCanBeThrownAndCaught() {
+    String errorMessage = "Order must have at least one item";
+ 
+    Exception exception = assertThrows(NotValidOrderException.class, () -> {
+      throw new NotValidOrderException(errorMessage);
+    });
+ 
+    assertEquals(errorMessage, exception.getMessage());
+  }
+ 
+  @Test
+  @DisplayName("Exception should be catchable as a general Exception")
+  void testExceptionInheritance() {
+    String errorMessage = "Quantity must be positive";
+ 
+    try {
+      throw new NotValidOrderException(errorMessage);
+    } catch (Exception e) {
+      assertEquals(NotValidOrderException.class, e.getClass());
+      assertEquals(errorMessage, e.getMessage());
+    }
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/order/exception/OrderNotFoundExceptionTest.java

@@ -0,0 +1,47 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.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 OrderNotFoundExceptionTest {
+ 
+  @Test
+  @DisplayName("Exception message should contain the UUID provided")
+  void testExceptionMessageContainsUUID() {
+    UUID uuid = UUID.randomUUID();
+ 
+    OrderNotFoundException exception = new OrderNotFoundException(uuid);
+ 
+    String expectedMessage = String.format("The order 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();
+ 
+    OrderNotFoundException exception = new OrderNotFoundException(uuid);
+ 
+    assertEquals("The order with id {0} does not exist",
+        OrderNotFoundException.THE_ORDER_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 OrderNotFoundException(uuid);
+    } catch (OrderNotFoundException e) {
+      String expectedMessage = String.format("The order with id %s does not exist", uuid);
+      assertEquals(expectedMessage, e.getMessage());
+    }
+  }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/order/repository/OrderRepositoryTest.java

@@ -0,0 +1,202 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.repository;
+ 
+import fr.iut_fbleau.but3.dev62.mylibrary.order.AdresseLivraison;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.ModePaiement;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.Order;
+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.util.List;
+import java.util.Optional;
+import java.util.UUID;
+ 
+import static org.junit.jupiter.api.Assertions.*;
+ 
+class OrderRepositoryTest {
+ 
+  private OrderRepository repository;
+  private Order order1;
+  private Order order2;
+  private UUID clientId1;
+  private UUID clientId2;
+ 
+  @BeforeEach
+  void setUp() {
+    repository = new OrderRepository();
+    clientId1 = UUID.randomUUID();
+    clientId2 = UUID.randomUUID();
+ 
+    AdresseLivraison adresse = new AdresseLivraison("1 rue de Paris", "Paris", "75001", "France");
+ 
+    order1 = Order.builder()
+        .clientId(clientId1)
+        .adresseLivraison(adresse)
+        .modePaiement(ModePaiement.CB)
+        .montantTotal(new BigDecimal("25.80"))
+        .pointsFideliteGagnes(25)
+        .lignesCommande(List.of())
+        .build();
+    order1.setRandomUUID();
+ 
+    order2 = Order.builder()
+        .clientId(clientId2)
+        .adresseLivraison(adresse)
+        .modePaiement(ModePaiement.PAYPAL)
+        .montantTotal(new BigDecimal("9.50"))
+        .pointsFideliteGagnes(9)
+        .lignesCommande(List.of())
+        .build();
+    order2.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 order")
+    void testSaveNewOrder() {
+      Order saved = repository.save(order1);
+ 
+      assertEquals(1, repository.findAll().size());
+      assertEquals(order1.getId(), saved.getId());
+    }
+ 
+    @Test
+    @DisplayName("Save should update existing order with same ID")
+    void testSaveUpdatesExistingOrder() {
+      repository.save(order1);
+      UUID id = order1.getId();
+ 
+      Order updatedOrder = Order.builder()
+          .id(id)
+          .clientId(clientId1)
+          .adresseLivraison(new AdresseLivraison("2 rue de Lyon", "Lyon", "69001", "France"))
+          .modePaiement(ModePaiement.PAYPAL)
+          .montantTotal(new BigDecimal("50.00"))
+          .pointsFideliteGagnes(50)
+          .lignesCommande(List.of())
+          .build();
+ 
+      Order saved = repository.save(updatedOrder);
+ 
+      assertEquals(1, repository.findAll().size());
+      assertEquals(id, saved.getId());
+      assertEquals(new BigDecimal("50.00"), saved.getMontantTotal());
+    }
+ 
+    @Test
+    @DisplayName("Save multiple orders should add all of them")
+    void testSaveMultipleOrders() {
+      repository.save(order1);
+      repository.save(order2);
+ 
+      assertEquals(2, repository.findAll().size());
+    }
+  }
+ 
+  @Nested
+  @DisplayName("Find operations")
+  class FindOperations {
+ 
+    @BeforeEach
+    void setUpOrders() {
+      repository.save(order1);
+      repository.save(order2);
+    }
+ 
+    @Test
+    @DisplayName("FindAll should return all orders")
+    void testFindAll() {
+      assertEquals(2, repository.findAll().size());
+    }
+ 
+    @Test
+    @DisplayName("FindById should return order with matching ID")
+    void testFindById() {
+      Optional<Order> found = repository.findById(order1.getId());
+ 
+      assertTrue(found.isPresent());
+      assertEquals(order1.getId(), found.get().getId());
+    }
+ 
+    @Test
+    @DisplayName("FindById should return empty Optional when ID doesn't exist")
+    void testFindByIdNotFound() {
+      Optional<Order> found = repository.findById(UUID.randomUUID());
+ 
+      assertTrue(found.isEmpty());
+    }
+ 
+    @Test
+    @DisplayName("FindByClientId should return all orders for a client")
+    void testFindByClientId() {
+      List<Order> found = repository.findByClientId(clientId1);
+ 
+      assertEquals(1, found.size());
+      assertEquals(order1.getId(), found.getFirst().getId());
+    }
+ 
+    @Test
+    @DisplayName("ExistsById should return true when ID exists")
+    void testExistsByIdExists() {
+      assertTrue(repository.existsById(order1.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 setUpOrders() {
+      repository.save(order1);
+      repository.save(order2);
+    }
+ 
+    @Test
+    @DisplayName("Delete should remove the specified order")
+    void testDelete() {
+      repository.delete(order1);
+ 
+      assertEquals(1, repository.findAll().size());
+      assertFalse(repository.findAll().contains(order1));
+      assertTrue(repository.findAll().contains(order2));
+    }
+ 
+    @Test
+    @DisplayName("DeleteAll should remove all orders")
+    void testDeleteAll() {
+      repository.deleteAll();
+ 
+      assertTrue(repository.findAll().isEmpty());
+    }
+ 
+    @Test
+    @DisplayName("Delete should not throw exception when order doesn't exist")
+    void testDeleteNonExistentOrder() {
+      Order nonExistent = Order.builder().build();
+      nonExistent.setRandomUUID();
+ 
+      assertDoesNotThrow(() -> repository.delete(nonExistent));
+      assertEquals(2, repository.findAll().size());
+    }
+  }
+}
+ 

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/order/validator/OrderValidatorTest.java

@@ -0,0 +1,155 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.validator;
+ 
+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.OrderInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.exception.NotValidOrderException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+ 
+import java.util.List;
+import java.util.UUID;
+ 
+import static org.junit.jupiter.api.Assertions.*;
+ 
+class OrderValidatorTest {
+ 
+  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");
+ 
+  private OrderInfo validOrder() {
+    return new OrderInfo(
+        clientId,
+        List.of(new LigneCommandeInfo(livreId, 1)),
+        adresse,
+        ModePaiement.CB
+    );
+  }
+ 
+  @Test
+  @DisplayName("Should validate order with valid data")
+  void testValidateValidOrder() {
+    assertDoesNotThrow(() -> OrderValidator.validate(validOrder()));
+  }
+ 
+  @Nested
+  @DisplayName("ClientId validation tests")
+  class ClientIdValidationTests {
+ 
+    @Test
+    @DisplayName("Should throw exception when clientId is null")
+    void testValidateNullClientId() {
+      OrderInfo order = new OrderInfo(null, List.of(new LigneCommandeInfo(livreId, 1)), adresse, ModePaiement.CB);
+ 
+      NotValidOrderException exception = assertThrows(NotValidOrderException.class,
+          () -> OrderValidator.validate(order));
+ 
+      assertEquals(OrderValidator.CLIENT_ID_CANNOT_BE_NULL, exception.getMessage());
+    }
+  }
+ 
+  @Nested
+  @DisplayName("LignesCommande validation tests")
+  class LignesCommandeValidationTests {
+ 
+    @Test
+    @DisplayName("Should throw exception when lignesCommande is empty")
+    void testValidateEmptyLignesCommande() {
+      OrderInfo order = new OrderInfo(clientId, List.of(), adresse, ModePaiement.CB);
+ 
+      NotValidOrderException exception = assertThrows(NotValidOrderException.class,
+          () -> OrderValidator.validate(order));
+ 
+      assertEquals(OrderValidator.LIGNES_COMMANDE_CANNOT_BE_EMPTY, exception.getMessage());
+    }
+ 
+    @Test
+    @DisplayName("Should throw exception when lignesCommande is null")
+    void testValidateNullLignesCommande() {
+      OrderInfo order = new OrderInfo(clientId, null, adresse, ModePaiement.CB);
+ 
+      NotValidOrderException exception = assertThrows(NotValidOrderException.class,
+          () -> OrderValidator.validate(order));
+ 
+      assertEquals(OrderValidator.LIGNES_COMMANDE_CANNOT_BE_EMPTY, exception.getMessage());
+    }
+ 
+    @Test
+    @DisplayName("Should throw exception when quantite is zero")
+    void testValidateZeroQuantite() {
+      OrderInfo order = new OrderInfo(clientId, List.of(new LigneCommandeInfo(livreId, 0)), adresse, ModePaiement.CB);
+ 
+      NotValidOrderException exception = assertThrows(NotValidOrderException.class,
+          () -> OrderValidator.validate(order));
+ 
+      assertEquals(OrderValidator.QUANTITE_MUST_BE_POSITIVE, exception.getMessage());
+    }
+ 
+    @Test
+    @DisplayName("Should throw exception when quantite is negative")
+    void testValidateNegativeQuantite() {
+      OrderInfo order = new OrderInfo(clientId, List.of(new LigneCommandeInfo(livreId, -1)), adresse, ModePaiement.CB);
+ 
+      NotValidOrderException exception = assertThrows(NotValidOrderException.class,
+          () -> OrderValidator.validate(order));
+ 
+      assertEquals(OrderValidator.QUANTITE_MUST_BE_POSITIVE, exception.getMessage());
+    }
+  }
+ 
+  @Nested
+  @DisplayName("AdresseLivraison validation tests")
+  class AdresseLivraisonValidationTests {
+ 
+    @Test
+    @DisplayName("Should throw exception when adresseLivraison is null")
+    void testValidateNullAdresseLivraison() {
+      OrderInfo order = new OrderInfo(clientId, List.of(new LigneCommandeInfo(livreId, 1)), null, ModePaiement.CB);
+ 
+      NotValidOrderException exception = assertThrows(NotValidOrderException.class,
+          () -> OrderValidator.validate(order));
+ 
+      assertEquals(OrderValidator.ADRESSE_LIVRAISON_CANNOT_BE_NULL, exception.getMessage());
+    }
+  }
+ 
+  @Nested
+  @DisplayName("ModePaiement validation tests")
+  class ModePaiementValidationTests {
+ 
+    @Test
+    @DisplayName("Should throw exception when modePaiement is null")
+    void testValidateNullModePaiement() {
+      OrderInfo order = new OrderInfo(clientId, List.of(new LigneCommandeInfo(livreId, 1)), adresse, null);
+ 
+      NotValidOrderException exception = assertThrows(NotValidOrderException.class,
+          () -> OrderValidator.validate(order));
+ 
+      assertEquals(OrderValidator.MODE_PAIEMENT_CANNOT_BE_NULL, exception.getMessage());
+    }
+ 
+    @Test
+    @DisplayName("Should validate with CB payment method")
+    void testValidateWithCB() {
+      OrderInfo order = new OrderInfo(clientId, List.of(new LigneCommandeInfo(livreId, 1)), adresse, ModePaiement.CB);
+      assertDoesNotThrow(() -> OrderValidator.validate(order));
+    }
+ 
+    @Test
+    @DisplayName("Should validate with PAYPAL payment method")
+    void testValidateWithPaypal() {
+      OrderInfo order = new OrderInfo(clientId, List.of(new LigneCommandeInfo(livreId, 1)), adresse, ModePaiement.PAYPAL);
+      assertDoesNotThrow(() -> OrderValidator.validate(order));
+    }
+ 
+    @Test
+    @DisplayName("Should validate with POINTS_FIDELITE payment method")
+    void testValidateWithPointsFidelite() {
+      OrderInfo order = new OrderInfo(clientId, List.of(new LigneCommandeInfo(livreId, 1)), adresse, ModePaiement.POINTS_FIDELITE);
+      assertDoesNotThrow(() -> OrderValidator.validate(order));
+    }
+  }
+}

src/test/resources/features/order.feature

@@ -0,0 +1,49 @@
+# language: en
+
+Feature: Place an order
+
+  Background:
+    Given the system has the following customers for order:
+      | prenom | nom    | numeroTelephone | pointsFidelite |
+      | Marie  | Dupont | 0612345678      | 100            |
+      | Jean   | Martin | 0687654321      | 50             |
+    And the catalog has the following books for order:
+      | isbn          | titre           | auteur                   | editeur   | datePublication | prix  | stockInitial | categories | description  | langue |
+      | 9782016289308 | Le Petit Prince | Antoine de Saint-Exupery | Gallimard | 1943-04-06      | 12.90 | 10           | Roman      | Un classique | FR     |
+      | 9782070409189 | L Etranger      | Albert Camus              | Gallimard | 1942-05-19      | 9.50  | 5            | Roman      | Philosophique| FR     |
+
+  Scenario: Place an order with CB payment
+    When I place an order for customer "0612345678" with:
+      | livreIsbn     | quantite | rue            | ville | codePostal | pays   | modePaiement |
+      | 9782016289308 | 2        | 1 rue de Paris | Paris | 75001      | France | CB           |
+    Then a new order is created
+    And the order total is 25.80
+    And the customer "0612345678" now has 125 loyalty points
+
+  Scenario: Place an order with PAYPAL payment
+    When I place an order for customer "0687654321" with:
+      | livreIsbn     | quantite | rue           | ville | codePostal | pays   | modePaiement |
+      | 9782070409189 | 1        | 5 rue de Lyon | Lyon  | 69001      | France | PAYPAL       |
+    Then a new order is created
+    And the order total is 9.50
+    And the customer "0687654321" now has 59 loyalty points
+
+  Scenario: Attempt to place an order with no items
+    When I try to place an order for customer "0612345678" with no items:
+      | rue            | ville | codePostal | pays   | modePaiement |
+      | 1 rue de Paris | Paris | 75001      | France | CB           |
+    Then the order placement fails
+    And I receive a validation order error containing "Order must have at least one item"
+
+  Scenario: Attempt to place an order with invalid quantity
+    When I try to place an order for customer "0612345678" with invalid quantity:
+      | livreIsbn     | quantite | rue            | ville | codePostal | pays   | modePaiement |
+      | 9782016289308 | 0        | 1 rue de Paris | Paris | 75001      | France | CB           |
+    Then the order placement fails
+    And I receive a validation order error containing "Quantity must be positive"
+
+  Scenario: Attempt to place an order for unknown customer
+    When I try to place an order for an unknown customer with:
+      | livreIsbn     | quantite | rue            | ville | codePostal | pays   | modePaiement |
+      | 9782016289308 | 1        | 1 rue de Paris | Paris | 75001      | France | CB           |
+    Then the order placement fails with customer not found