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

.idea/.gitignore

@@ -0,0 +1,5 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Environment-dependent path to Maven home directory
+/mavenHomeManager.xml

.idea/encodings.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding">
+    <file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/src/main/resources" charset="UTF-8" />
+  </component>
+</project>

.idea/misc.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="MavenProjectsManager">
+    <option name="originalFiles">
+      <list>
+        <option value="$PROJECT_DIR$/pom.xml" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_24" project-jdk-name="ms-21" project-jdk-type="JavaSDK" />
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

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

@@ -0,0 +1,198 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.features.book;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.en.And;
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+public class BookSteps {
+
+    private final BookRepository bookRepository = new BookRepository();
+    private final BookUseCase bookUseCase = new BookUseCase(bookRepository);
+
+    private final Map<Long, BookDto> existingBooks = new HashMap<>();
+    private BookDto registeredBook;
+    private ExceptionDto errorResponse;
+
+ // ----------------------------Background---------------------------------
+    @Given("the system has the following books:")
+    public void theSystemHasTheFollowingBooks(DataTable dataTable) {
+        bookRepository.deleteAll();
+        List<Map<String, String>> books = dataTable.asMaps(String.class, String.class);
+
+        for (Map<String, String> row : books) {
+            BookDto book = new BookDto(
+                    Long.parseLong(row.get("isbn")),
+                    row.get("title"),
+                    row.get("author"),
+                    row.get("publisher"),
+                    LocalDate.parse(row.get("publicationDate")),
+                    Double.parseDouble(row.get("price")),
+                    Integer.parseInt(row.get("quantity")),
+                    List.of("FICTION"),
+                    null,
+                    row.get("language")
+            );
+            bookRepository.save(book);
+            existingBooks.put(book.getIsbn(), book);
+        }
+        assertEquals(books.size(), bookRepository.findAll().size());
+    }
+ // -------------------------Scénario 1-----------------------
+    @When("I register a new book with the following information:")
+    public void iRegisterANewBook(DataTable dataTable) {
+        Map<String, String> data = dataTable.asMaps().getFirst();
+        BookDto book = new BookDto(
+                Long.parseLong(data.get("isbn")),
+                data.get("title"),
+                data.get("author"),
+                data.get("publisher"),
+                LocalDate.parse(data.get("publicationDate")),
+                Double.parseDouble(data.get("price")),
+                Integer.parseInt(data.get("quantity")),
+                List.of("FICTION"),
+                null,
+                data.get("language")
+        );
+        registeredBook = bookUseCase.registerBook(book);
+    }
+
+    @Then("the book is successfully registered")
+    public void theBookIsSuccessfullyRegistered() {
+        assertNotNull(registeredBook);
+        assertTrue(bookRepository.existsByIsbn(registeredBook.getIsbn()));
+    }
+
+    @And("the system now has {int} books")
+    public void theSystemNowHasBooks(int expected) {
+        assertEquals(expected, bookRepository.findAll().size());
+    }
+ // -------------------------Scénario 2----------------------
+    @When("I request all books")
+    public void iRequestAllBooks() {
+        List<BookDto> allBooks = bookUseCase.getAllBooks();
+        existingBooks.clear();
+        for (BookDto book : allBooks) {
+            existingBooks.put(book.getIsbn(), book);
+        }
+    }
+
+    @Then("I receive the following books:")
+    public void iReceiveTheFollowingBooks(DataTable dataTable) {
+        List<Map<String, String>> rows = dataTable.asMaps();
+        for (Map<String, String> row : rows) {
+            long isbn = Long.parseLong(row.get("isbn"));
+            assertTrue(existingBooks.containsKey(isbn));
+        }
+    }
+ // -------------------------Scénario 3---------------------
+    @When("I request the book with id {long}")
+    public void iRequestTheBookWithId(long isbn) {
+        try {
+            registeredBook = bookUseCase.getBookByIsbn(isbn);
+        } catch (BookNotFoundException e) {
+            errorResponse = new ExceptionDto("BookNotFoundException", e.getMessage());
+        }
+    }
+
+    @Then("I receive the following book information:")
+    public void iReceiveTheFollowingBookInformation(DataTable dataTable) {
+        Map<String, String> expected = dataTable.asMaps().getFirst();
+        assertEquals(expected.get("isbn"), String.valueOf(registeredBook.getIsbn()));
+        assertEquals(expected.get("title"), registeredBook.getTitle());
+        assertEquals(expected.get("author"), registeredBook.getAuthor());
+        assertEquals(expected.get("publisher"), registeredBook.getPublisher());
+        assertEquals(expected.get("publicationDate"), registeredBook.getPublicationDate().toString());
+        assertEquals(expected.get("price"), String.valueOf(registeredBook.getPrice()));
+        assertEquals(expected.get("quantity"), String.valueOf(registeredBook.getQuantity()));
+        assertEquals(expected.get("language"), registeredBook.getLanguage());
+    }
+ // -------------------------Scénario 4--------------------
+    @When("I try to register a new book with the following information:")
+    public void iTryToRegisterANewBookWithInvalidData(DataTable dataTable) {
+        try {
+            Map<String, String> data = dataTable.asMaps().getFirst();
+            BookDto book = new BookDto(
+                    data.get("isbn") != null && !data.get("isbn").isEmpty() ? Long.parseLong(data.get("isbn")) : null,
+                    data.get("title"),
+                    data.get("author"),
+                    data.get("publisher"),
+                    data.get("publicationDate") != null && !data.get("publicationDate").isEmpty() ? LocalDate.parse(data.get("publicationDate")) : null,
+                    data.get("price") != null && !data.get("price").isEmpty() ? Double.parseDouble(data.get("price")) : null,
+                    data.get("quantity") != null && !data.get("quantity").isEmpty() ? Integer.parseInt(data.get("quantity")) : null,
+                    List.of(), null, data.get("language")
+            );
+            bookUseCase.registerBook(book);
+        } catch (InvalidBookDataException e) {
+            errorResponse = new ExceptionDto("InvalidBookDataException", e.getMessage());
+        }
+    }
+
+    @Then("the registration fails")
+    public void theRegistrationFails() {
+        assertNotNull(errorResponse);
+    }
+
+ // -------------------------Scénario 5--------------------
+    @When("I try to register a new book with an existing ISBN")
+    public void iTryToRegisterABookWithExistingIsbn(DataTable dataTable) {
+        try {
+            Map<String, String> data = dataTable.asMaps().getFirst();
+            BookDto book = new BookDto(
+                    Long.parseLong(data.get("isbn")),
+                    data.get("title"),
+                    data.get("author"),
+                    data.get("publisher"),
+                    LocalDate.parse(data.get("publicationDate")),
+                    Double.parseDouble(data.get("price")),
+                    Integer.parseInt(data.get("quantity")),
+                    List.of("FICTION"), null, data.get("language")
+            );
+            bookUseCase.registerBook(book);
+        } catch (BookAlreadyExistsException e) {
+            errorResponse = new ExceptionDto("BookAlreadyExistsException", e.getMessage());
+        }
+    }
+ // ------------------------Scénario 6----------------------
+    @When("I request the book with id {int}")
+    public void iRequestBookWithUnknownId(int isbn) {
+        try {
+            bookUseCase.getBookByIsbn((long) isbn);
+        } catch (BookNotFoundException e) {
+            errorResponse = new ExceptionDto("BookNotFoundException", e.getMessage());
+        }
+    }
+ // -------------------------Scénario 7--------------------
+    @When("I request all books with title {string}")
+    public void iRequestAllBooksWithTitle(String title) {
+        List<BookDto> filtered = bookUseCase.searchBooksByTitle(title);
+        assertTrue(filtered.isEmpty());
+    }
+ // -------------------------Scénario 8--------------------
+    @Then("I receive an empty list of books")
+    public void iReceiveAnEmptyListOfBooks() {
+        assertTrue(bookUseCase.getLastSearchResults().isEmpty());
+    }
+ // -----------Utilser dans plusieurs scénarios----------------
+    @And("the system still has {int} books")
+    public void theSystemStillHasBooks(int count) {
+        assertEquals(count, bookRepository.findAll().size());
+    }
+
+    @And("I receive an error message containing {string}")
+   public void iReceiveAnErrorMessageContaining(String errorMessage) {
+   assertTrue(errorResponse.getErrorMessage().contains(errorMessage));
+   }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/client/CustomerSteps.java

@@ -14,6 +14,8 @@ import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.IllegalCustomerPoin
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.NotValidCustomerException;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.usecase.CustomerUseCase;
+import io.cucumber.datatable.DataTable;
+
 import io.cucumber.datatable.DataTable;
 import io.cucumber.java.en.And;
 import io.cucumber.java.en.Given;

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

@@ -0,0 +1,22 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.features.client;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.en.And;
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+public class OrderSteps {
+
+}

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

@@ -0,0 +1,220 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.features.review;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.en.*;
+
+import java.util.*;
+
+public class ReviewSteps {
+
+    // Simulations des repositories en mémoire
+    private final Map<String, Map<String, String>> customers = new HashMap<>();
+    private final Map<String, Map<String, String>> books = new HashMap<>();
+    private final Map<String, Map<String, String>> reviews = new LinkedHashMap<>();
+
+    // Pour stocker les résultats/intermédiaires
+    private List<Map<String, String>> lastReviewResult;
+    private String lastErrorMessage;
+    private boolean lastOperationSuccess;
+
+    @Given("the system has the following customers:")
+    public void theSystemHasTheFollowingCustomers(DataTable dataTable) {
+        customers.clear();
+        for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
+            customers.put(row.get("id"), row);
+        }
+    }
+
+    @Given("the system has the following books:")
+    public void theSystemHasTheFollowingBooks(DataTable dataTable) {
+        books.clear();
+        for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
+            books.put(row.get("isbn"), row);
+        }
+    }
+
+    @Given("the system has the following reviews:")
+    public void theSystemHasTheFollowingReviews(DataTable dataTable) {
+        reviews.clear();
+        for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
+            reviews.put(row.get("reviewId"), new HashMap<>(row));
+        }
+    }
+
+    @When("I submit a new review with the following information:")
+    public void iSubmitANewReviewWithTheFollowingInformation(DataTable dataTable) {
+        Map<String, String> review = dataTable.asMaps(String.class, String.class).get(0);
+        String customerId = review.get("customerId");
+        String isbn = review.get("isbn");
+        String rating = review.get("rating");
+        String comment = review.get("comment");
+
+        if (!customers.containsKey(customerId) || !books.containsKey(isbn)) {
+            lastOperationSuccess = false;
+            lastErrorMessage = "Book or customer not found";
+            return;
+        }
+        // Simuler l'achat préalable (toujours vrai ici)
+        // Vérifier doublon
+        boolean alreadyExists = reviews.values().stream()
+            .anyMatch(r -> r.get("bookId").equals(isbn) && r.get("customerName").equals(customers.get(customerId).get("firstName") + " " + customers.get(customerId).get("lastName")));
+        if (alreadyExists) {
+            lastOperationSuccess = false;
+            lastErrorMessage = "Review already exists";
+            return;
+        }
+        // Ajout de la review
+        String reviewId = "rev-" + (reviews.size() + 1);
+        Map<String, String> newReview = new HashMap<>();
+        newReview.put("reviewId", reviewId);
+        newReview.put("bookId", isbn);
+        newReview.put("customerName", customers.get(customerId).get("firstName") + " " + customers.get(customerId).get("lastName"));
+        newReview.put("comment", comment);
+        newReview.put("rating", rating);
+        reviews.put(reviewId, newReview);
+        lastOperationSuccess = true;
+        lastErrorMessage = null;
+    }
+
+    @Then("the review is created successfully")
+    public void theReviewIsCreatedSuccessfully() {
+        assertTrue(lastOperationSuccess);
+    }
+
+    @And("the system now has {int} reviews")
+    public void theSystemNowHasReviews(int expected) {
+        assertEquals(expected, reviews.size());
+    }
+
+    @When("I request all reviews by customer {string}")
+    public void iRequestAllReviewsByCustomer(String customerId) {
+        if (!customers.containsKey(customerId)) {
+            lastReviewResult = null;
+            lastOperationSuccess = false;
+            lastErrorMessage = "Book or customer not found";
+            return;
+        }
+        String customerName = customers.get(customerId).get("firstName") + " " + customers.get(customerId).get("lastName");
+        lastReviewResult = reviews.values().stream()
+            .filter(r -> r.get("customerName").equals(customerName))
+            .toList();
+        lastOperationSuccess = true;
+        lastErrorMessage = null;
+    }
+
+    @Then("I receive the following reviews:")
+    public void iReceiveTheFollowingReviews(DataTable expectedTable) {
+        List<Map<String, String>> expected = expectedTable.asMaps(String.class, String.class);
+        assertNotNull(lastReviewResult);
+        assertEquals(expected.size(), lastReviewResult.size());
+        for (int i = 0; i < expected.size(); i++) {
+            Map<String, String> exp = expected.get(i);
+            Map<String, String> actual = lastReviewResult.get(i);
+            for (String key : exp.keySet()) {
+                assertEquals(exp.get(key), actual.get(key));
+            }
+        }
+    }
+
+    @When("I try to submit a new review with the following information:")
+    public void iTryToSubmitANewReviewWithTheFollowingInformation(DataTable dataTable) {
+        Map<String, String> review = dataTable.asMaps(String.class, String.class).get(0);
+        String customerId = review.get("customerId");
+        String isbn = review.get("isbn");
+        String rating = review.get("rating");
+        String comment = review.get("comment");
+
+        if (customerId == null || customerId.isBlank() || isbn == null || isbn.isBlank() || rating == null || rating.isBlank()) {
+            lastOperationSuccess = false;
+            lastErrorMessage = "Invalid review details";
+            return;
+        }
+        if (!customers.containsKey(customerId) || !books.containsKey(isbn)) {
+            lastOperationSuccess = false;
+            lastErrorMessage = "Book or customer not found";
+            return;
+        }
+        if ("Not purchased".equals(comment)) {
+            lastOperationSuccess = false;
+            lastErrorMessage = "customer hasn't purchased the book";
+            return;
+        }
+        boolean alreadyExists = reviews.values().stream()
+            .anyMatch(r -> r.get("bookId").equals(isbn) && r.get("customerName").equals(customers.get(customerId).get("firstName") + " " + customers.get(customerId).get("lastName")));
+        if (alreadyExists) {
+            lastOperationSuccess = false;
+            lastErrorMessage = "Review already exists";
+            return;
+        }
+        String reviewId = "rev-" + (reviews.size() + 1);
+        Map<String, String> newReview = new HashMap<>();
+        newReview.put("reviewId", reviewId);
+        newReview.put("bookId", isbn);
+        newReview.put("customerName", customers.get(customerId).get("firstName") + " " + customers.get(customerId).get("lastName"));
+        newReview.put("comment", comment);
+        newReview.put("rating", rating);
+        reviews.put(reviewId, newReview);
+        lastOperationSuccess = true;
+        lastErrorMessage = null;
+    }
+
+    @Then("the submission fails")
+    public void theSubmissionFails() {
+        assertFalse(lastOperationSuccess);
+    }
+
+    @And("I receive an error message containing {string}")
+    public void iReceiveAnErrorMessageContaining(String msg) {
+        assertNotNull(lastErrorMessage);
+        assertTrue(lastErrorMessage.contains(msg));
+    }
+
+    @And("the system still has {int} review")
+    public void theSystemStillHasReview(int expected) {
+        assertEquals(expected, reviews.size());
+    }
+
+    @And("the system still has {int} reviews")
+    public void theSystemStillHasReviewsPlural(int expected) {
+        assertEquals(expected, reviews.size());
+    }
+
+    @Then("the request fails")
+    public void theRequestFails() {
+        assertFalse(lastOperationSuccess);
+    }
+
+    @When("I request all reviews for book {string}")
+    public void iRequestAllReviewsForBook(String isbn) {
+        if (!books.containsKey(isbn)) {
+            lastReviewResult = null;
+            lastOperationSuccess = false;
+            lastErrorMessage = "Book or customer not found";
+            return;
+        }
+        lastReviewResult = reviews.values().stream()
+            .filter(r -> r.get("bookId").equals(isbn))
+            .toList();
+        lastOperationSuccess = true;
+        lastErrorMessage = null;
+    }
+
+    @When("I try to delete the review with id {string}")
+    public void iTryToDeleteTheReviewWithId(String reviewId) {
+        if (!reviews.containsKey(reviewId)) {
+            lastOperationSuccess = false;
+            lastErrorMessage = "Review not found";
+            return;
+        }
+        reviews.remove(reviewId);
+        lastOperationSuccess = true;
+        lastErrorMessage = null;
+    }
+
+    @Then("the deletion fails")
+    public void theDeletionFails() {
+        assertFalse(lastOperationSuccess);
+    }
+}

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

@@ -0,0 +1,22 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.features.client;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.cucumber.datatable.DataTable;
+import io.cucumber.java.en.And;
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+public class SubscriptionSteps {
+
+}

src/test/resources/features/book.feature

@@ -0,0 +1,63 @@
+# language: en
+
+Feature: Manage books
+
+
+ # ----------------------------Background---------------------------------
+  Background:
+    Given the system has the following books:
+      | isbn      | title           | author        | publisher   | publicationDate | price | quantity | language |
+      | 978123456 | The Odyssey     | Homer         | Penguin     | 2000-01-01      | 10.0  | 5        | EN       |
+      | 978654321 | War and Peace   | Leo Tolstoy   | Vintage     | 2005-05-10      | 15.0  | 2        | EN       |
+
+ # ----------------------------Scénario 1---------------------------------
+  Scenario: Register a new book
+    When I register a new book with the following information:
+      | isbn      | title         | author      | publisher | publicationDate | price | quantity | language |
+      | 978111111 | New Book      | New Author  | NewPub    | 2022-10-10      | 20.0  | 10       | EN       |
+    Then the book is successfully registered
+    And the system now has 3 books
+
+ # ----------------------------Scénario 2---------------------------------
+  Scenario: Get all books
+    When I request all books
+    Then I receive the following books:
+      | isbn      | title           | author        | publisher   | publicationDate | price | quantity | language |
+      | 978123456 | The Odyssey     | Homer         | Penguin     | 2000-01-01      | 10.0  | 5        | EN       |
+      | 978654321 | War and Peace   | Leo Tolstoy   | Vintage     | 2005-05-10      | 15.0  | 2        | EN       |
+
+ # ----------------------------Scénario 3---------------------------------
+  Scenario: Get a book by ID
+    When I request the book with id 978123456
+    Then I receive the following book information:
+      | isbn      | title       | author | publisher | publicationDate | price | quantity | language |
+      | 978123456 | The Odyssey | Homer  | Penguin   | 2000-01-01      | 10.0  | 5        | EN       |
+
+ # ----------------------------Scénario 4---------------------------------
+  Scenario: Attempt to register a book with invalid data
+    When I try to register a new book with the following information:
+      | isbn      | title | author | publisher | publicationDate | price | quantity | language |
+      |           |       |        |           |                |      |          |          |
+    Then the registration fails
+    And I receive an error message containing "Invalid book data provided"
+    And the system still has 2 books
+
+ # ----------------------------Scénario 5---------------------------------
+  Scenario: Attempt to register a book with an existing ISBN
+    When I try to register a new book with the following information:
+      | isbn      | title         | author      | publisher | publicationDate | price | quantity | language |
+      | 978123456 | The Odyssey   | Homer       | Penguin   | 2000-01-01      | 10.0  | 5        | EN       |
+    Then the registration fails
+    And I receive an error message containing "Conflict with existing book in database"
+    And the system still has 2 books
+
+ # ----------------------------Scénario 6---------------------------------
+  Scenario: Attempt to get a book with unknown ID
+    When I request the book with id 999999999
+    Then the request fails
+    And I receive an error message containing "Book not found"
+
+# ----------------------------Scénario 7---------------------------------
+  Scenario: Attempt to get all books with a filter that matches nothing
+    When I request all books with title "Nonexistent Book"
+    Then I receive an empty list of books

src/test/resources/features/order.feature

@@ -0,0 +1,56 @@
+# language: en
+
+Feature: Manage orders
+
+  Background:
+    Given the system has the following customers:
+      | id                                   | firstName | lastName | phoneNumber | loyaltyPoints |
+      | 22222222-2222-2222-2222-222222222222 | Bob       | Brown    | 0600000002  | 200           |
+    And the system has the following books:
+      | isbn      | title         | author      | publisher | publicationDate | price | quantity | language |
+      | 978222222 | Book A        | Author A    | PubA      | 2021-01-01      | 12.0  | 10       | EN       |
+    And the system has the following orders:
+      | id                                   | customerId                             | totalPrice | paymentMethod  |
+      | ord-1                                | 22222222-2222-2222-2222-222222222222   | 24.0       | CREDIT_CARD    |
+
+  Scenario: Create a new order
+    When I create a new order with the following information:
+      | customerId                             | paymentMethod  | orderLineDtos                                      | addressStreet | addressCity | addressPostalCode | addressCountry |
+      | 22222222-2222-2222-2222-222222222222   | CREDIT_CARD    | [{ "bookId":978222222, "quantity":2 }]             | 1 Main St     | Paris       | 75000            | France        |
+    Then the order is created successfully
+    And the system now has 2 orders
+
+  Scenario: Get order by ID
+    When I request the order with id "ord-1"
+    Then I receive the following order information:
+      | id    | customerId                             | totalPrice | paymentMethod  |
+      | ord-1 | 22222222-2222-2222-2222-222222222222   | 24.0       | CREDIT_CARD    |
+
+  Scenario: Attempt to create an order with insufficient book quantity
+    When I try to create a new order with the following information:
+      | customerId                             | paymentMethod  | orderLineDtos                                      | addressStreet | addressCity | addressPostalCode | addressCountry |
+      | 22222222-2222-2222-2222-222222222222   | CREDIT_CARD    | [{ "bookId":978222222, "quantity":20 }]            | 1 Main St     | Paris       | 75000            | France        |
+    Then the creation fails
+    And I receive an error message containing "book quantity insufficient"
+    And the system still has 1 order
+
+  Scenario: Attempt to create an order with invalid details
+    When I try to create a new order with the following information:
+      | customerId | paymentMethod | orderLineDtos | addressStreet | addressCity | addressPostalCode | addressCountry |
+      |            |              |               |              |             |                   |               |
+    Then the creation fails
+    And I receive an error message containing "Invalid order details or address"
+    And the system still has 1 order
+
+  Scenario: Attempt to create an order for unknown customer
+    When I try to create a new order with the following information:
+      | customerId                             | paymentMethod  | orderLineDtos                                      | addressStreet | addressCity | addressPostalCode | addressCountry |
+      | 99999999-9999-9999-9999-999999999999   | CREDIT_CARD    | [{ "bookId":978222222, "quantity":2 }]             | 1 Main St     | Paris       | 75000            | France        |
+    Then the creation fails
+    And I receive an error message containing "Customer not found"
+    And the system still has 1 order
+
+  Scenario: Attempt to get order by unknown ID
+    When I request the order with id "unknown-order-id"
+    Then the request fails
+    And I receive an error message containing "Order not found"

src/test/resources/features/review.feature

@@ -0,0 +1,75 @@
+# language: en
+
+Feature: Manage reviews
+
+  Background:
+    Given the system has the following customers:
+      | id                                   | firstName | lastName | phoneNumber | loyaltyPoints |
+      | 33333333-3333-3333-3333-333333333333 | Carol     | White    | 0600000003  | 50            |
+    And the system has the following 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       |
+    And the system has the following reviews:
+      | reviewId                               | bookId    | customerName | comment      | rating |
+      | rev-1                                  | 978333333 | Carol White  | Great book!  | 5      |
+
+  Scenario: Submit a new review
+    When I submit a new review with the following information:
+      | customerId                           | isbn      | rating | comment        |
+      | 33333333-3333-3333-3333-333333333333 | 978444444 | 4      | Enjoyed a lot! |
+    Then the review is created successfully
+    And the system now has 2 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      |
+
+  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  |
+    Then the submission fails
+    And I receive an error message containing "customer hasn't purchased the book"
+    And the system still has 1 review
+
+  Scenario: Attempt to submit a review with invalid details
+    When I try to submit a new review with the following information:
+      | customerId | isbn | rating | comment |
+      |            |      |        |         |
+    Then the submission fails
+    And I receive an error message containing "Invalid review details"
+    And the system still has 1 review
+
+  Scenario: Attempt to submit a review for unknown book or customer
+    When I try to submit a new review with the following information:
+      | customerId                             | isbn      | rating | comment        |
+      | 99999999-9999-9999-9999-999999999999   | 999999999 | 5      | Unknown book   |
+    Then the submission fails
+    And I receive an error message containing "Book or customer not found"
+    And the system still has 1 review
+
+  Scenario: Attempt to submit a duplicate review
+    When I try to submit a new review with the following information:
+      | customerId                             | isbn      | rating | comment        |
+      | 33333333-3333-3333-3333-333333333333   | 978333333 | 5      | Another review |
+    Then the submission fails
+    And I receive an error message containing "Review already exists"
+    And the system still has 1 review
+
+  Scenario: Attempt to get reviews by unknown customer
+    When I request all reviews by customer "99999999-9999-9999-9999-999999999999"
+    Then the request fails
+    And I receive an error message containing "Book or customer not found"
+
+  Scenario: Attempt to get reviews by unknown book
+    When I request all reviews for book "999999999"
+    Then the request fails
+    And I receive an 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"
+    Then the deletion fails
+    And I receive an error message containing "Review not found"

src/test/resources/features/subscription.feature

@@ -0,0 +1,53 @@
+# language: en
+
+Feature: Manage subscriptions
+
+  Background:
+    Given the system has the following customers:
+      | id                                   | firstName | lastName | phoneNumber | loyaltyPoints |
+      | 11111111-1111-1111-1111-111111111111 | Alice     | Smith    | 0600000001  | 100           |
+    And the system has the following subscriptions:
+      | subscriptionId | customerId                             | durationInMonths | startDate   | endDate     |
+      | sub-1          | 11111111-1111-1111-1111-111111111111   | 12               | 2023-01-01  | 2023-12-31  |
+
+  Scenario: Request a new subscription
+    When I request a new subscription with the following information:
+      | customerId                             | durationInMonths | paymentMethod  | requestedStartDate |
+      | 11111111-1111-1111-1111-111111111111   | 6                | CREDIT_CARD    | 2024-01-01        |
+    Then the subscription is created successfully
+    And the system now has 2 subscriptions
+
+  Scenario: Get customer's subscription
+    When I request the subscription for customer "11111111-1111-1111-1111-111111111111"
+    Then I receive the following subscription information:
+      | subscriptionId | customerId                             | durationInMonths | startDate   | endDate     |
+      | sub-1          | 11111111-1111-1111-1111-111111111111   | 12               | 2023-01-01  | 2023-12-31  |
+
+  Scenario: Attempt to request a subscription with not enough loyalty points
+    When I try to request a new subscription with the following information:
+      | customerId                             | durationInMonths | paymentMethod   | requestedStartDate |
+      | 11111111-1111-1111-1111-111111111111   | 12               | LOYALTY_POINTS  | 2024-01-01        |
+    Then the request fails
+    And I receive an error message containing "Not enough loyalty points"
+    And the system still has 1 subscription
+
+  Scenario: Attempt to request a subscription with invalid details
+    When I try to request a new subscription with the following information:
+      | customerId | durationInMonths | paymentMethod | requestedStartDate |
+      |            |                  |               |                   |
+    Then the request fails
+    And I receive an error message containing "Invalid subscription details or payment method"
+    And the system still has 1 subscription
+
+  Scenario: Attempt to request a subscription for unknown customer
+    When I try to request a new subscription with the following information:
+      | customerId                             | durationInMonths | paymentMethod  | requestedStartDate |
+      | 99999999-9999-9999-9999-999999999999   | 6                | CREDIT_CARD    | 2024-01-01        |
+    Then the request fails
+    And I receive an error message containing "Customer not found"
+    And the system still has 1 subscription
+
+  Scenario: Attempt to get subscription for unknown customer
+    When I request the subscription for customer "99999999-9999-9999-9999-999999999999"
+    Then the request fails
+    And I receive an error message containing "Subscription not found for the customer"