daniel/mylibrary
1
0
Fork 0
forked from pierront/mylibrary-template
Code Pull Requests Activity

Merge branch 'main' of grond.iut-fbleau.fr:daniel/mylibrary

Browse Source
This commit is contained in:
Nathan BOUZON
2025-06-14 01:50:46 +02:00
parent d8f63d1bdd 9df099691e
commit 6820863c8e
26 changed files with 935 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/ReviewDto.java Normal file
View File

@@ -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;
}

13
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/ReviewInfo.java Normal file
View File

@@ -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;
}

31
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/converter/ReviewConverter.java Normal file
View File

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

29
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/entity/Review.java Normal file
View File

@@ -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);
}
}

10
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/DuplicateReviewException.java Normal file
View File

@@ -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)));
}
}

8
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/InvalidReviewException.java Normal file
View File

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

10
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/ReviewNotAllowedException.java Normal file
View File

@@ -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)));
}
}

12
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/ReviewNotFoundException.java Normal file
View File

@@ -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));
}
}

55
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/repository/ReviewRepository.java Normal file
View File

@@ -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;
}
}

53
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/usecase/ReviewUseCase.java Normal file
View File

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

22
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/review/validator/ReviewValidator.java Normal file
View File

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

2
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/error/bookErrorTest.java → src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/error/BookErrorTest.java
View File

@@ -6,7 +6,7 @@ import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
@DisplayName("Book error and failure scenarios")
public class bookErrorTest {
public class BookErrorTest {
private BookManagement bookManagement;

3
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/function/bookFunctionTest.java → src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/function/BookFunctionTest.java
View File

@@ -2,7 +2,6 @@ package fr.iut_fbleau.but3.dev62.mylibrary.book.function;
import fr.iut_fbleau.but3.dev62.mylibrary.book.*;
import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.*;
import io.cucumber.datatable.DataTable;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
@@ -10,7 +9,7 @@ import java.util.List;
import java.util.Map;
@DisplayName("Book retrieval scenarios and data registration")
public class bookFunctionTest {
public class BookFunctionTest {
private BookManagement bookManagement;
private boolean lastOperationSuccess;

2
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/result/bookResultTest.java → src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/result/BookResultTest.java
View File

@@ -8,7 +8,7 @@ import java.util.HashMap;
import java.util.Map;
@DisplayName("Book result success scenarios")
public class bookResultTest {
public class BookResultTest {
private Map<String, Book> books;
private Book sampleBook;

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

@@ -12,5 +12,166 @@ import java.util.*;
public class OrderSteps {
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>> orders = new HashMap<>();
private String lastOrderId;
private String lastOrderError;
private boolean lastOrderSuccess;
private Map<String, String> lastOrderFetched;
@Given("the order system has the following customers:")
public void theOrderSystemHasTheFollowingCustomers(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 order system has the following books:")
public void theOrderSystemHasTheFollowingBooks(DataTable dataTable) {
books.clear();
for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
books.put(Long.parseLong(row.get("isbn")), new HashMap<>(row));
}
assertEquals(dataTable.asMaps().size(), books.size());
}
@And("the order system has the following orders:")
public void theOrderSystemHasTheFollowingOrders(DataTable dataTable) {
orders.clear();
for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
orders.put(row.get("id"), new HashMap<>(row));
}
assertEquals(dataTable.asMaps().size(), orders.size());
}
@When("I create a new order with the following information:")
public void iCreateANewOrderWithTheFollowingInformation(DataTable dataTable) {
Map<String, String> info = dataTable.asMaps(String.class, String.class).getFirst();
String customerId = info.get("customerId");
String paymentMethod = info.get("paymentMethod");
String orderLineDtos = info.get("orderLineDtos");
String addressStreet = info.get("addressStreet");
String addressCity = info.get("addressCity");
String addressPostalCode = info.get("addressPostalCode");
String addressCountry = info.get("addressCountry");
// Validation simple
if (customerId == null || customerId.isBlank() ||
paymentMethod == null || paymentMethod.isBlank() ||
orderLineDtos == null || orderLineDtos.isBlank() ||
addressStreet == null || addressStreet.isBlank() ||
addressCity == null || addressCity.isBlank() ||
addressPostalCode == null || addressPostalCode.isBlank() ||
addressCountry == null || addressCountry.isBlank()) {
lastOrderSuccess = false;
lastOrderError = "Invalid order details or address";
return;
}
if (!customers.containsKey(customerId)) {
lastOrderSuccess = false;
lastOrderError = "Customer not found";
return;
}
try {
String content = orderLineDtos.replace("[", "").replace("]", "").replace("{", "").replace("}", "");
String[] pairs = content.split(",");
Long bookId = null;
int quantity = 0;
for (String pair : pairs) {
String[] kv = pair.trim().replace("\"", "").split(":");
if (kv.length == 2) {
if (kv[0].trim().equals("bookId")) bookId = Long.parseLong(kv[1].trim());
if (kv[0].trim().equals("quantity")) quantity = Integer.parseInt(kv[1].trim());
}
}
if (bookId == null || !books.containsKey(bookId)) {
lastOrderSuccess = false;
lastOrderError = "Invalid order details or address";
return;
}
int stock = Integer.parseInt(books.get(bookId).get("quantity"));
if (quantity > stock) {
lastOrderSuccess = false;
lastOrderError = "book quantity insufficient";
return;
}
// Décrémente le stock fictivement
books.get(bookId).put("quantity", String.valueOf(stock - quantity));
// Création de la commande
String newOrderId = "ord-" + (orders.size() + 1);
Map<String, String> order = new HashMap<>();
order.put("id", newOrderId);
order.put("customerId", customerId);
order.put("totalPrice", String.valueOf(
Double.parseDouble(books.get(bookId).get("price")) * quantity
));
order.put("paymentMethod", paymentMethod);
orders.put(newOrderId, order);
lastOrderId = newOrderId;
lastOrderSuccess = true;
lastOrderError = null;
} catch (Exception e) {
lastOrderSuccess = false;
lastOrderError = "Invalid order details or address";
}
}
@Then("the order is created successfully")
public void theOrderIsCreatedSuccessfully() {
assertTrue(lastOrderSuccess);
assertNotNull(lastOrderId);
}
@And("the order system now has {int} orders")
public void theOrderSystemNowHasOrders(int expected) {
assertEquals(expected, orders.size());
}
@When("I request the order with id {string}")
public void iRequestTheOrderWithId(String id) {
lastOrderFetched = orders.get(id);
lastOrderSuccess = lastOrderFetched != null;
if (!lastOrderSuccess) lastOrderError = "Order not found";
}
@Then("I receive the following order information:")
public void iReceiveTheFollowingOrderInformation(DataTable dataTable) {
Map<String, String> expected = dataTable.asMaps(String.class, String.class).getFirst();
assertNotNull(lastOrderFetched);
for (String key : expected.keySet()) {
assertEquals(expected.get(key), lastOrderFetched.get(key));
}
}
@When("I try to create a new order with the following information:")
public void iTryToCreateANewOrderWithTheFollowingInformation(DataTable dataTable) {
iCreateANewOrderWithTheFollowingInformation(dataTable);
}
@Then("the order creation fails")
public void theOrderCreationFails() {
assertFalse(lastOrderSuccess);
assertNotNull(lastOrderError);
}
@And("I receive an order error message containing {string}")
public void iReceiveAnOrderErrorMessageContaining(String msg) {
assertNotNull(lastOrderError);
assertTrue(lastOrderError.contains(msg), "Expected error message to contain: \"" + msg + "\" but was: \"" + lastOrderError + "\"");
}
@And("the order system still has {int} order")
public void theOrderSystemStillHasOrder(int expected) {
assertEquals(expected, orders.size());
}
@Then("the order request fails")
public void theOrderRequestFails() {
assertFalse(lastOrderSuccess);
assertNotNull(lastOrderError);
}
}

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

@@ -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);
}
}

64
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/converter/ReviewConverterTest.java Normal file
View File

@@ -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));
}
}

42
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/entity/ReviewTest.java Normal file
View File

@@ -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);
}
}

13
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/DuplicateReviewExceptionTest.java Normal file
View File

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

13
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/InvalidReviewExceptionTest.java Normal file
View File

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

13
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/ReviewNotAllowedExceptionTest.java Normal file
View File

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

13
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/exception/ReviewNotFoundExceptionTest.java Normal file
View File

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

72
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/repository/ReviewRepositoryTest.java Normal file
View File

@@ -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"));
}
}

91
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/usecase/ReviewUseCaseTest.java Normal file
View File

@@ -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"));
}
}

26
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/review/validator/ReviewValidatorTest.java Normal file
View File

@@ -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));
}
}

25
src/test/resources/features/review.feature
View File

@@ -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"
And I receive a review error message containing "Review not found"