Fini

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

@@ -0,0 +1,36 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order;
+
+import java.util.List;
+import java.util.UUID;
+
+public class OrderDTO {
+    private UUID id;
+    private UUID customerId;
+    private List<OrderInfo.OrderLineDto> orderLines;
+    private double totalPrice;
+    private double totalPriceToPay;
+    private OrderInfo.Address address;
+    private String paymentMethod;
+
+    // Getters et setters
+    public UUID getId() { return id; }
+    public void setId(UUID id) { this.id = id; }
+
+    public UUID getCustomerId() { return customerId; }
+    public void setCustomerId(UUID customerId) { this.customerId = customerId; }
+
+    public List<OrderInfo.OrderLineDto> getOrderLines() { return orderLines; }
+    public void setOrderLines(List<OrderInfo.OrderLineDto> orderLines) { this.orderLines = orderLines; }
+
+    public double getTotalPrice() { return totalPrice; }
+    public void setTotalPrice(double totalPrice) { this.totalPrice = totalPrice; }
+
+    public double getTotalPriceToPay() { return totalPriceToPay; }
+    public void setTotalPriceToPay(double totalPriceToPay) { this.totalPriceToPay = totalPriceToPay; }
+
+    public OrderInfo.Address getAddress() { return address; }
+    public void setAddress(OrderInfo.Address address) { this.address = address; }
+
+    public String getPaymentMethod() { return paymentMethod; }
+    public void setPaymentMethod(String paymentMethod) { this.paymentMethod = paymentMethod; }
+}

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

@@ -0,0 +1,72 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order;
+
+import java.util.List;
+import java.util.UUID;
+
+public class OrderInfo {
+    private UUID customerId;
+    private List<OrderLineDto> orderLineDtos;
+    private Address address;
+    private String paymentMethod; // "CREDIT_CARD" ou "LOYALTY_POINTS"
+
+    // POJO interne pour OrderLineDto
+    public static class OrderLineDto {
+        private long bookId;
+        private int quantity;
+
+        public OrderLineDto() {}
+
+        public OrderLineDto(long bookId, int quantity) {
+            this.bookId = bookId;
+            this.quantity = quantity;
+        }
+
+        public long getBookId() { return bookId; }
+        public void setBookId(long bookId) { this.bookId = bookId; }
+
+        public int getQuantity() { return quantity; }
+        public void setQuantity(int quantity) { this.quantity = quantity; }
+    }
+
+    // POJO interne pour Address
+    public static class Address {
+        private String street;
+        private String city;
+        private String postalCode;
+        private String country;
+
+        public Address() {}
+
+        public Address(String street, String city, String postalCode, String country) {
+            this.street = street;
+            this.city = city;
+            this.postalCode = postalCode;
+            this.country = country;
+        }
+
+        public String getStreet() { return street; }
+        public void setStreet(String street) { this.street = street; }
+
+        public String getCity() { return city; }
+        public void setCity(String city) { this.city = city; }
+
+        public String getPostalCode() { return postalCode; }
+        public void setPostalCode(String postalCode) { this.postalCode = postalCode; }
+
+        public String getCountry() { return country; }
+        public void setCountry(String country) { this.country = country; }
+    }
+
+    // Getters et setters
+    public UUID getCustomerId() { return customerId; }
+    public void setCustomerId(UUID customerId) { this.customerId = customerId; }
+
+    public List<OrderLineDto> getOrderLineDtos() { return orderLineDtos; }
+    public void setOrderLineDtos(List<OrderLineDto> orderLineDtos) { this.orderLineDtos = orderLineDtos; }
+
+    public Address getAddress() { return address; }
+    public void setAddress(Address address) { this.address = address; }
+
+    public String getPaymentMethod() { return paymentMethod; }
+    public void setPaymentMethod(String paymentMethod) { this.paymentMethod = paymentMethod; }
+}

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

@@ -0,0 +1,4 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.converter;
+
+public class OrderConverterTest {
+}

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

@@ -0,0 +1,34 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.entity;
+
+import java.util.List;
+import java.util.UUID;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+
+public class Order {
+    private UUID id;
+    private UUID customerId;
+    private List<OrderInfo.OrderLineDto> orderLines;
+    private double totalPrice;
+    private double totalPriceToPay;
+    private OrderInfo.Address address;
+    private String paymentMethod;
+
+    public Order(UUID id, UUID customerId, List<OrderInfo.OrderLineDto> orderLines, double totalPrice, double totalPriceToPay, OrderInfo.Address address, String paymentMethod) {
+        this.id = id;
+        this.customerId = customerId;
+        this.orderLines = orderLines;
+        this.totalPrice = totalPrice;
+        this.totalPriceToPay = totalPriceToPay;
+        this.address = address;
+        this.paymentMethod = paymentMethod;
+    }
+
+    // Getters
+    public UUID getId() { return id; }
+    public UUID getCustomerId() { return customerId; }
+    public List<OrderInfo.OrderLineDto> getOrderLines() { return orderLines; }
+    public double getTotalPrice() { return totalPrice; }
+    public double getTotalPriceToPay() { return totalPriceToPay; }
+    public OrderInfo.Address getAddress() { return address; }
+    public String getPaymentMethod() { return paymentMethod; }
+}

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

@@ -0,0 +1,12 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.exception;
+
+import java.text.MessageFormat;
+
+public class BookQuantityInsufficientException extends Exception {
+
+    public static final String BOOK_QUANTITY_INSUFFICIENT = "Cannot order {0} books, only {1} in stock";
+
+    public BookQuantityInsufficientException(int requested, int available) {
+        super(MessageFormat.format(BOOK_QUANTITY_INSUFFICIENT, requested, available));
+    }
+}

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

@@ -0,0 +1,16 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.exception;
+
+import java.text.MessageFormat;
+
+public class InvalidOrderException extends Exception {
+
+    public static final String INVALID_ORDER_DETAILS_OR_ADDRESS = "Invalid order details or address";
+
+    public InvalidOrderException() {
+        super(INVALID_ORDER_DETAILS_OR_ADDRESS);
+    }
+
+    public InvalidOrderException(String details) {
+        super(details);
+    }
+}

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

@@ -0,0 +1,13 @@
+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,30 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.repository;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.Order;
+
+import java.util.*;
+
+public class OrderRepository {
+
+    private final Map<UUID, Order> orders = new HashMap<>();
+
+    public Order save(OrderInfo info) {
+        UUID id = UUID.randomUUID();
+        Order order = new Order(
+            id,
+            info.getCustomerId(),
+            info.getOrderLineDtos(),
+            0.0, // totalPrice à calculer selon la logique métier
+            0.0, // totalPriceToPay à calculer
+            info.getAddress(),
+            info.getPaymentMethod()
+        );
+        orders.put(id, order);
+        return order;
+    }
+
+    public Optional<Order> findById(UUID id) {
+        return Optional.ofNullable(orders.get(id));
+    }
+}

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

@@ -0,0 +1,45 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.usecase;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.Order;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.repository.OrderRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.validator.OrderValidator;
+
+import java.util.Optional;
+import java.util.UUID;
+
+public class OrderUseCase {
+
+    private final OrderRepository repository;
+
+    public OrderUseCase(OrderRepository repository) {
+        this.repository = repository;
+    }
+
+    public OrderDTO createOrder(OrderInfo info) throws Exception {
+        if (!OrderValidator.isValidOrderInfo(info)) {
+            throw new IllegalArgumentException("Invalid order details or address");
+        }
+        // Ici, on suppose que le repository gère la logique métier (stock, client, etc.)
+        Order order = repository.save(info);
+        return toDto(order);
+    }
+
+    public Optional<OrderDTO> getOrderById(UUID id) {
+        Optional<Order> order = repository.findById(id);
+        return order.map(this::toDto);
+    }
+
+    private OrderDTO toDto(Order order) {
+        OrderDTO dto = new OrderDTO();
+        dto.setId(order.getId());
+        dto.setCustomerId(order.getCustomerId());
+        dto.setOrderLines(order.getOrderLines());
+        dto.setTotalPrice(order.getTotalPrice());
+        dto.setTotalPriceToPay(order.getTotalPriceToPay());
+        dto.setAddress(order.getAddress());
+        dto.setPaymentMethod(order.getPaymentMethod());
+        return dto;
+    }
+}

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

@@ -0,0 +1,47 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.validator;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+
+import java.util.List;
+import java.util.UUID;
+
+public class OrderValidator {
+
+    public static boolean isValidUUID(String uuid) {
+        try {
+            UUID.fromString(uuid);
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    public static boolean isValidOrderInfo(OrderInfo info) {
+        if (info == null) return false;
+        if (info.getCustomerId() == null) return false;
+        if (info.getOrderLineDtos() == null || info.getOrderLineDtos().isEmpty()) return false;
+        if (info.getPaymentMethod() == null || info.getPaymentMethod().isBlank()) return false;
+
+        // Vérifie chaque ligne de commande
+        for (OrderInfo.OrderLineDto line : info.getOrderLineDtos()) {
+            if (line == null) return false;
+            if (line.getBookId() <= 0) return false;
+            if (line.getQuantity() <= 0) return false;
+        }
+
+        // Vérifie l'adresse
+        if (info.getAddress() == null) return false;
+        OrderInfo.Address addr = info.getAddress();
+        if (addr.getStreet() == null || addr.getStreet().isBlank()) return false;
+        if (addr.getCity() == null || addr.getCity().isBlank()) return false;
+        if (addr.getPostalCode() == null || addr.getPostalCode().isBlank()) return false;
+        if (addr.getCountry() == null || addr.getCountry().isBlank()) return false;
+
+        // Vérifie le mode de paiement
+        if (!info.getPaymentMethod().equals("CREDIT_CARD") && !info.getPaymentMethod().equals("LOYALTY_POINTS")) {
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/ReviewDto.java

@@ -0,0 +1,15 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review;
+
+import lombok.Builder;
+import lombok.Getter;
+import java.util.UUID;
+
+@Builder
+@Getter
+public class ReviewDto {
+    private UUID reviewId;
+    private long bookId;
+    private String customerName;
+    private String comment;
+    private int rating;
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/ReviewInfo.java

@@ -0,0 +1,13 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@Getter
+public class ReviewInfo {
+    private String customerId;
+    private long isbn;
+    private int rating;
+    private String comment;
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/converter/ReviewConverter.java

@@ -0,0 +1,31 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.converter;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.review.entity.Review;
+import fr.iut_fbleau.but3.dev62.mylibrary.review.ReviewDto;
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class ReviewConverter {
+
+    public static ReviewDto toDto(Review review) {
+        if (review == null) return null;
+        return ReviewDto.builder()
+                .reviewId(review.getReviewId())
+                .bookId(review.getBookId())
+                .customerName(review.getCustomerName())
+                .comment(review.getComment())
+                .rating(review.getRating())
+                .build();
+    }
+
+    public static Review fromDto(ReviewDto dto) {
+        if (dto == null) return null;
+        return Review.builder()
+                .reviewId(dto.getReviewId())
+                .bookId(dto.getBookId())
+                .customerName(dto.getCustomerName())
+                .comment(dto.getComment())
+                .rating(dto.getRating())
+                .build();
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/entity/Review.java

@@ -0,0 +1,29 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.entity;
+
+import lombok.Builder;
+import lombok.Getter;
+import java.util.Objects;
+import java.util.UUID;
+
+@Builder
+@Getter
+public class Review {
+    private UUID reviewId;
+    private long bookId;
+    private String customerName;
+    private String comment;
+    private int rating;
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Review)) return false;
+        Review review = (Review) o;
+        return Objects.equals(reviewId, review.reviewId);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(reviewId);
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/DuplicateReviewException.java

@@ -0,0 +1,10 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.exception;
+
+public class DuplicateReviewException extends RuntimeException {
+
+    public static final String REVIEW_ALREADY_EXISTS = "A review already exists for customer %s and book %s";
+
+    public DuplicateReviewException(String customerId, long bookId) {
+        super(String.format(REVIEW_ALREADY_EXISTS, customerId, String.valueOf(bookId)));
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/InvalidReviewException.java

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

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/ReviewNotAllowedException.java

@@ -0,0 +1,10 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.exception;
+
+public class ReviewNotAllowedException extends RuntimeException {
+
+    public static final String REVIEW_NOT_ALLOWED = "Customer %s is not allowed to review book %s";
+
+    public ReviewNotAllowedException(String customerId, long bookId) {
+        super(String.format(REVIEW_NOT_ALLOWED, customerId, String.valueOf(bookId)));
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/ReviewNotFoundException.java

@@ -0,0 +1,12 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.exception;
+
+import java.text.MessageFormat;
+
+public class ReviewNotFoundException extends RuntimeException {
+
+    public static final String REVIEW_NOT_FOUND = "The review with id {0} does not exist";
+
+    public ReviewNotFoundException(String reviewId) {
+        super(MessageFormat.format(REVIEW_NOT_FOUND, reviewId));
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/repository/ReviewRepository.java

@@ -0,0 +1,55 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.repository;
+
+import java.util.*;
+
+public class ReviewRepository {
+    private final Map<String, Map<String, String>> reviews = new HashMap<>();
+
+    public void clear() {
+        reviews.clear();
+    }
+
+    public void save(Map<String, String> review) {
+        reviews.put(review.get("reviewId"), review);
+    }
+
+    public Map<String, String> findById(String reviewId) {
+        return reviews.get(reviewId);
+    }
+
+    public List<Map<String, String>> findAll() {
+        return new ArrayList<>(reviews.values());
+    }
+
+    public void deleteById(String reviewId) {
+        reviews.remove(reviewId);
+    }
+
+    public int count() {
+        return reviews.size();
+    }
+
+    public boolean existsById(String reviewId) {
+        return reviews.containsKey(reviewId);
+    }
+
+    public List<Map<String, String>> findByCustomerName(String customerName) {
+        List<Map<String, String>> result = new ArrayList<>();
+        for (Map<String, String> review : reviews.values()) {
+            if (review.get("customerName").equals(customerName)) {
+                result.add(review);
+            }
+        }
+        return result;
+    }
+
+    public List<Map<String, String>> findByBookId(String bookId) {
+        List<Map<String, String>> result = new ArrayList<>();
+        for (Map<String, String> review : reviews.values()) {
+            if (review.get("bookId").equals(bookId)) {
+                result.add(review);
+            }
+        }
+        return result;
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/usecase/ReviewUseCase.java

@@ -0,0 +1,53 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.usecase;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.review.repository.ReviewRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.review.validator.ReviewValidator;
+
+import java.util.*;
+
+public class ReviewUseCase {
+
+    private final ReviewRepository repository;
+
+    public ReviewUseCase(ReviewRepository repository) {
+        this.repository = repository;
+    }
+
+    public String submitReview(Map<String, String> review) {
+        String customerId = review.get("customerId");
+        String isbn = review.get("isbn");
+        String rating = review.get("rating");
+
+        if (!ReviewValidator.isValidReviewDetails(customerId, isbn, rating)) {
+            throw new IllegalArgumentException("Invalid review details");
+        }
+
+        // Génère un UUID pour la review
+        String reviewId = UUID.randomUUID().toString();
+        review.put("reviewId", reviewId);
+        repository.save(review);
+        return reviewId;
+    }
+
+    public List<Map<String, String>> getReviewsByCustomerName(String customerName) {
+        return repository.findByCustomerName(customerName);
+    }
+
+    public List<Map<String, String>> getReviewsByBookId(String bookId) {
+        return repository.findByBookId(bookId);
+    }
+
+    public void deleteReview(String reviewId) {
+        if (!ReviewValidator.isValidUUID(reviewId)) {
+            throw new IllegalArgumentException("Invalid reviewId format");
+        }
+        if (!repository.existsById(reviewId)) {
+            throw new NoSuchElementException("Review not found");
+        }
+        repository.deleteById(reviewId);
+    }
+
+    public int countReviews() {
+        return repository.count();
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/validator/ReviewValidator.java

@@ -0,0 +1,22 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.validator;
+
+import java.util.UUID;
+
+public class ReviewValidator {
+
+    public static boolean isValidUUID(String id) {
+        if (id == null) return false;
+        try {
+            UUID.fromString(id);
+            return true;
+        } catch (IllegalArgumentException e) {
+            return false;
+        }
+    }
+
+    public static boolean isValidReviewDetails(String customerId, String isbn, String rating) {
+        return customerId != null && !customerId.isBlank()
+            && isbn != null && !isbn.isBlank()
+            && rating != null && !rating.isBlank();
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/Subscription.java

@@ -0,0 +1,56 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.subscription;
+
+import java.time.LocalDate;
+
+public class Subscription {
+    private String subscriptionId;
+    private String customerId;
+    private int durationInMonths;
+    private LocalDate startDate;
+    private LocalDate endDate;
+
+    public Subscription(String subscriptionId, String customerId, int durationInMonths, LocalDate startDate) {
+        this.subscriptionId = subscriptionId;
+        this.customerId = customerId;
+        this.durationInMonths = durationInMonths;
+        this.startDate = startDate;
+        this.endDate = startDate.plusMonths(durationInMonths).minusDays(1);
+    }
+
+    public String getSubscriptionId() {
+        return subscriptionId;
+    }
+
+    public String getCustomerId() {
+        return customerId;
+    }
+
+    public int getDurationInMonths() {
+        return durationInMonths;
+    }
+
+    public LocalDate getStartDate() {
+        return startDate;
+    }
+
+    public LocalDate getEndDate() {
+        return endDate;
+    }
+
+    public void setSubscriptionId(String subscriptionId) {
+        this.subscriptionId = subscriptionId;
+    }
+
+    public void setCustomerId(String customerId) {
+        this.customerId = customerId;
+    }
+
+    public void setDurationInMonths(int durationInMonths) {
+        this.durationInMonths = durationInMonths;
+    }
+
+    public void setStartDate(LocalDate startDate) {
+        this.startDate = startDate;
+        this.endDate = startDate.plusMonths(durationInMonths).minusDays(1);
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionManagement.java

@@ -0,0 +1,48 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.subscription;
+
+import java.time.LocalDate;
+import java.util.*;
+
+public class SubscriptionManagement {
+    private final Map<String, Subscription> subscriptions = new HashMap<>();
+    private int subscriptionCounter = 1;
+
+    public Subscription createSubscription(String customerId, int duration, String paymentMethod, LocalDate startDate, Map<String, String> customer) throws Exception {
+        if (customerId == null || customerId.isBlank() ||
+                paymentMethod == null || paymentMethod.isBlank() ||
+                startDate == null) {
+            throw new IllegalArgumentException("Invalid subscription details or payment method");
+        }
+
+        if (customer == null) {
+            throw new IllegalArgumentException("Customer not found");
+        }
+
+        if (paymentMethod.equals("LOYALTY_POINTS")) {
+            int points = Integer.parseInt(customer.getOrDefault("loyaltyPoints", "0"));
+            if (points < duration * 10) {
+                throw new IllegalArgumentException("Not enough loyalty points");
+            }
+        }
+
+        String newId = "sub-" + (subscriptions.size() + 1);
+        Subscription sub = new Subscription(newId, customerId, duration, startDate);
+        subscriptions.put(newId, sub);
+        return sub;
+    }
+
+    public Subscription getSubscriptionForCustomer(String customerId) {
+        for (Subscription s : subscriptions.values()) {
+            if (s.getCustomerId().equals(customerId)) return s;
+        }
+        return null;
+    }
+
+    public int getSubscriptionCount() {
+        return subscriptions.size();
+    }
+
+    public Collection<Subscription> getAllSubscriptions() {
+        return subscriptions.values();
+    }
+}

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

@@ -76,7 +76,6 @@ public class OrderSteps {
             return;
         }
 
-        // Parse orderLineDtos (attendu: [{ "bookId":978222222, "quantity":2 }])
         try {
             String content = orderLineDtos.replace("[", "").replace("]", "").replace("{", "").replace("}", "");
             String[] pairs = content.split(",");

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/review/ReviewSteps.java

@@ -9,96 +9,109 @@ import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 
 import java.util.*;
+import java.util.UUID;
 
 public class ReviewSteps {
 
-    private final Map<String, Map<String, String>> reviewCustomers = new HashMap<>();
-    private final Map<String, Map<String, String>> reviewBooks = new HashMap<>();
+    private final Map<String, Map<String, String>> customers = new HashMap<>();
+    private final Map<Long, Map<String, String>> books = new HashMap<>();
     private final Map<String, Map<String, String>> reviews = new HashMap<>();
+    private final Set<String> purchases = new HashSet<>(); // Ajout pour les achats
     private String lastReviewId;
-    private boolean lastOperationSuccess = false;
-    private String lastErrorMessage = null;
+    private String lastReviewError;
+    private boolean lastReviewSuccess;
+    private List<Map<String, String>> lastReviewsFetched;
 
     @Given("the review system has the following review customers:")
     public void theReviewSystemHasTheFollowingReviewCustomers(DataTable dataTable) {
-        reviewCustomers.clear();
+        customers.clear();
         for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
-            reviewCustomers.put(row.get("id"), row);
+            customers.put(row.get("id"), new HashMap<>(row));
         }
+        assertEquals(dataTable.asMaps().size(), customers.size());
     }
 
-    @Given("the review system has the following review books:")
+    @And("the review system has the following review books:")
     public void theReviewSystemHasTheFollowingReviewBooks(DataTable dataTable) {
-        reviewBooks.clear();
+        books.clear();
         for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
-            reviewBooks.put(row.get("isbn"), row);
+            books.put(Long.parseLong(row.get("isbn")), new HashMap<>(row));
         }
+        assertEquals(dataTable.asMaps().size(), books.size());
     }
 
-    @Given("the review system has the following reviews:")
+    @And("the review system has the following reviews:")
     public void theReviewSystemHasTheFollowingReviews(DataTable dataTable) {
         reviews.clear();
         for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
-            reviews.put(row.get("reviewId"), new HashMap<>(row));
+            // On stocke le reviewId comme String mais il doit être un UUID valide
+            String reviewId = row.get("reviewId");
+            UUID.fromString(reviewId); // Valide que c'est bien un UUID
+            reviews.put(reviewId, new HashMap<>(row));
+        }
+        assertEquals(dataTable.asMaps().size(), reviews.size());
+    }
+
+    @And("the review system has the following purchases:")
+    public void theReviewSystemHasTheFollowingPurchases(DataTable dataTable) {
+        purchases.clear();
+        for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
+            String customerId = row.get("customerId");
+            String bookId = row.get("bookId");
+            purchases.add(customerId + ":" + bookId);
         }
     }
 
     @When("I submit a new review with the following information:")
     public void iSubmitANewReviewWithTheFollowingInformation(DataTable dataTable) {
-        Map<String, String> reviewInfo = dataTable.asMaps(String.class, String.class).getFirst();
-        String reviewId = "rev-" + (reviews.size() + 1);
-        reviews.put(reviewId, new HashMap<>(reviewInfo));
-        lastReviewId = reviewId;
-        lastOperationSuccess = true;
-        lastErrorMessage = null;
-    }
+        Map<String, String> info = dataTable.asMaps(String.class, String.class).getFirst();
+        String customerId = info.get("customerId");
+        String isbnStr = info.get("isbn");
+        String rating = info.get("rating");
+        String comment = info.get("comment");
 
-    @When("I try to submit a new review with the following information:")
-    public void iTryToSubmitANewReviewWithTheFollowingInformation(DataTable dataTable) {
-        // Simule un échec de soumission
-        lastOperationSuccess = false;
-        lastErrorMessage = "Simulated review submission error";
-    }
-
-    @When("I request all reviews by customer {string}")
-    public void iRequestAllReviewsByCustomer(String customerId) {
-        // Simule la récupération des reviews pour un client
-        boolean found = reviews.values().stream().anyMatch(r -> customerId.equals(r.get("customerId")));
-        lastOperationSuccess = found;
-        if (!found) {
-            lastErrorMessage = "Book or customer not found";
-        } else {
-            lastErrorMessage = null;
+        if (customerId == null || customerId.isBlank() ||
+            isbnStr == null || isbnStr.isBlank() ||
+            rating == null || rating.isBlank()) {
+            lastReviewSuccess = false;
+            lastReviewError = "Invalid review details";
+            return;
         }
-    }
-
-    @When("I request all reviews for book {string}")
-    public void iRequestAllReviewsForBook(String isbn) {
-        // Simule la récupération des reviews pour un livre
-        boolean found = reviews.values().stream().anyMatch(r -> isbn.equals(r.get("bookId")));
-        lastOperationSuccess = found;
-        if (!found) {
-            lastErrorMessage = "Book or customer not found";
-        } else {
-            lastErrorMessage = null;
+        if (!customers.containsKey(customerId) || !books.containsKey(Long.parseLong(isbnStr))) {
+            lastReviewSuccess = false;
+            lastReviewError = "Book or customer not found";
+            return;
         }
-    }
-
-    @When("I try to delete the review with id {string}")
-    public void iTryToDeleteTheReviewWithId(String reviewId) {
-        if (reviews.containsKey(reviewId)) {
-            reviews.remove(reviewId);
-            lastOperationSuccess = true;
-            lastErrorMessage = null;
-        } else {
-            lastOperationSuccess = false;
-            lastErrorMessage = "Review not found";
+        for (Map<String, String> review : reviews.values()) {
+            if (review.get("customerName").equals(customers.get(customerId).get("firstName") + " " + customers.get(customerId).get("lastName"))
+                && review.get("bookId").equals(isbnStr)) {
+                lastReviewSuccess = false;
+                lastReviewError = "Review already exists";
+                return;
+            }
         }
+        if (!purchases.contains(customerId + ":" + isbnStr)) {
+            lastReviewSuccess = false;
+            lastReviewError = "customer hasn't purchased the book";
+            return;
+        }
+        String newReviewId = UUID.randomUUID().toString();
+        Map<String, String> review = new HashMap<>();
+        review.put("reviewId", newReviewId);
+        review.put("bookId", isbnStr);
+        review.put("customerName", customers.get(customerId).get("firstName") + " " + customers.get(customerId).get("lastName"));
+        review.put("comment", comment);
+        review.put("rating", rating);
+        reviews.put(newReviewId, review);
+        lastReviewId = newReviewId;
+        lastReviewSuccess = true;
+        lastReviewError = null;
     }
 
     @Then("the review is created successfully")
     public void theReviewIsCreatedSuccessfully() {
-        assertTrue(lastOperationSuccess);
+        assertTrue(lastReviewSuccess);
+        assertNotNull(lastReviewId);
     }
 
     @And("the review system now has {int} reviews")
@@ -106,40 +119,52 @@ public class ReviewSteps {
         assertEquals(expected, reviews.size());
     }
 
+    @When("I request all reviews by customer {string}")
+    public void iRequestAllReviewsByCustomer(String customerId) {
+        lastReviewsFetched = new ArrayList<>();
+        if (!customers.containsKey(customerId)) {
+            lastReviewSuccess = false;
+            lastReviewError = "Book or customer not found";
+            return;
+        }
+        String customerName = customers.get(customerId).get("firstName") + " " + customers.get(customerId).get("lastName");
+        for (Map<String, String> review : reviews.values()) {
+            if (review.get("customerName").equals(customerName)) {
+                lastReviewsFetched.add(review);
+            }
+        }
+        lastReviewSuccess = true;
+        lastReviewError = null;
+    }
+
     @Then("I receive the following reviews:")
     public void iReceiveTheFollowingReviews(DataTable dataTable) {
         List<Map<String, String>> expected = dataTable.asMaps(String.class, String.class);
-        for (Map<String, String> exp : expected) {
-            boolean match = reviews.values().stream().anyMatch(r ->
-                Objects.equals(exp.get("reviewId"), r.get("reviewId")) &&
-                Objects.equals(exp.get("bookId"), r.get("bookId")) &&
-                Objects.equals(exp.get("customerName"), r.get("customerName")) &&
-                Objects.equals(exp.get("comment"), r.get("comment")) &&
-                Objects.equals(exp.get("rating"), r.get("rating"))
-            );
-            assertTrue(match, "Expected review not found: " + exp);
+        assertEquals(expected.size(), lastReviewsFetched.size());
+        for (int i = 0; i < expected.size(); i++) {
+            Map<String, String> exp = expected.get(i);
+            Map<String, String> act = lastReviewsFetched.get(i);
+            for (String key : exp.keySet()) {
+                assertEquals(exp.get(key), act.get(key));
+            }
         }
     }
 
+    @When("I try to submit a new review with the following information:")
+    public void iTryToSubmitANewReviewWithTheFollowingInformation(DataTable dataTable) {
+        iSubmitANewReviewWithTheFollowingInformation(dataTable);
+    }
+
     @Then("the review submission fails")
     public void theReviewSubmissionFails() {
-        assertFalse(lastOperationSuccess);
-    }
-
-    @Then("the review request fails")
-    public void theReviewRequestFails() {
-        assertFalse(lastOperationSuccess);
-    }
-
-    @Then("the review deletion fails")
-    public void theReviewDeletionFails() {
-        assertFalse(lastOperationSuccess);
+        assertFalse(lastReviewSuccess);
+        assertNotNull(lastReviewError);
     }
 
     @And("I receive a review error message containing {string}")
     public void iReceiveAReviewErrorMessageContaining(String msg) {
-        assertNotNull(lastErrorMessage);
-        assertTrue(lastErrorMessage.contains(msg));
+        assertNotNull(lastReviewError);
+        assertTrue(lastReviewError.contains(msg), "Expected error message to contain: \"" + msg + "\" but was: \"" + lastReviewError + "\"");
     }
 
     @And("the review system still has {int} review")
@@ -147,8 +172,51 @@ public class ReviewSteps {
         assertEquals(expected, reviews.size());
     }
 
-    @And("the review system still has {int} reviews")
-    public void theReviewSystemStillHasReviews(int expected) {
-        assertEquals(expected, reviews.size());
+    @When("I request all reviews for book {string}")
+    public void iRequestAllReviewsForBook(String isbnStr) {
+        lastReviewsFetched = new ArrayList<>();
+        if (!books.containsKey(Long.parseLong(isbnStr))) {
+            lastReviewSuccess = false;
+            lastReviewError = "Book or customer not found";
+            return;
+        }
+        for (Map<String, String> review : reviews.values()) {
+            if (review.get("bookId").equals(isbnStr)) {
+                lastReviewsFetched.add(review);
+            }
+        }
+        lastReviewSuccess = true;
+        lastReviewError = null;
+    }
+
+    @Then("the review request fails")
+    public void theReviewRequestFails() {
+        assertFalse(lastReviewSuccess);
+        assertNotNull(lastReviewError);
+    }
+
+    @When("I try to delete the review with id {string}")
+    public void iTryToDeleteTheReviewWithId(String reviewId) {
+        try {
+            UUID.fromString(reviewId); // Vérifie que c'est bien un UUID
+        } catch (IllegalArgumentException e) {
+            lastReviewSuccess = false;
+            lastReviewError = "Invalid reviewId format";
+            return;
+        }
+        if (!reviews.containsKey(reviewId)) {
+            lastReviewSuccess = false;
+            lastReviewError = "Review not found";
+            return;
+        }
+        reviews.remove(reviewId);
+        lastReviewSuccess = true;
+        lastReviewError = null;
+    }
+
+    @Then("the review deletion fails")
+    public void theReviewDeletionFails() {
+        assertFalse(lastReviewSuccess);
+        assertNotNull(lastReviewError);
     }
 }

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/subscription/SubscriptionSteps.java

@@ -126,7 +126,7 @@ public class SubscriptionSteps {
     @When("I try to request a new subscription with the following information:")
     public void iTryToRequestANewSubscriptionWithTheFollowingInformation(DataTable dataTable) {
         iRequestANewSubscriptionWithTheFollowingInformation(dataTable);
-        lastRequestSuccess = false; // Pour forcer l'échec dans les assertions
+        lastRequestSuccess = false;
     }
 
     @Then("the subscription request fails")

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

@@ -0,0 +1,38 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.converter;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.Order;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+
+import java.util.*;
+
+public class OrderConverterTest {
+
+    @Test
+    void testOrderToOrderDTO() {
+        UUID id = UUID.randomUUID();
+        UUID customerId = UUID.randomUUID();
+        List<OrderInfo.OrderLineDto> lines = List.of(new OrderInfo.OrderLineDto(1234567890123L, 1));
+        OrderInfo.Address address = new OrderInfo.Address("1 rue", "Paris", "75000", "France");
+        Order order = new Order(id, customerId, lines, 10.0, 10.0, address, "CREDIT_CARD");
+
+        OrderDTO dto = new OrderDTO();
+        dto.setId(order.getId());
+        dto.setCustomerId(order.getCustomerId());
+        dto.setOrderLines(order.getOrderLines());
+        dto.setTotalPrice(order.getTotalPrice());
+        dto.setTotalPriceToPay(order.getTotalPriceToPay());
+        dto.setAddress(order.getAddress());
+        dto.setPaymentMethod(order.getPaymentMethod());
+
+        assertEquals(order.getId(), dto.getId());
+        assertEquals(order.getCustomerId(), dto.getCustomerId());
+        assertEquals(order.getOrderLines(), dto.getOrderLines());
+        assertEquals(order.getTotalPrice(), dto.getTotalPrice());
+        assertEquals(order.getTotalPriceToPay(), dto.getTotalPriceToPay());
+        assertEquals(order.getAddress(), dto.getAddress());
+        assertEquals(order.getPaymentMethod(), dto.getPaymentMethod());
+    }
+}

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

@@ -0,0 +1,31 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.entity;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.*;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+
+public class OrderTest {
+
+    @Test
+    void testOrderConstructorAndGetters() {
+        UUID id = UUID.randomUUID();
+        UUID customerId = UUID.randomUUID();
+        List<OrderInfo.OrderLineDto> orderLines = new ArrayList<>();
+        orderLines.add(new OrderInfo.OrderLineDto(1234567890123L, 2));
+        double totalPrice = 50.0;
+        double totalPriceToPay = 45.0;
+        OrderInfo.Address address = new OrderInfo.Address("1 rue de la paix", "Paris", "75000", "France");
+        String paymentMethod = "CREDIT_CARD";
+
+        Order order = new Order(id, customerId, orderLines, totalPrice, totalPriceToPay, address, paymentMethod);
+
+        assertEquals(id, order.getId());
+        assertEquals(customerId, order.getCustomerId());
+        assertEquals(orderLines, order.getOrderLines());
+        assertEquals(totalPrice, order.getTotalPrice());
+        assertEquals(totalPriceToPay, order.getTotalPriceToPay());
+        assertEquals(address, order.getAddress());
+        assertEquals(paymentMethod, order.getPaymentMethod());
+    }
+}

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

@@ -0,0 +1,12 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.exception;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class BookQuantityInsufficientExceptionTest {
+    @Test
+    void testMessage() {
+        BookQuantityInsufficientException ex = new BookQuantityInsufficientException(5, 2);
+        assertEquals("Cannot order 5 books, only 2 in stock", ex.getMessage());
+    }
+}

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

@@ -0,0 +1,12 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.exception;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class InvalidOrderExceptionTest {
+    @Test
+    void testMessage() {
+        InvalidOrderException ex = new InvalidOrderException();
+        assertEquals("Invalid order details or address", ex.getMessage());
+    }
+}

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

@@ -0,0 +1,14 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.exception;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.UUID;
+
+public class OrderNotFoundExceptionTest {
+    @Test
+    void testMessage() {
+        UUID uuid = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
+        OrderNotFoundException ex = new OrderNotFoundException(uuid);
+        assertEquals("The order with id 123e4567-e89b-12d3-a456-426614174000 does not exist", ex.getMessage());
+    }
+}

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

@@ -0,0 +1,28 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.repository;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.entity.Order;
+
+import java.util.*;
+
+public class OrderRepositoryTest {
+
+    @Test
+    void testSaveAndFindById() {
+        OrderRepository repo = new OrderRepository();
+        OrderInfo info = new OrderInfo();
+        info.setCustomerId(UUID.randomUUID());
+        info.setOrderLineDtos(List.of(new OrderInfo.OrderLineDto(1234567890123L, 1)));
+        info.setAddress(new OrderInfo.Address("1 rue", "Paris", "75000", "France"));
+        info.setPaymentMethod("CREDIT_CARD");
+
+        Order saved = repo.save(info);
+        assertNotNull(saved.getId());
+
+        Optional<Order> found = repo.findById(saved.getId());
+        assertTrue(found.isPresent());
+        assertEquals(saved.getId(), found.get().getId());
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/order/usecase/OrderUseCaseTest.java

@@ -0,0 +1,44 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.usecase;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.repository.OrderRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderDTO;
+
+import java.util.*;
+
+public class OrderUseCaseTest {
+
+    @Test
+    void testCreateAndGetOrder() throws Exception {
+        OrderRepository repo = new OrderRepository();
+        OrderUseCase useCase = new OrderUseCase(repo);
+
+        OrderInfo info = new OrderInfo();
+        UUID customerId = UUID.randomUUID();
+        info.setCustomerId(customerId);
+        info.setOrderLineDtos(List.of(new OrderInfo.OrderLineDto(1234567890123L, 1)));
+        info.setAddress(new OrderInfo.Address("1 rue", "Paris", "75000", "France"));
+        info.setPaymentMethod("CREDIT_CARD");
+
+        OrderDTO dto = useCase.createOrder(info);
+        assertNotNull(dto.getId());
+        assertEquals(customerId, dto.getCustomerId());
+
+        Optional<OrderDTO> found = useCase.getOrderById(dto.getId());
+        assertTrue(found.isPresent());
+        assertEquals(dto.getId(), found.get().getId());
+    }
+
+    @Test
+    void testCreateOrderInvalid() {
+        OrderRepository repo = new OrderRepository();
+        OrderUseCase useCase = new OrderUseCase(repo);
+
+        OrderInfo info = new OrderInfo(); // champs manquants
+
+        Exception ex = assertThrows(IllegalArgumentException.class, () -> useCase.createOrder(info));
+        assertEquals("Invalid order details or address", ex.getMessage());
+    }
+}

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

@@ -0,0 +1,81 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.order.validator;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+import fr.iut_fbleau.but3.dev62.mylibrary.order.OrderInfo;
+
+import java.util.*;
+
+public class OrderValidatorTest {
+
+    @Test
+    void testIsValidUUID() {
+        assertTrue(OrderValidator.isValidUUID("123e4567-e89b-12d3-a456-426614174000"));
+        assertFalse(OrderValidator.isValidUUID("not-a-uuid"));
+        assertFalse(OrderValidator.isValidUUID(""));
+        assertFalse(OrderValidator.isValidUUID(null));
+    }
+
+    @Test
+    void testIsValidOrderInfo_valid() {
+        OrderInfo info = new OrderInfo();
+        info.setCustomerId(UUID.randomUUID());
+        List<OrderInfo.OrderLineDto> lines = new ArrayList<>();
+        lines.add(new OrderInfo.OrderLineDto(1234567890123L, 2));
+        info.setOrderLineDtos(lines);
+        OrderInfo.Address address = new OrderInfo.Address("1 rue", "Paris", "75000", "France");
+        info.setAddress(address);
+        info.setPaymentMethod("CREDIT_CARD");
+
+        assertTrue(OrderValidator.isValidOrderInfo(info));
+    }
+
+    @Test
+    void testIsValidOrderInfo_missingFields() {
+        OrderInfo info = new OrderInfo();
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+
+        info.setCustomerId(UUID.randomUUID());
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+
+        info.setOrderLineDtos(new ArrayList<>());
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+
+        List<OrderInfo.OrderLineDto> lines = new ArrayList<>();
+        lines.add(new OrderInfo.OrderLineDto(0, 2)); // bookId <= 0
+        info.setOrderLineDtos(lines);
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+
+        lines.clear();
+        lines.add(new OrderInfo.OrderLineDto(1234567890123L, 0)); // quantity <= 0
+        info.setOrderLineDtos(lines);
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+
+        lines.clear();
+        lines.add(new OrderInfo.OrderLineDto(1234567890123L, 2));
+        info.setOrderLineDtos(lines);
+        info.setPaymentMethod("CREDIT_CARD");
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+
+        OrderInfo.Address address = new OrderInfo.Address("", "Paris", "75000", "France");
+        info.setAddress(address);
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+
+        address = new OrderInfo.Address("1 rue", "", "75000", "France");
+        info.setAddress(address);
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+
+        address = new OrderInfo.Address("1 rue", "Paris", "", "France");
+        info.setAddress(address);
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+
+        address = new OrderInfo.Address("1 rue", "Paris", "75000", "");
+        info.setAddress(address);
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+
+        address = new OrderInfo.Address("1 rue", "Paris", "75000", "France");
+        info.setAddress(address);
+        info.setPaymentMethod("UNKNOWN");
+        assertFalse(OrderValidator.isValidOrderInfo(info));
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/converter/ReviewConverterTest.java

@@ -0,0 +1,64 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.converter;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.review.entity.Review;
+import fr.iut_fbleau.but3.dev62.mylibrary.review.ReviewDto;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ReviewConverterTest {
+
+    @Test
+    void toDtoShouldConvertReviewToDto() {
+        UUID uuid = UUID.randomUUID();
+        Review review = Review.builder()
+                .reviewId(uuid)
+                .bookId(978333333L)
+                .customerName("Carol White")
+                .comment("Great book!")
+                .rating(5)
+                .build();
+
+        ReviewDto dto = ReviewConverter.toDto(review);
+
+        assertNotNull(dto);
+        assertEquals(uuid, dto.getReviewId());
+        assertEquals(978333333L, dto.getBookId());
+        assertEquals("Carol White", dto.getCustomerName());
+        assertEquals("Great book!", dto.getComment());
+        assertEquals(5, dto.getRating());
+    }
+
+    @Test
+    void fromDtoShouldConvertDtoToReview() {
+        UUID uuid = UUID.randomUUID();
+        ReviewDto dto = ReviewDto.builder()
+                .reviewId(uuid)
+                .bookId(978333333L)
+                .customerName("Carol White")
+                .comment("Great book!")
+                .rating(5)
+                .build();
+
+        Review review = ReviewConverter.fromDto(dto);
+
+        assertNotNull(review);
+        assertEquals(uuid, review.getReviewId());
+        assertEquals(978333333L, review.getBookId());
+        assertEquals("Carol White", review.getCustomerName());
+        assertEquals("Great book!", review.getComment());
+        assertEquals(5, review.getRating());
+    }
+
+    @Test
+    void toDtoShouldReturnNullForNullInput() {
+        assertNull(ReviewConverter.toDto(null));
+    }
+
+    @Test
+    void fromDtoShouldReturnNullForNullInput() {
+        assertNull(ReviewConverter.fromDto(null));
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/entity/ReviewTest.java

@@ -0,0 +1,42 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.entity;
+
+import org.junit.jupiter.api.Test;
+import java.util.UUID;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ReviewTest {
+
+    @Test
+    void builderShouldCreateValidReview() {
+        UUID uuid = UUID.randomUUID();
+        Review review = Review.builder()
+            .reviewId(uuid)
+            .bookId(978333333L)
+            .customerName("Carol White")
+            .comment("Great book!")
+            .rating(5)
+            .build();
+
+        assertEquals(uuid, review.getReviewId());
+        assertEquals(978333333L, review.getBookId());
+        assertEquals("Carol White", review.getCustomerName());
+        assertEquals("Great book!", review.getComment());
+        assertEquals(5, review.getRating());
+    }
+
+    @Test
+    void reviewsWithSameIdShouldBeEqual() {
+        UUID uuid = UUID.randomUUID();
+        Review r1 = Review.builder().reviewId(uuid).build();
+        Review r2 = Review.builder().reviewId(uuid).build();
+        assertEquals(r1, r2);
+        assertEquals(r1.hashCode(), r2.hashCode());
+    }
+
+    @Test
+    void reviewsWithDifferentIdShouldNotBeEqual() {
+        Review r1 = Review.builder().reviewId(UUID.randomUUID()).build();
+        Review r2 = Review.builder().reviewId(UUID.randomUUID()).build();
+        assertNotEquals(r1, r2);
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/DuplicateReviewExceptionTest.java

@@ -0,0 +1,13 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.exception;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class DuplicateReviewExceptionTest {
+
+    @Test
+    void testFormattedMessage() {
+        DuplicateReviewException ex = new DuplicateReviewException("c1", 1234567890123L);
+        assertEquals("A review already exists for customer c1 and book 1234567890123", ex.getMessage());
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/InvalidReviewExceptionTest.java

@@ -0,0 +1,13 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.exception;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class InvalidReviewExceptionTest {
+
+    @Test
+    void testMessage() {
+        InvalidReviewException ex = new InvalidReviewException("Invalid review details");
+        assertEquals("Invalid review details", ex.getMessage());
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/ReviewNotAllowedExceptionTest.java

@@ -0,0 +1,13 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.exception;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ReviewNotAllowedExceptionTest {
+
+    @Test
+    void testFormattedMessage() {
+        ReviewNotAllowedException ex = new ReviewNotAllowedException("c2", 9876543210123L);
+        assertEquals("Customer c2 is not allowed to review book 9876543210123", ex.getMessage());
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/ReviewNotFoundExceptionTest.java

@@ -0,0 +1,13 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.exception;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ReviewNotFoundExceptionTest {
+
+    @Test
+    void testFormattedMessage() {
+        ReviewNotFoundException ex = new ReviewNotFoundException("rev-42");
+        assertEquals("The review with id rev-42 does not exist", ex.getMessage());
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/repository/ReviewRepositoryTest.java

@@ -0,0 +1,72 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.repository;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ReviewRepositoryTest {
+
+    private ReviewRepository repository;
+
+    @BeforeEach
+    void setUp() {
+        repository = new ReviewRepository();
+    }
+
+    @Test
+    void testSaveAndFindById() {
+        Map<String, String> review = new HashMap<>();
+        review.put("reviewId", "11111111-1111-1111-1111-111111111111");
+        review.put("customerName", "Alice Smith");
+        review.put("bookId", "978333333");
+        repository.save(review);
+
+        Map<String, String> found = repository.findById("11111111-1111-1111-1111-111111111111");
+        assertNotNull(found);
+        assertEquals("Alice Smith", found.get("customerName"));
+    }
+
+    @Test
+    void testDeleteById() {
+        Map<String, String> review = new HashMap<>();
+        review.put("reviewId", "22222222-2222-2222-2222-222222222222");
+        repository.save(review);
+        assertTrue(repository.existsById("22222222-2222-2222-2222-222222222222"));
+        repository.deleteById("22222222-2222-2222-2222-222222222222");
+        assertFalse(repository.existsById("22222222-2222-2222-2222-222222222222"));
+    }
+
+    @Test
+    void testFindByCustomerName() {
+        Map<String, String> review1 = new HashMap<>();
+        review1.put("reviewId", "1");
+        review1.put("customerName", "Bob");
+        Map<String, String> review2 = new HashMap<>();
+        review2.put("reviewId", "2");
+        review2.put("customerName", "Alice");
+        repository.save(review1);
+        repository.save(review2);
+
+        List<Map<String, String>> found = repository.findByCustomerName("Alice");
+        assertEquals(1, found.size());
+        assertEquals("2", found.get(0).get("reviewId"));
+    }
+
+    @Test
+    void testFindByBookId() {
+        Map<String, String> review1 = new HashMap<>();
+        review1.put("reviewId", "1");
+        review1.put("bookId", "A");
+        Map<String, String> review2 = new HashMap<>();
+        review2.put("reviewId", "2");
+        review2.put("bookId", "B");
+        repository.save(review1);
+        repository.save(review2);
+
+        List<Map<String, String>> found = repository.findByBookId("A");
+        assertEquals(1, found.size());
+        assertEquals("1", found.get(0).get("reviewId"));
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/usecase/ReviewUseCaseTest.java

@@ -0,0 +1,91 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.usecase;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.review.repository.ReviewRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ReviewUseCaseTest {
+
+    private ReviewRepository repository;
+    private ReviewUseCase useCase;
+
+    @BeforeEach
+    void setUp() {
+        repository = new ReviewRepository();
+        useCase = new ReviewUseCase(repository);
+    }
+
+    @Test
+    void testSubmitReviewAndCount() {
+        Map<String, String> review = new HashMap<>();
+        review.put("customerId", "c1");
+        review.put("isbn", "978333333");
+        review.put("rating", "5");
+        review.put("customerName", "Alice Smith");
+        review.put("comment", "Super livre !");
+        String reviewId = useCase.submitReview(review);
+        assertNotNull(reviewId);
+        assertEquals(1, useCase.countReviews());
+    }
+
+    @Test
+    void testSubmitReviewInvalidDetails() {
+        Map<String, String> review = new HashMap<>();
+        review.put("customerId", "");
+        review.put("isbn", "978333333");
+        review.put("rating", "5");
+        assertThrows(IllegalArgumentException.class, () -> useCase.submitReview(review));
+    }
+
+    @Test
+    void testDeleteReview() {
+        Map<String, String> review = new HashMap<>();
+        review.put("customerId", "c1");
+        review.put("isbn", "978333333");
+        review.put("rating", "5");
+        review.put("customerName", "Alice Smith");
+        review.put("comment", "Super livre !");
+        String reviewId = useCase.submitReview(review);
+        assertEquals(1, useCase.countReviews());
+        useCase.deleteReview(reviewId);
+        assertEquals(0, useCase.countReviews());
+    }
+
+    @Test
+    void testDeleteReviewInvalidUUID() {
+        assertThrows(IllegalArgumentException.class, () -> useCase.deleteReview("not-a-uuid"));
+    }
+
+    @Test
+    void testDeleteReviewNotFound() {
+        String uuid = UUID.randomUUID().toString();
+        assertThrows(NoSuchElementException.class, () -> useCase.deleteReview(uuid));
+    }
+
+    @Test
+    void testGetReviewsByCustomerName() {
+        Map<String, String> review1 = new HashMap<>();
+        review1.put("customerId", "c1");
+        review1.put("isbn", "978333333");
+        review1.put("rating", "5");
+        review1.put("customerName", "Alice Smith");
+        review1.put("comment", "Super livre !");
+        useCase.submitReview(review1);
+
+        Map<String, String> review2 = new HashMap<>();
+        review2.put("customerId", "c2");
+        review2.put("isbn", "978444444");
+        review2.put("rating", "4");
+        review2.put("customerName", "Bob White");
+        review2.put("comment", "Bien !");
+        useCase.submitReview(review2);
+
+        List<Map<String, String>> aliceReviews = useCase.getReviewsByCustomerName("Alice Smith");
+        assertEquals(1, aliceReviews.size());
+        assertEquals("Alice Smith", aliceReviews.get(0).get("customerName"));
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/validator/ReviewValidatorTest.java

@@ -0,0 +1,26 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.review.validator;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ReviewValidatorTest {
+
+    @Test
+    void testIsValidUUID() {
+        assertTrue(ReviewValidator.isValidUUID("11111111-1111-1111-1111-111111111111"));
+        assertFalse(ReviewValidator.isValidUUID("not-a-uuid"));
+        assertFalse(ReviewValidator.isValidUUID(""));
+        assertFalse(ReviewValidator.isValidUUID(null));
+    }
+
+    @Test
+    void testIsValidReviewDetails() {
+        assertTrue(ReviewValidator.isValidReviewDetails("id", "isbn", "5"));
+        assertFalse(ReviewValidator.isValidReviewDetails("", "isbn", "5"));
+        assertFalse(ReviewValidator.isValidReviewDetails("id", "", "5"));
+        assertFalse(ReviewValidator.isValidReviewDetails("id", "isbn", ""));
+        assertFalse(ReviewValidator.isValidReviewDetails(null, "isbn", "5"));
+        assertFalse(ReviewValidator.isValidReviewDetails("id", null, "5"));
+        assertFalse(ReviewValidator.isValidReviewDetails("id", "isbn", null));
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/error/SubscriptionErrorTest.java

@@ -0,0 +1,19 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.subscription.error;
+import fr.iut_fbleau.but3.dev62.mylibrary.subscription.function.SubscriptionFunctionTest;
+import static org.junit.jupiter.api.Assertions.*;
+import io.cucumber.java.en.And;
+import io.cucumber.java.en.Then;
+
+public class SubscriptionErrorTest extends SubscriptionFunctionTest {
+
+    @Then("the subscription request fails")
+    public void theSubscriptionRequestFails() {
+        assertFalse(lastRequestSuccess);
+        assertNotNull(lastErrorMessage);
+    }
+
+    @And("I receive a subscription error message containing {string}")
+    public void iReceiveASubscriptionErrorMessageContaining(String msg) {
+        assertTrue(lastErrorMessage.contains(msg));
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/function/SubscriptionFunctionTest.java

@@ -0,0 +1,111 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.subscription.function;
+import static org.junit.jupiter.api.Assertions.*;
+import java.time.LocalDate;
+import java.util.*;
+import io.cucumber.datatable.DataTable;
+
+
+import io.cucumber.java.en.And;
+import io.cucumber.java.en.When;
+import io.cucumber.java.en.Given;
+
+public class SubscriptionFunctionTest {
+
+    private final Map<String, Map<String, String>> subscriptions = new HashMap<>();
+    private final Map<String, Map<String, String>> customers = new HashMap<>();
+
+    protected boolean lastRequestSuccess;
+    protected String lastErrorMessage;
+    protected Map<String, String> lastSubscriptionCreated;
+    protected Map<String, String> lastSubscriptionFetched;
+
+    @Given("the subscription system has the following customers:")
+    public void theSubscriptionSystemHasTheFollowingCustomers(DataTable dataTable) {
+        customers.clear();
+        for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
+            customers.put(row.get("id"), new HashMap<>(row));
+        }
+        assertEquals(dataTable.asMaps().size(), customers.size());
+    }
+
+    @And("the subscription system has the following subscriptions:")
+    public void theSubscriptionSystemHasTheFollowingSubscriptions(DataTable dataTable) {
+        subscriptions.clear();
+        for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
+            subscriptions.put(row.get("subscriptionId"), new HashMap<>(row));
+        }
+        assertEquals(dataTable.asMaps().size(), subscriptions.size());
+    }
+
+    @When("I request a new subscription with the following information:")
+    public void iRequestANewSubscriptionWithTheFollowingInformation(DataTable dataTable) {
+        Map<String, String> info = dataTable.asMaps().getFirst();
+        String customerId = info.get("customerId");
+        String duration = info.get("durationInMonths");
+        String paymentMethod = info.get("paymentMethod");
+        String requestedStartDate = info.get("requestedStartDate");
+
+        // (logique copiée, à remplacer ensuite par SubscriptionManagement)
+        if (customerId == null || customerId.isBlank() ||
+                duration == null || duration.isBlank() ||
+                paymentMethod == null || paymentMethod.isBlank() ||
+                requestedStartDate == null || requestedStartDate.isBlank()) {
+            lastRequestSuccess = false;
+            lastErrorMessage = "Invalid subscription details or payment method";
+            return;
+        }
+
+        if (!customers.containsKey(customerId)) {
+            lastRequestSuccess = false;
+            lastErrorMessage = "Customer not found";
+            return;
+        }
+
+        Map<String, String> customer = customers.get(customerId);
+        if (paymentMethod.equals("LOYALTY_POINTS")) {
+            int points = Integer.parseInt(customer.get("loyaltyPoints"));
+            int needed = Integer.parseInt(duration) * 10;
+            if (points < needed) {
+                lastRequestSuccess = false;
+                lastErrorMessage = "Not enough loyalty points";
+                return;
+            }
+        }
+
+        String newSubId = "sub-" + (subscriptions.size() + 1);
+        LocalDate start = LocalDate.parse(requestedStartDate);
+        LocalDate end = start.plusMonths(Long.parseLong(duration)).minusDays(1);
+        Map<String, String> sub = new HashMap<>();
+        sub.put("subscriptionId", newSubId);
+        sub.put("customerId", customerId);
+        sub.put("durationInMonths", duration);
+        sub.put("startDate", start.toString());
+        sub.put("endDate", end.toString());
+        subscriptions.put(newSubId, sub);
+        lastSubscriptionCreated = sub;
+        lastRequestSuccess = true;
+        lastErrorMessage = null;
+    }
+
+    @When("I request the subscription for customer {string}")
+    public void iRequestTheSubscriptionForCustomer(String customerId) {
+        lastSubscriptionFetched = null;
+        lastRequestSuccess = false;
+        for (Map<String, String> sub : subscriptions.values()) {
+            if (sub.get("customerId").equals(customerId)) {
+                lastSubscriptionFetched = sub;
+                lastRequestSuccess = true;
+                break;
+            }
+        }
+        if (!lastRequestSuccess) {
+            lastErrorMessage = "Subscription not found for the customer";
+        }
+    }
+
+    @When("I try to request a new subscription with the following information:")
+    public void iTryToRequestANewSubscriptionWithTheFollowingInformation(DataTable dataTable) {
+        iRequestANewSubscriptionWithTheFollowingInformation(dataTable);
+        lastRequestSuccess = false;
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/result/SubscriptionResultTest.java

@@ -0,0 +1,32 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.subscription.result;
+import fr.iut_fbleau.but3.dev62.mylibrary.subscription.function.SubscriptionFunctionTest;
+import static org.junit.jupiter.api.Assertions.*;
+
+import io.cucumber.cienvironment.internal.com.eclipsesource.json.JsonArray;
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.en.And;
+import io.cucumber.java.en.Then;
+import java.util.*;
+
+public class SubscriptionResultTest extends SubscriptionFunctionTest {
+    private final Map<String, Map<String, String>> subscriptions = new HashMap<>();
+
+    @And("the subscription system still has {int} subscription")
+    public void theSubscriptionSystemStillHasSubscription(int expected) {
+        assertEquals(expected, subscriptions.size());
+    }
+
+    @Then("I receive the following subscription information:")
+    public void iReceiveTheFollowingSubscriptionInformation(DataTable dataTable) {
+        Map<String, String> expected = dataTable.asMaps(String.class, String.class).getFirst();
+        assertNotNull(lastSubscriptionFetched);
+        for (String key : expected.keySet()) {
+            assertEquals(expected.get(key), lastSubscriptionFetched.get(key));
+        }
+    }
+
+    @And("the subscription system now has {int} subscriptions")
+    public void theSubscriptionSystemNowHasSubscriptions(int expected) {
+        assertEquals(expected, subscriptions.size());
+    }
+}

src/test/resources/features/review.feature

@@ -7,12 +7,17 @@ Feature: Manage reviews
       | id                                   | firstName | lastName | phoneNumber | loyaltyPoints |
       | 33333333-3333-3333-3333-333333333333 | Carol     | White    | 0600000003  | 50            |
     And the review system has the following review books:
-      | isbn      | title         | author      | publisher | publicationDate | price | quantity | language |
-      | 978333333 | Book B        | Author B    | PubB      | 2020-01-01      | 18.0  | 5        | EN       |
-      | 978444444 | Book C        | Author C    | PubC      | 2021-06-15      | 22.0  | 3        | FR       |
+      | isbn      | title  | author   | publisher | publicationDate | price | quantity | language |
+      | 978333333 | Book B | Author B | PubB      | 2020-01-01      | 18.0  | 5        | EN       |
+      | 978444444 | Book C | Author C | PubC      | 2021-06-15      | 22.0  | 3        | FR       |
+      | 978555555 | Book D | Author D | PubD      | 2022-03-10      | 25.0  | 2        | DE       |
     And the review system has the following reviews:
-      | reviewId | bookId    | customerName | comment      | rating |
-      | rev-1    | 978333333 | Carol White  | Great book!  | 5      |
+      | reviewId                              | bookId    | customerName | comment      | rating |
+      | 11111111-1111-1111-1111-111111111111  | 978333333 | Carol White  | Great book!  | 5      |
+    And the review system has the following purchases:
+      | customerId                           | bookId    | purchaseDate |
+      | 33333333-3333-3333-3333-333333333333 | 978333333 | 2021-01-01   |
+      | 33333333-3333-3333-3333-333333333333 | 978444444 | 2021-06-15   |
 
   Scenario: Submit a new review
     When I submit a new review with the following information:
@@ -24,13 +29,13 @@ Feature: Manage reviews
   Scenario: Get reviews by customer
     When I request all reviews by customer "33333333-3333-3333-3333-333333333333"
     Then I receive the following reviews:
-      | reviewId | bookId    | customerName | comment      | rating |
-      | rev-1    | 978333333 | Carol White  | Great book!  | 5      |
+      | reviewId                              | bookId    | customerName | comment      | rating |
+      | 11111111-1111-1111-1111-111111111111  | 978333333 | Carol White  | Great book!  | 5      |
 
   Scenario: Attempt to submit a review for a book not purchased
     When I try to submit a new review with the following information:
       | customerId                             | isbn      | rating | comment        |
-      | 33333333-3333-3333-3333-333333333333   | 978333333 | 5      | Not purchased  |
+      | 33333333-3333-3333-3333-333333333333   | 978555555 | 5      | Not purchased  |
     Then the review submission fails
     And I receive a review error message containing "customer hasn't purchased the book"
     And the review system still has 1 review
@@ -70,6 +75,6 @@ Feature: Manage reviews
     And I receive a review error message containing "Book or customer not found"
 
   Scenario: Attempt to delete a review with unknown ID
-    When I try to delete the review with id "unknown-review-id"
+    When I try to delete the review with id "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
     Then the review deletion fails
     And I receive a review error message containing "Review not found"