README.md

@@ -0,0 +1,50 @@
+# MyLibrary — backend Java
+
+Backend métier du projet librairie (Maxime Lebreton / Marvin Aubert / Patrick Felix-Vimalaratnam).  
+Pendant visuel : dépôt **`2026-DEV-BUT3`** (React).
+
+## Stack
+
+- Java 21, Maven
+- Couche domaine : livres, clients, points de fidélité
+- **API REST** (branche `fusion`) : Spring Boot sur le port **8080**
+
+## Lancer l’API
+
+```bash
+mvn spring-boot:run
+```
+
+Vérifier : [http://localhost:8080/api/health](http://localhost:8080/api/health)
+
+## Endpoints exposés au front
+
+| Méthode | Route | Rôle |
+|---------|-------|------|
+| GET | `/api/health` | Ping |
+| GET | `/api/books` | Liste des livres (format UI) |
+| POST | `/api/books` | Créer un livre |
+| GET | `/api/books/{isbn}` | Détail |
+| DELETE | `/api/books/{isbn}` | Supprimer |
+| POST | `/api/books/{isbn}/read` | Basculer lu / non lu |
+| GET | `/api/users/{uuid}/loyalty-points` | Points fidélité client |
+
+Au démarrage, deux livres démo + un client Marie Dupont (100 pts) sont chargés si le catalogue est vide.
+
+## Brancher le front React
+
+Dans `2026-DEV-BUT3` (branche `fusion`) :
+
+```bash
+cp .env.example .env
+npm install
+npm run dev
+```
+
+Le proxy Vite envoie `/api` vers `localhost:8080`. Commandes, promos, réservations, avis, abo, prêts et groupes restent côté front (local) tant que ces use cases ne sont pas exposés ici.
+
+## Tests unitaires
+
+```bash
+mvn test
+```

interface-contracts.json

@@ -14,6 +14,7 @@
         "langue": "string"
       },
       "output": {
+        "_comment": "c'est ce qui affiche quand tu crée avec la usecase (regarde register de customer)",
         "isbn": "string(13)"
       }
     },

pom.xml

@@ -15,6 +15,7 @@
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
     <!--    Main dependencies -->
+    <spring.boot.version>3.4.1</spring.boot.version>
     <lombok.version>1.18.36</lombok.version>
 
     <!--    Test Verisons-->
@@ -48,6 +49,12 @@
   </dependencyManagement>
 
   <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+      <version>${spring.boot.version}</version>
+    </dependency>
+
     <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
@@ -146,6 +153,18 @@
           </properties>
         </configuration>
       </plugin>
+      <plugin>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-maven-plugin</artifactId>
+        <version>${spring.boot.version}</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>repackage</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
     </plugins>
   </build>
 </project>

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/MyLibraryApplication.java

@@ -0,0 +1,12 @@
+package fr.iut_fbleau.but3.dev62.mylibrary;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class MyLibraryApplication {
+
+  public static void main(String[] args) {
+    SpringApplication.run(MyLibraryApplication.class, args);
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/api/ApiExceptionHandler.java

@@ -0,0 +1,23 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.api;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
+import java.util.Map;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+@RestControllerAdvice
+public class ApiExceptionHandler {
+
+  @ExceptionHandler(BookNotFoundException.class)
+  public ResponseEntity<Map<String, String>> handleBookNotFound(BookNotFoundException ex) {
+    return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of("error", ex.getMessage()));
+  }
+
+  @ExceptionHandler(NotValidBookException.class)
+  public ResponseEntity<Map<String, String>> handleNotValidBook(NotValidBookException ex) {
+    return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(Map.of("error", ex.getMessage()));
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/api/BookController.java

@@ -0,0 +1,86 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.api;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.api.dto.FrontendBookRequest;
+import fr.iut_fbleau.but3.dev62.mylibrary.api.dto.FrontendBookResponse;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDTO;
+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.usecase.BookUseCase;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/books")
+public class BookController {
+
+  private final BookUseCase bookUseCase;
+  private final Map<String, Boolean> readStatusByIsbn = new ConcurrentHashMap<>();
+
+  public BookController(BookUseCase bookUseCase) {
+    this.bookUseCase = bookUseCase;
+  }
+
+  @GetMapping
+  public List<FrontendBookResponse> listBooks() {
+    return bookUseCase.findAllBooks().stream()
+        .map(book -> FrontendBookMapper.toResponse(book, readStatusByIsbn.getOrDefault(book.getIsbn(), false)))
+        .toList();
+  }
+
+  @GetMapping("/{id}")
+  public ResponseEntity<FrontendBookResponse> getBook(@PathVariable String id) {
+    return bookUseCase.findBookByIsbn(id)
+        .map(book -> FrontendBookMapper.toResponse(book, readStatusByIsbn.getOrDefault(id, false)))
+        .map(ResponseEntity::ok)
+        .orElse(ResponseEntity.notFound().build());
+  }
+
+  @PostMapping
+  public ResponseEntity<?> createBook(@RequestBody FrontendBookRequest request)
+      throws NotValidBookException {
+    if (request.title() == null || request.title().isBlank()
+        || request.author() == null || request.author().isBlank()) {
+      return ResponseEntity.badRequest().body(Map.of("error", "title and author are required"));
+    }
+
+    String isbn = FrontendBookMapper.generateIsbn();
+    bookUseCase.registerBook(
+        FrontendBookMapper.toBookInfo(isbn, request),
+        FrontendBookMapper.toBookSalesInfo(request),
+        FrontendBookMapper.toBookDetails(request));
+    readStatusByIsbn.put(isbn, request.read());
+
+    return bookUseCase.findBookByIsbn(isbn)
+        .map(book -> ResponseEntity.status(HttpStatus.CREATED)
+            .body(FrontendBookMapper.toResponse(book, request.read())))
+        .orElse(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build());
+  }
+
+  @DeleteMapping("/{id}")
+  public ResponseEntity<Void> deleteBook(@PathVariable String id) throws BookNotFoundException {
+    bookUseCase.deleteBook(id);
+    readStatusByIsbn.remove(id);
+    return ResponseEntity.noContent().build();
+  }
+
+  @PostMapping("/{id}/read")
+  public ResponseEntity<FrontendBookResponse> toggleRead(@PathVariable String id) {
+    return bookUseCase.findBookByIsbn(id)
+        .map(book -> {
+          boolean next = !readStatusByIsbn.getOrDefault(id, false);
+          readStatusByIsbn.put(id, next);
+          return ResponseEntity.ok(FrontendBookMapper.toResponse(book, next));
+        })
+        .orElse(ResponseEntity.notFound().build());
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/api/CustomerController.java

@@ -0,0 +1,31 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.api;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.api.dto.LoyaltyPointsResponse;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.usecase.CustomerUseCase;
+import java.util.Optional;
+import java.util.UUID;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/users")
+public class CustomerController {
+
+  private final CustomerUseCase customerUseCase;
+
+  public CustomerController(CustomerUseCase customerUseCase) {
+    this.customerUseCase = customerUseCase;
+  }
+
+  @GetMapping("/{id}/loyalty-points")
+  public ResponseEntity<LoyaltyPointsResponse> getLoyaltyPoints(@PathVariable UUID id) {
+    Optional<CustomerDTO> customer = customerUseCase.findCustomerById(id);
+    return customer
+        .map(c -> ResponseEntity.ok(new LoyaltyPointsResponse(c.getId().toString(), c.getLoyaltyPoints())))
+        .orElse(ResponseEntity.notFound().build());
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/api/FrontendBookMapper.java

@@ -0,0 +1,67 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.api;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.api.dto.FrontendBookRequest;
+import fr.iut_fbleau.but3.dev62.mylibrary.api.dto.FrontendBookResponse;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDTO;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDetails;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicLong;
+
+public final class FrontendBookMapper {
+
+  private static final AtomicLong ISBN_SEQUENCE = new AtomicLong(System.nanoTime() % 1_000_000_000L);
+
+  private FrontendBookMapper() {}
+
+  public static String generateIsbn() {
+    long value = ISBN_SEQUENCE.incrementAndGet() % 10_000_000_000L;
+    return String.format("978%010d", value);
+  }
+
+  public static BookInfo toBookInfo(String isbn, FrontendBookRequest request) {
+    int safeYear = request.year() > 0 ? request.year() : LocalDate.now().getYear();
+    return new BookInfo(
+        isbn,
+        request.title().trim(),
+        request.author().trim(),
+        "Ma librairie",
+        LocalDate.of(safeYear, 1, 1));
+  }
+
+  public static BookSalesInfo toBookSalesInfo(FrontendBookRequest request) {
+    return BookSalesInfo.builder()
+        .price(request.price())
+        .stock(1)
+        .build();
+  }
+
+  public static BookDetails toBookDetails(FrontendBookRequest request) {
+    ArrayList<String> categories = new ArrayList<>();
+    String genre = request.genre() == null ? "" : request.genre().trim();
+    categories.add(genre.isBlank() ? "Général" : genre);
+    return BookDetails.builder()
+        .categories(categories)
+        .description("")
+        .language("fr")
+        .build();
+  }
+
+  public static FrontendBookResponse toResponse(BookDTO book, boolean read) {
+    int year = book.getDate() != null ? book.getDate().getYear() : LocalDate.now().getYear();
+    String genre = book.getCategories() == null || book.getCategories().isEmpty()
+        ? "Général"
+        : book.getCategories().getFirst();
+    return new FrontendBookResponse(
+        book.getIsbn(),
+        book.getTitle(),
+        book.getAuthor(),
+        year,
+        genre,
+        book.getPrice(),
+        read,
+        book.getStock() == null ? 0 : book.getStock());
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/api/HealthController.java

@@ -0,0 +1,16 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.api;
+
+import java.util.Map;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api")
+public class HealthController {
+
+  @GetMapping("/health")
+  public Map<String, String> health() {
+    return Map.of("status", "ok", "service", "mylibrary-backend");
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/api/dto/FrontendBookRequest.java

@@ -0,0 +1,10 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.api.dto;
+
+public record FrontendBookRequest(
+    String title,
+    String author,
+    int year,
+    String genre,
+    double price,
+    boolean read
+) {}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/api/dto/FrontendBookResponse.java

@@ -0,0 +1,12 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.api.dto;
+
+public record FrontendBookResponse(
+    String id,
+    String title,
+    String author,
+    int year,
+    String genre,
+    double price,
+    boolean read,
+    int stock
+) {}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/api/dto/LoyaltyPointsResponse.java

@@ -0,0 +1,3 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.api.dto;
+
+public record LoyaltyPointsResponse(String userId, int points) {}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/BookDTO.java

@@ -0,0 +1,23 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book;
+
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+
+@Getter
+@Builder
+public class BookDTO {
+    private String isbn;
+    private String title;
+    private String author;
+    private String editor;
+    private LocalDate date;
+    private double price;
+    private Integer stock;
+    private ArrayList<String> categories = new ArrayList<>();
+    private String description ;
+    private String language;
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/BookDetails.java

@@ -0,0 +1,17 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book;
+
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.ArrayList;
+
+@Builder
+@Getter
+public class BookDetails {
+    private ArrayList<String> categories = new ArrayList<>();
+    private  String description ;
+    private  String language;
+
+
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/BookInfo.java

@@ -0,0 +1,6 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book;
+
+import java.time.LocalDate;
+
+public record BookInfo(String isbn, String title, String author, String editor, LocalDate date) {
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/BookSalesInfo.java

@@ -0,0 +1,11 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@Getter
+public class BookSalesInfo {
+    private double price;
+    private Integer stock;
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/converter/BookConverter.java

@@ -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.BookDetails;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+
+public final class BookConverter {
+    private BookConverter(){}
+
+    public static Book ToDomain(BookInfo bookinfo, BookSalesInfo booksalesinfo, BookDetails bookdetails){
+        return Book.builder()
+                .isbn(bookinfo.isbn())
+                .title(bookinfo.title())
+                .author(bookinfo.author())
+                .editor(bookinfo.editor())
+                .date(bookinfo.date())
+                .price(booksalesinfo.getPrice())
+                .stock(booksalesinfo.getStock())
+                .categories(bookdetails.getCategories())
+                .description(bookdetails.getDescription())
+                .language(bookdetails.getLanguage())
+                .build();
+    }
+
+    public static BookDTO ToDTO(Book book){
+        return BookDTO.builder()
+                .isbn(book.getIsbn())
+                .title(book.getTitle())
+                .author(book.getAuthor())
+                .editor(book.getEditor())
+                .date(book.getDate())
+                .price(book.getPrice())
+                .stock(book.getStock())
+                .categories(book.getCategories())
+                .description(book.getDescription())
+                .language(book.getLanguage())
+                .build();
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/entity/Book.java

@@ -0,0 +1,35 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.entity;
+
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.IllegalBookStockException;
+import lombok.Builder;
+import lombok.Getter;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+
+@Getter
+@Builder
+public class Book {
+    private String isbn;
+    private String title;
+    private String author;
+    private String editor;
+    private LocalDate date;
+    private double price;
+    private Integer stock;
+    private ArrayList<String> categories = new ArrayList<>();
+    private String description ;
+    private String language;
+
+    public void addStock(Integer copyToAdd){
+        this.stock += copyToAdd;
+    }
+
+    public void removeStock(Integer copyToRemomve) throws IllegalBookStockException {
+        if (copyToRemomve > this.stock){
+            throw new IllegalBookStockException(copyToRemomve, this.stock);
+        }
+        this.stock -= copyToRemomve;
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/BookNotFoundException.java

@@ -0,0 +1,11 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
+
+import java.text.MessageFormat;
+
+public class BookNotFoundException extends RuntimeException {
+    public static final String THE_BOOK_WITH_ID_DOES_NOT_EXIST_MESSAGE = "The book with isbn {0} does not exist";
+
+    public BookNotFoundException(String isbn) {
+        super(MessageFormat.format(THE_BOOK_WITH_ID_DOES_NOT_EXIST_MESSAGE, isbn));
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/IllegalBookStockException.java

@@ -0,0 +1,13 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.exception;
+
+import java.text.MessageFormat;
+
+public class IllegalBookStockException extends Exception {
+    public static final String CANNOT_REMOVE_COPY = "Cannot remove {0} copy from {1} copy";
+
+    public IllegalBookStockException(Integer toremove, Integer actual ) {
+
+        super(MessageFormat.format(CANNOT_REMOVE_COPY, toremove,
+                actual));
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/NotValidBookException.java

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

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/repository/BookRepository.java

@@ -0,0 +1,43 @@
+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;
+
+public class BookRepository {
+
+    private final List<Book> books = new ArrayList<>();
+
+    public List<Book> findAll() {
+        return books;
+    }
+
+    public void deleteAll() {
+        books.clear();
+    }
+
+    public Book save(Book newBook) {
+        Optional<Book> optionalBookWithSameIsbn = this.findByIsbn(newBook.getIsbn());
+        optionalBookWithSameIsbn.ifPresent(books::remove);
+        this.books.add(newBook);
+        return newBook;
+    }
+
+    public Optional<Book> findByIsbn(String isbn) {
+        return this.books.stream()
+                .filter(book -> book.getIsbn().equals(isbn))
+                .findFirst();
+    }
+
+    public boolean existsByIsbn(String isbn) {
+        return this.books.stream()
+                .anyMatch(book -> book.getIsbn().equals(isbn));
+    }
+
+    public void delete(Book book) {
+
+        this.books.remove(book);
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/usecase/BookUseCase.java

@@ -0,0 +1,97 @@
+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.BookDetails;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
+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.BookNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.IllegalBookStockException;
+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 class BookUseCase {
+
+    private final BookRepository bookRepository;
+
+    public BookUseCase(BookRepository bookRepository) {
+
+        this.bookRepository = bookRepository;
+    }
+
+    public String registerBook(BookInfo newbook, BookSalesInfo newbooksalesinfo, BookDetails newbookdetails) throws NotValidBookException {
+        BookValidator.validate(newbook);
+        BookValidator.validate(newbooksalesinfo);
+        BookValidator.validate(newbookdetails);
+        Book bookToRegister = BookConverter.ToDomain(newbook, newbooksalesinfo, newbookdetails);
+        Book bookToRegistered = bookRepository.save(bookToRegister);
+        return bookToRegistered.getIsbn();
+    }
+
+    public List<BookDTO> findAllBooks() {
+        return bookRepository.findAll().stream()
+                .map(BookConverter::ToDTO)
+                .toList();
+    }
+
+    public Optional<BookDTO> findBookByIsbn(String isbn) {
+        Optional<Book> optionalBook = bookRepository.findByIsbn(isbn);
+        return optionalBook.map(BookConverter::ToDTO);
+    }
+
+    public BookDTO updateBook(String isbn, BookInfo bookinfo, BookSalesInfo booksalesinfo, BookDetails bookdetails)
+            throws BookNotFoundException, NotValidBookException {
+        BookValidator.validate(bookinfo);
+        BookValidator.validate(booksalesinfo);
+        BookValidator.validate(bookdetails);
+        Book bookByIsbn = getBookIfDoesNotExistThrowBookNotFoundException(isbn);
+        Book book = Book.builder()
+                .isbn(isbn)
+                .title(bookinfo.title())
+                .author(bookinfo.author())
+                .editor(bookinfo.editor())
+                .date(bookByIsbn.getDate())
+                .price(booksalesinfo.getPrice())
+                .stock(booksalesinfo.getStock())
+                .categories(bookdetails.getCategories())
+                .description(bookdetails.getDescription())
+                .language(bookByIsbn.getLanguage())
+                .build();
+        Book updatedBook = bookRepository.save(book);
+        return BookConverter.ToDTO(updatedBook);
+    }
+
+    public void deleteBook(String isbn) throws BookNotFoundException {
+        Book bookToDelete = getBookIfDoesNotExistThrowBookNotFoundException(isbn);
+        this.bookRepository.delete(bookToDelete);
+    }
+
+    public int addStockCopies(String isbn, int stockCopiesToAdd) throws BookNotFoundException {
+        Book bookToAddStockCopies = getBookIfDoesNotExistThrowBookNotFoundException(isbn);
+        bookToAddStockCopies.addStock(stockCopiesToAdd);
+        bookRepository.save(bookToAddStockCopies);
+        return bookToAddStockCopies.getStock();
+    }
+
+    public int subtractStockCopies(String isbn, int stockCopiesToRemove)
+            throws BookNotFoundException, IllegalBookStockException {
+        Book bookToSubtractStockCopies = getBookIfDoesNotExistThrowBookNotFoundException(isbn);
+        bookToSubtractStockCopies.removeStock(stockCopiesToRemove);
+        bookRepository.save(bookToSubtractStockCopies);
+        return bookToSubtractStockCopies.getStock();
+    }
+
+    private Book getBookIfDoesNotExistThrowBookNotFoundException(String isbn)
+            throws BookNotFoundException {
+        Optional<Book> optionalBookByIsbn = bookRepository.findByIsbn(isbn);
+        if (optionalBookByIsbn.isEmpty()) {
+            throw new BookNotFoundException(isbn);
+        }
+        return optionalBookByIsbn.get();
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/book/validator/BookValidator.java

@@ -0,0 +1,110 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.validator;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDetails;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+
+public class BookValidator {
+
+    public static final String ISBN_IS_NOT_VALID = "Isbn is not valid";
+    public static final String TITLE_CANNOT_BE_BLANK = "Title cannot be blank";
+    public static final String AUTHOR_CANNOT_BE_BLANK = "Author cannot be blank";
+    public static final String EDITOR_CANNOT_BE_BLANK = "Editor cannot be blank";
+    public static final String DATE_IS_NOT_VALID = "Date is not valid";
+    public static final String PRICE_IS_NOT_VALID = "Price is not valid";
+    public static final String STOCK_IS_NOT_VALID = "Stock is not valid";
+    public static final String CATEGORIES_IS_NOT_VALID = "Categories is not valid";
+    public static final String LANGUAGE_CANNOT_BE_BLANK = "Language cannot be blank";
+
+    private BookValidator() {
+    }
+
+    public static void validate(BookInfo newBook) throws NotValidBookException {
+        validateISBN(newBook);
+        validateTitle(newBook);
+        validateAuthor(newBook);
+        validateEditor(newBook);
+        validateDate(newBook);
+    }
+
+    public static void validate(BookSalesInfo newBook) throws NotValidBookException {
+        validatePrice(newBook);
+        validateStock(newBook);
+    }
+
+    public static void validate(BookDetails newBook) throws NotValidBookException {
+        validateCategories(newBook);
+        validateLanguage(newBook);
+    }
+
+    private static void validateISBN(BookInfo newBook) throws NotValidBookException {
+        if (newBook.isbn().isBlank()) {
+            throw new NotValidBookException(ISBN_IS_NOT_VALID);
+        } else if (newBook.isbn().length() != 13) {
+            throw new NotValidBookException(ISBN_IS_NOT_VALID);
+        }
+    }
+
+    private static void validateTitle(BookInfo newBook) throws NotValidBookException {
+        if (newBook.title().isBlank()) {
+            throw new NotValidBookException(TITLE_CANNOT_BE_BLANK);
+        }
+    }
+
+    private static void validateAuthor(BookInfo newBook) throws NotValidBookException {
+        if (newBook.author().isBlank()) {
+            throw new NotValidBookException(AUTHOR_CANNOT_BE_BLANK);
+        }
+    }
+
+    private static void validateEditor(BookInfo newBook) throws NotValidBookException {
+        if (newBook.editor().isBlank()) {
+            throw new NotValidBookException(EDITOR_CANNOT_BE_BLANK);
+        }
+    }
+
+    private static void validateDate(BookInfo newBook) throws NotValidBookException {
+        if (newBook.date().isAfter(LocalDate.now())) {
+            throw new NotValidBookException(DATE_IS_NOT_VALID);
+        }
+    }
+
+    private static void validatePrice(BookSalesInfo newBook) throws NotValidBookException {
+        if (newBook.getPrice() <= 0) {
+            throw new NotValidBookException(PRICE_IS_NOT_VALID);
+        }
+    }
+
+    private static void validateStock(BookSalesInfo newBook) throws NotValidBookException {
+        if (newBook.getStock() < 0) {
+            throw new NotValidBookException(STOCK_IS_NOT_VALID);
+        }
+    }
+
+    private static void validateCategories(BookDetails newBook) throws NotValidBookException {
+        if (newBook.getCategories().isEmpty()) {
+            throw new NotValidBookException(CATEGORIES_IS_NOT_VALID);
+        }else if (CategoriesNotBlank(newBook.getCategories())) {
+            throw new NotValidBookException(CATEGORIES_IS_NOT_VALID);
+        }
+    }
+
+    private static boolean CategoriesNotBlank(ArrayList<String> categories){
+        for (String categorie : categories) {
+            if (categorie.isBlank()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static void validateLanguage(BookDetails newBook) throws NotValidBookException {
+        if (newBook.getLanguage().isBlank()) {
+            throw new NotValidBookException(LANGUAGE_CANNOT_BE_BLANK);
+        }
+    }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/config/AppConfig.java

@@ -0,0 +1,32 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.config;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.usecase.BookUseCase;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.usecase.CustomerUseCase;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class AppConfig {
+
+  @Bean
+  BookRepository bookRepository() {
+    return new BookRepository();
+  }
+
+  @Bean
+  BookUseCase bookUseCase(BookRepository bookRepository) {
+    return new BookUseCase(bookRepository);
+  }
+
+  @Bean
+  CustomerRepository customerRepository() {
+    return new CustomerRepository();
+  }
+
+  @Bean
+  CustomerUseCase customerUseCase(CustomerRepository customerRepository) {
+    return new CustomerUseCase(customerRepository);
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/config/DemoDataLoader.java

@@ -0,0 +1,74 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.config;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDetails;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.usecase.BookUseCase;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.NotValidCustomerException;
+import fr.iut_fbleau.but3.dev62.mylibrary.customer.usecase.CustomerUseCase;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+
+@Component
+public class DemoDataLoader implements ApplicationRunner {
+
+  private final BookUseCase bookUseCase;
+  private final CustomerUseCase customerUseCase;
+
+  public DemoDataLoader(BookUseCase bookUseCase, CustomerUseCase customerUseCase) {
+    this.bookUseCase = bookUseCase;
+    this.customerUseCase = customerUseCase;
+  }
+
+  @Override
+  public void run(ApplicationArguments args) throws NotValidBookException, NotValidCustomerException {
+    if (!bookUseCase.findAllBooks().isEmpty()) {
+      return;
+    }
+
+    registerBook(
+        "9782070612758",
+        "Le Petit Prince",
+        "Antoine de Saint-Exupéry",
+        LocalDate.of(1943, 1, 1),
+        8.5,
+        "Conte");
+    registerBook(
+        "9782070368228",
+        "1984",
+        "George Orwell",
+        LocalDate.of(1949, 1, 1),
+        9.9,
+        "Science-fiction");
+
+    customerUseCase.registerCustomer(new CustomerInfo("Marie", "Dupont", "0612345678"));
+    customerUseCase.addLoyaltyPoints(
+        customerUseCase.findCustomerByPhoneNumber("0612345678").orElseThrow().getId(),
+        100);
+  }
+
+  private void registerBook(
+      String isbn,
+      String title,
+      String author,
+      LocalDate date,
+      double price,
+      String category)
+      throws NotValidBookException {
+    ArrayList<String> categories = new ArrayList<>();
+    categories.add(category);
+    bookUseCase.registerBook(
+        new BookInfo(isbn, title, author, "Gallimard", date),
+        BookSalesInfo.builder().price(price).stock(5).build(),
+        BookDetails.builder()
+            .categories(categories)
+            .description("")
+            .language("fr")
+            .build());
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/config/WebConfig.java

@@ -0,0 +1,17 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class WebConfig implements WebMvcConfigurer {
+
+  @Override
+  public void addCorsMappings(CorsRegistry registry) {
+    registry.addMapping("/api/**")
+        .allowedOrigins("http://localhost:5173", "http://127.0.0.1:5173")
+        .allowedMethods("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS")
+        .allowedHeaders("*");
+  }
+}

src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/customer/usecase/CustomerUseCase.java

@@ -32,6 +32,10 @@ public final class CustomerUseCase {
     return optionalCustomer.map(CustomerConverter::toDTO);
   }
 
+  public Optional<CustomerDTO> findCustomerById(UUID uuid) {
+    return customerRepository.findById(uuid).map(CustomerConverter::toDTO);
+  }
+
   public CustomerDTO updateCustomer(UUID uuid, CustomerInfo customerInfo)
       throws CustomerNotFoundException, NotValidCustomerException {
     CustomerValidator.validate(customerInfo);

src/main/resources/application.properties

@@ -0,0 +1,2 @@
+server.port=8080
+spring.application.name=mylibrary

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/converter/BookConverterTest.java

@@ -0,0 +1,118 @@
+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.BookDetails;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@DisplayName("BookConverterTest Unit Tests")
+public class BookConverterTest {
+
+    @Nested
+    @DisplayName("toDomain() method tests")
+    class ToDomainTests {
+
+        @Test
+        void ShouldConvertBookToDomain(){
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookinfo = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", "Kioon", date);
+            BookSalesInfo booksalesinfo = BookSalesInfo.builder()
+                    .price(12)
+                    .stock(10)
+                    .build();
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+            BookDetails bookdetails = BookDetails.builder()
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt")
+                    .language("Français")
+                    .build();
+
+            Book result = BookConverter.ToDomain(bookinfo, booksalesinfo, bookdetails);
+
+            assertEquals(bookinfo.isbn(), result.getIsbn());
+            assertEquals(bookinfo.title(), result.getTitle());
+            assertEquals(bookinfo.author(), result.getAuthor());
+            assertEquals(bookinfo.editor(), result.getEditor());
+            assertEquals(bookinfo.date(), result.getDate());
+            assertEquals(booksalesinfo.getPrice(), result.getPrice());
+            assertEquals(booksalesinfo.getStock(), result.getStock());
+            assertEquals(bookdetails.getCategories(), result.getCategories());
+            assertEquals(bookdetails.getDescription(), result.getDescription());
+            assertEquals(bookdetails.getLanguage(), result.getLanguage());
+        }
+    }
+
+    @Nested
+    @DisplayName("toDTO() method tests")
+    class ToDTOTests {
+
+        @Test
+        void ShouldConvertBookToDTO() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+            Book book = Book.builder()
+                    .isbn("1234567891012")
+                    .title("La vie de Maxime")
+                    .author("Marvin Aubert")
+                    .editor("Kioon")
+                    .date(date)
+                    .price(12.99)
+                    .stock(50)
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt")
+                    .language("Français")
+                    .build();
+
+            BookDTO result = BookConverter.ToDTO(book);
+
+            assertEquals(book.getIsbn(), result.getIsbn());
+            assertEquals(book.getTitle(), result.getTitle());
+            assertEquals(book.getAuthor(), result.getAuthor());
+            assertEquals(book.getEditor(), result.getEditor());
+            assertEquals(book.getDate(), result.getDate());
+            assertEquals(book.getPrice(), result.getPrice());
+            assertEquals(book.getStock(), result.getStock());
+            assertEquals(book.getCategories(), result.getCategories());
+            assertEquals(book.getDescription(), result.getDescription());
+            assertEquals(book.getLanguage(), result.getLanguage());
+        }
+    }
+
+    @Test
+    @DisplayName("Should preserve empty string values during conversion")
+    void shouldPreserveEmptyStrings() {
+        LocalDate date = LocalDate.of(2026, 3, 24);
+        BookInfo bookinfo = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", "Kioon", date);
+        BookSalesInfo booksalesinfo = BookSalesInfo.builder()
+                .price(12)
+                .stock(10)
+                .build();
+        ArrayList<String> categories = new ArrayList<>();
+        categories.add("Thriller");
+        categories.add("Biographie");
+        BookDetails bookdetails = BookDetails.builder()
+                .categories(categories)
+                .description("")
+                .language("Français")
+                .build();
+
+        Book book = BookConverter.ToDomain(bookinfo, booksalesinfo, bookdetails);
+        BookDTO result = BookConverter.ToDTO(book);
+
+        assertEquals("", result.getDescription());
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/entity/BookTest.java

@@ -0,0 +1,168 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.entity;
+
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.IllegalBookStockException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class BookTest {
+
+    @Test
+    @DisplayName("Builder should create a valid Book instance")
+    void testBookBuilder() {
+        String isbn = "1234567891012";
+        String title = "La vie de Maxime";
+        String author = "Marvin Aubert";
+        String editor = "Kioon";
+        LocalDate date = LocalDate.of(2026, 3, 24);
+        double price = 12.99;
+        Integer stock = 50;
+        ArrayList<String> categories = new ArrayList<>();
+        categories.add("Thriller");
+        categories.add("Biographie");
+        String description = "C'était un brave partit trop tôt";
+        String language = "Français";
+        Book book = Book.builder()
+                .isbn(isbn)
+                .title(title)
+                .author(author)
+                .editor(editor)
+                .date(date)
+                .price(price)
+                .stock(stock)
+                .categories(categories)
+                .description(description)
+                .language(language)
+                .build();
+
+        assertEquals(isbn, book.getIsbn());
+        assertEquals(title, book.getTitle());
+        assertEquals(author, book.getAuthor());
+        assertEquals(editor, book.getEditor());
+        assertEquals(date, book.getDate());
+        assertEquals(price, book.getPrice());
+        assertEquals(stock, book.getStock());
+        assertEquals(categories, book.getCategories());
+        assertEquals(description, book.getDescription());
+        assertEquals(language, book.getLanguage());
+    }
+
+    @Nested
+    @DisplayName("Stock Tests")
+    class StockTests {
+
+        @Test
+        @DisplayName("addCopy should correctly increment stocks")
+        void testAddCopy() {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToAdd = 5;
+            Integer copyExpected = 10;
+
+            book.addStock(copyToAdd);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+
+        @Test
+        @DisplayName("addCopy should correctly increment zero points correctly")
+        void testAddZeroToCopy() {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToAdd = 0;
+            Integer copyExpected = 5;
+
+            book.addStock(copyToAdd);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+
+        @Test
+        @DisplayName("removeLoyaltyPoints should correctly decrement loyalty points")
+        void testRemoveCopy() throws IllegalBookStockException {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToRemove = 2;
+            Integer copyExpected = 3;
+
+            book.removeStock(copyToRemove);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+
+        @Test
+        @DisplayName("removeLoyaltyPoints should correctly decrement loyalty points")
+        void testRemoveZeroToCopy() throws IllegalBookStockException {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToRemove = 0;
+            Integer copyExpected = 5;
+
+            book.removeStock(copyToRemove);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+
+        @Test
+        @DisplayName("removeLoyaltyPoints should correctly decrement loyalty points")
+        void testRemoveAllToCopy() throws IllegalBookStockException {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToRemove = 5;
+            Integer copyExpected = 0;
+
+            book.removeStock(copyToRemove);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+
+        @Test
+        @DisplayName("removeSTock should throw exception when trying to remove more copy than available")
+        void testRemoveTooManyCopy() {
+            Book book = Book.builder()
+                    .stock(50)
+                    .build();
+            int copyToRemove = 75;
+
+            IllegalBookStockException exception = assertThrows(
+                    IllegalBookStockException.class,
+                    () -> book.removeStock(copyToRemove)
+            );
+
+            assertEquals(50, book.getStock());
+
+            assertTrue(exception.getMessage().contains(String.valueOf(copyToRemove)));
+            assertTrue(exception.getMessage().contains(String.valueOf(book.getStock())));
+        }
+    }
+
+    @Nested
+    @DisplayName("Price Tests")
+    class PriceTests {
+        @Test
+        @DisplayName("addCopy should correctly increment stocks")
+        void testAddCopy() {
+            Book book =Book.builder()
+                    .stock(5)
+                    .build();
+            Integer copyToAdd = 5;
+            Integer copyExpected = 10;
+
+            book.addStock(copyToAdd);
+
+            assertEquals(copyExpected, book.getStock());
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/BookNotFoundExceptionTest.java

@@ -0,0 +1,48 @@
+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.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class BookNotFoundExceptionTest {
+
+    @Test
+    @DisplayName("Exception message should contain the isbn provided")
+    void testExceptionMessageContainsIsbn() {
+        String isbn = "1234567891012";
+
+        BookNotFoundException exception = new BookNotFoundException(isbn);
+
+        String expectedMessage = String.format("The book with isbn %s does not exist", isbn);
+        assertEquals(expectedMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should use the correct constant message format")
+    void testExceptionUsesConstantMessageFormat() {
+        String isbn = "1234567891012";
+
+        BookNotFoundException exception = new BookNotFoundException(isbn);
+
+        String expectedFormatWithPlaceholder = "The book with isbn {0} does not exist";
+        assertEquals(BookNotFoundException.THE_BOOK_WITH_ID_DOES_NOT_EXIST_MESSAGE,
+                expectedFormatWithPlaceholder);
+        assertTrue(exception.getMessage().contains(isbn.toString()));
+    }
+
+    @Test
+    @DisplayName("Exception should be properly thrown and caught")
+    void testExceptionCanBeThrownAndCaught() {
+        String isbn = "1234567891012";
+
+        try {
+            throw new BookNotFoundException(isbn);
+        } catch (BookNotFoundException e) {
+            String expectedMessage = String.format("The book with isbn %s does not exist", isbn);
+            assertEquals(expectedMessage, e.getMessage());
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/IllegalBookStockExceptionTest.java

@@ -0,0 +1,70 @@
+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.CsvSource;
+
+import java.text.MessageFormat;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class IllegalBookStockExceptionTest {
+
+    @Test
+    @DisplayName("Exception message should contain the needed and actual stock")
+    void testExceptionMessageContainsStock() {
+        int neededStock = 100;
+        int actualStock = 50;
+
+        IllegalBookStockException exception = new IllegalBookStockException(neededStock, actualStock);
+
+        String expectedMessage = "Cannot remove 100 copy from 50 copy";
+        assertEquals(expectedMessage, exception.getMessage());
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            "100, 50",
+            "75, 25",
+            "200, 150",
+            "1000, 750"
+    })
+    @DisplayName("Exception message should be formatted correctly for different stock values")
+    void testExceptionMessageForDifferentStockValues(int neededStock, int actualStock) {
+        IllegalBookStockException exception = new IllegalBookStockException(neededStock, actualStock);
+
+        String expectedMessage = MessageFormat.format(IllegalBookStockException.CANNOT_REMOVE_COPY, neededStock, actualStock);
+        assertEquals(expectedMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should use the correct constant message format")
+    void testExceptionUsesConstantMessageFormat() {
+        int neededStock = 100;
+        int actualStock = 50;
+
+        IllegalBookStockException exception = new IllegalBookStockException(neededStock, actualStock);
+
+        String expectedFormatWithPlaceholder = "Cannot remove {0} copy from {1} copy";
+        assertEquals(IllegalBookStockException.CANNOT_REMOVE_COPY,
+                expectedFormatWithPlaceholder);
+        assertTrue(exception.getMessage().contains(String.valueOf(neededStock)));
+        assertTrue(exception.getMessage().contains(String.valueOf(actualStock)));
+    }
+
+    @Test
+    @DisplayName("Exception should be properly thrown and caught")
+    void testExceptionCanBeThrownAndCaught() {
+        int neededStock = 100;
+        int actualStock = 50;
+
+        try {
+            throw new IllegalBookStockException(neededStock, actualStock);
+        } catch (IllegalBookStockException e) {
+            String expectedMessage = String.format("Cannot remove %d copy from %d copy", neededStock, actualStock);
+            assertEquals(expectedMessage, e.getMessage());
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/exception/NotValidBookExceptionTest.java

@@ -0,0 +1,61 @@
+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.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class NotValidBookExceptionTest {
+
+    @Test
+    @DisplayName("Exception should be created with the provided message")
+    void testExceptionCreation() {
+        String errorMessage = "Book data is not valid";
+
+        NotValidBookException exception = new NotValidBookException(errorMessage);
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "Isbn is required",
+            "Title cannot be empty",
+            "Date format is invalid",
+            "Price must be above 0"
+    })
+    @DisplayName("Exception should handle different validation messages")
+    void testExceptionWithDifferentMessages(String errorMessage) {
+        NotValidBookException exception = new NotValidBookException(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(NotValidBookException.class, () -> {
+            throw new NotValidBookException(errorMessage);
+        });
+
+        assertEquals(errorMessage, exception.getMessage());
+    }
+
+    @Test
+    @DisplayName("Exception should be catchable as a general Exception")
+    void testExceptionInheritance() {
+        String errorMessage = "Invalid book data";
+
+        try {
+            throw new NotValidBookException(errorMessage);
+        } catch (Exception e) {
+            assertEquals(NotValidBookException.class, e.getClass());
+            assertEquals(errorMessage, e.getMessage());
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/repository/BookRepositoryTest.java

@@ -0,0 +1,255 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.repository;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+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.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class BookRepositoryTest {
+
+    private BookRepository repository;
+    private Book book1;
+    private Book book2;
+
+    @BeforeEach
+    void setUp() {
+        repository = new BookRepository();
+
+        LocalDate date = LocalDate.of(2026, 3, 24);
+        ArrayList<String> categories = new ArrayList<>();
+        categories.add("Thriller");
+        categories.add("Biographie");
+
+        book1 = Book.builder()
+                .isbn("1234567891012")
+                .title("La vie de Maxime")
+                .author("Marvin Aubert")
+                .editor("Kioon")
+                .date(date)
+                .price(12.99)
+                .stock(50)
+                .categories(categories)
+                .description("C'était un brave partit trop tôt")
+                .language("Français")
+                .build();
+
+        book2 = Book.builder()
+                .isbn("1234567891015")
+                .title("La vie de Marvin")
+                .author("Maxime Lebreton")
+                .editor("Kioon")
+                .date(date)
+                .price(12.99)
+                .stock(50)
+                .categories(categories)
+                .description("C'était un brave partit trop tôt")
+                .language("Français")
+                .build();
+    }
+
+    @Test
+    @DisplayName("New repository should be empty")
+    void testNewRepositoryIsEmpty() {
+        List<Book> books = repository.findAll();
+
+        assertTrue(books.isEmpty());
+        assertEquals(0, books.size());
+    }
+
+    @Nested
+    @DisplayName("Save operations")
+    class SaveOperations {
+
+        @Test
+        @DisplayName("Save should add a new book")
+        void testSaveNewBook() {
+            Book savedBook = repository.save(book1);
+
+            assertEquals(1, repository.findAll().size());
+            assertEquals(book1.getIsbn(), savedBook.getIsbn());
+            assertEquals(book1.getTitle(), savedBook.getTitle());
+        }
+
+        @Test
+        @DisplayName("Save should update existing book with same isbn")
+        void testSaveUpdatesExistingBook() {
+            repository.save(book1);
+
+            String isbn = "1234567891012";
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+
+            Book updatedBook = Book.builder()
+                    .isbn(isbn)
+                    .title("La vie de Maxime")
+                    .author("Updated")
+                    .editor("Kioon")
+                    .date(date)
+                    .price(12.99)
+                    .stock(50)
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt beaucoup trop tôt")
+                    .language("Français")
+                    .build();
+
+            Book savedBook = repository.save(updatedBook);
+
+            assertEquals(1, repository.findAll().size());
+            assertEquals(isbn, savedBook.getIsbn());
+            assertEquals("La vie de Maxime", savedBook.getTitle());
+            assertEquals("Updated", savedBook.getAuthor());
+            assertEquals("Kioon", savedBook.getEditor());
+            assertEquals(date, savedBook.getDate());
+            assertEquals(12.99, savedBook.getPrice());
+            assertEquals(50, savedBook.getStock());
+            assertEquals(categories, savedBook.getCategories());
+            assertEquals("C'était un brave partit trop tôt beaucoup trop tôt", savedBook.getDescription());
+            assertEquals("Français", savedBook.getLanguage());
+        }
+
+        @Test
+        @DisplayName("Save multiple books should add all of them")
+        void testSaveMultipleBooks() {
+            repository.save(book1);
+            repository.save(book2);
+
+            List<Book> books = repository.findAll();
+
+            assertEquals(2, books.size());
+            assertTrue(books.contains(book1));
+            assertTrue(books.contains(book2));
+        }
+    }
+
+    @Nested
+    @DisplayName("Find operations")
+    class FindOperations {
+
+        @BeforeEach
+        void setUpBooks() {
+            repository.save(book1);
+            repository.save(book2);
+        }
+
+        @Test
+        @DisplayName("FindAll should return all books")
+        void testFindAll() {
+            List<Book> books = repository.findAll();
+
+            assertEquals(2, books.size());
+            assertTrue(books.contains(book1));
+            assertTrue(books.contains(book2));
+        }
+
+        @Test
+        @DisplayName("FindByIsbn should return book with matching isbn")
+        void testFindByIsbn() {
+            Optional<Book> foundBook = repository.findByIsbn(book1.getIsbn());
+
+            assertTrue(foundBook.isPresent());
+            assertEquals(book1.getTitle(), foundBook.get().getTitle());
+            assertEquals(book1.getAuthor(), foundBook.get().getAuthor());
+        }
+
+        @Test
+        @DisplayName("FindByIsbn should return empty Optional when isbn doesn't exist")
+        void testFindByIsbnNotFound() {
+            String nonExistedisbn = "1515265522652";
+
+            Optional<Book> foundBook = repository.findByIsbn(nonExistedisbn);
+
+            assertTrue(foundBook.isEmpty());
+        }
+
+        @Test
+        @DisplayName("ExistsByIsbn should return true when isbn exists")
+        void testExistsByIsbnExists() {
+            boolean exists = repository.existsByIsbn(book1.getIsbn());
+
+            assertTrue(exists);
+        }
+
+        @Test
+        @DisplayName("ExistsByIsbn should return false when isbn doesn't exist")
+        void testExistsByIsbnNotExists() {
+            String nonExistedisbn = "1515265522652";
+
+            boolean exists = repository.existsByIsbn(nonExistedisbn);
+
+            assertFalse(exists);
+        }
+    }
+
+    @Nested
+    @DisplayName("Delete operations")
+    class DeleteOperations {
+
+        @BeforeEach
+        void setUpBooks() {
+            repository.save(book1);
+            repository.save(book2);
+        }
+
+        @Test
+        @DisplayName("Delete should remove the specified book")
+        void testDelete() {
+            repository.delete(book1);
+
+            List<Book> books = repository.findAll();
+
+            assertEquals(1, books.size());
+            assertFalse(books.contains(book1));
+            assertTrue(books.contains(book2));
+        }
+
+        @Test
+        @DisplayName("DeleteAll should remove all books")
+        void testDeleteAll() {
+            repository.deleteAll();
+
+            List<Book> books = repository.findAll();
+
+            assertTrue(books.isEmpty());
+            assertEquals(0, books.size());
+        }
+
+        @Test
+        @DisplayName("Delete should not throw exception when book doesn't exist")
+        void testDeleteNonExistentBook() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+            Book nonExistentBook = Book.builder()
+                    .isbn("1515466461319")
+                    .title("La vie de Patrick")
+                    .author("Updated")
+                    .editor("Kioon")
+                    .date(date)
+                    .price(12.99)
+                    .stock(50)
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt")
+                    .language("Français")
+                    .build();
+
+            assertDoesNotThrow(() -> repository.delete(nonExistentBook));
+
+            assertEquals(2, repository.findAll().size());
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/usecase/BookUseCaseTest.java

@@ -0,0 +1,356 @@
+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.BookDetails;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.entity.Book;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.BookNotFoundExceptionTest;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.IllegalBookStockException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.repository.BookRepository;
+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.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Optional;
+
+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 static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.never;
+
+@ExtendWith(MockitoExtension.class)
+public class BookUseCaseTest {
+
+    @Mock
+    private BookRepository bookRepository;
+
+    @InjectMocks
+    private BookUseCase bookUseCase;
+
+    private String bookIsbn;
+    private ArrayList<String> categories;
+    private LocalDate date;
+    private Book testBook;
+    private BookInfo validBookInfo;
+    private BookDetails validBookDetails;
+    private BookSalesInfo validBookSalesInfo;
+
+    @BeforeEach
+    void setUp() {
+        bookIsbn = "1234567891012";
+        date = LocalDate.of(2026, 3, 24);
+        categories = new ArrayList<>();
+        categories.add("Thriller");
+        categories.add("Biographie");
+
+        testBook = Book.builder()
+                .isbn(bookIsbn)
+                .title("La vie de Maxime")
+                .author("Marvin AUbert")
+                .editor("Kioon")
+                .date(date)
+                .price(12.99)
+                .stock(50)
+                .categories(categories)
+                .description("C'était un brave partit trop tôt")
+                .language("Français")
+                .build();
+
+        validBookInfo = new BookInfo(bookIsbn,"La vie de Maxime", "Marvin AUbert", "Kioon", date);
+        validBookSalesInfo = BookSalesInfo.builder()
+                .price(12.99)
+                .stock(50)
+                .build();
+        validBookDetails = BookDetails.builder()
+                .categories(categories)
+                .description("C'était un brave partit trop tôt")
+                .language("Français")
+                .build();
+    }
+
+    @Nested
+    @DisplayName("Register Book tests")
+    class RegisterBookTests {
+
+        @Test
+        @DisplayName("Should register book when valid data is provided")
+        void testRegisterBookWithValidData() throws NotValidBookException {
+            when(bookRepository.save(any(Book.class))).thenReturn(testBook);
+
+            String registeredIsbn = bookUseCase.registerBook(validBookInfo, validBookSalesInfo, validBookDetails);
+
+            assertNotNull(registeredIsbn);
+            assertEquals(bookIsbn, registeredIsbn);
+            verify(bookRepository, times(1)).save(any(Book.class));
+        }
+
+        @Test
+        @DisplayName("Should throw exception when book data is not valid")
+        void testRegisterBookWithInvalidData() {
+            BookInfo invalidBookInfo = new BookInfo(bookIsbn,"", "", "", date);
+            BookSalesInfo invalidUpdateSalesInfo = BookSalesInfo.builder()
+                    .price(0)
+                    .stock(-3)
+                    .build();
+            BookDetails invalidUpdateDetails = BookDetails.builder()
+                    .categories(categories)
+                    .description("")
+                    .language("")
+                    .build();
+            assertThrows(NotValidBookException.class,
+                    () -> bookUseCase.registerBook(invalidBookInfo, invalidUpdateSalesInfo, invalidUpdateDetails));
+
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+    }
+
+    @Nested
+    @DisplayName("Find book tests")
+    class FindBookTests {
+
+        @Test
+        @DisplayName("Should return book when isbn exists")
+        void testFindBookByIsbn() {
+            when(bookRepository.findByIsbn("1234567891012")).thenReturn(Optional.of(testBook));
+
+            Optional<BookDTO> foundBook = bookUseCase.findBookByIsbn("1234567891012");
+
+            assertTrue(foundBook.isPresent());
+            assertEquals(testBook.getIsbn(), foundBook.get().getIsbn());
+            assertEquals(testBook.getTitle(), foundBook.get().getTitle());
+            verify(bookRepository, times(1)).findByIsbn("1234567891012");
+        }
+
+        @Test
+        @DisplayName("Should return empty Optional when isbn doesn't exist")
+        void testFindBookByIsbnNotFound() {
+            when(bookRepository.findByIsbn("1656546262516")).thenReturn(Optional.empty());
+
+            Optional<BookDTO> foundBook = bookUseCase.findBookByIsbn("1656546262516");
+
+            assertTrue(foundBook.isEmpty());
+            verify(bookRepository, times(1)).findByIsbn("1656546262516");
+        }
+    }
+
+    @Nested
+    @DisplayName("Update book tests")
+    class UpdateBookTests {
+
+        @Test
+        @DisplayName("Should update book when valid data is provided")
+        void testUpdateBookWithValidData() throws BookNotFoundException, NotValidBookException {
+            when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
+
+            Book updatedBook = Book.builder()
+                    .isbn(bookIsbn)
+                    .title("La vie de Maxime")
+                    .author("Updated")
+                    .editor("Kioon")
+                    .date(date)
+                    .price(12.99)
+                    .stock(50)
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt")
+                    .language("Français")
+                    .build();
+
+            when(bookRepository.save(any(Book.class))).thenReturn(updatedBook);
+
+            BookInfo updateInfo = new BookInfo(bookIsbn, "La vie de Maxime", "Updated", "Kioon", date);
+            BookSalesInfo updateSalesInfo = BookSalesInfo.builder()
+                    .price(12.99)
+                    .stock(50)
+                    .build();
+            BookDetails updateDetails = BookDetails.builder()
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt beaucoup trop tôt")
+                    .language("Français")
+                    .build();
+            BookDTO result = bookUseCase.updateBook(bookIsbn, updateInfo, updateSalesInfo, updateDetails);
+
+            assertNotNull(result);
+            assertEquals(bookIsbn, result.getIsbn());
+            assertEquals("La vie de Maxime", result.getTitle());
+            assertEquals("Updated", result.getAuthor());
+            assertEquals("Kioon", result.getEditor());
+            assertEquals(date, result.getDate());
+            assertEquals(12.99, result.getPrice());
+            assertEquals(50, result.getStock());
+            assertEquals(categories, result.getCategories());
+            assertEquals("C'était un brave partit trop tôt", result.getDescription());
+            assertEquals("Français", result.getLanguage());
+            verify(bookRepository, times(1)).findByIsbn(bookIsbn);
+            verify(bookRepository, times(1)).save(any(Book.class));
+        }
+
+        @Test
+        @DisplayName("Should throw exception when book isbn doesn't exist")
+        void testUpdateBookNotFound() {
+            String nonExistentIsbn = "1656546262516";
+            when(bookRepository.findByIsbn(nonExistentIsbn)).thenReturn(Optional.empty());
+
+            BookInfo updateInfo = new BookInfo(nonExistentIsbn, "La vie de Maxime", "Updated", "Kioon", date);
+            BookSalesInfo updateSalesInfo = BookSalesInfo.builder()
+                    .price(12.99)
+                    .stock(50)
+                    .build();
+            BookDetails updateDetails = BookDetails.builder()
+                    .categories(categories)
+                    .description("C'était un brave partit trop tôt")
+                    .language("Français")
+                    .build();
+
+            assertThrows(BookNotFoundException.class,
+                    () -> bookUseCase.updateBook(nonExistentIsbn, updateInfo, updateSalesInfo, updateDetails));
+
+            verify(bookRepository, times(1)).findByIsbn(nonExistentIsbn);
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+
+        @Test
+        @DisplayName("Should throw exception when update data is not valid")
+        void testUpdateBookWithInvalidData() {
+            BookInfo invalidUpdateInfo = new BookInfo(bookIsbn,"", "", "", date);
+            BookSalesInfo invalidUpdateSalesInfo = BookSalesInfo.builder()
+                    .price(0)
+                    .stock(-3)
+                    .build();
+            BookDetails invalidUpdateDetails = BookDetails.builder()
+                    .categories(categories)
+                    .description("")
+                    .language("")
+                    .build();
+
+            assertThrows(NotValidBookException.class,
+                    () -> bookUseCase.updateBook(bookIsbn, invalidUpdateInfo, invalidUpdateSalesInfo, invalidUpdateDetails));
+
+            verify(bookRepository, never()).findByIsbn(any(String.class));
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+    }
+
+    @Nested
+    @DisplayName("Delete book tests")
+    class DeleteBookTests {
+
+        @Test
+        @DisplayName("Should delete book when isbn exists")
+        void testDeleteBook() throws BookNotFoundException {
+            when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
+            doNothing().when(bookRepository).delete(testBook);
+
+            bookUseCase.deleteBook(bookIsbn);
+
+            verify(bookRepository, times(1)).findByIsbn(bookIsbn);
+            verify(bookRepository, times(1)).delete(testBook);
+        }
+
+        @Test
+        @DisplayName("Should throw exception when book isbn doesn't exist")
+        void testDeleteBookNotFound() {
+            String nonExistentIsbn = "1656546262516";
+            when(bookRepository.findByIsbn(nonExistentIsbn)).thenReturn(Optional.empty());
+
+            assertThrows(BookNotFoundException.class,
+                    () -> bookUseCase.deleteBook(nonExistentIsbn));
+
+            verify(bookRepository, times(1)).findByIsbn(nonExistentIsbn);
+            verify(bookRepository, never()).delete(any(Book.class));
+        }
+    }
+
+    @Nested
+    @DisplayName("Stock copies tests")
+    class StockCopiesTests {
+
+        @Test
+        @DisplayName("Should add stock copies to book")
+        void testAddStockCopies() throws BookNotFoundException {
+            when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
+            when(bookRepository.save(testBook)).thenReturn(testBook);
+
+            int initialCopies = testBook.getStock();
+            int copiesToAdd = 50;
+            int expectedCopies = initialCopies + copiesToAdd;
+
+            int newCopies = bookUseCase.addStockCopies(bookIsbn, copiesToAdd);
+
+            assertEquals(expectedCopies, newCopies);
+            assertEquals(expectedCopies, testBook.getStock());
+            verify(bookRepository, times(1)).findByIsbn(bookIsbn);
+            verify(bookRepository, times(1)).save(testBook);
+        }
+
+        @Test
+        @DisplayName("Should throw exception when adding copies to non-existent book")
+        void testAddStockCopiesToNonExistentBook() {
+            String nonExistentIsbn = "1656546262516";
+            when(bookRepository.findByIsbn(nonExistentIsbn)).thenReturn(Optional.empty());
+
+            assertThrows(BookNotFoundException.class,
+                    () -> bookUseCase.addStockCopies(nonExistentIsbn, 50));
+
+            verify(bookRepository, times(1)).findByIsbn(nonExistentIsbn);
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+
+        @Test
+        @DisplayName("Should subtract stock copies from book")
+        void testSubtractStockCopies() throws BookNotFoundException, IllegalBookStockException {
+            when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
+            when(bookRepository.save(testBook)).thenReturn(testBook);
+
+            int initialCopies = testBook.getStock();
+            int copiesToRemove = 30;
+            int expectedCopies = initialCopies - copiesToRemove;
+
+            int newCopies = bookUseCase.subtractStockCopies(bookIsbn, copiesToRemove);
+
+            assertEquals(expectedCopies, newCopies);
+            assertEquals(expectedCopies, testBook.getStock());
+            verify(bookRepository, times(1)).findByIsbn(bookIsbn);
+            verify(bookRepository, times(1)).save(testBook);
+        }
+
+        @Test
+        @DisplayName("Should throw exception when trying to remove more copies than available")
+        void testSubtractTooManyStockCopies() {
+            when(bookRepository.findByIsbn(bookIsbn)).thenReturn(Optional.of(testBook));
+
+            int copiesToRemove = 200;
+
+            assertThrows(IllegalBookStockException.class,
+                    () -> bookUseCase.subtractStockCopies(bookIsbn, copiesToRemove));
+
+            verify(bookRepository, times(1)).findByIsbn(bookIsbn);
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+
+        @Test
+        @DisplayName("Should throw exception when subtracting copies from non-existent book")
+        void testSubtractStockCopiesFromNonExistentBook() {
+            String nonExistentIsbn = "1656546262516";
+            when(bookRepository.findByIsbn(nonExistentIsbn)).thenReturn(Optional.empty());
+
+            assertThrows(BookNotFoundException.class,
+                    () -> bookUseCase.subtractStockCopies(nonExistentIsbn, 50));
+
+            verify(bookRepository, times(1)).findByIsbn(nonExistentIsbn);
+            verify(bookRepository, never()).save(any(Book.class));
+        }
+    }
+}

src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/validator/BookValidatorTest.java

@@ -0,0 +1,379 @@
+package fr.iut_fbleau.but3.dev62.mylibrary.book.validator;
+
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookDetails;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.BookSalesInfo;
+import fr.iut_fbleau.but3.dev62.mylibrary.book.exception.NotValidBookException;
+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.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BookValidatorTest {
+
+    @Test
+    @DisplayName("Should validate book with valid data")
+    void testValidateValidBook() {
+        LocalDate date = LocalDate.of(2026, 3, 24);
+        BookInfo validBook = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", "Kioon", date);
+
+        assertDoesNotThrow(() -> BookValidator.validate(validBook));
+    }
+
+    @Test
+    @DisplayName("Should validate book details with valid data")
+    void testValidateValidBookDetails() {
+        ArrayList<String> categories = new ArrayList<>();
+        categories.add("Thriller");
+        categories.add("Biographie");
+        BookDetails validBookDetails = BookDetails.builder()
+                .categories(categories)
+                .description("C'était un brave partit trop tôt")
+                .language("Français")
+                .build();
+
+        assertDoesNotThrow(() -> BookValidator.validate(validBookDetails));
+    }
+
+    @Test
+    @DisplayName("Should validate book sales informations with valid data")
+    void testValidateValidBookSalesInfo() {
+        BookSalesInfo validBookSalesInfo = BookSalesInfo.builder()
+                .price(15)
+                .stock(10)
+                .build();
+
+        assertDoesNotThrow(() -> BookValidator.validate(validBookSalesInfo));
+    }
+
+    @Nested
+    @DisplayName("ISBN validation tests")
+    class ISBNValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when isbn is blank")
+        void testValidateBlankISBN() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithBlankISBN = new BookInfo("", "La vie de Maxime", "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithBlankISBN)
+            );
+
+            assertEquals(BookValidator.ISBN_IS_NOT_VALID, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        @DisplayName("Should throw exception when isbn contains only whitespace")
+        void testValidateWhitespaceISBN(String whitespace) {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithWhitespaceISBN = new BookInfo(whitespace, "La vie de Maxime", "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceISBN)
+            );
+
+            assertEquals(BookValidator.ISBN_IS_NOT_VALID, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"00000", "0000000000", "0000000000000000"})
+        @DisplayName("Should throw exception when isbn contains only thriteen character")
+        void testValidateThirteenCharacterISBN(String number) {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithNotExactCharacterISBN = new BookInfo(number, "La vie de Maxime", "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithNotExactCharacterISBN)
+            );
+
+            assertEquals(BookValidator.ISBN_IS_NOT_VALID, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("Title validation tests")
+    class TitleValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when title is blank")
+        void testValidateBlankTitle() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithBlankTitle = new BookInfo("0000000000000","", "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithBlankTitle)
+            );
+
+            assertEquals(BookValidator.TITLE_CANNOT_BE_BLANK, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        @DisplayName("Should throw exception when title contains only whitespace")
+        void testValidateWhitespaceFirstName(String whitespace) {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithWhitespaceTitle = new BookInfo("0000000000000",whitespace, "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceTitle)
+            );
+
+            assertEquals(BookValidator.TITLE_CANNOT_BE_BLANK, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("author validation tests")
+    class AuthorValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when author is blank")
+        void testValidateBlankAuthor() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithBlankAuthor = new BookInfo("0000000000000","La vie de Maxime", "", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithBlankAuthor)
+            );
+
+            assertEquals(BookValidator.AUTHOR_CANNOT_BE_BLANK, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        @DisplayName("Should throw exception when author contains only whitespace")
+        void testValidateWhitespaceAuthor(String whitespace) {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithWhitespaceAuthor = new BookInfo("0000000000000","La vie de Maxime", whitespace, "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceAuthor)
+            );
+
+            assertEquals(BookValidator.AUTHOR_CANNOT_BE_BLANK, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("editor validation tests")
+    class EditorValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when editor is blank")
+        void testValidateBlankEditor() {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithBlankEditor = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", "", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithBlankEditor)
+            );
+
+            assertEquals(BookValidator.EDITOR_CANNOT_BE_BLANK, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        @DisplayName("Should throw exception when editor contains only whitespace")
+        void testValidateWhitespaceEditor(String whitespace) {
+            LocalDate date = LocalDate.of(2026, 3, 24);
+            BookInfo bookWithWhitespaceEditor = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", whitespace, date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceEditor)
+            );
+
+            assertEquals(BookValidator.EDITOR_CANNOT_BE_BLANK, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("date validation tests")
+    class DateValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when date is after the actual date")
+        void testValidateFuturDate() {
+            LocalDate date = LocalDate.of(2026, 5, 24);
+            BookInfo bookWithFuturDate = new BookInfo("0000000000000","La vie de Maxime", "Marvin Aubert", "Kioon", date);
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithFuturDate)
+            );
+
+            assertEquals(BookValidator.DATE_IS_NOT_VALID, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("price validation tests")
+    class PriceValidationTests {
+
+        @ParameterizedTest
+        @ValueSource(doubles = {-3, -15, 0})
+        @DisplayName("Should throw exception when price is negative or equal to zero")
+        void testValidateNegativePrice(double invalidprice) {
+            BookSalesInfo bookWithNegativePrice = BookSalesInfo.builder()
+                    .price(invalidprice)
+                    .stock(10)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithNegativePrice)
+            );
+
+            assertEquals(BookValidator.PRICE_IS_NOT_VALID, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("stock validation tests")
+    class StockValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when stock is negative")
+        void testValidateNegativeSTock() {
+            BookSalesInfo bookWithNegativeStock = BookSalesInfo.builder()
+                    .price(3)
+                    .stock(-3)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithNegativeStock)
+            );
+
+            assertEquals(BookValidator.STOCK_IS_NOT_VALID, exception.getMessage());
+        }
+    }
+
+    @Nested
+    @DisplayName("categories validation tests")
+    class CategoriesValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when categories is empty")
+        void testValidateBlankCategories() {
+            ArrayList<String> categories = new ArrayList<>();
+            String description = "C'était un brave partit trop tôt";
+            String language = "Français";
+            BookDetails bookWithEmptyCategories = BookDetails.builder()
+                    .categories(categories)
+                    .description(description)
+                    .language(language)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithEmptyCategories)
+            );
+
+            assertEquals(BookValidator.CATEGORIES_IS_NOT_VALID, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @MethodSource("provideLists")
+        @DisplayName("Should throw exception when categories contains an whitespace")
+        void testValidateWhitespaceCategories(ArrayList<String> invalidlist) {
+            String description = "C'était un brave partit trop tôt";
+            String language = "Français";
+            BookDetails bookWithWhitespaceCategories = BookDetails.builder()
+                    .categories(invalidlist)
+                    .description(description)
+                    .language(language)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceCategories)
+            );
+
+            assertEquals(BookValidator.CATEGORIES_IS_NOT_VALID, exception.getMessage());
+        }
+
+        static Stream<ArrayList<String>> provideLists() {
+            return Stream.of(
+                    new ArrayList<String>(java.util.List.of("")),
+                    new ArrayList<String>(java.util.List.of(" ")),
+                    new ArrayList<String>(java.util.List.of("  ")),
+                    new ArrayList<String>(java.util.List.of("\t")),
+                    new ArrayList<String>(java.util.List.of("\n")),
+                    new ArrayList<String>(java.util.List.of("A", "", "C"))
+            );
+        }
+    }
+
+    @Nested
+    @DisplayName("language validation tests")
+    class LanguageValidationTests {
+
+        @Test
+        @DisplayName("Should throw exception when language is blank")
+        void testValidateNegativeLanguage() {
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+            String description = "C'était un brave partit trop tôt";
+            String language = "";
+
+            BookDetails bookWithBlankLanguage = BookDetails.builder()
+                    .categories(categories)
+                    .description(description)
+                    .language(language)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithBlankLanguage)
+            );
+
+            assertEquals(BookValidator.LANGUAGE_CANNOT_BE_BLANK, exception.getMessage());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {" ", "  ", "\t", "\n"})
+        @DisplayName("Should throw exception when language contains only whitespace")
+        void testValidateWhitespaceLanguage(String whitespace) {
+            ArrayList<String> categories = new ArrayList<>();
+            categories.add("Thriller");
+            categories.add("Biographie");
+            String description = "C'était un brave partit trop tôt";
+
+            BookDetails bookWithWhitespaceLanguage = BookDetails.builder()
+                    .categories(categories)
+                    .description(description)
+                    .language(whitespace)
+                    .build();
+
+            NotValidBookException exception = assertThrows(
+                    NotValidBookException.class,
+                    () -> BookValidator.validate(bookWithWhitespaceLanguage)
+            );
+
+            assertEquals(BookValidator.LANGUAGE_CANNOT_BE_BLANK, exception.getMessage());
+        }
+    }
+}