tests pt.1

pom.xml

@@ -29,6 +29,37 @@
             <artifactId>h2</artifactId>
             <scope>runtime</scope>
         </dependency>
+        <!-- JUnit 5 (Jupiter) -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.10.0</version> <!-- Tu peux adapter la version -->
+            <scope>test</scope>
+        </dependency>
+
+        <!-- Mockito pour les mocks -->
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.10.0</version>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- Mockito + JUnit 5 integration -->
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-junit-jupiter</artifactId>
+            <version>5.10.0</version>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- Spring Boot Test (utile pour les tests d'intégration ou avec contexte Spring) -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-hateoas</artifactId>
@@ -78,6 +109,16 @@
                     <useDefaultDelimiters>false</useDefaultDelimiters>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.1.2</version>
+                <configuration>
+                    <includes>
+                        <include>**/*Test.java</include>
+                    </includes>
+                </configuration>
+            </plugin>
             <plugin>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-maven-plugin</artifactId>

src/main/java/com/example/wfwebapi/controller/FavoriteController.java

@@ -4,7 +4,11 @@ import java.util.List;
 import com.example.wfwebapi.exception.ResourceNotFoundException;
 import com.example.wfwebapi.model.Favorite;
 import com.example.wfwebapi.model.FavoriteId;
+import com.example.wfwebapi.model.User;
+import com.example.wfwebapi.model.Quote;
 import com.example.wfwebapi.repository.FavoriteRepository;
+import com.example.wfwebapi.repository.UserRepository;
+import com.example.wfwebapi.repository.QuoteRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
 
@@ -15,6 +19,12 @@ public class FavoriteController {
     @Autowired
     private FavoriteRepository favoriteRepository;
 
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private QuoteRepository quoteRepository;
+
     @GetMapping("/{userId}")
     public List<Favorite> getFavoritesByUser(@PathVariable Long userId) {
         return favoriteRepository.findByUser_Id(userId);
@@ -22,8 +32,15 @@ public class FavoriteController {
 
     @PostMapping
     public Favorite addFavorite(@RequestParam Long user, @RequestParam Long quote) {
+        User u = userRepository.findById(user)
+                .orElseThrow(() -> new ResourceNotFoundException("Utilisateur non trouvé : " + user));
+        Quote q = quoteRepository.findById(quote)
+                .orElseThrow(() -> new ResourceNotFoundException("Citation non trouvée : " + quote));
+
         Favorite favorite = new Favorite();
         favorite.setId(new FavoriteId(user, quote));
+        favorite.setUser(u);
+        favorite.setQuote(q);
         return favoriteRepository.save(favorite);
     }
 

src/main/java/com/example/wfwebapi/controller/QuizController.java

@@ -37,6 +37,7 @@ public class QuizController {
                 .map(q -> {
                     q.setTitle(updatedQuiz.getTitle());
                     q.setImage(updatedQuiz.getImage());
+                    q.setNbQuest(updatedQuiz.getNbQuest()); // ✅ champ maintenant mis à jour
                     return quizRepository.save(q);
                 }).orElseThrow(() -> new ResourceNotFoundException("Quiz non trouvé : " + updatedQuiz.getId()));
     }

src/main/java/com/example/wfwebapi/controller/QuoteController.java

@@ -32,7 +32,8 @@ public class QuoteController {
     @GetMapping("/all")
     public CollectionModel<EntityModel<Quote>> getAllQuotes(@RequestParam int index, @RequestParam int count) {
         List<EntityModel<Quote>> quotes = quoteRepository.findAll(PageRequest.of(index, count))
-                .stream().map(assembler::toModel)
+                .stream()
+                .map(assembler::toModel)
                 .collect(Collectors.toList());
         return CollectionModel.of(quotes);
     }
@@ -40,7 +41,6 @@ public class QuoteController {
     @GetMapping("/dailyquote")
     public EntityModel<Quote> getDailyQuote(@RequestParam int year, @RequestParam int month,
                                             @RequestParam int day, @RequestParam String lang) {
-        // Exemple : renvoi la première citation correspondant à la langue
         Quote quote = quoteRepository.findAll().stream()
                 .filter(q -> q.getLangue().equalsIgnoreCase(lang))
                 .findFirst()
@@ -50,8 +50,8 @@ public class QuoteController {
 
     @PostMapping
     public EntityModel<Quote> createQuote(@RequestBody Quote newQuote) {
-        Quote quote = quoteRepository.save(newQuote);
-        return assembler.toModel(quote);
+        Quote saved = quoteRepository.save(newQuote);
+        return assembler.toModel(saved);
     }
 
     @PutMapping
@@ -67,14 +67,16 @@ public class QuoteController {
                     q.setSource(updatedQuote.getSource());
                     q.setUserVerif(updatedQuote.getUserVerif());
                     return quoteRepository.save(q);
-                }).orElseThrow(() -> new ResourceNotFoundException("Citation non trouvée : " + updatedQuote.getId()));
+                })
+                .orElseThrow(() -> new ResourceNotFoundException("Citation non trouvée : " + updatedQuote.getId()));
         return assembler.toModel(quote);
     }
 
     @DeleteMapping("/delete")
     public void deleteQuote(@RequestParam Long idQuote) {
-        if (!quoteRepository.existsById(idQuote))
+        if (!quoteRepository.existsById(idQuote)) {
             throw new ResourceNotFoundException("Citation non trouvée : " + idQuote);
+        }
         quoteRepository.deleteById(idQuote);
     }
 }

src/test/java/com/example/wfwebapi/assembler/QuoteModelAssemblerTest.java

@@ -0,0 +1,54 @@
+package com.example.wfwebapi.assembler;
+
+import com.example.wfwebapi.controller.QuoteController;
+import com.example.wfwebapi.model.Quote;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.hateoas.EntityModel;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.*;
+
+class QuoteModelAssemblerTest {
+
+    private QuoteModelAssembler assembler;
+    private Quote quote;
+    private EntityModel<Quote> model;
+
+    @BeforeEach
+    void setUp() {
+        assembler = new QuoteModelAssembler();
+        quote = new Quote();
+        quote.setId(1L);
+        model = assembler.toModel(quote);
+    }
+
+    @Test
+    void testModelContent() {
+        assertEquals(quote, model.getContent());
+    }
+
+    @Test
+    void testHasSelfLink() {
+        assertTrue(model.getLinks().hasLink("self"));
+    }
+
+    @Test
+    void testHasQuotesLink() {
+        assertTrue(model.getLinks().hasLink("quotes"));
+    }
+
+    @Test
+    void testSelfLinkHref() {
+        String expectedHref = linkTo(methodOn(QuoteController.class).getQuoteById(1L)).withSelfRel().getHref();
+        String actualHref = model.getRequiredLink("self").getHref();
+        assertEquals(expectedHref, actualHref);
+    }
+
+    @Test
+    void testQuotesLinkHref() {
+        String expectedHref = linkTo(methodOn(QuoteController.class).getAllQuotes(0, 10)).withRel("quotes").getHref();
+        String actualHref = model.getRequiredLink("quotes").getHref();
+        assertEquals(expectedHref, actualHref);
+    }
+}

src/test/java/com/example/wfwebapi/controller/AdminControllerTest.java

@@ -0,0 +1,51 @@
+package com.example.wfwebapi.controller;
+
+import com.example.wfwebapi.exception.ResourceNotFoundException;
+import com.example.wfwebapi.model.Admin;
+import com.example.wfwebapi.repository.AdminRepository;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class AdminControllerTest {
+
+    @LocalServerPort
+    private int port;
+
+    @Autowired
+    private AdminRepository adminRepository;
+
+    private String baseUrl() {
+        return "http://localhost:" + port + "/api/v1/admin/";
+    }
+
+    @Test
+    void testGetAdminFound() {
+        Admin admin = new Admin();
+        admin.setUserId(999L);
+        adminRepository.save(admin);
+
+        RestTemplate restTemplate = new RestTemplate();
+        ResponseEntity<Admin> response = restTemplate.getForEntity(baseUrl() + "999", Admin.class);
+
+        assertEquals(200, response.getStatusCodeValue());
+        assertEquals(999L, response.getBody().getUserId());
+    }
+
+    @Test
+    void testGetAdminNotFound() {
+        RestTemplate restTemplate = new RestTemplate();
+
+        Exception exception = assertThrows(Exception.class, () ->
+                restTemplate.getForEntity(baseUrl() + "123456", Admin.class)
+        );
+
+        assertTrue(exception.getMessage().contains("404"));
+    }
+}

src/test/java/com/example/wfwebapi/controller/AuthControllerTest.java

@@ -0,0 +1,111 @@
+package com.example.wfwebapi.controller;
+
+import com.example.wfwebapi.model.Image;
+import com.example.wfwebapi.model.User;
+import com.example.wfwebapi.repository.ImageRepository;
+import com.example.wfwebapi.repository.UserRepository;
+import com.example.wfwebapi.security.JwtTokenProvider;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class AuthControllerTest {
+
+    @LocalServerPort
+    private int port;
+
+    @Autowired
+    private AuthController authController;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private ImageRepository imageRepository;
+
+    @Autowired
+    private JwtTokenProvider tokenProvider;
+
+    @Autowired
+    private TestRestTemplate restTemplate;
+
+    private String getUrl(String path) {
+        return "http://localhost:" + port + "/api/v1/auth" + path;
+    }
+
+    @BeforeEach
+    void setup() {
+        userRepository.deleteAll();
+        imageRepository.deleteAll();
+
+        Image image = new Image();
+        image.setImgPath("fake/path.png");
+        image = imageRepository.save(image);
+
+        User user = new User();
+        user.setUsername("john");
+        user.setPassword("password123");
+        user.setEmail("john@example.com");
+        user.setCreation(java.time.LocalDate.now());
+        user.setImage(image);
+
+        userRepository.save(user);
+    }
+
+    @Test
+    void contextLoads() {
+        assertNotNull(authController);
+        assertNotNull(userRepository);
+        assertNotNull(tokenProvider);
+    }
+
+    @Test
+    void testLoginSuccess() {
+        AuthController.AuthRequest request = new AuthController.AuthRequest();
+        request.setUsername("john");
+        request.setPassword("password123");
+
+        ResponseEntity<AuthController.AuthResponse> response = restTemplate.postForEntity(
+                getUrl("/login"), request, AuthController.AuthResponse.class
+        );
+
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertNotNull(response.getBody());
+        assertNotNull(response.getBody().getToken());
+    }
+
+    @Test
+    void testLoginInvalidPassword() {
+        AuthController.AuthRequest request = new AuthController.AuthRequest();
+        request.setUsername("john");
+        request.setPassword("wrongpass");
+
+        ResponseEntity<String> response = restTemplate.postForEntity(
+                getUrl("/login"), request, String.class
+        );
+
+        assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
+        assertEquals("Mot de passe invalide", response.getBody());
+    }
+
+    @Test
+    void testLoginUserNotFound() {
+        AuthController.AuthRequest request = new AuthController.AuthRequest();
+        request.setUsername("unknown");
+        request.setPassword("any");
+
+        ResponseEntity<String> response = restTemplate.postForEntity(
+                getUrl("/login"), request, String.class
+        );
+
+        assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
+        assertTrue(response.getBody().contains("Utilisateur non trouvé"));
+    }
+}

src/test/java/com/example/wfwebapi/controller/CaracterControllerTest.java

@@ -0,0 +1,118 @@
+package com.example.wfwebapi.controller;
+
+import com.example.wfwebapi.model.Caracter;
+import com.example.wfwebapi.model.Image;
+import com.example.wfwebapi.repository.CaracterRepository;
+import com.example.wfwebapi.repository.ImageRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.*;
+
+import java.util.Objects;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class CaracterControllerTest {
+
+    @LocalServerPort
+    private int port;
+
+    @Autowired
+    private TestRestTemplate restTemplate;
+
+    @Autowired
+    private CaracterRepository caracterRepository;
+
+    @Autowired
+    private ImageRepository imageRepository;
+
+    private Image image;
+
+    private String getUrl(String path) {
+        return "http://localhost:" + port + "/api/v1/caracter" + path;
+    }
+
+    @BeforeEach
+    void setup() {
+        caracterRepository.deleteAll();
+        imageRepository.deleteAll();
+
+        image = new Image();
+        image.setImgPath("path/to/image.png");
+        imageRepository.save(image);
+    }
+
+    @Test
+    void testCreateAndGetCaracterById() {
+        Caracter caracter = new Caracter();
+        caracter.setCaracter("Déterminé");
+        caracter.setImage(image);
+
+        ResponseEntity<Caracter> postResponse = restTemplate.postForEntity(getUrl(""), caracter, Caracter.class);
+        assertEquals(HttpStatus.OK, postResponse.getStatusCode());
+        Long id = Objects.requireNonNull(postResponse.getBody()).getId();
+
+        ResponseEntity<Caracter> getResponse = restTemplate.getForEntity(getUrl("/" + id), Caracter.class);
+        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
+        assertEquals("Déterminé", getResponse.getBody().getCaracter());
+    }
+
+    @Test
+    void testGetAllCaracters() {
+        Caracter c = new Caracter();
+        c.setCaracter("Créatif");
+        c.setImage(image);
+        caracterRepository.save(c);
+
+        ResponseEntity<Caracter[]> response = restTemplate.getForEntity(getUrl("/"), Caracter[].class);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertTrue(response.getBody().length >= 1);
+    }
+
+    @Test
+    void testUpdateCaracter() {
+        Caracter c = new Caracter();
+        c.setCaracter("Patient");
+        c.setImage(image);
+        c = caracterRepository.save(c);
+
+        c.setCaracter("Impulsif");
+
+        HttpEntity<Caracter> request = new HttpEntity<>(c);
+        ResponseEntity<Caracter> response = restTemplate.exchange(getUrl(""), HttpMethod.PUT, request, Caracter.class);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals("Impulsif", response.getBody().getCaracter());
+    }
+
+    @Test
+    void testDeleteCaracter() {
+        Caracter c = new Caracter();
+        c.setCaracter("Sérieux");
+        c.setImage(image);
+        c = caracterRepository.save(c);
+
+        ResponseEntity<Void> response = restTemplate.exchange(getUrl("?id=" + c.getId()), HttpMethod.DELETE, null, Void.class);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertFalse(caracterRepository.existsById(c.getId()));
+    }
+
+    @Test
+    void testGetCaracterNotFound() {
+        ResponseEntity<String> response = restTemplate.getForEntity(getUrl("/999999"), String.class);
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Caracter non trouvé"));
+    }
+
+    @Test
+    void testDeleteCaracterNotFound() {
+        ResponseEntity<String> response = restTemplate.exchange(getUrl("?id=999999"), HttpMethod.DELETE, null, String.class);
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Caracter non trouvé"));
+    }
+}

src/test/java/com/example/wfwebapi/controller/CommentaryControllerTest.java

@@ -0,0 +1,138 @@
+package com.example.wfwebapi.controller;
+
+import com.example.wfwebapi.model.*;
+import com.example.wfwebapi.repository.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.*;
+
+import java.time.LocalDate;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class CommentaryControllerTest {
+
+    @LocalServerPort
+    private int port;
+
+    @Autowired private TestRestTemplate restTemplate;
+
+    @Autowired private CommentaryRepository commentaryRepository;
+    @Autowired private QuoteRepository quoteRepository;
+    @Autowired private UserRepository userRepository;
+    @Autowired private ImageRepository imageRepository;
+    @Autowired private CaracterRepository caracterRepository;
+    @Autowired private SourceRepository sourceRepository;
+
+    private Quote quote;
+    private User user;
+
+    private String getUrl(String path) {
+        return "http://localhost:" + port + "/api/v1/commentary" + path;
+    }
+
+    @BeforeEach
+    void setup() {
+        clearDatabase();
+
+        Image image = new Image();
+        image.setImgPath("test.png");
+        imageRepository.save(image);
+
+        user = new User();
+        user.setUsername("user");
+        user.setEmail("user@mail.com");
+        user.setPassword("pass");
+        user.setCreation(LocalDate.now());
+        user.setImage(image);
+        userRepository.save(user);
+
+        Caracter caracter = new Caracter();
+        caracter.setCaracter("Fort");
+        caracter.setImage(image);
+        caracterRepository.save(caracter);
+
+        Source source = new Source();
+        source.setTitle("source");
+        source.setDateS(2000);
+        sourceRepository.save(source);
+
+        quote = new Quote();
+        quote.setContent("Ceci est une citation.");
+        quote.setLangue("fr");
+        quote.setIsValide(true);
+        quote.setLikes(0);
+        quote.setReason("valid");
+        quote.setCaracter(caracter);
+        quote.setSource(source);
+        quote.setUserVerif(user);
+        quoteRepository.save(quote);
+    }
+
+    void clearDatabase() {
+        commentaryRepository.deleteAll();
+        quoteRepository.deleteAll();
+        caracterRepository.deleteAll();
+        sourceRepository.deleteAll();
+        userRepository.deleteAll();
+        imageRepository.deleteAll();
+    }
+
+    @Test
+    void testAddAndGetCommentary() {
+        Commentary commentary = new Commentary();
+        commentary.setUser(user);
+        commentary.setComment("Super citation !");
+        commentary.setDateC(LocalDate.now());
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+
+        HttpEntity<Commentary> request = new HttpEntity<>(commentary, headers);
+
+        ResponseEntity<Commentary> postResponse = restTemplate.postForEntity(
+                getUrl("?quote=" + quote.getId()), request, Commentary.class);
+
+        assertEquals(HttpStatus.OK, postResponse.getStatusCode());
+        assertNotNull(postResponse.getBody().getId());
+
+        ResponseEntity<Commentary[]> getResponse = restTemplate.getForEntity(
+                getUrl("/" + quote.getId()), Commentary[].class);
+
+        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
+        assertEquals(1, getResponse.getBody().length);
+    }
+
+    @Test
+    void testDeleteCommentary() {
+        Commentary commentary = new Commentary();
+        commentary.setUser(user);
+        commentary.setQuote(quote);
+        commentary.setComment("À supprimer");
+        commentary.setDateC(LocalDate.now());
+        commentaryRepository.save(commentary);
+
+        ResponseEntity<Void> deleteResponse = restTemplate.exchange(
+                getUrl("?id=" + quote.getId()), HttpMethod.DELETE, null, Void.class);
+
+        assertEquals(HttpStatus.OK, deleteResponse.getStatusCode());
+
+        List<Commentary> remaining = commentaryRepository.findByQuote_Id(quote.getId());
+        assertTrue(remaining.isEmpty());
+    }
+
+    @Test
+    void testDeleteCommentaryNotFound() {
+        ResponseEntity<String> response = restTemplate.exchange(
+                getUrl("?id=99999"), HttpMethod.DELETE, null, String.class);
+
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Aucun commentaire trouvé"));
+    }
+}

src/test/java/com/example/wfwebapi/controller/DailyQuoteControllerTest.java

@@ -0,0 +1,103 @@
+package com.example.wfwebapi.controller;
+
+import com.example.wfwebapi.model.*;
+import com.example.wfwebapi.repository.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.*;
+
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class DailyQuoteControllerTest {
+
+    @LocalServerPort
+    private int port;
+
+    @Autowired private TestRestTemplate restTemplate;
+
+    @Autowired private DailyQuoteRepository dailyQuoteRepository;
+    @Autowired private QuoteRepository quoteRepository;
+    @Autowired private UserRepository userRepository;
+    @Autowired private ImageRepository imageRepository;
+    @Autowired private CaracterRepository caracterRepository;
+    @Autowired private SourceRepository sourceRepository;
+
+    private Quote quote;
+
+    private String getUrl() {
+        return "http://localhost:" + port + "/api/v1/dailyquote";
+    }
+
+    @BeforeEach
+    void setup() {
+        dailyQuoteRepository.deleteAll();
+        quoteRepository.deleteAll();
+        caracterRepository.deleteAll();
+        sourceRepository.deleteAll();
+        userRepository.deleteAll();
+        imageRepository.deleteAll();
+
+        Image image = new Image();
+        image.setImgPath("daily.png");
+        imageRepository.save(image);
+
+        User user = new User();
+        user.setUsername("dailyUser");
+        user.setPassword("pwd");
+        user.setEmail("daily@mail.com");
+        user.setCreation(LocalDate.now());
+        user.setImage(image);
+        userRepository.save(user);
+
+        Caracter caracter = new Caracter();
+        caracter.setCaracter("Calme");
+        caracter.setImage(image);
+        caracterRepository.save(caracter);
+
+        Source source = new Source();
+        source.setTitle("Livre A");
+        source.setDateS(2001);
+        sourceRepository.save(source);
+
+        quote = new Quote();
+        quote.setContent("Chaque jour est un cadeau.");
+        quote.setLangue("fr");
+        quote.setIsValide(true);
+        quote.setLikes(10);
+        quote.setReason("approuvée");
+        quote.setUserVerif(user);
+        quote.setCaracter(caracter);
+        quote.setSource(source);
+        quoteRepository.save(quote);
+
+        DailyQuote dailyQuote = new DailyQuote();
+        dailyQuote.setCitationId(quote.getId()); // CORRECT : ne pas faire setQuote()
+        dailyQuoteRepository.save(dailyQuote);
+    }
+
+    @Test
+    void testGetDailyQuote() {
+        ResponseEntity<DailyQuote> response = restTemplate.getForEntity(getUrl(), DailyQuote.class);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertNotNull(response.getBody());
+        assertEquals(quote.getId(), response.getBody().getCitationId());
+    }
+
+    @Test
+    void testGetDailyQuoteNotFound() {
+        dailyQuoteRepository.deleteAll();
+
+        ResponseEntity<String> response = restTemplate.getForEntity(getUrl(), String.class);
+
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Aucune DailyQuote définie"));
+    }
+}

src/test/java/com/example/wfwebapi/controller/FavoriteControllerTest.java

@@ -0,0 +1,133 @@
+package com.example.wfwebapi.controller;
+
+import com.example.wfwebapi.model.*;
+import com.example.wfwebapi.repository.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.*;
+
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class FavoriteControllerTest {
+
+    @LocalServerPort
+    private int port;
+
+    @Autowired private TestRestTemplate restTemplate;
+
+    @Autowired private FavoriteRepository favoriteRepository;
+    @Autowired private QuoteRepository quoteRepository;
+    @Autowired private UserRepository userRepository;
+    @Autowired private ImageRepository imageRepository;
+    @Autowired private CaracterRepository caracterRepository;
+    @Autowired private SourceRepository sourceRepository;
+
+    private User user;
+    private Quote quote;
+
+    private String getUrl(String path) {
+        return "http://localhost:" + port + "/api/v1/favorite" + path;
+    }
+
+    @BeforeEach
+    void setup() {
+        favoriteRepository.deleteAll();
+        quoteRepository.deleteAll();
+        caracterRepository.deleteAll();
+        sourceRepository.deleteAll();
+        userRepository.deleteAll();
+        imageRepository.deleteAll();
+
+        Image image = new Image();
+        image.setImgPath("fav.png");
+        imageRepository.save(image);
+
+        user = new User();
+        user.setUsername("testuser");
+        user.setPassword("secret");
+        user.setEmail("test@ex.com");
+        user.setCreation(LocalDate.now());
+        user.setImage(image);
+        userRepository.save(user);
+
+        Caracter caracter = new Caracter();
+        caracter.setCaracter("Sérieux");
+        caracter.setImage(image);
+        caracterRepository.save(caracter);
+
+        Source source = new Source();
+        source.setTitle("Source X");
+        source.setDateS(1999);
+        sourceRepository.save(source);
+
+        quote = new Quote();
+        quote.setContent("La connaissance est le pouvoir.");
+        quote.setLangue("fr");
+        quote.setIsValide(true);
+        quote.setLikes(100);
+        quote.setReason("Validée");
+        quote.setCaracter(caracter);
+        quote.setSource(source);
+        quote.setUserVerif(user);
+        quoteRepository.save(quote);
+    }
+
+    @Test
+    void testAddAndGetFavorite() {
+        ResponseEntity<Void> postResponse = restTemplate.postForEntity(
+                getUrl("?user=" + user.getId() + "&quote=" + quote.getId()),
+                null,
+                Void.class
+        );
+
+        assertEquals(HttpStatus.OK, postResponse.getStatusCode());
+
+        ResponseEntity<Favorite[]> getResponse = restTemplate.getForEntity(
+                getUrl("/" + user.getId()),
+                Favorite[].class
+        );
+
+        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
+        assertEquals(1, getResponse.getBody().length);
+        assertEquals(quote.getId(), getResponse.getBody()[0].getQuote().getId());
+    }
+
+    @Test
+    void testDeleteFavorite() {
+        Favorite favorite = new Favorite();
+        favorite.setId(new FavoriteId(user.getId(), quote.getId()));
+        favorite.setUser(user);
+        favorite.setQuote(quote);
+        favoriteRepository.save(favorite);
+
+        ResponseEntity<Void> response = restTemplate.exchange(
+                getUrl("?user=" + user.getId() + "&quote=" + quote.getId()),
+                HttpMethod.DELETE,
+                null,
+                Void.class
+        );
+
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertFalse(favoriteRepository.existsById(new FavoriteId(user.getId(), quote.getId())));
+    }
+
+    @Test
+    void testDeleteFavoriteNotFound() {
+        ResponseEntity<String> response = restTemplate.exchange(
+                getUrl("?user=9999&quote=9999"),
+                HttpMethod.DELETE,
+                null,
+                String.class
+        );
+
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Favorite non trouvée"));
+    }
+}

src/test/java/com/example/wfwebapi/controller/ImageControllerTest.java

@@ -0,0 +1,102 @@
+package com.example.wfwebapi.controller;
+
+import com.example.wfwebapi.model.Image;
+import com.example.wfwebapi.repository.ImageRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class ImageControllerTest {
+
+    @LocalServerPort
+    private int port;
+
+    @Autowired private TestRestTemplate restTemplate;
+    @Autowired private ImageRepository imageRepository;
+
+    private String getUrl(String path) {
+        return "http://localhost:" + port + "/api/v1/image" + path;
+    }
+
+    @BeforeEach
+    void setup() {
+        imageRepository.deleteAll();
+    }
+
+    @Test
+    void testCreateAndGetImage() {
+        Image image = new Image();
+        image.setImgPath("assets/img/test.png");
+
+        ResponseEntity<Image> postResponse = restTemplate.postForEntity(
+                getUrl(""), image, Image.class);
+
+        assertEquals(HttpStatus.OK, postResponse.getStatusCode());
+        Image created = postResponse.getBody();
+        assertNotNull(created);
+        assertNotNull(created.getId());
+
+        ResponseEntity<Image> getResponse = restTemplate.getForEntity(
+                getUrl("/" + created.getId()), Image.class);
+
+        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
+        assertEquals("assets/img/test.png", getResponse.getBody().getImgPath());
+    }
+
+    @Test
+    void testUpdateImage() {
+        Image image = new Image();
+        image.setImgPath("original.png");
+        image = imageRepository.save(image);
+
+        image.setImgPath("updated.png");
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        HttpEntity<Image> entity = new HttpEntity<>(image, headers);
+
+        ResponseEntity<Image> putResponse = restTemplate.exchange(
+                getUrl(""), HttpMethod.PUT, entity, Image.class);
+
+        assertEquals(HttpStatus.OK, putResponse.getStatusCode());
+        assertEquals("updated.png", putResponse.getBody().getImgPath());
+    }
+
+    @Test
+    void testDeleteImage() {
+        Image image = new Image();
+        image.setImgPath("todelete.png");
+        image = imageRepository.save(image);
+
+        ResponseEntity<Void> deleteResponse = restTemplate.exchange(
+                getUrl("?id=" + image.getId()), HttpMethod.DELETE, null, Void.class);
+
+        assertEquals(HttpStatus.OK, deleteResponse.getStatusCode());
+        assertFalse(imageRepository.existsById(image.getId()));
+    }
+
+    @Test
+    void testGetImageNotFound() {
+        ResponseEntity<String> response = restTemplate.getForEntity(
+                getUrl("/9999"), String.class);
+
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Image non trouvée"));
+    }
+
+    @Test
+    void testDeleteImageNotFound() {
+        ResponseEntity<String> response = restTemplate.exchange(
+                getUrl("?id=9999"), HttpMethod.DELETE, null, String.class);
+
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Image non trouvée"));
+    }
+}

src/test/java/com/example/wfwebapi/controller/QuestionControllerTest.java

@@ -0,0 +1,112 @@
+package com.example.wfwebapi.controller;
+
+import com.example.wfwebapi.model.Question;
+import com.example.wfwebapi.repository.QuestionRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class QuestionControllerTest {
+
+    @LocalServerPort
+    private int port;
+
+    @Autowired private TestRestTemplate restTemplate;
+    @Autowired private QuestionRepository questionRepository;
+
+    private String getUrl(String path) {
+        return "http://localhost:" + port + "/api/v1/question" + path;
+    }
+
+    @BeforeEach
+    void setup() {
+        questionRepository.deleteAll();
+    }
+
+    @Test
+    void testCreateAndGetQuestion() {
+        Question question = new Question();
+        question.setTexte("Quel est le langage de ce test ?");
+        question.setAnswerA("Python");
+        question.setAnswerB("Java");
+        question.setAnswerC("C++");
+        question.setAnswerD("JavaScript");
+        question.setCAnswer("Java");
+
+        ResponseEntity<Question> postResponse = restTemplate.postForEntity(getUrl(""), question, Question.class);
+        assertEquals(HttpStatus.OK, postResponse.getStatusCode());
+        assertNotNull(postResponse.getBody());
+        Long id = postResponse.getBody().getId();
+        assertNotNull(id);
+
+        ResponseEntity<Question> getResponse = restTemplate.getForEntity(getUrl("/" + id), Question.class);
+        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
+        assertEquals("Java", getResponse.getBody().getCAnswer());
+    }
+
+    @Test
+    void testUpdateQuestion() {
+        Question q = new Question();
+        q.setTexte("Old Q");
+        q.setAnswerA("A");
+        q.setAnswerB("B");
+        q.setAnswerC("C");
+        q.setAnswerD("D");
+        q.setCAnswer("B");
+        q = questionRepository.save(q);
+
+        q.setTexte("Updated Q");
+        q.setCAnswer("A");
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        HttpEntity<Question> entity = new HttpEntity<>(q, headers);
+
+        ResponseEntity<Question> response = restTemplate.exchange(
+                getUrl(""), HttpMethod.PUT, entity, Question.class);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals("Updated Q", response.getBody().getTexte());
+        assertEquals("A", response.getBody().getCAnswer());
+    }
+
+    @Test
+    void testDeleteQuestion() {
+        Question q = new Question();
+        q.setTexte("À supprimer");
+        q.setAnswerA("1");
+        q.setAnswerB("2");
+        q.setAnswerC("3");
+        q.setAnswerD("4");
+        q.setCAnswer("2");
+        q = questionRepository.save(q);
+
+        ResponseEntity<Void> delete = restTemplate.exchange(
+                getUrl("?id=" + q.getId()), HttpMethod.DELETE, null, Void.class);
+
+        assertEquals(HttpStatus.OK, delete.getStatusCode());
+        assertFalse(questionRepository.existsById(q.getId()));
+    }
+
+    @Test
+    void testGetQuestionNotFound() {
+        ResponseEntity<String> response = restTemplate.getForEntity(getUrl("/9999"), String.class);
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Question non trouvée"));
+    }
+
+    @Test
+    void testDeleteQuestionNotFound() {
+        ResponseEntity<String> response = restTemplate.exchange(
+                getUrl("?id=9999"), HttpMethod.DELETE, null, String.class);
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Question non trouvée"));
+    }
+}

src/test/java/com/example/wfwebapi/controller/QuizControllerTest.java

@@ -0,0 +1,130 @@
+package com.example.wfwebapi.controller;
+
+import com.example.wfwebapi.model.Image;
+import com.example.wfwebapi.model.Quiz;
+import com.example.wfwebapi.repository.ImageRepository;
+import com.example.wfwebapi.repository.QuizRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class QuizControllerTest {
+
+    @LocalServerPort
+    private int port;
+
+    @Autowired private TestRestTemplate restTemplate;
+    @Autowired private QuizRepository quizRepository;
+    @Autowired private ImageRepository imageRepository;
+
+    private String getUrl(String path) {
+        return "http://localhost:" + port + "/api/v1/quiz" + path;
+    }
+
+    private Image image;
+
+    @BeforeEach
+    void setup() {
+        quizRepository.deleteAll();
+        imageRepository.deleteAll();
+
+        image = new Image();
+        image.setImgPath("quiz/image.png");
+        imageRepository.save(image);
+    }
+
+    @Test
+    void testCreateAndGetQuiz() {
+        Quiz quiz = new Quiz();
+        quiz.setTitle("Histoire");
+        quiz.setImage(image);
+        quiz.setNbQuest(5);
+
+        ResponseEntity<Quiz> postResponse = restTemplate.postForEntity(getUrl(""), quiz, Quiz.class);
+        assertEquals(HttpStatus.OK, postResponse.getStatusCode());
+        Quiz created = postResponse.getBody();
+        assertNotNull(created);
+        assertNotNull(created.getId());
+
+        ResponseEntity<Quiz> getResponse = restTemplate.getForEntity(getUrl("/" + created.getId()), Quiz.class);
+        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
+        assertEquals("Histoire", getResponse.getBody().getTitle());
+    }
+
+    @Test
+    void testUpdateQuiz() {
+        Quiz quiz = new Quiz();
+        quiz.setTitle("Sciences");
+        quiz.setImage(image);
+        quiz.setNbQuest(10);
+        quiz = quizRepository.save(quiz);
+
+        quiz.setTitle("Sciences - Maj");
+        quiz.setNbQuest(12);
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        HttpEntity<Quiz> entity = new HttpEntity<>(quiz, headers);
+
+        ResponseEntity<Quiz> putResponse = restTemplate.exchange(getUrl(""), HttpMethod.PUT, entity, Quiz.class);
+        assertEquals(HttpStatus.OK, putResponse.getStatusCode());
+        assertEquals("Sciences - Maj", putResponse.getBody().getTitle());
+        assertEquals(12, putResponse.getBody().getNbQuest());
+    }
+
+    @Test
+    void testDeleteQuiz() {
+        Quiz quiz = new Quiz();
+        quiz.setTitle("À supprimer");
+        quiz.setImage(image);
+        quiz.setNbQuest(3);
+        quiz = quizRepository.save(quiz);
+
+        ResponseEntity<Void> deleteResponse = restTemplate.exchange(
+                getUrl("?id=" + quiz.getId()), HttpMethod.DELETE, null, Void.class);
+        assertEquals(HttpStatus.OK, deleteResponse.getStatusCode());
+        assertFalse(quizRepository.existsById(quiz.getId()));
+    }
+
+    @Test
+    void testGetQuizNotFound() {
+        ResponseEntity<String> response = restTemplate.getForEntity(getUrl("/9999"), String.class);
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Quiz non trouvé"));
+    }
+
+    @Test
+    void testDeleteQuizNotFound() {
+        ResponseEntity<String> response = restTemplate.exchange(
+                getUrl("?id=9999"), HttpMethod.DELETE, null, String.class);
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Quiz non trouvé"));
+    }
+
+    @Test
+    void testGetAllQuizzes() {
+        Quiz q1 = new Quiz();
+        q1.setTitle("Test 1");
+        q1.setImage(image);
+        q1.setNbQuest(5);
+
+        Quiz q2 = new Quiz();
+        q2.setTitle("Test 2");
+        q2.setImage(image);
+        q2.setNbQuest(10);
+
+        quizRepository.save(q1);
+        quizRepository.save(q2);
+
+        ResponseEntity<Quiz[]> response = restTemplate.getForEntity(getUrl(""), Quiz[].class);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(2, response.getBody().length);
+    }
+}

src/test/java/com/example/wfwebapi/controller/QuoteControllerTest.java

@@ -0,0 +1,201 @@
+package com.example.wfwebapi.controller;
+
+import com.example.wfwebapi.model.*;
+import com.example.wfwebapi.repository.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.hateoas.EntityModel;
+import org.springframework.http.*;
+
+import java.util.LinkedHashMap;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class QuoteControllerTest {
+
+    @LocalServerPort
+    private int port;
+
+    @Autowired private TestRestTemplate restTemplate;
+    @Autowired private QuoteRepository quoteRepository;
+    @Autowired private UserRepository userRepository;
+    @Autowired private SourceRepository sourceRepository;
+    @Autowired private CaracterRepository caracterRepository;
+
+    private User user;
+    private Source source;
+    private Caracter caracter;
+
+    private String getUrl(String path) {
+        return "http://localhost:" + port + "/api/v1/quote" + path;
+    }
+
+    @BeforeEach
+    void setup() {
+        quoteRepository.deleteAll();
+        userRepository.deleteAll();
+        sourceRepository.deleteAll();
+        caracterRepository.deleteAll();
+
+        Image img = new Image();
+        img.setImgPath("img.png");
+
+        caracter = new Caracter();
+        caracter.setCaracter("Test Character");
+        caracter.setImage(img);
+        caracter = caracterRepository.save(caracter);
+
+        source = new Source();
+        source.setTitle("Test Source");
+        source.setDateS(2020);
+        source = sourceRepository.save(source);
+
+        user = new User();
+        user.setUsername("verif");
+        user.setEmail("v@v.fr");
+        user.setPassword("pass");
+        user.setImage(img);
+        user.setCreation(java.time.LocalDate.now());
+        user = userRepository.save(user);
+    }
+
+    @Test
+    void testCreateAndGetQuote() {
+        Quote quote = new Quote();
+        quote.setContent("Ceci est une citation.");
+        quote.setLangue("fr");
+        quote.setLikes(15);
+        quote.setIsValide(true);
+        quote.setReason("valide");
+        quote.setCaracter(caracter);
+        quote.setSource(source);
+        quote.setUserVerif(user);
+
+        ResponseEntity<EntityModel> postResponse = restTemplate.postForEntity(
+                getUrl(""), quote, EntityModel.class);
+        assertEquals(HttpStatus.OK, postResponse.getStatusCode());
+        assertNotNull(postResponse.getBody());
+
+        Long id = ((Number)((LinkedHashMap)postResponse.getBody().getContent()).get("id")).longValue();
+        ResponseEntity<EntityModel> getResponse = restTemplate.getForEntity(
+                getUrl("/" + id), EntityModel.class);
+        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
+    }
+
+    @Test
+    void testUpdateQuote() {
+        Quote quote = new Quote();
+        quote.setContent("Ancienne");
+        quote.setLangue("fr");
+        quote.setLikes(1);
+        quote.setIsValide(false);
+        quote.setReason("...");
+        quote.setCaracter(caracter);
+        quote.setSource(source);
+        quote.setUserVerif(user);
+        quote = quoteRepository.save(quote);
+
+        quote.setContent("Nouvelle version");
+        quote.setLangue("en");
+        quote.setLikes(100);
+        quote.setIsValide(true);
+        quote.setReason("modifiée");
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        HttpEntity<Quote> request = new HttpEntity<>(quote, headers);
+
+        ResponseEntity<EntityModel> response = restTemplate.exchange(
+                getUrl(""), HttpMethod.PUT, request, EntityModel.class);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+    }
+
+    @Test
+    void testDeleteQuote() {
+        Quote quote = new Quote();
+        quote.setContent("À supprimer");
+        quote.setLangue("fr");
+        quote.setLikes(0);
+        quote.setIsValide(false);
+        quote.setReason("test");
+        quote.setCaracter(caracter);
+        quote.setSource(source);
+        quote.setUserVerif(user);
+        quote = quoteRepository.save(quote);
+
+        ResponseEntity<Void> response = restTemplate.exchange(
+                getUrl("/delete?idQuote=" + quote.getId()), HttpMethod.DELETE, null, Void.class);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertFalse(quoteRepository.existsById(quote.getId()));
+    }
+
+    @Test
+    void testGetQuoteNotFound() {
+        ResponseEntity<String> response = restTemplate.getForEntity(
+                getUrl("/9999"), String.class);
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Citation non trouvée"));
+    }
+
+    @Test
+    void testGetAllQuotes() {
+        Quote quote1 = new Quote();
+        quote1.setContent("Q1");
+        quote1.setLangue("fr");
+        quote1.setLikes(5);
+        quote1.setIsValide(true);
+        quote1.setReason("ok");
+        quote1.setCaracter(caracter);
+        quote1.setSource(source);
+        quote1.setUserVerif(user);
+
+        Quote quote2 = new Quote();
+        quote2.setContent("Q2");
+        quote2.setLangue("en");
+        quote2.setLikes(10);
+        quote2.setIsValide(true);
+        quote2.setReason("ok");
+        quote2.setCaracter(caracter);
+        quote2.setSource(source);
+        quote2.setUserVerif(user);
+
+        quoteRepository.save(quote1);
+        quoteRepository.save(quote2);
+
+        ResponseEntity<String> response = restTemplate.getForEntity(
+                getUrl("/all?index=0&count=10"), String.class);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+    }
+
+    @Test
+    void testGetDailyQuote() {
+        Quote quote = new Quote();
+        quote.setContent("Jour");
+        quote.setLangue("fr");
+        quote.setLikes(3);
+        quote.setIsValide(true);
+        quote.setReason("OK");
+        quote.setCaracter(caracter);
+        quote.setSource(source);
+        quote.setUserVerif(user);
+        quoteRepository.save(quote);
+
+        ResponseEntity<EntityModel> response = restTemplate.getForEntity(
+                getUrl("/dailyquote?year=2023&month=12&day=1&lang=fr"), EntityModel.class);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+    }
+
+    @Test
+    void testGetDailyQuoteNotFound() {
+        ResponseEntity<String> response = restTemplate.getForEntity(
+                getUrl("/dailyquote?year=2023&month=12&day=1&lang=zz"), String.class);
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+        assertTrue(response.getBody().contains("Aucune citation trouvée"));
+    }
+}

src/test/java/com/example/wfwebapi/model/AdminTest.java

@@ -0,0 +1,20 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class AdminTest {
+
+    @Test
+    void testGettersAndSetters() {
+        Admin admin = new Admin();
+        User user = new User();
+
+        admin.setUserId(123L);
+        admin.setUser(user);
+
+        assertEquals(123L, admin.getUserId());
+        assertEquals(user, admin.getUser());
+    }
+}

src/test/java/com/example/wfwebapi/model/CaracterTest.java

@@ -0,0 +1,22 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CaracterTest {
+
+    @Test
+    void testGettersAndSetters() {
+        Caracter caracter = new Caracter();
+        Image image = new Image();
+
+        caracter.setId(1L);
+        caracter.setCaracter("Guerrier");
+        caracter.setImage(image);
+
+        assertEquals(1L, caracter.getId());
+        assertEquals("Guerrier", caracter.getCaracter());
+        assertEquals(image, caracter.getImage());
+    }
+}

src/test/java/com/example/wfwebapi/model/CommentaryTest.java

@@ -0,0 +1,31 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CommentaryTest {
+
+    @Test
+    void testGettersAndSetters() {
+        Commentary commentary = new Commentary();
+        Quote quote = new Quote();
+        User user = new User();
+        LocalDate date = LocalDate.of(2024, 4, 5);
+        String text = "Ceci est un commentaire";
+
+        commentary.setId(1L);
+        commentary.setQuote(quote);
+        commentary.setUser(user);
+        commentary.setDateC(date);
+        commentary.setComment(text);
+
+        assertEquals(1L, commentary.getId());
+        assertEquals(quote, commentary.getQuote());
+        assertEquals(user, commentary.getUser());
+        assertEquals(date, commentary.getDateC());
+        assertEquals(text, commentary.getComment());
+    }
+}

src/test/java/com/example/wfwebapi/model/DailyQuoteTest.java

@@ -0,0 +1,20 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DailyQuoteTest {
+
+    @Test
+    void testGettersAndSetters() {
+        DailyQuote dailyQuote = new DailyQuote();
+        Quote quote = new Quote();
+
+        dailyQuote.setCitationId(1L);
+        dailyQuote.setQuote(quote);
+
+        assertEquals(1L, dailyQuote.getCitationId());
+        assertEquals(quote, dailyQuote.getQuote());
+    }
+}

src/test/java/com/example/wfwebapi/model/FavoriteIdTest.java

@@ -0,0 +1,37 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class FavoriteIdTest {
+
+    @Test
+    void testGettersAndSetters() {
+        FavoriteId id = new FavoriteId();
+        id.setUser(1L);
+        id.setQuote(2L);
+
+        assertEquals(1L, id.getUser());
+        assertEquals(2L, id.getQuote());
+    }
+
+    @Test
+    void testConstructor() {
+        FavoriteId id = new FavoriteId(3L, 4L);
+
+        assertEquals(3L, id.getUser());
+        assertEquals(4L, id.getQuote());
+    }
+
+    @Test
+    void testEqualsAndHashCode() {
+        FavoriteId id1 = new FavoriteId(1L, 2L);
+        FavoriteId id2 = new FavoriteId(1L, 2L);
+        FavoriteId id3 = new FavoriteId(2L, 1L);
+
+        assertEquals(id1, id2);
+        assertEquals(id1.hashCode(), id2.hashCode());
+        assertNotEquals(id1, id3);
+    }
+}

src/test/java/com/example/wfwebapi/model/FavoriteTest.java

@@ -0,0 +1,24 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class FavoriteTest {
+
+    @Test
+    void testGettersAndSetters() {
+        Favorite favorite = new Favorite();
+        FavoriteId favoriteId = new FavoriteId();
+        User user = new User();
+        Quote quote = new Quote();
+
+        favorite.setId(favoriteId);
+        favorite.setUser(user);
+        favorite.setQuote(quote);
+
+        assertEquals(favoriteId, favorite.getId());
+        assertEquals(user, favorite.getUser());
+        assertEquals(quote, favorite.getQuote());
+    }
+}

src/test/java/com/example/wfwebapi/model/ImageTest.java

@@ -0,0 +1,18 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ImageTest {
+
+    @Test
+    void testGettersAndSetters() {
+        Image image = new Image();
+        image.setId(1L);
+        image.setImgPath("/images/avatar.png");
+
+        assertEquals(1L, image.getId());
+        assertEquals("/images/avatar.png", image.getImgPath());
+    }
+}

src/test/java/com/example/wfwebapi/model/QuestionTest.java

@@ -0,0 +1,29 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class QuestionTest {
+
+    @Test
+    void testGettersAndSetters() {
+        Question question = new Question();
+
+        question.setId(1L);
+        question.setTexte("Quelle est la capitale de la France ?");
+        question.setAnswerA("Paris");
+        question.setAnswerB("Lyon");
+        question.setAnswerC("Marseille");
+        question.setAnswerD("Nice");
+        question.setCAnswer("Paris");
+
+        assertEquals(1L, question.getId());
+        assertEquals("Quelle est la capitale de la France ?", question.getTexte());
+        assertEquals("Paris", question.getAnswerA());
+        assertEquals("Lyon", question.getAnswerB());
+        assertEquals("Marseille", question.getAnswerC());
+        assertEquals("Nice", question.getAnswerD());
+        assertEquals("Paris", question.getCAnswer());
+    }
+}

src/test/java/com/example/wfwebapi/model/QuizQuestionIdTest.java

@@ -0,0 +1,37 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class QuizQuestionIdTest {
+
+    @Test
+    void testGettersAndSetters() {
+        QuizQuestionId id = new QuizQuestionId();
+        id.setQuiz(1L);
+        id.setQuestion(2L);
+
+        assertEquals(1L, id.getQuiz());
+        assertEquals(2L, id.getQuestion());
+    }
+
+    @Test
+    void testConstructor() {
+        QuizQuestionId id = new QuizQuestionId(3L, 4L);
+
+        assertEquals(3L, id.getQuiz());
+        assertEquals(4L, id.getQuestion());
+    }
+
+    @Test
+    void testEqualsAndHashCode() {
+        QuizQuestionId id1 = new QuizQuestionId(1L, 2L);
+        QuizQuestionId id2 = new QuizQuestionId(1L, 2L);
+        QuizQuestionId id3 = new QuizQuestionId(2L, 1L);
+
+        assertEquals(id1, id2);
+        assertEquals(id1.hashCode(), id2.hashCode());
+        assertNotEquals(id1, id3);
+    }
+}

src/test/java/com/example/wfwebapi/model/QuizQuestionTest.java

@@ -0,0 +1,24 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class QuizQuestionTest {
+
+    @Test
+    void testGettersAndSetters() {
+        QuizQuestion quizQuestion = new QuizQuestion();
+        QuizQuestionId id = new QuizQuestionId();
+        Quiz quiz = new Quiz();
+        Question question = new Question();
+
+        quizQuestion.setId(id);
+        quizQuestion.setQuiz(quiz);
+        quizQuestion.setQuestion(question);
+
+        assertEquals(id, quizQuestion.getId());
+        assertEquals(quiz, quizQuestion.getQuiz());
+        assertEquals(question, quizQuestion.getQuestion());
+    }
+}

src/test/java/com/example/wfwebapi/model/QuizTest.java

@@ -0,0 +1,24 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class QuizTest {
+
+    @Test
+    void testGettersAndSetters() {
+        Quiz quiz = new Quiz();
+        Image image = new Image();
+
+        quiz.setId(1L);
+        quiz.setTitle("Histoire de France");
+        quiz.setImage(image);
+        quiz.setNbQuest(10);
+
+        assertEquals(1L, quiz.getId());
+        assertEquals("Histoire de France", quiz.getTitle());
+        assertEquals(image, quiz.getImage());
+        assertEquals(10, quiz.getNbQuest());
+    }
+}

src/test/java/com/example/wfwebapi/model/QuoteTest.java

@@ -0,0 +1,36 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class QuoteTest {
+
+    @Test
+    void testGettersAndSetters() {
+        Quote quote = new Quote();
+        Caracter caracter = new Caracter();
+        Source source = new Source();
+        User user = new User();
+
+        quote.setId(1L);
+        quote.setContent("Ceci est une citation.");
+        quote.setLikes(42);
+        quote.setLangue("fr");
+        quote.setIsValide(true);
+        quote.setReason("Vérifiée manuellement");
+        quote.setCaracter(caracter);
+        quote.setSource(source);
+        quote.setUserVerif(user);
+
+        assertEquals(1L, quote.getId());
+        assertEquals("Ceci est une citation.", quote.getContent());
+        assertEquals(42, quote.getLikes());
+        assertEquals("fr", quote.getLangue());
+        assertTrue(quote.getIsValide());
+        assertEquals("Vérifiée manuellement", quote.getReason());
+        assertEquals(caracter, quote.getCaracter());
+        assertEquals(source, quote.getSource());
+        assertEquals(user, quote.getUserVerif());
+    }
+}

src/test/java/com/example/wfwebapi/model/RecordQuizIdTest.java

@@ -0,0 +1,37 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RecordQuizIdTest {
+
+    @Test
+    void testGettersAndSetters() {
+        RecordQuizId id = new RecordQuizId();
+        id.setUser(1L);
+        id.setQuiz(2L);
+
+        assertEquals(1L, id.getUser());
+        assertEquals(2L, id.getQuiz());
+    }
+
+    @Test
+    void testConstructor() {
+        RecordQuizId id = new RecordQuizId(3L, 4L);
+
+        assertEquals(3L, id.getUser());
+        assertEquals(4L, id.getQuiz());
+    }
+
+    @Test
+    void testEqualsAndHashCode() {
+        RecordQuizId id1 = new RecordQuizId(1L, 2L);
+        RecordQuizId id2 = new RecordQuizId(1L, 2L);
+        RecordQuizId id3 = new RecordQuizId(2L, 1L);
+
+        assertEquals(id1, id2);
+        assertEquals(id1.hashCode(), id2.hashCode());
+        assertNotEquals(id1, id3);
+    }
+}

src/test/java/com/example/wfwebapi/model/RecordQuizTest.java

@@ -0,0 +1,28 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RecordQuizTest {
+
+    @Test
+    void testGettersAndSetters() {
+        RecordQuiz record = new RecordQuiz();
+        RecordQuizId id = new RecordQuizId();
+        User user = new User();
+        Quiz quiz = new Quiz();
+
+        record.setId(id);
+        record.setUser(user);
+        record.setQuiz(quiz);
+        record.setNbPoint(8);
+        record.setTimeQ(120);
+
+        assertEquals(id, record.getId());
+        assertEquals(user, record.getUser());
+        assertEquals(quiz, record.getQuiz());
+        assertEquals(8, record.getNbPoint());
+        assertEquals(120, record.getTimeQ());
+    }
+}

src/test/java/com/example/wfwebapi/model/SourceTest.java

@@ -0,0 +1,21 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SourceTest {
+
+    @Test
+    void testGettersAndSetters() {
+        Source source = new Source();
+
+        source.setId(1L);
+        source.setTitle("Discours historique");
+        source.setDateS(1945);
+
+        assertEquals(1L, source.getId());
+        assertEquals("Discours historique", source.getTitle());
+        assertEquals(1945, source.getDateS());
+    }
+}

src/test/java/com/example/wfwebapi/model/UserTest.java

@@ -0,0 +1,31 @@
+package com.example.wfwebapi.model;
+
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class UserTest {
+
+    @Test
+    void testGettersAndSetters() {
+        User user = new User();
+        Image image = new Image();
+        LocalDate creationDate = LocalDate.of(2024, 1, 1);
+
+        user.setId(1L);
+        user.setUsername("testuser");
+        user.setEmail("test@example.com");
+        user.setPassword("securePassword123");
+        user.setImage(image);
+        user.setCreation(creationDate);
+
+        assertEquals(1L, user.getId());
+        assertEquals("testuser", user.getUsername());
+        assertEquals("test@example.com", user.getEmail());
+        assertEquals("securePassword123", user.getPassword());
+        assertEquals(image, user.getImage());
+        assertEquals(creationDate, user.getCreation());
+    }
+}