Merge pull request '✨ Enregistrer un livre' (#2 ) from EnregistrerLivre into main

Reviewed-on: #2
✨ Enregistrer un livre
2026-06-11 11:35:23 +02:00 · 2026-06-11 05:15:30 -04:00
50 changed files with 113 additions and 3173 deletions
@@ -5,6 +5,7 @@ import Books from './pages/Books';
 import Orders from './pages/Orders';
 import Profile from './pages/Profile';
 import NotFound from './pages/NotFound';
 import AddBook from './pages/AddBook';
 export default function App() {
  return (
@@ -15,6 +16,7 @@ export default function App() {
        <Route path="orders" element={<Orders />} />
        <Route path="profile" element={<Profile />} />
        <Route path="*" element={<NotFound />} />
        <Route path="books/new" element={<AddBook />} />
      </Route>
    </Routes>
  );
@@ -2,4 +2,8 @@ import client from './client';
 export function getBooks(page = 0, size = 20) {
  return client.get('/api/books', { params: { page, size } });
 }
 export function registerBook(book) {
  return client.post('/api/books', book);
 }
@@ -0,0 +1,105 @@
 import { useState } from 'react';
 import { registerBook } from '../api/books';
 const CATEGORIES = ['FICTION', 'NON_FICTION', 'SCIENCE_FICTION', 'FANTASY', 'MYSTERY', 'THRILLER', 'ROMANCE', 'BIOGRAPHY', 'HISTORY', 'POETRY', 'CHILDRENS', 'YOUNG_ADULT', 'SCIENCE', 'PHILOSOPHY', 'SELF_HELP', 'TRAVEL', 'COOKING', 'ART', 'RELIGION', 'REFERENCE'];
 const initialForm = {
  isbn: '', title: '', author: '', publisher: '', publicationDate: '', price: '', quantity: '', categories: [], description: '', language: '',
 };
 export default function AddBook() {
  const [form, setForm] = useState(initialForm);
  const [message, setMessage] = useState(null);
  const [submitting, setSubmitting] = useState(false);
  function handleChange(e) {
    const { name, value } = e.target;
    setForm((prev) => ({ ...prev, [name]: value }));
  }
  function handleCategoryChange(e) {
    setForm((prev) => ({ ...prev, categories: e.target.value ? [e.target.value] : [] }));
  }
  function handleSubmit(e) {
    e.preventDefault();
    setSubmitting(true);
    setMessage(null);
    const payload = {
      ...form,
      isbn: Number(form.isbn),
      price: Number(form.price),
      quantity: Number(form.quantity),
    };
    registerBook(payload)
      .then((response) => {
        setMessage({ type: 'success', text: `Livre créé (id : ${response.data}) ✅` });
        setForm(initialForm);  
      })
      .catch((error) => {
        console.error(error);
        const status = error.response?.status;
        if (status === 406) setMessage({ type: 'error', text: 'Ce livre existe déjà.' });
        else if (status === 400) setMessage({ type: 'error', text: 'Données invalides, vérifie les champs.' });
        else setMessage({ type: 'error', text: 'Erreur lors de la création.' });
      })
      .finally(() => setSubmitting(false));
  }
  return (
    <main>
      <h1>Ajouter un livre</h1>
      <form onSubmit={handleSubmit}>
        <table>
            <tr>
                <td>ISBN</td>
                <td><input name="isbn" type="number" value={form.isbn} onChange={handleChange} required /></td>
            </tr>
            <tr>
                <td>Titre</td>
                <td><input name="title" value={form.title} onChange={handleChange} required /></td>
            </tr>
            <tr>
                <td>Auteur</td>
                <td><input name="author" value={form.author} onChange={handleChange} required /></td>
            </tr>
            <tr>
                <td>Éditeur</td>
                <td><input name="publisher" value={form.publisher} onChange={handleChange} required /></td>
            </tr>
            <tr>
                <td>Date de publication</td>
                <td><input name="publicationDate" type="date" value={form.publicationDate} onChange={handleChange} required /></td>
            </tr>
            <tr>
                <td>Prix</td>
                <td><input name="price" type="number" step="0.01" value={form.price} onChange={handleChange} required /></td>
            </tr>
            <tr>
                <td>Quantité</td>
                <td><input name="quantity" type="number" value={form.quantity} onChange={handleChange} required /></td>
            </tr>
            <tr>
                <td>Langue</td>
                <td><input name="language" value={form.language} onChange={handleChange} required /></td>
            </tr>
            <tr>
                <td>Catégorie</td>
                <td><select value={form.categories[0] || ''} onChange={handleCategoryChange} required><option value=""> choisir </option>{CATEGORIES.map((c) => <option key={c} value={c}>{c}</option>)}</select></td>
            </tr>
            <tr>
                <td>Description</td>
                <td><textarea name="description" value={form.description} onChange={handleChange} /></td>
            </tr>
        </table>
        <button type="submit" disabled={submitting}>
          {submitting ? 'Envoi…' : 'Ajouter le livre'}
        </button>
      </form>
      {message && <p>{message.text}</p>}
    </main>
  );
 }
@@ -1,5 +1,6 @@
 import { useState, useEffect } from 'react';
 import { getBooks } from '../api/books';
 import { Link } from 'react-router-dom';
 export default function Books() {
  const [books, setBooks] = useState([]);
@@ -27,6 +28,7 @@ export default function Books() {
  return (
    <main>
      <h1>Catalogue</h1>
      <Link to="/books/new">+ Ajouter un livre</Link>
      <ul>
        {books.map((book) => (
          <li key={book.isbn}>
@@ -1,38 +0,0 @@
 target/
 !.mvn/wrapper/maven-wrapper.jar
 !**/src/main/**/target/
 !**/src/test/**/target/
 ### IntelliJ IDEA ###
 .idea/modules.xml
 .idea/jarRepositories.xml
 .idea/compiler.xml
 .idea/libraries/
 *.iws
 *.iml
 *.ipr
 ### Eclipse ###
 .apt_generated
 .classpath
 .factorypath
 .project
 .settings
 .springBeans
 .sts4-cache
 ### NetBeans ###
 /nbproject/private/
 /nbbuild/
 /dist/
 /nbdist/
 /.nb-gradle/
 build/
 !**/src/main/**/build/
 !**/src/test/**/build/
 ### VS Code ###
 .vscode/
 ### Mac OS ###
 .DS_Store
@@ -1,78 +0,0 @@
 # mylibrary — back-end Java (méthode BDD)
 Back-end du projet **2026-DEV-BUT3**. Reproduit, en Java pur, le cœur métier
 de l'API consommée par le front React `my-library/`.
 ## Méthode
 Conformément au cours `maintenanceApplicativeCours1.pdf` (Behavior-Driven
 Development), pour chaque comportement on :
 1. Écrit le scénario attendu (en Gherkin / `.feature` ou en `@DisplayName` JUnit)
 2. Écrit le test qui le vérifie
 3. Implémente le code qui fait passer le test
 ## Structure (calquée sur le module `customer` fourni par le prof)
 ```
 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/
 ├─ customer/        Module fourni par l'enseignant (intact)
 │  ├─ CustomerInfo.java   record d'entrée
 │  ├─ CustomerDTO.java    DTO de sortie
 │  ├─ entity/             Customer (objet métier, règles fidélité)
 │  ├─ exception/          Exceptions métier
 │  ├─ converter/          Mapping Info <-> entity <-> DTO
 │  ├─ validator/          Règles de validation
 │  ├─ repository/         Stockage en mémoire (List)
 │  └─ usecase/            Cas d'usage (orchestration)
 └─ book/             Module développé en miroir (notre travail)
   └─ … (mêmes sous-paquets, même découpage)
 src/test/java/.../mylibrary/
 ├─ customer/         Tests JUnit fournis par l'enseignant
 ├─ book/             Tests JUnit que nous avons écrits
 └─ features/
   ├─ RunCucumberTest.java         (du prof, intact)
   ├─ client/CustomerSteps.java    (du prof, intact)
   ├─ book/BookSteps.java          (notre travail)
   └─ resources/features/
      ├─ client.feature            (du prof, intact)
      └─ book.feature              (notre travail)
 ```
 ## Dépendances
 Strictement les mêmes que dans le template du prof :
 - JUnit 5 (jupiter-api, params, engine + platform-suite, platform-engine, platform-launcher)
 - Mockito (core, junit-jupiter)
 - Cucumber (cucumber-java, cucumber-junit-platform-engine)
 - Lombok
 ## Build & test
 Pré-requis : **JDK 21** + **Maven 3.9+**
 ```bash
 mvn -f mylibrary test
 ```
 Cette commande exécute :
 - les tests unitaires JUnit (entity, validator, converter, repository, usecase, exceptions)
 - les scénarios Cucumber (`client.feature` + `book.feature`) via `RunCucumberTest`
 ## Périmètre couvert
 Conformément à la consigne (« reproduire le strict nécessaire pour démontrer
 la maîtrise »), l'API se limite aux deux domaines présents dans le swagger
 qui structurent l'app React :
 - **Catalogue** (`book`) : enregistrer, consulter par ISBN, lister tous les livres,
  refuser ISBN dupliqué, refuser un livre invalide, gérer le stock.
 - **Comptes clients** (`customer`) : enregistrer, consulter par téléphone, mettre
  à jour, supprimer, ajouter / retirer des points de fidélité (module fourni).
 L'exposition HTTP réelle utilisée par les développeurs front est l'API du prof
 (`mylibrary-0.0.1-SNAPSHOT.jar`) ; ce module sert à démontrer la maîtrise
 de la **conception métier en BDD/TDD**.
@@ -1,151 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>fr.iut_fbleau.but3.dev62</groupId>
  <artifactId>mylibrary</artifactId>
  <version>1.0-SNAPSHOT</version>
  <properties>
    <!--    Your java version-->
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!--    Main dependencies -->
    <lombok.version>1.18.36</lombok.version>
    <!--    Test Verisons-->
    <junit.version>5.11.4</junit.version>
    <junit.platform.version>1.11.4</junit.platform.version>
    <cucumber.version>7.21.1</cucumber.version>
    <mockito.version>5.16.0</mockito.version>
    <!--  Maven build version  -->
    <maven.compiler.version>3.13.0</maven.compiler.version>
    <maven.surefire.version>3.5.2</maven.surefire.version>
  </properties>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-bom</artifactId>
        <version>${cucumber.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <dependency>
        <groupId>org.junit</groupId>
        <artifactId>junit-bom</artifactId>
        <version>${junit.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>${lombok.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>io.cucumber</groupId>
      <artifactId>cucumber-java</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>io.cucumber</groupId>
      <artifactId>cucumber-junit-platform-engine</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.platform</groupId>
      <artifactId>junit-platform-suite</artifactId>
      <version>${junit.platform.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.platform</groupId>
      <artifactId>junit-platform-engine</artifactId>
      <version>${junit.platform.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-params</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-engine</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.platform</groupId>
      <artifactId>junit-platform-launcher</artifactId>
      <version>${junit.platform.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-core</artifactId>
      <version>${mockito.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-junit-jupiter</artifactId>
      <version>${mockito.version}</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>${maven.compiler.version}</version>
        <configuration>
          <encoding>${project.build.sourceEncoding}</encoding>
          <source>${maven.compiler.source}</source>
          <target>${maven.compiler.target}</target>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>${maven.surefire.version}</version>
        <configuration>
          <properties>
            <!-- Work around. Surefire does not include enough
                 information to disambiguate between different
                 examples and scenarios. -->
            <configurationParameters>
              cucumber.junit-platform.naming-strategy=long
            </configurationParameters>
          </properties>
        </configuration>
      </plugin>
    </plugins>
  </build>
 </project>
@@ -1,22 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Category;
 import java.time.LocalDate;
 import java.util.List;
 import lombok.Builder;
 import lombok.Getter;
@Builder
@Getter
 public class BookDTO {
  private final long isbn;
  private final String title;
  private final String author;
  private final String publisher;
  private final LocalDate publicationDate;
  private final double price;
  private final int quantity;
  private final List<Category> categories;
  private final String description;
  private final String language;
 }
@@ -1,19 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Category;
 import java.time.LocalDate;
 import java.util.List;
 public record BookInfo(
    long isbn,
    String title,
    String author,
    String publisher,
    LocalDate publicationDate,
    double price,
    int quantity,
    List<Category> categories,
    String description,
    String language
 ) {
 }
@@ -1,42 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.converter;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDTO;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
 public final class BookConverter {
  private BookConverter() {
  }
  public static Book toDomain(BookInfo book) {
    return Book.builder()
        .isbn(book.isbn())
        .title(book.title())
        .author(book.author())
        .publisher(book.publisher())
        .publicationDate(book.publicationDate())
        .price(book.price())
        .quantity(book.quantity())
        .categories(book.categories())
        .description(book.description())
        .language(book.language())
        .build();
  }
  public static BookDTO toDTO(Book book) {
    return BookDTO.builder()
        .isbn(book.getIsbn())
        .title(book.getTitle())
        .author(book.getAuthor())
        .publisher(book.getPublisher())
        .publicationDate(book.getPublicationDate())
        .price(book.getPrice())
        .quantity(book.getQuantity())
        .categories(book.getCategories())
        .description(book.getDescription())
        .language(book.getLanguage())
        .build();
  }
 }
@@ -1,24 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.entity;
 public enum Category {
  FICTION,
  NON_FICTION,
  SCIENCE_FICTION,
  FANTASY,
  MYSTERY,
  THRILLER,
  ROMANCE,
  BIOGRAPHY,
  HISTORY,
  POETRY,
  CHILDRENS,
  YOUNG_ADULT,
  SCIENCE,
  PHILOSOPHY,
  SELF_HELP,
  TRAVEL,
  COOKING,
  ART,
  RELIGION,
  REFERENCE
 }
@@ -1,13 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
 import java.text.MessageFormat;
 public class BookAlreadyExistsException extends Exception {
  public static final String A_BOOK_WITH_ISBN_ALREADY_EXISTS_MESSAGE = "A book with isbn {0} already exists";
  public BookAlreadyExistsException(long isbn) {
    // ISBN passe en String pour ne pas que MessageFormat ajoute le separateur de milliers
    super(MessageFormat.format(A_BOOK_WITH_ISBN_ALREADY_EXISTS_MESSAGE, String.valueOf(isbn)));
  }
 }
@@ -1,13 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
 import java.text.MessageFormat;
 public class BookNotFoundException extends Exception {
  public static final String THE_BOOK_WITH_ISBN_DOES_NOT_EXIST_MESSAGE = "The book with isbn {0} does not exist";
  public BookNotFoundException(long isbn) {
    // ISBN passe en String pour ne pas que MessageFormat ajoute le separateur de milliers
    super(MessageFormat.format(THE_BOOK_WITH_ISBN_DOES_NOT_EXIST_MESSAGE, String.valueOf(isbn)));
  }
 }
@@ -1,12 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
 import java.text.MessageFormat;
 public class IllegalBookQuantityException extends Exception {
  public static final String CANNOT_REMOVE_STOCK = "Cannot remove {0} units from {1} units in stock";
  public IllegalBookQuantityException(int needed, int actual) {
    super(MessageFormat.format(CANNOT_REMOVE_STOCK, needed, actual));
  }
 }
@@ -1,8 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
 public class NotValidBookException extends Exception {
  public NotValidBookException(String message) {
    super(message);
  }
 }
@@ -1,42 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.repository;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import lombok.NoArgsConstructor;
@NoArgsConstructor
 public final class BookRepository {
  private final List<Book> books = new ArrayList<>();
  public List<Book> findAll() {
    return books;
  }
  public void deleteAll() {
    books.clear();
  }
  public Book save(Book book) {
    Optional<Book> existing = findByIsbn(book.getIsbn());
    existing.ifPresent(books::remove);
    books.add(book);
    return book;
  }
  public Optional<Book> findByIsbn(long isbn) {
    return books.stream()
        .filter(b -> b.getIsbn() == isbn)
        .findFirst();
  }
  public boolean existsByIsbn(long isbn) {
    return books.stream().anyMatch(b -> b.getIsbn() == isbn);
  }
  public void delete(Book book) {
    books.remove(book);
  }
 }
@@ -1,46 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.usecase;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDTO;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.converter.BookConverter;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookAlreadyExistsException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.validator.BookValidator;
 import java.util.List;
 import java.util.Optional;
 public final class BookUseCase {
  private final BookRepository bookRepository;
  public BookUseCase(BookRepository bookRepository) {
    this.bookRepository = bookRepository;
  }
  public long registerBook(BookInfo bookInfo) throws NotValidBookException, BookAlreadyExistsException {
    BookValidator.validate(bookInfo);
    if (bookRepository.existsByIsbn(bookInfo.isbn())) {
      throw new BookAlreadyExistsException(bookInfo.isbn());
    }
    Book toRegister = BookConverter.toDomain(bookInfo);
    Book registered = bookRepository.save(toRegister);
    return registered.getIsbn();
  }
  public BookDTO getBookByIsbn(long isbn) throws BookNotFoundException {
    Optional<Book> optional = bookRepository.findByIsbn(isbn);
    if (optional.isEmpty()) {
      throw new BookNotFoundException(isbn);
    }
    return BookConverter.toDTO(optional.get());
  }
  public List<BookDTO> getAllBooks() {
    return bookRepository.findAll().stream()
        .map(BookConverter::toDTO)
        .toList();
  }
 }
@@ -1,93 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.validator;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
 public final class BookValidator {
  public static final int TITLE_MAX_LENGTH = 255;
  public static final String ISBN_MUST_BE_POSITIVE = "Isbn must be a positive number";
  public static final String TITLE_CANNOT_BE_BLANK = "Title cannot be blank";
  public static final String TITLE_TOO_LONG = "Title cannot exceed " + TITLE_MAX_LENGTH + " characters";
  public static final String AUTHOR_CANNOT_BE_BLANK = "Author cannot be blank";
  public static final String PUBLISHER_CANNOT_BE_BLANK = "Publisher cannot be blank";
  public static final String PUBLICATION_DATE_REQUIRED = "Publication date is required";
  public static final String PRICE_MUST_BE_POSITIVE = "Price must be strictly positive";
  public static final String QUANTITY_MUST_BE_POSITIVE_OR_ZERO = "Quantity must be >= 0";
  public static final String CATEGORIES_REQUIRED = "At least one category is required";
  public static final String LANGUAGE_CANNOT_BE_BLANK = "Language cannot be blank";
  private BookValidator() {
  }
  public static void validate(BookInfo book) throws NotValidBookException {
    validateIsbn(book);
    validateTitle(book);
    validateAuthor(book);
    validatePublisher(book);
    validatePublicationDate(book);
    validatePrice(book);
    validateQuantity(book);
    validateCategories(book);
    validateLanguage(book);
  }
  private static void validateIsbn(BookInfo book) throws NotValidBookException {
    if (book.isbn() <= 0) {
      throw new NotValidBookException(ISBN_MUST_BE_POSITIVE);
    }
  }
  private static void validateTitle(BookInfo book) throws NotValidBookException {
    if (book.title() == null || book.title().isBlank()) {
      throw new NotValidBookException(TITLE_CANNOT_BE_BLANK);
    }
    if (book.title().length() > TITLE_MAX_LENGTH) {
      throw new NotValidBookException(TITLE_TOO_LONG);
    }
  }
  private static void validateAuthor(BookInfo book) throws NotValidBookException {
    if (book.author() == null || book.author().isBlank()) {
      throw new NotValidBookException(AUTHOR_CANNOT_BE_BLANK);
    }
  }
  private static void validatePublisher(BookInfo book) throws NotValidBookException {
    if (book.publisher() == null || book.publisher().isBlank()) {
      throw new NotValidBookException(PUBLISHER_CANNOT_BE_BLANK);
    }
  }
  private static void validatePublicationDate(BookInfo book) throws NotValidBookException {
    if (book.publicationDate() == null) {
      throw new NotValidBookException(PUBLICATION_DATE_REQUIRED);
    }
  }
  private static void validatePrice(BookInfo book) throws NotValidBookException {
    if (book.price() <= 0) {
      throw new NotValidBookException(PRICE_MUST_BE_POSITIVE);
    }
  }
  private static void validateQuantity(BookInfo book) throws NotValidBookException {
    if (book.quantity() < 0) {
      throw new NotValidBookException(QUANTITY_MUST_BE_POSITIVE_OR_ZERO);
    }
  }
  private static void validateCategories(BookInfo book) throws NotValidBookException {
    if (book.categories() == null || book.categories().isEmpty()) {
      throw new NotValidBookException(CATEGORIES_REQUIRED);
    }
  }
  private static void validateLanguage(BookInfo book) throws NotValidBookException {
    if (book.language() == null || book.language().isBlank()) {
      throw new NotValidBookException(LANGUAGE_CANNOT_BE_BLANK);
    }
  }
 }
@@ -1,15 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer;
 import java.util.UUID;
 import lombok.Builder;
 import lombok.Getter;
@Builder
@Getter
 public class CustomerDTO {
  private final UUID id;
  private final String firstName;
  private final String lastName;
  private final String phoneNumber;
  private final int loyaltyPoints;
 }
@@ -1,4 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer;
 public record CustomerInfo(String firstName, String lastName, String phoneNumber) {
 }
@@ -1,30 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.converter;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerDTO;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
 public final class CustomerConverter {
  private CustomerConverter(){
  }
  public static Customer toDomain(CustomerInfo newCustomer) {
    return Customer.builder()
        .firstName(newCustomer.firstName())
        .lastName(newCustomer.lastName())
        .phoneNumber(newCustomer.phoneNumber())
        .loyaltyPoints(0)
        .build();
  }
  public static CustomerDTO toDTO(Customer customer) {
    return CustomerDTO.builder()
        .id(customer.getId())
        .firstName(customer.getFirstName())
        .lastName(customer.getLastName())
        .phoneNumber(customer.getPhoneNumber())
        .loyaltyPoints(customer.getLoyaltyPoints())
        .build();
  }
 }
@@ -1,30 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.entity;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.IllegalCustomerPointException;
 import java.util.UUID;
 import lombok.Builder;
 import lombok.Getter;
@Builder
@Getter
 public class Customer {
 private UUID id;
 private String firstName;
 private String lastName;
 private String phoneNumber;
 private int loyaltyPoints;
 public void setRandomUUID() {
  this.id = UUID.randomUUID();
 }
 public void addLoyaltyPoints(int loyaltyPointToAdd) {
  this.loyaltyPoints += loyaltyPointToAdd;
 }
 public void removeLoyaltyPoints(int loyaltyPointToRemove) throws IllegalCustomerPointException {
  if (loyaltyPointToRemove > this.loyaltyPoints) throw new IllegalCustomerPointException(loyaltyPointToRemove, this.loyaltyPoints);
  this.loyaltyPoints -= loyaltyPointToRemove;
 }
 }
@@ -1,13 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.exception;
 import java.text.MessageFormat;
 import java.util.UUID;
 public class CustomerNotFoundException extends Exception {
  public static final String THE_CUSTOMER_WITH_ID_DOES_NOT_EXIST_MESSAGE = "The customer with id {0} does not exist";
  public CustomerNotFoundException(UUID uuid) {
    super(MessageFormat.format(THE_CUSTOMER_WITH_ID_DOES_NOT_EXIST_MESSAGE, uuid));
  }
 }
@@ -1,13 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.exception;
 import java.text.MessageFormat;
 public class IllegalCustomerPointException extends Exception {
  public static final String CANNOT_REMOVE_LOYALTY_POINTS = "Cannot remove {0} points from {1} points";
  public IllegalCustomerPointException(int needed, int actual) {
    super(MessageFormat.format(CANNOT_REMOVE_LOYALTY_POINTS, needed,
        actual));
  }
 }
@@ -1,8 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.exception;
 public class NotValidCustomerException extends Exception {
  public NotValidCustomerException(String message) {
    super(message);
  }
 }
@@ -1,49 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.repository;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
 import lombok.NoArgsConstructor;
@NoArgsConstructor
 public final class CustomerRepository {
  private final List<Customer> customers = new ArrayList<>();
  public List<Customer> findAll() {
    return customers;
  }
  public void deleteAll() {
    customers.clear();
  }
  public Customer save(Customer newCustomer) {
    Optional<Customer> optionalCustomerWithSameId = this.findById(newCustomer.getId());
    optionalCustomerWithSameId.ifPresentOrElse(customers::remove, newCustomer::setRandomUUID);
    this.customers.add(newCustomer);
    return newCustomer;
  }
  public Optional<Customer> findById(UUID uuid) {
    return this.customers.stream()
        .filter(customer -> customer.getId().equals(uuid))
        .findFirst();
  }
  public boolean existsById(UUID uuid) {
    return this.customers.stream()
        .anyMatch(customer -> customer.getId().equals(uuid));
  }
  public Optional<Customer> findByPhoneNumber(String phoneNumber) {
    return this.customers.stream()
        .filter(customer -> customer.getPhoneNumber().equals(phoneNumber))
        .findFirst();
  }
  public void delete(Customer customer) {
    this.customers.remove(customer);
  }
 }
@@ -1,81 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.usecase;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerDTO;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.converter.CustomerConverter;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.CustomerNotFoundException;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.IllegalCustomerPointException;
 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.validator.CustomerValidator;
 import java.util.Optional;
 import java.util.UUID;
 public final class CustomerUseCase {
  private final CustomerRepository customerRepository;
  public CustomerUseCase(CustomerRepository customerRepository) {
    this.customerRepository = customerRepository;
  }
  public UUID registerCustomer(CustomerInfo newCustomer) throws NotValidCustomerException {
    CustomerValidator.validate(newCustomer);
    Customer customerToRegister = CustomerConverter.toDomain(newCustomer);
    Customer customerToRegistered = customerRepository.save(customerToRegister);
    return customerToRegistered.getId();
  }
  public Optional<CustomerDTO> findCustomerByPhoneNumber(String phoneNumber) {
    Optional<Customer> optionalCustomer = customerRepository.findByPhoneNumber(phoneNumber);
    return optionalCustomer.map(CustomerConverter::toDTO);
  }
  public CustomerDTO updateCustomer(UUID uuid, CustomerInfo customerInfo)
      throws CustomerNotFoundException, NotValidCustomerException {
    CustomerValidator.validate(customerInfo);
    Customer customerByUUID = getCustomerIfDoesNotExistThrowCustomerNotFoundException(
        uuid);
    Customer customer = Customer.builder()
        .id(uuid)
        .firstName(customerInfo.firstName())
        .lastName(customerInfo.lastName())
        .phoneNumber(customerInfo.phoneNumber())
        .loyaltyPoints(customerByUUID.getLoyaltyPoints())
        .build();
    Customer updatedCustomer = customerRepository.save(customer);
    return CustomerConverter.toDTO(updatedCustomer);
  }
  public void deleteCustomer(UUID uuid) throws CustomerNotFoundException {
    Customer customerToDelete = getCustomerIfDoesNotExistThrowCustomerNotFoundException(uuid);
    this.customerRepository.delete(customerToDelete);
  }
  public int addLoyaltyPoints(UUID uuid, int loyaltyPointToAdd) throws CustomerNotFoundException {
    Customer customerToAddLoyaltyPoints = getCustomerIfDoesNotExistThrowCustomerNotFoundException(
        uuid);
    customerToAddLoyaltyPoints.addLoyaltyPoints(loyaltyPointToAdd);
    customerRepository.save(customerToAddLoyaltyPoints);
    return customerToAddLoyaltyPoints.getLoyaltyPoints();
  }
  public int subtractLoyaltyPoints(UUID uuid, int loyaltyPointToRemove)
      throws CustomerNotFoundException, IllegalCustomerPointException {
    Customer customerToSubtractLoyaltyPoints = getCustomerIfDoesNotExistThrowCustomerNotFoundException(
        uuid);
    customerToSubtractLoyaltyPoints.removeLoyaltyPoints(loyaltyPointToRemove);
    customerRepository.save(customerToSubtractLoyaltyPoints);
    return customerToSubtractLoyaltyPoints.getLoyaltyPoints();
  }
  private Customer getCustomerIfDoesNotExistThrowCustomerNotFoundException(UUID uuid)
      throws CustomerNotFoundException {
    Optional<Customer> optionalCustomerById = customerRepository.findById(uuid);
    if (optionalCustomerById.isEmpty()) {
      throw new CustomerNotFoundException(uuid);
    }
    return optionalCustomerById.get();
  }
 }
@@ -1,44 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.validator;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.NotValidCustomerException;
 public final class CustomerValidator {
  public static final String PHONE_NUMBER_IS_NOT_VALID = "Phone number is not valid";
  public static final String LAST_NAME_CANNOT_BE_BLANK = "Last name cannot be blank";
  public static final String FIRST_NAME_CANNOT_BE_BLANK = "First name cannot be blank";
  public static final String PHONE_NUMBER_REGEX = "0([67])\\d{8}";
  private CustomerValidator() {
  }
  public static void validate(CustomerInfo newCustomer) throws NotValidCustomerException {
    validateFirstName(newCustomer);
    validateLastName(newCustomer);
    validatePhoneNumber(newCustomer);
  }
  private static void validatePhoneNumber(CustomerInfo newCustomer)
      throws NotValidCustomerException {
    if (newCustomer.phoneNumber().isBlank()) {
      throw new NotValidCustomerException("Phone number cannot be blank");
    }
    if (!newCustomer.phoneNumber().matches(PHONE_NUMBER_REGEX)) {
      throw new NotValidCustomerException(PHONE_NUMBER_IS_NOT_VALID);
    }
  }
  private static void validateLastName(CustomerInfo newCustomer) throws NotValidCustomerException {
    if (newCustomer.lastName().isBlank()) {
      throw new NotValidCustomerException(LAST_NAME_CANNOT_BE_BLANK);
    }
  }
  private static void validateFirstName(CustomerInfo newCustomer) throws NotValidCustomerException {
    if (newCustomer.firstName().isBlank()) {
      throw new NotValidCustomerException(FIRST_NAME_CANNOT_BE_BLANK);
    }
  }
 }
@@ -1,86 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.converter;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDTO;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Category;
 import java.time.LocalDate;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.*;
 class BookConverterTest {
  @Nested
  @DisplayName("toDomain() method tests")
  class ToDomainTests {
    @Test
    @DisplayName("Should convert BookInfo to Book entity preserving all fields")
    void testToDomain() {
      BookInfo info = new BookInfo(
          9780321125217L,
          "DDD",
          "Evans",
          "Addison-Wesley",
          LocalDate.of(2003, 8, 22),
          54.99,
          10,
          List.of(Category.SCIENCE),
          "desc",
          "EN"
      );
      Book book = BookConverter.toDomain(info);
      assertEquals(info.isbn(), book.getIsbn());
      assertEquals(info.title(), book.getTitle());
      assertEquals(info.author(), book.getAuthor());
      assertEquals(info.publisher(), book.getPublisher());
      assertEquals(info.publicationDate(), book.getPublicationDate());
      assertEquals(info.price(), book.getPrice());
      assertEquals(info.quantity(), book.getQuantity());
      assertEquals(info.categories(), book.getCategories());
      assertEquals(info.description(), book.getDescription());
      assertEquals(info.language(), book.getLanguage());
    }
  }
  @Nested
  @DisplayName("toDTO() method tests")
  class ToDTOTests {
    @Test
    @DisplayName("Should convert Book entity to BookDTO preserving all fields")
    void testToDTO() {
      Book book = Book.builder()
          .isbn(123L)
          .title("T")
          .author("A")
          .publisher("P")
          .publicationDate(LocalDate.of(2020, 1, 1))
          .price(9.99)
          .quantity(5)
          .categories(List.of(Category.FICTION))
          .description("d")
          .language("FR")
          .build();
      BookDTO dto = BookConverter.toDTO(book);
      assertEquals(123L, dto.getIsbn());
      assertEquals("T", dto.getTitle());
      assertEquals("A", dto.getAuthor());
      assertEquals("P", dto.getPublisher());
      assertEquals(LocalDate.of(2020, 1, 1), dto.getPublicationDate());
      assertEquals(9.99, dto.getPrice());
      assertEquals(5, dto.getQuantity());
      assertEquals(List.of(Category.FICTION), dto.getCategories());
      assertEquals("d", dto.getDescription());
      assertEquals("FR", dto.getLanguage());
    }
  }
 }
@@ -1,75 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.entity;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.IllegalBookQuantityException;
 import java.time.LocalDate;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.*;
 class BookTest {
  @Test
  @DisplayName("Builder should create a valid Book instance")
  void testBookBuilder() {
    long isbn = 9780321125217L;
    Book book = Book.builder()
        .isbn(isbn)
        .title("Domain-Driven Design")
        .author("Eric Evans")
        .publisher("Addison-Wesley")
        .publicationDate(LocalDate.of(2003, 8, 22))
        .price(54.99)
        .quantity(10)
        .categories(List.of(Category.SCIENCE, Category.REFERENCE))
        .description("Tackling complexity in the heart of software")
        .language("EN")
        .build();
    assertEquals(isbn, book.getIsbn());
    assertEquals("Domain-Driven Design", book.getTitle());
    assertEquals("Eric Evans", book.getAuthor());
    assertEquals("Addison-Wesley", book.getPublisher());
    assertEquals(LocalDate.of(2003, 8, 22), book.getPublicationDate());
    assertEquals(54.99, book.getPrice());
    assertEquals(10, book.getQuantity());
    assertEquals(List.of(Category.SCIENCE, Category.REFERENCE), book.getCategories());
    assertEquals("EN", book.getLanguage());
  }
  @Nested
  @DisplayName("Stock management")
  class StockTests {
    @Test
    @DisplayName("addStock should increase the quantity")
    void testAddStock() {
      Book book = Book.builder().quantity(5).build();
      book.addStock(7);
      assertEquals(12, book.getQuantity());
    }
    @Test
    @DisplayName("removeStock should decrease the quantity")
    void testRemoveStock() throws IllegalBookQuantityException {
      Book book = Book.builder().quantity(5).build();
      book.removeStock(3);
      assertEquals(2, book.getQuantity());
    }
    @Test
    @DisplayName("removeStock should throw when removing more than available")
    void testRemoveTooMuchStock() {
      Book book = Book.builder().quantity(5).build();
      IllegalBookQuantityException exception = assertThrows(
          IllegalBookQuantityException.class,
          () -> book.removeStock(10)
      );
      assertEquals(5, book.getQuantity());
      assertTrue(exception.getMessage().contains("10"));
      assertTrue(exception.getMessage().contains("5"));
    }
  }
 }
@@ -1,26 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.*;
 class BookAlreadyExistsExceptionTest {
  @Test
  @DisplayName("Exception message should contain the ISBN provided")
  void testExceptionMessageContainsIsbn() {
    long isbn = 9780321125217L;
    BookAlreadyExistsException exception = new BookAlreadyExistsException(isbn);
    assertTrue(exception.getMessage().contains(String.valueOf(isbn)));
  }
  @Test
  @DisplayName("Exception should expose its message constant")
  void testConstantMessage() {
    assertEquals("A book with isbn {0} already exists",
        BookAlreadyExistsException.A_BOOK_WITH_ISBN_ALREADY_EXISTS_MESSAGE);
  }
 }
@@ -1,37 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.*;
 class BookNotFoundExceptionTest {
  @Test
  @DisplayName("Exception message should contain the ISBN provided")
  void testExceptionMessageContainsIsbn() {
    long isbn = 9780321125217L;
    BookNotFoundException exception = new BookNotFoundException(isbn);
    assertTrue(exception.getMessage().contains(String.valueOf(isbn)));
  }
  @Test
  @DisplayName("Exception should expose its message constant")
  void testConstantMessage() {
    assertEquals("The book with isbn {0} does not exist",
        BookNotFoundException.THE_BOOK_WITH_ISBN_DOES_NOT_EXIST_MESSAGE);
  }
  @Test
  @DisplayName("Exception should be properly thrown and caught")
  void testExceptionCanBeThrownAndCaught() {
    long isbn = 1L;
    try {
      throw new BookNotFoundException(isbn);
    } catch (BookNotFoundException e) {
      assertTrue(e.getMessage().contains("1"));
    }
  }
 }
@@ -1,33 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
 import java.text.MessageFormat;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
 import static org.junit.jupiter.api.Assertions.*;
 class IllegalBookQuantityExceptionTest {
  @Test
  @DisplayName("Exception message should contain the requested and actual quantities")
  void testExceptionMessageContainsQuantities() {
    IllegalBookQuantityException exception = new IllegalBookQuantityException(10, 3);
    String expected = "Cannot remove 10 units from 3 units in stock";
    assertEquals(expected, exception.getMessage());
  }
  @ParameterizedTest
  @CsvSource({
      "10, 3",
      "100, 0",
      "5, 4"
  })
  @DisplayName("Message should be formatted using the constant template")
  void testFormattedMessage(int needed, int actual) {
    IllegalBookQuantityException exception = new IllegalBookQuantityException(needed, actual);
    String expected = MessageFormat.format(IllegalBookQuantityException.CANNOT_REMOVE_STOCK, needed, actual);
    assertEquals(expected, exception.getMessage());
  }
 }
@@ -1,44 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 import static org.junit.jupiter.api.Assertions.*;
 class NotValidBookExceptionTest {
  @Test
  @DisplayName("Exception should be created with the provided message")
  void testExceptionCreation() {
    String msg = "title cannot be blank";
    NotValidBookException exception = new NotValidBookException(msg);
    assertEquals(msg, exception.getMessage());
  }
  @ParameterizedTest
  @ValueSource(strings = {
      "Title cannot be blank",
      "Author cannot be blank",
      "Price must be strictly positive",
      "At least one category is required"
  })
  @DisplayName("Exception should propagate any validation message")
  void testExceptionWithDifferentMessages(String message) {
    NotValidBookException exception = new NotValidBookException(message);
    assertEquals(message, exception.getMessage());
  }
  @Test
  @DisplayName("Exception should be catchable as a general Exception")
  void testExceptionInheritance() {
    String msg = "invalid book";
    try {
      throw new NotValidBookException(msg);
    } catch (Exception e) {
      assertEquals(NotValidBookException.class, e.getClass());
      assertEquals(msg, e.getMessage());
    }
  }
 }
@@ -1,149 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.repository;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Category;
 import java.time.LocalDate;
 import java.util.List;
 import java.util.Optional;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.*;
 class BookRepositoryTest {
  private BookRepository repository;
  private Book book1;
  private Book book2;
  @BeforeEach
  void setUp() {
    repository = new BookRepository();
    book1 = Book.builder()
        .isbn(1111111111111L)
        .title("Book One")
        .author("Author A")
        .publisher("Pub")
        .publicationDate(LocalDate.of(2020, 1, 1))
        .price(10.0)
        .quantity(2)
        .categories(List.of(Category.FICTION))
        .language("EN")
        .build();
    book2 = Book.builder()
        .isbn(2222222222222L)
        .title("Book Two")
        .author("Author B")
        .publisher("Pub")
        .publicationDate(LocalDate.of(2021, 1, 1))
        .price(20.0)
        .quantity(0)
        .categories(List.of(Category.HISTORY))
        .language("FR")
        .build();
  }
  @Test
  @DisplayName("New repository should be empty")
  void testNewRepositoryIsEmpty() {
    assertTrue(repository.findAll().isEmpty());
  }
  @Nested
  @DisplayName("Save operations")
  class SaveOperations {
    @Test
    @DisplayName("Save should add a new book")
    void testSave() {
      Book saved = repository.save(book1);
      assertEquals(1, repository.findAll().size());
      assertEquals(book1.getIsbn(), saved.getIsbn());
    }
    @Test
    @DisplayName("Save should replace existing book with same ISBN (idempotency)")
    void testSaveReplacesExisting() {
      repository.save(book1);
      Book updated = Book.builder()
          .isbn(book1.getIsbn())
          .title("New title")
          .author("Author A")
          .publisher("Pub")
          .publicationDate(LocalDate.of(2020, 1, 1))
          .price(10.0)
          .quantity(99)
          .categories(List.of(Category.FICTION))
          .language("EN")
          .build();
      repository.save(updated);
      assertEquals(1, repository.findAll().size());
      assertEquals(99, repository.findByIsbn(book1.getIsbn()).orElseThrow().getQuantity());
      assertEquals("New title", repository.findByIsbn(book1.getIsbn()).orElseThrow().getTitle());
    }
  }
  @Nested
  @DisplayName("Find operations")
  class FindOperations {
    @BeforeEach
    void seed() {
      repository.save(book1);
      repository.save(book2);
    }
    @Test
    @DisplayName("findByIsbn returns the matching book")
    void testFindByIsbn() {
      Optional<Book> found = repository.findByIsbn(book1.getIsbn());
      assertTrue(found.isPresent());
      assertEquals(book1.getTitle(), found.get().getTitle());
    }
    @Test
    @DisplayName("findByIsbn returns empty when not found")
    void testFindByIsbnNotFound() {
      assertTrue(repository.findByIsbn(99L).isEmpty());
    }
    @Test
    @DisplayName("existsByIsbn returns true / false consistently")
    void testExistsByIsbn() {
      assertTrue(repository.existsByIsbn(book1.getIsbn()));
      assertFalse(repository.existsByIsbn(99L));
    }
  }
  @Nested
  @DisplayName("Delete operations")
  class DeleteOperations {
    @BeforeEach
    void seed() {
      repository.save(book1);
      repository.save(book2);
    }
    @Test
    @DisplayName("delete should remove the specified book")
    void testDelete() {
      repository.delete(book1);
      assertEquals(1, repository.findAll().size());
      assertFalse(repository.existsByIsbn(book1.getIsbn()));
    }
    @Test
    @DisplayName("deleteAll should clear the repository")
    void testDeleteAll() {
      repository.deleteAll();
      assertTrue(repository.findAll().isEmpty());
    }
  }
 }
@@ -1,152 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.usecase;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDTO;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Category;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookAlreadyExistsException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
 import java.time.LocalDate;
 import java.util.List;
 import java.util.Optional;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
 class BookUseCaseTest {
  @Mock
  private BookRepository bookRepository;
  @InjectMocks
  private BookUseCase bookUseCase;
  private BookInfo validInfo;
  private Book validBook;
  @BeforeEach
  void setUp() {
    validInfo = new BookInfo(
        9780321125217L,
        "DDD",
        "Evans",
        "Addison-Wesley",
        LocalDate.of(2003, 8, 22),
        54.99,
        10,
        List.of(Category.SCIENCE),
        "desc",
        "EN"
    );
    validBook = Book.builder()
        .isbn(validInfo.isbn())
        .title(validInfo.title())
        .author(validInfo.author())
        .publisher(validInfo.publisher())
        .publicationDate(validInfo.publicationDate())
        .price(validInfo.price())
        .quantity(validInfo.quantity())
        .categories(validInfo.categories())
        .description(validInfo.description())
        .language(validInfo.language())
        .build();
  }
  @Nested
  @DisplayName("registerBook tests")
  class RegisterTests {
    @Test
    @DisplayName("Should register a new book and return its ISBN")
    void testRegisterBook() throws NotValidBookException, BookAlreadyExistsException {
      when(bookRepository.existsByIsbn(validInfo.isbn())).thenReturn(false);
      when(bookRepository.save(any(Book.class))).thenReturn(validBook);
      long isbn = bookUseCase.registerBook(validInfo);
      assertEquals(validInfo.isbn(), isbn);
      verify(bookRepository).existsByIsbn(validInfo.isbn());
      verify(bookRepository).save(any(Book.class));
    }
    @Test
    @DisplayName("Should reject invalid book information without touching the repository")
    void testRegisterInvalidBook() {
      BookInfo invalid = new BookInfo(0L, "", "", "", null, -1, -1, null, "", "");
      assertThrows(NotValidBookException.class, () -> bookUseCase.registerBook(invalid));
      verifyNoInteractions(bookRepository);
    }
    @Test
    @DisplayName("Should reject duplicate ISBN")
    void testRegisterDuplicate() {
      when(bookRepository.existsByIsbn(validInfo.isbn())).thenReturn(true);
      assertThrows(BookAlreadyExistsException.class, () -> bookUseCase.registerBook(validInfo));
      verify(bookRepository).existsByIsbn(validInfo.isbn());
      verify(bookRepository, never()).save(any(Book.class));
    }
  }
  @Nested
  @DisplayName("getBookByIsbn tests")
  class GetByIdTests {
    @Test
    @DisplayName("Should return the BookDTO when ISBN exists")
    void testGetById() throws BookNotFoundException {
      when(bookRepository.findByIsbn(validInfo.isbn())).thenReturn(Optional.of(validBook));
      BookDTO dto = bookUseCase.getBookByIsbn(validInfo.isbn());
      assertEquals(validInfo.isbn(), dto.getIsbn());
      assertEquals(validInfo.title(), dto.getTitle());
    }
    @Test
    @DisplayName("Should throw when ISBN does not exist")
    void testGetByIdNotFound() {
      when(bookRepository.findByIsbn(99L)).thenReturn(Optional.empty());
      assertThrows(BookNotFoundException.class, () -> bookUseCase.getBookByIsbn(99L));
    }
  }
  @Nested
  @DisplayName("getAllBooks tests")
  class GetAllBooksTests {
    @Test
    @DisplayName("Should map every book returned by the repository to a DTO")
    void testGetAllBooks() {
      when(bookRepository.findAll()).thenReturn(List.of(validBook));
      List<BookDTO> result = bookUseCase.getAllBooks();
      assertEquals(1, result.size());
      assertEquals(validBook.getIsbn(), result.getFirst().getIsbn());
      assertEquals(validBook.getTitle(), result.getFirst().getTitle());
      verify(bookRepository).findAll();
    }
    @Test
    @DisplayName("Should return an empty list when no book is stored")
    void testGetAllBooksWhenEmpty() {
      when(bookRepository.findAll()).thenReturn(List.of());
      List<BookDTO> result = bookUseCase.getAllBooks();
      assertTrue(result.isEmpty());
    }
  }
 }
@@ -1,167 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.validator;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Category;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
 import java.time.LocalDate;
 import java.util.List;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 import static org.junit.jupiter.api.Assertions.*;
 class BookValidatorTest {
  private BookInfo valid() {
    return new BookInfo(
        9780321125217L,
        "Domain-Driven Design",
        "Eric Evans",
        "Addison-Wesley",
        LocalDate.of(2003, 8, 22),
        54.99,
        10,
        List.of(Category.SCIENCE),
        "Tackling complexity in the heart of software",
        "EN"
    );
  }
  @Test
  @DisplayName("Should accept a valid BookInfo")
  void testValidBook() {
    assertDoesNotThrow(() -> BookValidator.validate(valid()));
  }
  @Nested
  @DisplayName("ISBN validation")
  class IsbnTests {
    @ParameterizedTest
    @ValueSource(longs = {0L, -1L, -9999L})
    @DisplayName("Should reject ISBN that is not strictly positive")
    void testInvalidIsbn(long isbn) {
      BookInfo info = new BookInfo(isbn, "T", "A", "P", LocalDate.now(), 1.0, 0, List.of(Category.SCIENCE), "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.ISBN_MUST_BE_POSITIVE, ex.getMessage());
    }
  }
  @Nested
  @DisplayName("Title validation")
  class TitleTests {
    @ParameterizedTest
    @ValueSource(strings = {"", " ", "\t", "\n"})
    @DisplayName("Should reject blank title")
    void testBlankTitle(String title) {
      BookInfo info = new BookInfo(1L, title, "A", "P", LocalDate.now(), 1.0, 0, List.of(Category.SCIENCE), "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.TITLE_CANNOT_BE_BLANK, ex.getMessage());
    }
    @Test
    @DisplayName("Should reject null title")
    void testNullTitle() {
      BookInfo info = new BookInfo(1L, null, "A", "P", LocalDate.now(), 1.0, 0, List.of(Category.SCIENCE), "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.TITLE_CANNOT_BE_BLANK, ex.getMessage());
    }
    @Test
    @DisplayName("Should reject title longer than 255 characters")
    void testTitleTooLong() {
      String longTitle = "a".repeat(256);
      BookInfo info = new BookInfo(1L, longTitle, "A", "P", LocalDate.now(), 1.0, 0, List.of(Category.SCIENCE), "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.TITLE_TOO_LONG, ex.getMessage());
    }
  }
  @Nested
  @DisplayName("Author / Publisher validation")
  class AuthorPublisherTests {
    @ParameterizedTest
    @ValueSource(strings = {"", " ", "\t"})
    @DisplayName("Should reject blank author")
    void testBlankAuthor(String author) {
      BookInfo info = new BookInfo(1L, "T", author, "P", LocalDate.now(), 1.0, 0, List.of(Category.SCIENCE), "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.AUTHOR_CANNOT_BE_BLANK, ex.getMessage());
    }
    @ParameterizedTest
    @ValueSource(strings = {"", " ", "\t"})
    @DisplayName("Should reject blank publisher")
    void testBlankPublisher(String publisher) {
      BookInfo info = new BookInfo(1L, "T", "A", publisher, LocalDate.now(), 1.0, 0, List.of(Category.SCIENCE), "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.PUBLISHER_CANNOT_BE_BLANK, ex.getMessage());
    }
  }
  @Nested
  @DisplayName("Date / Price / Quantity validation")
  class NumericTests {
    @Test
    @DisplayName("Should reject null publication date")
    void testNullDate() {
      BookInfo info = new BookInfo(1L, "T", "A", "P", null, 1.0, 0, List.of(Category.SCIENCE), "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.PUBLICATION_DATE_REQUIRED, ex.getMessage());
    }
    @ParameterizedTest
    @ValueSource(doubles = {0.0, -0.01, -10.0})
    @DisplayName("Should reject non-positive price")
    void testNonPositivePrice(double price) {
      BookInfo info = new BookInfo(1L, "T", "A", "P", LocalDate.now(), price, 0, List.of(Category.SCIENCE), "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.PRICE_MUST_BE_POSITIVE, ex.getMessage());
    }
    @ParameterizedTest
    @ValueSource(ints = {-1, -100})
    @DisplayName("Should reject negative quantity")
    void testNegativeQuantity(int quantity) {
      BookInfo info = new BookInfo(1L, "T", "A", "P", LocalDate.now(), 1.0, quantity, List.of(Category.SCIENCE), "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.QUANTITY_MUST_BE_POSITIVE_OR_ZERO, ex.getMessage());
    }
  }
  @Nested
  @DisplayName("Categories / Language validation")
  class MetadataTests {
    @Test
    @DisplayName("Should reject empty categories")
    void testEmptyCategories() {
      BookInfo info = new BookInfo(1L, "T", "A", "P", LocalDate.now(), 1.0, 0, List.of(), "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.CATEGORIES_REQUIRED, ex.getMessage());
    }
    @Test
    @DisplayName("Should reject null categories")
    void testNullCategories() {
      BookInfo info = new BookInfo(1L, "T", "A", "P", LocalDate.now(), 1.0, 0, null, "", "EN");
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.CATEGORIES_REQUIRED, ex.getMessage());
    }
    @ParameterizedTest
    @ValueSource(strings = {"", " ", "\t"})
    @DisplayName("Should reject blank language")
    void testBlankLanguage(String language) {
      BookInfo info = new BookInfo(1L, "T", "A", "P", LocalDate.now(), 1.0, 0, List.of(Category.SCIENCE), "", language);
      NotValidBookException ex = assertThrows(NotValidBookException.class, () -> BookValidator.validate(info));
      assertEquals(BookValidator.LANGUAGE_CANNOT_BE_BLANK, ex.getMessage());
    }
  }
 }
@@ -1,97 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.converter;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerDTO;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
 import java.util.UUID;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
@DisplayName("CustomerConverter Unit Tests")
 class CustomerConverterTest {
  @Nested
  @DisplayName("toDomain() method tests")
  class ToDomainTests {
    @Test
    @DisplayName("Should convert CustomerInfo to Customer domain object with loyalty points initialized to 0")
    void shouldConvertCustomerInfoToDomain() {
      // Given
      CustomerInfo customerInfo = new CustomerInfo("John", "Doe", "0123456789");
      // When
      Customer result = CustomerConverter.toDomain(customerInfo);
      // Then
      assertNotNull(result);
      assertEquals(customerInfo.firstName(), result.getFirstName());
      assertEquals(customerInfo.lastName(), result.getLastName());
      assertEquals(customerInfo.phoneNumber(), result.getPhoneNumber());
      assertEquals(0, result.getLoyaltyPoints());
    }
  }
  @Nested
  @DisplayName("toDTO() method tests")
  class ToDTOTests {
    @Test
    @DisplayName("Should convert Customer domain object to CustomerDTO with all fields mapped correctly")
    void shouldConvertCustomerToDTO() {
      Customer customer = Customer.builder()
          .id(UUID.randomUUID())
          .firstName("Jane")
          .lastName("Smith")
          .phoneNumber("9876543210")
          .loyaltyPoints(100)
          .build();
      CustomerDTO result = CustomerConverter.toDTO(customer);
      assertNotNull(result);
      assertEquals(customer.getId(), result.getId());
      assertEquals(customer.getFirstName(), result.getFirstName());
      assertEquals(customer.getLastName(), result.getLastName());
      assertEquals(customer.getPhoneNumber(), result.getPhoneNumber());
      assertEquals(customer.getLoyaltyPoints(), result.getLoyaltyPoints());
    }
  }
  @Test
  @DisplayName("Should handle null values properly when converting between objects")
  void shouldHandleNullValuesGracefully() {
    Customer customer = Customer.builder()
        .id(UUID.randomUUID())
        .firstName(null)
        .lastName("NullTest")
        .phoneNumber(null)
        .loyaltyPoints(50)
        .build();
    CustomerDTO result = CustomerConverter.toDTO(customer);
    assertNotNull(result);
    assertNull(result.getFirstName());
    assertEquals("NullTest", result.getLastName());
    assertNull(result.getPhoneNumber());
  }
  @Test
  @DisplayName("Should preserve empty string values during conversion")
  void shouldPreserveEmptyStrings() {
    CustomerInfo customerInfo = new CustomerInfo("", "", "");
    Customer domainResult = CustomerConverter.toDomain(customerInfo);
    CustomerDTO dtoResult = CustomerConverter.toDTO(domainResult);
    assertEquals("", dtoResult.getFirstName());
    assertEquals("", dtoResult.getLastName());
    assertEquals("", dtoResult.getPhoneNumber());
  }
 }
@@ -1,136 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.entity;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.IllegalCustomerPointException;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import static org.junit.jupiter.api.Assertions.*;
 import java.util.UUID;
 class CustomerTest {
  @Test
  @DisplayName("Builder should create a valid Customer instance")
  void testCustomerBuilder() {
    UUID id = UUID.randomUUID();
    String firstName = "John";
    String lastName = "Doe";
    String phoneNumber = "0123456789";
    int loyaltyPoints = 100;
    Customer customer = Customer.builder()
        .id(id)
        .firstName(firstName)
        .lastName(lastName)
        .phoneNumber(phoneNumber)
        .loyaltyPoints(loyaltyPoints)
        .build();
    assertEquals(id, customer.getId());
    assertEquals(firstName, customer.getFirstName());
    assertEquals(lastName, customer.getLastName());
    assertEquals(phoneNumber, customer.getPhoneNumber());
    assertEquals(loyaltyPoints, customer.getLoyaltyPoints());
  }
  @Test
  @DisplayName("setRandomUUID should change the ID to a new random UUID")
  void testSetRandomUUID() {
    Customer customer = Customer.builder().build();
    UUID originalId = customer.getId();
    customer.setRandomUUID();
    assertNotNull(customer.getId());
    assertNotEquals(originalId, customer.getId());
  }
  @Nested
  @DisplayName("Loyalty Points Tests")
  class LoyaltyPointsTests {
    @Test
    @DisplayName("addLoyaltyPoints should correctly increment loyalty points")
    void testAddLoyaltyPoints() {
      Customer customer = Customer.builder()
          .loyaltyPoints(50)
          .build();
      int pointsToAdd = 25;
      int expectedPoints = 75;
      customer.addLoyaltyPoints(pointsToAdd);
      assertEquals(expectedPoints, customer.getLoyaltyPoints());
    }
    @Test
    @DisplayName("addLoyaltyPoints should handle zero points correctly")
    void testAddZeroLoyaltyPoints() {
      Customer customer = Customer.builder()
          .loyaltyPoints(50)
          .build();
      customer.addLoyaltyPoints(0);
      assertEquals(50, customer.getLoyaltyPoints());
    }
    @Test
    @DisplayName("removeLoyaltyPoints should correctly decrement loyalty points")
    void testRemoveLoyaltyPoints() throws IllegalCustomerPointException {
      Customer customer = Customer.builder()
          .loyaltyPoints(50)
          .build();
      int pointsToRemove = 20;
      int expectedPoints = 30;
      customer.removeLoyaltyPoints(pointsToRemove);
      assertEquals(expectedPoints, customer.getLoyaltyPoints());
    }
    @Test
    @DisplayName("removeLoyaltyPoints should handle removing exactly all points")
    void testRemoveAllLoyaltyPoints() throws IllegalCustomerPointException {
      Customer customer = Customer.builder()
          .loyaltyPoints(50)
          .build();
      customer.removeLoyaltyPoints(50);
      assertEquals(0, customer.getLoyaltyPoints());
    }
    @Test
    @DisplayName("removeLoyaltyPoints should throw exception when trying to remove more points than available")
    void testRemoveTooManyLoyaltyPoints() {
      Customer customer = Customer.builder()
          .loyaltyPoints(50)
          .build();
      int pointsToRemove = 75;
      IllegalCustomerPointException exception = assertThrows(
          IllegalCustomerPointException.class,
          () -> customer.removeLoyaltyPoints(pointsToRemove)
      );
      assertEquals(50, customer.getLoyaltyPoints());
      assertTrue(exception.getMessage().contains(String.valueOf(pointsToRemove)));
      assertTrue(exception.getMessage().contains(String.valueOf(customer.getLoyaltyPoints())));
    }
    @Test
    @DisplayName("removeLoyaltyPoints should handle removing zero points correctly")
    void testRemoveZeroLoyaltyPoints() throws IllegalCustomerPointException {
      Customer customer = Customer.builder()
          .loyaltyPoints(50)
          .build();
      customer.removeLoyaltyPoints(0);
      assertEquals(50, customer.getLoyaltyPoints());
    }
  }
 }
@@ -1,49 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.exception;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import java.util.UUID;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 class CustomerNotFoundExceptionTest {
  @Test
  @DisplayName("Exception message should contain the UUID provided")
  void testExceptionMessageContainsUUID() {
    UUID uuid = UUID.randomUUID();
    CustomerNotFoundException exception = new CustomerNotFoundException(uuid);
    String expectedMessage = String.format("The customer with id %s does not exist", uuid);
    assertEquals(expectedMessage, exception.getMessage());
  }
  @Test
  @DisplayName("Exception should use the correct constant message format")
  void testExceptionUsesConstantMessageFormat() {
    UUID uuid = UUID.randomUUID();
    CustomerNotFoundException exception = new CustomerNotFoundException(uuid);
    String expectedFormatWithPlaceholder = "The customer with id {0} does not exist";
    assertEquals(CustomerNotFoundException.THE_CUSTOMER_WITH_ID_DOES_NOT_EXIST_MESSAGE,
        expectedFormatWithPlaceholder);
    assertTrue(exception.getMessage().contains(uuid.toString()));
  }
  @Test
  @DisplayName("Exception should be properly thrown and caught")
  void testExceptionCanBeThrownAndCaught() {
    UUID uuid = UUID.randomUUID();
    try {
      throw new CustomerNotFoundException(uuid);
    } catch (CustomerNotFoundException e) {
      String expectedMessage = String.format("The customer with id %s does not exist", uuid);
      assertEquals(expectedMessage, e.getMessage());
    }
  }
 }
@@ -1,69 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.exception;
 import java.text.MessageFormat;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 class IllegalCustomerPointExceptionTest {
  @Test
  @DisplayName("Exception message should contain the needed and actual points")
  void testExceptionMessageContainsPoints() {
    int neededPoints = 100;
    int actualPoints = 50;
    IllegalCustomerPointException exception = new IllegalCustomerPointException(neededPoints, actualPoints);
    String expectedMessage = "Cannot remove 100 points from 50 points";
    assertEquals(expectedMessage, exception.getMessage());
  }
  @ParameterizedTest
  @CsvSource({
      "100, 50",
      "75, 25",
      "200, 150",
      "1000, 750"
  })
  @DisplayName("Exception message should be formatted correctly for different point values")
  void testExceptionMessageForDifferentPointValues(int neededPoints, int actualPoints) {
    IllegalCustomerPointException exception = new IllegalCustomerPointException(neededPoints, actualPoints);
    String expectedMessage = MessageFormat.format(IllegalCustomerPointException.CANNOT_REMOVE_LOYALTY_POINTS, neededPoints, actualPoints);
    assertEquals(expectedMessage, exception.getMessage());
  }
  @Test
  @DisplayName("Exception should use the correct constant message format")
  void testExceptionUsesConstantMessageFormat() {
    int neededPoints = 100;
    int actualPoints = 50;
    IllegalCustomerPointException exception = new IllegalCustomerPointException(neededPoints, actualPoints);
    String expectedFormatWithPlaceholder = "Cannot remove {0} points from {1} points";
    assertEquals(IllegalCustomerPointException.CANNOT_REMOVE_LOYALTY_POINTS,
        expectedFormatWithPlaceholder);
    assertTrue(exception.getMessage().contains(String.valueOf(neededPoints)));
    assertTrue(exception.getMessage().contains(String.valueOf(actualPoints)));
  }
  @Test
  @DisplayName("Exception should be properly thrown and caught")
  void testExceptionCanBeThrownAndCaught() {
    int neededPoints = 100;
    int actualPoints = 50;
    try {
      throw new IllegalCustomerPointException(neededPoints, actualPoints);
    } catch (IllegalCustomerPointException e) {
      String expectedMessage = String.format("Cannot remove %d points from %d points", neededPoints, actualPoints);
      assertEquals(expectedMessage, e.getMessage());
    }
  }
 }
@@ -1,61 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.exception;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 class NotValidCustomerExceptionTest {
  @Test
  @DisplayName("Exception should be created with the provided message")
  void testExceptionCreation() {
    String errorMessage = "Customer data is not valid";
    NotValidCustomerException exception = new NotValidCustomerException(errorMessage);
    assertEquals(errorMessage, exception.getMessage());
  }
  @ParameterizedTest
  @ValueSource(strings = {
      "First name is required",
      "Last name cannot be empty",
      "Phone number format is invalid",
      "Customer age must be above 18"
  })
  @DisplayName("Exception should handle different validation messages")
  void testExceptionWithDifferentMessages(String errorMessage) {
    NotValidCustomerException exception = new NotValidCustomerException(errorMessage);
    assertEquals(errorMessage, exception.getMessage());
  }
  @Test
  @DisplayName("Exception should be properly thrown and caught")
  void testExceptionCanBeThrownAndCaught() {
    String errorMessage = "Required field is missing";
    Exception exception = assertThrows(NotValidCustomerException.class, () -> {
      throw new NotValidCustomerException(errorMessage);
    });
    assertEquals(errorMessage, exception.getMessage());
  }
  @Test
  @DisplayName("Exception should be catchable as a general Exception")
  void testExceptionInheritance() {
    String errorMessage = "Invalid customer data";
    try {
      throw new NotValidCustomerException(errorMessage);
    } catch (Exception e) {
      assertEquals(NotValidCustomerException.class, e.getClass());
      assertEquals(errorMessage, e.getMessage());
    }
  }
 }
@@ -1,227 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.repository;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
 import static org.junit.jupiter.api.Assertions.*;
 class CustomerRepositoryTest {
  private CustomerRepository repository;
  private Customer customer1;
  private Customer customer2;
  @BeforeEach
  void setUp() {
    repository = new CustomerRepository();
    customer1 = Customer.builder()
        .firstName("John")
        .lastName("Doe")
        .phoneNumber("0123456789")
        .loyaltyPoints(100)
        .build();
    customer1.setRandomUUID();
    customer2 = Customer.builder()
        .firstName("Jane")
        .lastName("Smith")
        .phoneNumber("9876543210")
        .loyaltyPoints(200)
        .build();
    customer2.setRandomUUID();
  }
  @Test
  @DisplayName("New repository should be empty")
  void testNewRepositoryIsEmpty() {
    List<Customer> customers = repository.findAll();
    assertTrue(customers.isEmpty());
    assertEquals(0, customers.size());
  }
  @Nested
  @DisplayName("Save operations")
  class SaveOperations {
    @Test
    @DisplayName("Save should add a new customer")
    void testSaveNewCustomer() {
      Customer savedCustomer = repository.save(customer1);
      assertEquals(1, repository.findAll().size());
      assertEquals(customer1.getId(), savedCustomer.getId());
      assertEquals(customer1.getFirstName(), savedCustomer.getFirstName());
    }
    @Test
    @DisplayName("Save should update existing customer with same ID")
    void testSaveUpdatesExistingCustomer() {
      repository.save(customer1);
      UUID id = customer1.getId();
      Customer updatedCustomer = Customer.builder()
          .id(id)
          .firstName("John")
          .lastName("Updated")
          .phoneNumber("1111111111")
          .loyaltyPoints(150)
          .build();
      Customer savedCustomer = repository.save(updatedCustomer);
      assertEquals(1, repository.findAll().size());
      assertEquals(id, savedCustomer.getId());
      assertEquals("Updated", savedCustomer.getLastName());
      assertEquals("1111111111", savedCustomer.getPhoneNumber());
      assertEquals(150, savedCustomer.getLoyaltyPoints());
    }
    @Test
    @DisplayName("Save multiple customers should add all of them")
    void testSaveMultipleCustomers() {
      repository.save(customer1);
      repository.save(customer2);
      List<Customer> customers = repository.findAll();
      assertEquals(2, customers.size());
      assertTrue(customers.contains(customer1));
      assertTrue(customers.contains(customer2));
    }
  }
  @Nested
  @DisplayName("Find operations")
  class FindOperations {
    @BeforeEach
    void setUpCustomers() {
      repository.save(customer1);
      repository.save(customer2);
    }
    @Test
    @DisplayName("FindAll should return all customers")
    void testFindAll() {
      List<Customer> customers = repository.findAll();
      assertEquals(2, customers.size());
      assertTrue(customers.contains(customer1));
      assertTrue(customers.contains(customer2));
    }
    @Test
    @DisplayName("FindById should return customer with matching ID")
    void testFindById() {
      Optional<Customer> foundCustomer = repository.findById(customer1.getId());
      assertTrue(foundCustomer.isPresent());
      assertEquals(customer1.getFirstName(), foundCustomer.get().getFirstName());
      assertEquals(customer1.getLastName(), foundCustomer.get().getLastName());
    }
    @Test
    @DisplayName("FindById should return empty Optional when ID doesn't exist")
    void testFindByIdNotFound() {
      UUID nonExistentId = UUID.randomUUID();
      Optional<Customer> foundCustomer = repository.findById(nonExistentId);
      assertTrue(foundCustomer.isEmpty());
    }
    @Test
    @DisplayName("FindByPhoneNumber should return customer with matching phone number")
    void testFindByPhoneNumber() {
      Optional<Customer> foundCustomer = repository.findByPhoneNumber("0123456789");
      assertTrue(foundCustomer.isPresent());
      assertEquals(customer1.getId(), foundCustomer.get().getId());
      assertEquals(customer1.getFirstName(), foundCustomer.get().getFirstName());
    }
    @Test
    @DisplayName("FindByPhoneNumber should return empty Optional when phone number doesn't exist")
    void testFindByPhoneNumberNotFound() {
      Optional<Customer> foundCustomer = repository.findByPhoneNumber("0000000000");
      assertTrue(foundCustomer.isEmpty());
    }
    @Test
    @DisplayName("ExistsById should return true when ID exists")
    void testExistsByIdExists() {
      boolean exists = repository.existsById(customer1.getId());
      assertTrue(exists);
    }
    @Test
    @DisplayName("ExistsById should return false when ID doesn't exist")
    void testExistsByIdNotExists() {
      UUID nonExistentId = UUID.randomUUID();
      boolean exists = repository.existsById(nonExistentId);
      assertFalse(exists);
    }
  }
  @Nested
  @DisplayName("Delete operations")
  class DeleteOperations {
    @BeforeEach
    void setUpCustomers() {
      repository.save(customer1);
      repository.save(customer2);
    }
    @Test
    @DisplayName("Delete should remove the specified customer")
    void testDelete() {
      repository.delete(customer1);
      List<Customer> customers = repository.findAll();
      assertEquals(1, customers.size());
      assertFalse(customers.contains(customer1));
      assertTrue(customers.contains(customer2));
    }
    @Test
    @DisplayName("DeleteAll should remove all customers")
    void testDeleteAll() {
      repository.deleteAll();
      List<Customer> customers = repository.findAll();
      assertTrue(customers.isEmpty());
      assertEquals(0, customers.size());
    }
    @Test
    @DisplayName("Delete should not throw exception when customer doesn't exist")
    void testDeleteNonExistentCustomer() {
      Customer nonExistentCustomer = Customer.builder()
          .firstName("Non")
          .lastName("Existent")
          .phoneNumber("0000000000")
          .build();
      nonExistentCustomer.setRandomUUID();
      assertDoesNotThrow(() -> repository.delete(nonExistentCustomer));
      assertEquals(2, repository.findAll().size());
    }
  }
 }
@@ -1,279 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.usecase;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerDTO;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.CustomerNotFoundException;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.IllegalCustomerPointException;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.NotValidCustomerException;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import java.util.Optional;
 import java.util.UUID;
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
 class CustomerUseCaseTest {
  @Mock
  private CustomerRepository customerRepository;
  @InjectMocks
  private CustomerUseCase customerUseCase;
  private UUID customerId;
  private Customer testCustomer;
  private CustomerInfo validCustomerInfo;
  @BeforeEach
  void setUp() {
    customerId = UUID.randomUUID();
    testCustomer = Customer.builder()
        .id(customerId)
        .firstName("John")
        .lastName("Doe")
        .phoneNumber("0612345678")
        .loyaltyPoints(100)
        .build();
    validCustomerInfo = new CustomerInfo("John", "Doe", "0612345678");
  }
  @Nested
  @DisplayName("Register customer tests")
  class RegisterCustomerTests {
    @Test
    @DisplayName("Should register customer when valid data is provided")
    void testRegisterCustomerWithValidData() throws NotValidCustomerException {
      when(customerRepository.save(any(Customer.class))).thenReturn(testCustomer);
      UUID registeredId = customerUseCase.registerCustomer(validCustomerInfo);
      assertNotNull(registeredId);
      assertEquals(customerId, registeredId);
      verify(customerRepository, times(1)).save(any(Customer.class));
    }
    @Test
    @DisplayName("Should throw exception when customer data is not valid")
    void testRegisterCustomerWithInvalidData() {
      CustomerInfo invalidCustomerInfo = new CustomerInfo("", "", "");
      assertThrows(NotValidCustomerException.class,
          () -> customerUseCase.registerCustomer(invalidCustomerInfo));
      verify(customerRepository, never()).save(any(Customer.class));
    }
  }
  @Nested
  @DisplayName("Find customer tests")
  class FindCustomerTests {
    @Test
    @DisplayName("Should return customer when phone number exists")
    void testFindCustomerByPhoneNumber() {
      when(customerRepository.findByPhoneNumber("0612345678")).thenReturn(Optional.of(testCustomer));
      Optional<CustomerDTO> foundCustomer = customerUseCase.findCustomerByPhoneNumber("0612345678");
      assertTrue(foundCustomer.isPresent());
      assertEquals(testCustomer.getId(), foundCustomer.get().getId());
      assertEquals(testCustomer.getFirstName(), foundCustomer.get().getFirstName());
      verify(customerRepository, times(1)).findByPhoneNumber("0612345678");
    }
    @Test
    @DisplayName("Should return empty Optional when phone number doesn't exist")
    void testFindCustomerByPhoneNumberNotFound() {
      when(customerRepository.findByPhoneNumber("0799999999")).thenReturn(Optional.empty());
      Optional<CustomerDTO> foundCustomer = customerUseCase.findCustomerByPhoneNumber("0799999999");
      assertTrue(foundCustomer.isEmpty());
      verify(customerRepository, times(1)).findByPhoneNumber("0799999999");
    }
  }
  @Nested
  @DisplayName("Update customer tests")
  class UpdateCustomerTests {
    @Test
    @DisplayName("Should update customer when valid data is provided")
    void testUpdateCustomerWithValidData() throws CustomerNotFoundException, NotValidCustomerException {
      when(customerRepository.findById(customerId)).thenReturn(Optional.of(testCustomer));
      Customer updatedCustomer = Customer.builder()
          .id(customerId)
          .firstName("John")
          .lastName("Updated")
          .phoneNumber("0712345678")
          .loyaltyPoints(100)
          .build();
      when(customerRepository.save(any(Customer.class))).thenReturn(updatedCustomer);
      CustomerInfo updateInfo = new CustomerInfo("John", "Updated", "0712345678");
      CustomerDTO result = customerUseCase.updateCustomer(customerId, updateInfo);
      assertNotNull(result);
      assertEquals(customerId, result.getId());
      assertEquals("Updated", result.getLastName());
      assertEquals("0712345678", result.getPhoneNumber());
      verify(customerRepository, times(1)).findById(customerId);
      verify(customerRepository, times(1)).save(any(Customer.class));
    }
    @Test
    @DisplayName("Should throw exception when customer ID doesn't exist")
    void testUpdateCustomerNotFound() {
      UUID nonExistentId = UUID.randomUUID();
      when(customerRepository.findById(nonExistentId)).thenReturn(Optional.empty());
      CustomerInfo updateInfo = new CustomerInfo("John", "Updated", "0712345678");
      assertThrows(CustomerNotFoundException.class,
          () -> customerUseCase.updateCustomer(nonExistentId, updateInfo));
      verify(customerRepository, times(1)).findById(nonExistentId);
      verify(customerRepository, never()).save(any(Customer.class));
    }
    @Test
    @DisplayName("Should throw exception when update data is not valid")
    void testUpdateCustomerWithInvalidData() {
      CustomerInfo invalidUpdateInfo = new CustomerInfo("", "", "");
      assertThrows(NotValidCustomerException.class,
          () -> customerUseCase.updateCustomer(customerId, invalidUpdateInfo));
      verify(customerRepository, never()).findById(any(UUID.class));
      verify(customerRepository, never()).save(any(Customer.class));
    }
  }
  @Nested
  @DisplayName("Delete customer tests")
  class DeleteCustomerTests {
    @Test
    @DisplayName("Should delete customer when ID exists")
    void testDeleteCustomer() throws CustomerNotFoundException {
      when(customerRepository.findById(customerId)).thenReturn(Optional.of(testCustomer));
      doNothing().when(customerRepository).delete(testCustomer);
      customerUseCase.deleteCustomer(customerId);
      verify(customerRepository, times(1)).findById(customerId);
      verify(customerRepository, times(1)).delete(testCustomer);
    }
    @Test
    @DisplayName("Should throw exception when customer ID doesn't exist")
    void testDeleteCustomerNotFound() {
      UUID nonExistentId = UUID.randomUUID();
      when(customerRepository.findById(nonExistentId)).thenReturn(Optional.empty());
      assertThrows(CustomerNotFoundException.class,
          () -> customerUseCase.deleteCustomer(nonExistentId));
      verify(customerRepository, times(1)).findById(nonExistentId);
      verify(customerRepository, never()).delete(any(Customer.class));
    }
  }
  @Nested
  @DisplayName("Loyalty points tests")
  class LoyaltyPointsTests {
    @Test
    @DisplayName("Should add loyalty points to customer")
    void testAddLoyaltyPoints() throws CustomerNotFoundException {
      when(customerRepository.findById(customerId)).thenReturn(Optional.of(testCustomer));
      when(customerRepository.save(testCustomer)).thenReturn(testCustomer);
      int initialPoints = testCustomer.getLoyaltyPoints();
      int pointsToAdd = 50;
      int expectedPoints = initialPoints + pointsToAdd;
      int newPoints = customerUseCase.addLoyaltyPoints(customerId, pointsToAdd);
      assertEquals(expectedPoints, newPoints);
      assertEquals(expectedPoints, testCustomer.getLoyaltyPoints());
      verify(customerRepository, times(1)).findById(customerId);
      verify(customerRepository, times(1)).save(testCustomer);
    }
    @Test
    @DisplayName("Should throw exception when adding points to non-existent customer")
    void testAddLoyaltyPointsToNonExistentCustomer() {
      UUID nonExistentId = UUID.randomUUID();
      when(customerRepository.findById(nonExistentId)).thenReturn(Optional.empty());
      assertThrows(CustomerNotFoundException.class,
          () -> customerUseCase.addLoyaltyPoints(nonExistentId, 50));
      verify(customerRepository, times(1)).findById(nonExistentId);
      verify(customerRepository, never()).save(any(Customer.class));
    }
    @Test
    @DisplayName("Should subtract loyalty points from customer")
    void testSubtractLoyaltyPoints() throws CustomerNotFoundException, IllegalCustomerPointException {
      when(customerRepository.findById(customerId)).thenReturn(Optional.of(testCustomer));
      when(customerRepository.save(testCustomer)).thenReturn(testCustomer);
      int initialPoints = testCustomer.getLoyaltyPoints();
      int pointsToRemove = 30;
      int expectedPoints = initialPoints - pointsToRemove;
      int newPoints = customerUseCase.subtractLoyaltyPoints(customerId, pointsToRemove);
      assertEquals(expectedPoints, newPoints);
      assertEquals(expectedPoints, testCustomer.getLoyaltyPoints());
      verify(customerRepository, times(1)).findById(customerId);
      verify(customerRepository, times(1)).save(testCustomer);
    }
    @Test
    @DisplayName("Should throw exception when trying to remove more points than available")
    void testSubtractTooManyLoyaltyPoints() {
      when(customerRepository.findById(customerId)).thenReturn(Optional.of(testCustomer));
      int pointsToRemove = 200;
      assertThrows(IllegalCustomerPointException.class,
          () -> customerUseCase.subtractLoyaltyPoints(customerId, pointsToRemove));
      verify(customerRepository, times(1)).findById(customerId);
      verify(customerRepository, never()).save(any(Customer.class));
    }
    @Test
    @DisplayName("Should throw exception when subtracting points from non-existent customer")
    void testSubtractLoyaltyPointsFromNonExistentCustomer() {
      UUID nonExistentId = UUID.randomUUID();
      when(customerRepository.findById(nonExistentId)).thenReturn(Optional.empty());
      assertThrows(CustomerNotFoundException.class,
          () -> customerUseCase.subtractLoyaltyPoints(nonExistentId, 50));
      verify(customerRepository, times(1)).findById(nonExistentId);
      verify(customerRepository, never()).save(any(Customer.class));
    }
  }
 }
@@ -1,155 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.validator;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.NotValidCustomerException;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 import static org.junit.jupiter.api.Assertions.*;
 class CustomerValidatorTest {
  @Test
  @DisplayName("Should validate customer with valid data")
  void testValidateValidCustomer() {
    CustomerInfo validCustomer = new CustomerInfo("John", "Doe", "0612345678");
    assertDoesNotThrow(() -> CustomerValidator.validate(validCustomer));
  }
  @Nested
  @DisplayName("First name validation tests")
  class FirstNameValidationTests {
    @Test
    @DisplayName("Should throw exception when first name is blank")
    void testValidateBlankFirstName() {
      CustomerInfo customerWithBlankFirstName = new CustomerInfo("", "Doe", "0612345678");
      NotValidCustomerException exception = assertThrows(
          NotValidCustomerException.class,
          () -> CustomerValidator.validate(customerWithBlankFirstName)
      );
      assertEquals(CustomerValidator.FIRST_NAME_CANNOT_BE_BLANK, exception.getMessage());
    }
    @ParameterizedTest
    @ValueSource(strings = {" ", "  ", "\t", "\n"})
    @DisplayName("Should throw exception when first name contains only whitespace")
    void testValidateWhitespaceFirstName(String whitespace) {
      CustomerInfo customerWithWhitespaceFirstName = new CustomerInfo(whitespace, "Doe", "0612345678");
      NotValidCustomerException exception = assertThrows(
          NotValidCustomerException.class,
          () -> CustomerValidator.validate(customerWithWhitespaceFirstName)
      );
      assertEquals(CustomerValidator.FIRST_NAME_CANNOT_BE_BLANK, exception.getMessage());
    }
  }
  @Nested
  @DisplayName("Last name validation tests")
  class LastNameValidationTests {
    @Test
    @DisplayName("Should throw exception when last name is blank")
    void testValidateBlankLastName() {
      CustomerInfo customerWithBlankLastName = new CustomerInfo("John", "", "0612345678");
      NotValidCustomerException exception = assertThrows(
          NotValidCustomerException.class,
          () -> CustomerValidator.validate(customerWithBlankLastName)
      );
      assertEquals(CustomerValidator.LAST_NAME_CANNOT_BE_BLANK, exception.getMessage());
    }
    @ParameterizedTest
    @ValueSource(strings = {" ", "  ", "\t", "\n"})
    @DisplayName("Should throw exception when last name contains only whitespace")
    void testValidateWhitespaceLastName(String whitespace) {
      CustomerInfo customerWithWhitespaceLastName = new CustomerInfo("John", whitespace, "0612345678");
      NotValidCustomerException exception = assertThrows(
          NotValidCustomerException.class,
          () -> CustomerValidator.validate(customerWithWhitespaceLastName)
      );
      assertEquals(CustomerValidator.LAST_NAME_CANNOT_BE_BLANK, exception.getMessage());
    }
  }
  @Nested
  @DisplayName("Phone number validation tests")
  class PhoneNumberValidationTests {
    @Test
    @DisplayName("Should throw exception when phone number is blank")
    void testValidateBlankPhoneNumber() {
      CustomerInfo customerWithBlankPhoneNumber = new CustomerInfo("John", "Doe", "");
      NotValidCustomerException exception = assertThrows(
          NotValidCustomerException.class,
          () -> CustomerValidator.validate(customerWithBlankPhoneNumber)
      );
      assertEquals("Phone number cannot be blank", exception.getMessage());
    }
    @ParameterizedTest
    @ValueSource(strings = {" ", "  ", "\t", "\n"})
    @DisplayName("Should throw exception when phone number contains only whitespace")
    void testValidateWhitespacePhoneNumber(String whitespace) {
      CustomerInfo customerWithWhitespacePhoneNumber = new CustomerInfo("John", "Doe", whitespace);
      NotValidCustomerException exception = assertThrows(
          NotValidCustomerException.class,
          () -> CustomerValidator.validate(customerWithWhitespacePhoneNumber)
      );
      assertEquals("Phone number cannot be blank", exception.getMessage());
    }
    @ParameterizedTest
    @ValueSource(strings = {
        "0512345678", // Invalid prefix (not 06 or 07)
        "0812345678", // Invalid prefix (not 06 or 07)
        "061234567",  // Too short (missing one digit)
        "06123456789", // Too long (one extra digit)
        "6123456789", // Missing leading 0
        "O612345678", // Letter O instead of zero
        "+33612345678", // International format not supported
        "06 12 34 56 78" // Contains spaces
    })
    @DisplayName("Should throw exception when phone number format is invalid")
    void testValidateInvalidPhoneNumberFormat(String invalidPhoneNumber) {
      CustomerInfo customerWithInvalidPhoneNumber = new CustomerInfo("John", "Doe", invalidPhoneNumber);
      NotValidCustomerException exception = assertThrows(
          NotValidCustomerException.class,
          () -> CustomerValidator.validate(customerWithInvalidPhoneNumber)
      );
      assertEquals(CustomerValidator.PHONE_NUMBER_IS_NOT_VALID, exception.getMessage());
    }
    @ParameterizedTest
    @ValueSource(strings = {
        "0612345678", // Valid 06 number
        "0712345678", // Valid 07 number
        "0699999999", // Valid 06 number with all 9s
        "0700000000"  // Valid 07 number with all 0s
    })
    @DisplayName("Should validate when phone number format is valid")
    void testValidateValidPhoneNumberFormat(String validPhoneNumber) {
      CustomerInfo customerWithValidPhoneNumber = new CustomerInfo("John", "Doe", validPhoneNumber);
      assertDoesNotThrow(() -> CustomerValidator.validate(customerWithValidPhoneNumber));
    }
  }
 }
@@ -1,14 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.features;
 import org.junit.platform.suite.api.*;
 import static io.cucumber.junit.platform.engine.Constants.GLUE_PROPERTY_NAME;
 import static io.cucumber.junit.platform.engine.Constants.PLUGIN_PROPERTY_NAME;
@Suite
@IncludeEngines("cucumber")
@SelectClasspathResource("features")
@ConfigurationParameter(key = PLUGIN_PROPERTY_NAME, value = "pretty")
@ConfigurationParameter(key = GLUE_PROPERTY_NAME, value = "fr.iut_fbleau.but3.dev62.mylibrary.features")
 public class RunCucumberTest {
 }
@@ -1,106 +0,0 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.features.book;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDTO;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Category;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookAlreadyExistsException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
 import fr.iut_fbleau.but3.dev62.mylibrary.book.usecase.BookUseCase;
 import io.cucumber.datatable.DataTable;
 import io.cucumber.java.en.And;
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
 import java.time.LocalDate;
 import java.util.List;
 import java.util.Map;
 public class BookSteps {
  private final BookRepository bookRepository = new BookRepository();
  private final BookUseCase bookUseCase = new BookUseCase(bookRepository);
  private long lastRegisteredIsbn;
  private BookDTO retrievedBook;
  private List<BookDTO> allBooks;
  private Exception lastException;
  @Given("the catalog has the following books:")
  public void theCatalogHasTheFollowingBooks(DataTable dataTable) throws NotValidBookException, BookAlreadyExistsException {
    bookRepository.deleteAll();
    for (Map<String, String> row : dataTable.asMaps(String.class, String.class)) {
      bookUseCase.registerBook(toBookInfo(row));
    }
  }
  @When("I register a new book with the following information:")
  public void iRegisterANewBook(DataTable dataTable) throws NotValidBookException, BookAlreadyExistsException {
    Map<String, String> row = dataTable.asMaps(String.class, String.class).getFirst();
    lastRegisteredIsbn = bookUseCase.registerBook(toBookInfo(row));
  }
  @When("I try to register a new book with the following information:")
  public void iTryToRegisterANewBook(DataTable dataTable) {
    Map<String, String> row = dataTable.asMaps(String.class, String.class).getFirst();
    lastException = assertThrows(Exception.class, () -> bookUseCase.registerBook(toBookInfo(row)));
  }
  @When("I request the book with isbn {long}")
  public void iRequestTheBook(long isbn) throws BookNotFoundException {
    retrievedBook = bookUseCase.getBookByIsbn(isbn);
  }
  @When("I list all books")
  public void iListAllBooks() {
    allBooks = bookUseCase.getAllBooks();
  }
  @Then("the book is created")
  public void theBookIsCreated() {
    assertNotNull(lastRegisteredIsbn);
  }
  @And("the catalog now has {int} book(s)")
  public void theCatalogNowHasNBooks(int expected) {
    assertEquals(expected, bookRepository.findAll().size());
  }
  @Then("the registration fails with a {string}")
  public void theRegistrationFailsWith(String exceptionSimpleName) {
    assertNotNull(lastException);
    assertEquals(exceptionSimpleName, lastException.getClass().getSimpleName());
  }
  @Then("I receive a book whose title is {string}")
  public void iReceiveABookWhoseTitleIs(String title) {
    assertNotNull(retrievedBook);
    assertEquals(title, retrievedBook.getTitle());
  }
  @Then("I receive {int} book(s)")
  public void iReceiveNBooks(int expected) {
    assertNotNull(allBooks);
    assertEquals(expected, allBooks.size());
  }
  private static BookInfo toBookInfo(Map<String, String> row) {
    return new BookInfo(
        Long.parseLong(row.get("isbn")),
        row.get("titre"),
        row.get("auteur"),
        row.get("editeur"),
        LocalDate.parse(row.get("datePublication")),
        Double.parseDouble(row.get("prix")),
        Integer.parseInt(row.get("stock")),
        List.of(Category.valueOf(row.get("categorie"))),
        "",
        row.get("langue")
    );
  }
 }
@@ -1,223 +0,0 @@
 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 fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerDTO;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.CustomerNotFoundException;
 import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.IllegalCustomerPointException;
 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.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 CustomerSteps {
  private final CustomerRepository customerRepository = new CustomerRepository();
  private final CustomerUseCase customerUseCase = new CustomerUseCase(customerRepository);
  private final Map<String, UUID> customerPhoneUUID = new HashMap<>();
  private UUID customerRegistration;
  private Optional<CustomerDTO> customerByPhoneNumber;
  private Customer updatedCustomer;
  private IllegalCustomerPointException illegalCustomerPointException;
  private NotValidCustomerException notValidCustomerException;
  @Given("the system has the following customers:")
  public void theSystemHasTheFollowingCustomers(DataTable dataTable) {
    int size = customerRepository.findAll().size();
    if (size > 0) {
      customerRepository.deleteAll();
    }
    List<Map<String, String>> customers = dataTable.asMaps(String.class, String.class);
    for (Map<String, String> customer : customers) {
      String numeroTelephone = customer.get("numeroTelephone");
      Customer newCustomer = Customer.builder()
          .firstName(customer.get("prenom"))
          .lastName(customer.get("nom"))
          .phoneNumber(numeroTelephone)
          .loyaltyPoints(Integer.parseInt(customer.get("pointsFidelite")))
          .build();
      Customer save = customerRepository.save(newCustomer);
      customerPhoneUUID.put(numeroTelephone, save.getId());
    }
    assertEquals(customers.size(), customerRepository.findAll().size());
  }
  @When("I create a new customer with the following information:")
  public void iCreateANewCustomerWithTheFollowingInformation(DataTable dataTable) throws NotValidCustomerException {
    List<Map<String, String>> rows = dataTable.asMaps(String.class, String.class);
    Map<String, String> customerInfo = rows.getFirst();
    CustomerInfo newCustomer = new CustomerInfo(
        customerInfo.get("prenom"),
        customerInfo.get("nom"),
        customerInfo.get("numeroTelephone")
    );
    customerRegistration = customerUseCase.registerCustomer(newCustomer);
  }
  @And("the system now has {int} customers")
  public void theSystemNowHasCustomers(int numberOfCustomers) {
    assertEquals(numberOfCustomers, customerRepository.findAll().size());
  }
  @And("the customer has {int} loyalty points")
  public void theCustomerHasLoyaltyPoints(int loyaltyPoints) {
    Customer customer = customerRepository.findById(customerRegistration).orElseThrow();
    assertEquals(loyaltyPoints, customer.getLoyaltyPoints());
  }
  @Then("a new customer is created")
  public void aNewCustomerIsCreated() {
    assertNotNull(customerRegistration);
  }
  @When("I request the customer with phone number {string}")
  public void iRequestTheCustomerWithPhoneNumber(String phoneNumber) {
    customerByPhoneNumber = customerUseCase.findCustomerByPhoneNumber(phoneNumber);
  }
  @Then("I receive the following customer information:")
  public void iReceiveTheFollowingCustomerInformation(DataTable dataTable) {
    List<Map<String, String>> customers = dataTable.asMaps(String.class, String.class);
    Map<String, String> customerInfo = customers.getFirst();
    assertTrue(customerByPhoneNumber.isPresent());
    CustomerDTO customerDTO = customerByPhoneNumber.get();
    assertEquals(customerInfo.get("prenom"), customerDTO.getFirstName());
    assertEquals(customerInfo.get("nom"), customerDTO.getLastName());
    assertEquals(customerInfo.get("numeroTelephone"), customerDTO.getPhoneNumber());
  }
  @When("I update customer {string} with the following information:")
  public void iUpdateCustomerWithTheFollowingInformation(String phoneNumber, DataTable dataTable)
      throws CustomerNotFoundException, NotValidCustomerException {
    List<Map<String, String>> rows = dataTable.asMaps(String.class, String.class);
    Map<String, String> customerData = rows.getFirst();
    CustomerInfo customerInfo = new CustomerInfo(
        customerData.get("prenom"),
        customerData.get("nom"),
        customerData.get("numeroTelephone")
    );
    UUID uuid = customerPhoneUUID.get(phoneNumber);
    customerUseCase.updateCustomer(uuid, customerInfo);
  }
  @Then("the customer {string} has the following updated information:")
  public void theCustomerHasTheFollowingUpdatedInformation(String phoneNumber, DataTable dataTable) {
    List<Map<String, String>> rows = dataTable.asMaps(String.class, String.class);
    Map<String, String> updatedDate = rows.getFirst();
    UUID uuid = customerPhoneUUID.get(phoneNumber);
    updatedCustomer = customerRepository.findById(uuid).orElseThrow();
    assertEquals(updatedDate.get("numeroTelephone"), updatedCustomer.getPhoneNumber());
    assertEquals(updatedDate.get("prenom"), updatedCustomer.getFirstName());
    assertEquals(updatedDate.get("nom"), updatedCustomer.getLastName());
  }
  @And("the loyalty points remain unchanged at {int}")
  public void theLoyaltyPointsRemainUnchangedAt(int expectedLoyaltyPoint) {
    assertEquals(expectedLoyaltyPoint, updatedCustomer.getLoyaltyPoints());
  }
  @When("I delete the customer with phone number {string}")
  public void iDeleteTheCustomerWithPhoneNumber(String phoneNumber) throws CustomerNotFoundException {
    UUID uuid = customerPhoneUUID.get(phoneNumber);
    customerUseCase.deleteCustomer(uuid);
  }
  @Then("the customer {string} is removed from the system")
  public void theCustomerIsRemovedFromTheSystem(String phoneNumber) {
    UUID uuid = customerPhoneUUID.get(phoneNumber);
    assertFalse(customerRepository.existsById(uuid));
  }
  @When("I add {int} loyalty points to customer {string}")
  public void iAddLoyaltyPointsToCustomer(int loyaltyPointToAdd, String phoneNumber) throws CustomerNotFoundException {
    UUID uuid = customerPhoneUUID.get(phoneNumber);
    customerUseCase.addLoyaltyPoints(uuid, loyaltyPointToAdd);
  }
  @Then("customer {string} now has {int} loyalty points")
  public void customerNowHasLoyaltyPoints(String phoneNumber, int expectedLoyaltyPoints) {
    UUID uuid = customerPhoneUUID.get(phoneNumber);
    Customer customer = customerRepository.findById(uuid).orElseThrow();
    assertEquals(expectedLoyaltyPoints, customer.getLoyaltyPoints());
  }
  @When("I deduct {int} loyalty points from customer {string} for a purchase")
  public void iDeductLoyaltyPointsFromCustomerForAPurchase(int pointsToRemove, String phoneNumber) throws CustomerNotFoundException, IllegalCustomerPointException {
    UUID uuid = customerPhoneUUID.get(phoneNumber);
    customerUseCase.subtractLoyaltyPoints(uuid, pointsToRemove);
  }
  @When("I try to create a new customer with the following information:")
  public void iTryToCreateANewCustomerWithTheFollowingInformation(DataTable ddataTable) {
    List<Map<String, String>> rows = ddataTable.asMaps(String.class, String.class);
    Map<String, String> customerInfo = rows.getFirst();
    CustomerInfo newCustomer = new CustomerInfo(
        customerInfo.get("prenom"),
        customerInfo.get("nom"),
        customerInfo.get("numeroTelephone")
    );
    notValidCustomerException = assertThrows(NotValidCustomerException.class, () -> customerUseCase.registerCustomer(newCustomer));
  }
  @Then("the creation fails")
  public void theCreationFails() {
    assertNotNull(notValidCustomerException);
  }
  @And("I receive an error for validation customer message containing {string}")
  public void iReceiveAnErrorMessageContaining(String errorMessage) {
    assertEquals(errorMessage, notValidCustomerException.getMessage());
  }
  @And("the system still has {int} customers")
  public void theSystemStillHasCustomers(int expectedNumberOfUser) {
    assertEquals(expectedNumberOfUser, customerRepository.findAll().size());
  }
  @When("I try to deduct {int} loyalty points from customer {string} for a purchase")
  public void iTryToDeductLoyaltyPointsFromCustomerForAPurchase(int points, String phoneNumber) {
    UUID uuid = customerPhoneUUID.get(phoneNumber);
    illegalCustomerPointException = assertThrows(IllegalCustomerPointException.class, () -> customerUseCase.subtractLoyaltyPoints(uuid, points));
  }
  @Then("the deduction fails")
  public void theDeductionFails() {
    assertNotNull(illegalCustomerPointException);
  }
  @And("I receive an error for illegal customer exception message containing {string}")
  public void iReceiveAnErrorForIllegalCustomerExceptionMessageContaining(String errorMessage) {
    assertEquals(errorMessage, illegalCustomerPointException.getMessage());
  }
 }
@@ -1,40 +0,0 @@
 # language: en
 Feature: Manage book catalog
  Scenario: Register a new book in the catalog
    When I register a new book with the following information:
      | isbn          | titre    | auteur  | editeur | datePublication | prix  | stock | categorie | langue |
      | 9780321125217 | DDD      | Evans   | AW      | 2003-08-22      | 54.99 | 10    | SCIENCE   | EN     |
    Then the book is created
    And the catalog now has 1 book
  Scenario: Reject duplicate ISBN
    Given the catalog has the following books:
      | isbn          | titre    | auteur  | editeur | datePublication | prix  | stock | categorie | langue |
      | 9780321125217 | DDD      | Evans   | AW      | 2003-08-22      | 54.99 | 10    | SCIENCE   | EN     |
    When I try to register a new book with the following information:
      | isbn          | titre    | auteur  | editeur | datePublication | prix  | stock | categorie | langue |
      | 9780321125217 | DDD copy | Evans   | AW      | 2003-08-22      | 54.99 | 10    | SCIENCE   | EN     |
    Then the registration fails with a "BookAlreadyExistsException"
  Scenario: Reject invalid book information
    When I try to register a new book with the following information:
      | isbn          | titre | auteur | editeur | datePublication | prix | stock | categorie | langue |
      | 9780321125217 |       | Evans  | AW      | 2003-08-22      | 0    | -1    | SCIENCE   | EN     |
    Then the registration fails with a "NotValidBookException"
  Scenario: Retrieve a book by its ISBN
    Given the catalog has the following books:
      | isbn          | titre    | auteur  | editeur | datePublication | prix  | stock | categorie | langue |
      | 9780321125217 | DDD      | Evans   | AW      | 2003-08-22      | 54.99 | 10    | SCIENCE   | EN     |
    When I request the book with isbn 9780321125217
    Then I receive a book whose title is "DDD"
  Scenario: List all books in the catalog
    Given the catalog has the following books:
      | isbn          | titre    | auteur  | editeur | datePublication | prix  | stock | categorie | langue |
      | 9780321125217 | DDD      | Evans   | AW      | 2003-08-22      | 54.99 | 10    | SCIENCE   | EN     |
      | 9780132350884 | Clean    | Martin  | PH      | 2008-08-01      | 30.00 | 5     | SCIENCE   | EN     |
    When I list all books
    Then I receive 2 books
@@ -1,60 +0,0 @@
 # language: en
 Feature: Manage customer accounts
  Background:
    Given the system has the following customers:
      | prenom | nom    | numeroTelephone | pointsFidelite |
      | Marie  | Dupont | 0612345678      | 100            |
      | Jean   | Martin | 0687654321      | 50             |
      | Sophie | Dubois | 0698765432      | 0              |
  Scenario: Create a new customer account
    When I create a new customer with the following information:
      | prenom | nom     | numeroTelephone |
      | Pierre | Lambert | 0611223344      |
    Then a new customer is created
    And the customer has 0 loyalty points
    And the system now has 4 customers
  Scenario: Retrieve a customer by ID
    When I request the customer with phone number "0612345678"
    Then I receive the following customer information:
      | prenom | nom    | numeroTelephone | pointsFidelite |
      | Marie  | Dupont | 0612345678      | 100            |
  Scenario: Update a customer's information
    When I update customer "0687654321" with the following information:
      | prenom | nom     | numeroTelephone |
      | Jean   | Bernard | 0666666666      |
    Then the customer "0687654321" has the following updated information:
      | prenom | nom     | numeroTelephone |
      | Jean   | Bernard | 0666666666      |
    And the loyalty points remain unchanged at 50
  Scenario: Delete a customer
    When I delete the customer with phone number "0698765432"
    Then the customer "0698765432" is removed from the system
    And the system now has 2 customers
  Scenario: Add loyalty points to a customer
    When I add 25 loyalty points to customer "0687654321"
    Then customer "0687654321" now has 75 loyalty points
  Scenario: Deduct loyalty points for a purchase
    When I deduct 30 loyalty points from customer "0612345678" for a purchase
    Then customer "0612345678" now has 70 loyalty points
  Scenario: Attempt to create a customer with invalid phone number
    When I try to create a new customer with the following information:
      | prenom | nom   | numeroTelephone |
      | Thomas | Petit | abcdefgh        |
    Then the creation fails
    And I receive an error for validation customer message containing "Phone number is not valid"
    And the system still has 3 customers
  Scenario: Attempt to deduct more loyalty points than available
    When I try to deduct 150 loyalty points from customer "0687654321" for a purchase
    Then the deduction fails
    And I receive an error for illegal customer exception message containing "Cannot remove 150 points from 50 points"
    And customer "0687654321" now has 50 loyalty points
Author	SHA1	Message	Date
Adrien DICK	e438373370	Merge pull request '✨ Enregistrer un livre' (#2 ) from EnregistrerLivre into main Reviewed-on: #2	2026-06-11 11:35:23 +02:00
Adrien DICK	2c0f30f0a2	✨ Enregistrer un livre	2026-06-11 05:15:30 -04:00