ajout du scenario cucumber et du README

ajout du usecase pour les livres + tests
ajout du repository en memoire + tests
2026-06-14 15:22:36 +02:00 · 2026-06-14 15:22:29 +02:00 · 2026-06-12 23:32:35 +02:00 · 2026-06-12 23:32:26 +02:00 · 2026-06-12 23:32:17 +02:00 · 2026-06-12 23:30:58 +02:00
51 changed files with 3174 additions and 153 deletions
@@ -5,8 +5,6 @@ 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';
 import BookDetail from './pages/BookDetail';
 export default function App() {
  return (
@@ -17,8 +15,6 @@ 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 path="books/:bookId" element={<BookDetail />} />
      </Route>
    </Routes>
  );
@@ -3,11 +3,3 @@ 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);
 }
 export function getBookById(id) {
  return client.get(`/api/books/${id}`);
 }
@@ -1,105 +0,0 @@
 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,31 +0,0 @@
 import { useState, useEffect } from 'react';
 import { useParams, Link } from 'react-router-dom';
 import { getBookById } from '../api/books';
 export default function BookDetail() {
  const { bookId } = useParams();  
  const [book, setBook] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  useEffect(() => {getBookById(bookId).then((response) => setBook(response.data)).catch((err) => {console.error(err);setError('Livre introuvable.');}).finally(() => setLoading(false));}, [bookId]);             
  if (loading) return <main><p>Chargement…</p></main>;
  if (error) return <main><p>{error}</p><Link to="/books">← Retour au catalogue</Link></main>;
  return (
    <main>
      <Link to="/books">← Retour au catalogue</Link>
      <h1>{book.title}</h1>
      <p>Auteur : {book.author}</p>
      <p>ISBN : {book.isbn}</p>
      <p>Éditeur : {book.publisher}</p>
      <p>Publié le : {book.publicationDate}</p>
      <p>Prix : {book.price} €</p>
      <p>Stock : {book.quantity}</p>
      <p>Langue : {book.language}</p>
      <p>Catégories : {book.categories?.join(', ')}</p>
      {book.description && <p>{book.description}</p>}
    </main>
  );
 }
@@ -1,6 +1,5 @@
 import { useState, useEffect } from 'react';
 import { getBooks } from '../api/books';
 import { Link } from 'react-router-dom';
 export default function Books() {
  const [books, setBooks] = useState([]);
@@ -28,13 +27,10 @@ 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}>
-            <Link to={`/books/${book.isbn}`}>
+            <strong>{book.title}</strong> - {book.author}
              <strong>{book.title}</strong> - {book.author}
            </Link>
          </li>
        ))}
      </ul>
@@ -0,0 +1,38 @@
 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
@@ -0,0 +1,78 @@
 # 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**.
@@ -0,0 +1,151 @@
 <?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>
@@ -0,0 +1,22 @@
 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;
 }
@@ -0,0 +1,19 @@
 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
 ) {
 }
@@ -0,0 +1,42 @@
 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();
  }
 }
@@ -0,0 +1,24 @@
 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
 }
@@ -0,0 +1,13 @@
 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)));
  }
 }
@@ -0,0 +1,13 @@
 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)));
  }
 }
@@ -0,0 +1,12 @@
 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));
  }
 }
@@ -0,0 +1,8 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
 public class NotValidBookException extends Exception {
  public NotValidBookException(String message) {
    super(message);
  }
 }
@@ -0,0 +1,42 @@
 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);
  }
 }
@@ -0,0 +1,46 @@
 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();
  }
 }
@@ -0,0 +1,93 @@
 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);
    }
  }
 }
@@ -0,0 +1,15 @@
 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;
 }
@@ -0,0 +1,4 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer;
 public record CustomerInfo(String firstName, String lastName, String phoneNumber) {
 }
@@ -0,0 +1,30 @@
 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();
  }
 }
@@ -0,0 +1,30 @@
 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;
 }
 }
@@ -0,0 +1,13 @@
 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));
  }
 }
@@ -0,0 +1,13 @@
 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));
  }
 }
@@ -0,0 +1,8 @@
 package fr.iut_fbleau.but3.dev62.mylibrary.customer.exception;
 public class NotValidCustomerException extends Exception {
  public NotValidCustomerException(String message) {
    super(message);
  }
 }
@@ -0,0 +1,49 @@
 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);
  }
 }
@@ -0,0 +1,81 @@
 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();
  }
 }
@@ -0,0 +1,44 @@
 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);
    }
  }
 }
@@ -0,0 +1,86 @@
 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());
    }
  }
 }
@@ -0,0 +1,75 @@
 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"));
    }
  }
 }
@@ -0,0 +1,26 @@
 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);
  }
 }
@@ -0,0 +1,37 @@
 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"));
    }
  }
 }
@@ -0,0 +1,33 @@
 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());
  }
 }
@@ -0,0 +1,44 @@
 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());
    }
  }
 }
@@ -0,0 +1,149 @@
 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());
    }
  }
 }
@@ -0,0 +1,152 @@
 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());
    }
  }
 }
@@ -0,0 +1,167 @@
 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());
    }
  }
 }
@@ -0,0 +1,97 @@
 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());
  }
 }
@@ -0,0 +1,136 @@
 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());
    }
  }
 }
@@ -0,0 +1,49 @@
 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());
    }
  }
 }
@@ -0,0 +1,69 @@
 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());
    }
  }
 }
@@ -0,0 +1,61 @@
 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());
    }
  }
 }
@@ -0,0 +1,227 @@
 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());
    }
  }
 }
@@ -0,0 +1,279 @@
 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));
    }
  }
 }
@@ -0,0 +1,155 @@
 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));
    }
  }
 }
@@ -0,0 +1,14 @@
 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 {
 }
@@ -0,0 +1,106 @@
 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")
    );
  }
 }
@@ -0,0 +1,223 @@
 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());
  }
 }
@@ -0,0 +1,40 @@
 # 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
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
RKaraMos_EVO	092a020059	ajout du scenario cucumber et du README	2026-06-14 15:22:36 +02:00
RKaraMos_EVO	8708686994	ajout du usecase pour les livres + tests	2026-06-14 15:22:29 +02:00
RKaraMos_EVO	a595750194	ajout du repository en memoire + tests	2026-06-12 23:32:35 +02:00
RKaraMos_EVO	00e90aaa0c	ajout du converter Info-entity-DTO + tests	2026-06-12 23:32:26 +02:00
RKaraMos_EVO	009ac7f5f7	ajout du validator pour les livres + tests	2026-06-12 23:32:17 +02:00
RKaraMos_EVO	9080b8e67e	ajout entity Book et BookDTO + tests	2026-06-12 23:30:58 +02:00
RKaraMos_EVO	179f259c3d	ajout des exceptions du module book et leurs tests	2026-06-12 23:30:45 +02:00
RKaraMos_EVO	1aa83b0911	ajout enum Category et record BookInfo	2026-06-11 14:23:15 +02:00
RKaraMos_EVO	abbd3ee95d	ajout du module customer fourni par le prof	2026-06-11 14:22:59 +02:00
RKaraMos_EVO	efa6fc49eb	ajout du pom et du gitignore pour le module	2026-06-11 14:22:13 +02:00