From 27535e063c7aa4b2ce0cc5455a906142646284fa Mon Sep 17 00:00:00 2001
From: Morph01 <thibaut6969delastreet@gmail.com>
Date: Wed, 3 Dec 2025 19:36:02 +0100
Subject: [PATCH] feat: add tests

---
 .../CascadeDeleteIntegrationTest.java         | 297 ++++++++++++++++
 .../PhotoUploadIntegrationTest.java           | 288 ++++++++++++++++
 .../fotosharing/mapper/PhotoMapperTest.java   | 153 +++++++++
 .../security/SecurityServiceTest.java         | 319 ++++++++++++++++++
 target/FotoSharing-0.0.1-SNAPSHOT.war         | Bin 61677273 -> 61677420 bytes
 .../FotoSharing-0.0.1-SNAPSHOT.war.original   | Bin 51126359 -> 51126506 bytes
 6 files changed, 1057 insertions(+)
 create mode 100644 src/test/java/local/epul4a/fotosharing/integration/CascadeDeleteIntegrationTest.java
 create mode 100644 src/test/java/local/epul4a/fotosharing/integration/PhotoUploadIntegrationTest.java
 create mode 100644 src/test/java/local/epul4a/fotosharing/mapper/PhotoMapperTest.java
 create mode 100644 src/test/java/local/epul4a/fotosharing/security/SecurityServiceTest.java

diff --git a/src/test/java/local/epul4a/fotosharing/integration/CascadeDeleteIntegrationTest.java b/src/test/java/local/epul4a/fotosharing/integration/CascadeDeleteIntegrationTest.java
new file mode 100644
index 0000000..eb32461
--- /dev/null
+++ b/src/test/java/local/epul4a/fotosharing/integration/CascadeDeleteIntegrationTest.java
@@ -0,0 +1,297 @@
+package local.epul4a.fotosharing.integration;
+
+import local.epul4a.fotosharing.model.Commentaire;
+import local.epul4a.fotosharing.model.Photo;
+import local.epul4a.fotosharing.model.Utilisateur;
+import local.epul4a.fotosharing.repository.CommentaireRepository;
+import local.epul4a.fotosharing.repository.PhotoRepository;
+import local.epul4a.fotosharing.repository.UtilisateurRepository;
+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.security.crypto.password.PasswordEncoder;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests d'intégration pour la suppression en cascade
+ * Teste : Supprimer un user doit supprimer ses photos et commentaires
+ */
+@SpringBootTest
+@ActiveProfiles("test")
+@Transactional
+class CascadeDeleteIntegrationTest {
+
+    @Autowired
+    private UtilisateurRepository utilisateurRepository;
+
+    @Autowired
+    private PhotoRepository photoRepository;
+
+    @Autowired
+    private CommentaireRepository commentaireRepository;
+
+    @Autowired
+    private PasswordEncoder passwordEncoder;
+
+    private Utilisateur userA;
+    private Utilisateur userB;
+
+    @BeforeEach
+    void setUp() {
+        // Nettoyer la BDD
+        commentaireRepository.deleteAll();
+        photoRepository.deleteAll();
+        utilisateurRepository.deleteAll();
+
+        // Créer User A
+        userA = new Utilisateur();
+        userA.setEmail("userA@example.com");
+        userA.setNom("A");
+        userA.setPrenom("User");
+        userA.setPassword(passwordEncoder.encode("password"));
+        userA = utilisateurRepository.save(userA);
+
+        // Créer User B
+        userB = new Utilisateur();
+        userB.setEmail("userB@example.com");
+        userB.setNom("B");
+        userB.setPrenom("User");
+        userB.setPassword(passwordEncoder.encode("password"));
+        userB = utilisateurRepository.save(userB);
+    }
+
+    @Test
+    void testDeleteUser_ShouldDeleteUserOwnPhotos() {
+        // Given - User A possède 3 photos
+        Photo photo1 = createPhoto("photo1.jpg", userA);
+        Photo photo2 = createPhoto("photo2.jpg", userA);
+        Photo photo3 = createPhoto("photo3.jpg", userA);
+
+        photoRepository.save(photo1);
+        photoRepository.save(photo2);
+        photoRepository.save(photo3);
+
+        // Given - User B possède 2 photos (ne doivent PAS être supprimées)
+        Photo photoB1 = createPhoto("photoB1.jpg", userB);
+        Photo photoB2 = createPhoto("photoB2.jpg", userB);
+        photoRepository.save(photoB1);
+        photoRepository.save(photoB2);
+
+        // Vérifier la situation initiale
+        assertEquals(5, photoRepository.count(), "5 photos au total");
+        assertEquals(3, photoRepository.findByProprietaire_Email(userA.getEmail()).size());
+        assertEquals(2, photoRepository.findByProprietaire_Email(userB.getEmail()).size());
+
+        // When - Supprimer User A
+        utilisateurRepository.delete(userA);
+        utilisateurRepository.flush();
+
+        // Then - Les photos de User A doivent être supprimées
+        assertEquals(2, photoRepository.count(),
+                "Seules les 2 photos de User B doivent rester");
+
+        List<Photo> remainingPhotos = photoRepository.findAll();
+        assertEquals(2, remainingPhotos.size());
+        assertTrue(remainingPhotos.stream().allMatch(p -> p.getProprietaire().getId().equals(userB.getId())),
+                "Toutes les photos restantes doivent appartenir à User B");
+    }
+
+    @Test
+    void testDeleteUser_ShouldDeleteUserOwnComments() {
+        // Given - Photo de User B
+        Photo photoB = createPhoto("photoB.jpg", userB);
+        photoB = photoRepository.save(photoB);
+
+        // Given - User A commente la photo de User B
+        Commentaire comment1 = createCommentaire("Super photo !", userA, photoB);
+        Commentaire comment2 = createCommentaire("J'adore !", userA, photoB);
+        Commentaire comment3 = createCommentaire("Merci !", userB, photoB); // Commentaire de User B
+
+        commentaireRepository.save(comment1);
+        commentaireRepository.save(comment2);
+        commentaireRepository.save(comment3);
+
+        // Vérifier la situation initiale
+        assertEquals(3, commentaireRepository.count());
+
+        // When - Supprimer User A
+        utilisateurRepository.delete(userA);
+        utilisateurRepository.flush();
+
+        // Then - Les commentaires de User A doivent être supprimés
+        assertEquals(1, commentaireRepository.count(),
+                "Seul le commentaire de User B doit rester");
+
+        List<Commentaire> remainingComments = commentaireRepository.findAll();
+        assertEquals(1, remainingComments.size());
+        assertEquals(userB.getId(), remainingComments.get(0).getAuteur().getId(),
+                "Le commentaire restant doit être celui de User B");
+    }
+
+    @Test
+    void testDeleteUser_ShouldDeletePhotosAndAllCommentsOnThosePhotos() {
+        // Given - User A possède une photo
+        Photo photoA = createPhoto("photoA.jpg", userA);
+        photoA = photoRepository.save(photoA);
+
+        // Given - Plusieurs utilisateurs commentent la photo de User A
+        Commentaire commentByA = createCommentaire("Ma photo", userA, photoA);
+        Commentaire commentByB = createCommentaire("Belle photo", userB, photoA);
+
+        commentaireRepository.save(commentByA);
+        commentaireRepository.save(commentByB);
+
+        // Vérifier la situation initiale
+        assertEquals(1, photoRepository.count());
+        assertEquals(2, commentaireRepository.count());
+
+        // When - Supprimer User A (et donc sa photo)
+        utilisateurRepository.delete(userA);
+        utilisateurRepository.flush();
+
+        // Then - La photo ET tous ses commentaires doivent être supprimés
+        assertEquals(0, photoRepository.count(),
+                "La photo de User A doit être supprimée");
+
+        assertEquals(0, commentaireRepository.count(),
+                "TOUS les commentaires sur la photo supprimée doivent disparaître (cascade)");
+    }
+
+    @Test
+    void testDeleteUser_ComplexScenario() {
+        // Scénario complexe :
+        // - User A a 2 photos
+        // - User B a 1 photo
+        // - User A commente sa propre photo ET la photo de User B
+        // - User B commente sa propre photo ET une photo de User A
+
+        // Given - Photos
+        Photo photoA1 = photoRepository.save(createPhoto("photoA1.jpg", userA));
+        Photo photoA2 = photoRepository.save(createPhoto("photoA2.jpg", userA));
+        Photo photoB = photoRepository.save(createPhoto("photoB.jpg", userB));
+
+        // Given - Commentaires
+        commentaireRepository.save(createCommentaire("A sur A1", userA, photoA1));
+        commentaireRepository.save(createCommentaire("A sur A2", userA, photoA2));
+        commentaireRepository.save(createCommentaire("A sur B", userA, photoB));
+        commentaireRepository.save(createCommentaire("B sur A1", userB, photoA1));
+        commentaireRepository.save(createCommentaire("B sur B", userB, photoB));
+
+        // Vérifier la situation initiale
+        assertEquals(3, photoRepository.count());
+        assertEquals(5, commentaireRepository.count());
+
+        // When - Supprimer User A
+        utilisateurRepository.delete(userA);
+        utilisateurRepository.flush();
+
+        // Then - Vérifier les suppressions
+        assertEquals(1, photoRepository.count(),
+                "Seule la photo de User B doit rester");
+
+        List<Photo> remainingPhotos = photoRepository.findAll();
+        assertEquals(photoB.getId(), remainingPhotos.get(0).getId());
+
+        // Then - Vérifier les commentaires restants
+        List<Commentaire> remainingComments = commentaireRepository.findAll();
+        assertEquals(1, remainingComments.size(),
+                "Seul le commentaire 'B sur B' doit rester");
+
+        Commentaire lastComment = remainingComments.get(0);
+        assertEquals("B sur B", lastComment.getTexte());
+        assertEquals(userB.getId(), lastComment.getAuteur().getId());
+        assertEquals(photoB.getId(), lastComment.getPhoto().getId());
+    }
+
+    @Test
+    void testDeleteUser_ShouldNotAffectOtherUsers() {
+        // Given - Créer User C
+        Utilisateur userC = new Utilisateur();
+        userC.setEmail("userC@example.com");
+        userC.setNom("C");
+        userC.setPrenom("User");
+        userC.setPassword(passwordEncoder.encode("password"));
+        userC = utilisateurRepository.save(userC);
+
+        // Given - Chaque utilisateur a des photos et commentaires
+        Photo photoA = photoRepository.save(createPhoto("photoA.jpg", userA));
+        Photo photoB = photoRepository.save(createPhoto("photoB.jpg", userB));
+        Photo photoC = photoRepository.save(createPhoto("photoC.jpg", userC));
+
+        commentaireRepository.save(createCommentaire("Comment A", userA, photoA));
+        commentaireRepository.save(createCommentaire("Comment B", userB, photoB));
+        commentaireRepository.save(createCommentaire("Comment C", userC, photoC));
+
+        // Vérifier la situation initiale
+        assertEquals(3, utilisateurRepository.count());
+        assertEquals(3, photoRepository.count());
+        assertEquals(3, commentaireRepository.count());
+
+        // When - Supprimer User A
+        utilisateurRepository.delete(userA);
+        utilisateurRepository.flush();
+
+        // Then - User B et C ne doivent pas être affectés
+        assertEquals(2, utilisateurRepository.count(),
+                "Users B et C doivent rester");
+        assertEquals(2, photoRepository.count(),
+                "Photos de B et C doivent rester");
+        assertEquals(2, commentaireRepository.count(),
+                "Commentaires de B et C doivent rester");
+
+        // Then - Vérifier que les bonnes entités restent
+        assertTrue(utilisateurRepository.findById(userB.getId()).isPresent());
+        assertTrue(utilisateurRepository.findById(userC.getId()).isPresent());
+        assertFalse(utilisateurRepository.findById(userA.getId()).isPresent());
+    }
+
+    @Test
+    void testDeleteMultipleUsers_ShouldDeleteRespectiveData() {
+        // Given - Chaque user a des photos
+        photoRepository.save(createPhoto("photoA.jpg", userA));
+        photoRepository.save(createPhoto("photoB.jpg", userB));
+
+        assertEquals(2, photoRepository.count());
+
+        // When - Supprimer les deux utilisateurs
+        utilisateurRepository.delete(userA);
+        utilisateurRepository.delete(userB);
+        utilisateurRepository.flush();
+
+        // Then - Tout doit être supprimé
+        assertEquals(0, utilisateurRepository.count());
+        assertEquals(0, photoRepository.count());
+    }
+
+    // ===================== Méthodes Utilitaires =====================
+
+    private Photo createPhoto(String filename, Utilisateur owner) {
+        Photo photo = new Photo();
+        photo.setNomFichierOriginal(filename);
+        photo.setUuidFichier("uuid-" + filename);
+        photo.setUuidThumbnail("thumb-" + filename);
+        photo.setVisibilite(Photo.Visibilite.PUBLIC);
+        photo.setDateUpload(LocalDateTime.now());
+        photo.setProprietaire(owner);
+        photo.setMimeType("image/jpeg");
+        photo.setTailleFichier(1024L);
+        return photo;
+    }
+
+    private Commentaire createCommentaire(String texte, Utilisateur auteur, Photo photo) {
+        Commentaire commentaire = new Commentaire();
+        commentaire.setTexte(texte);
+        commentaire.setAuteur(auteur);
+        commentaire.setPhoto(photo);
+        commentaire.setDateCommentaire(LocalDateTime.now());
+        return commentaire;
+    }
+}
+
diff --git a/src/test/java/local/epul4a/fotosharing/integration/PhotoUploadIntegrationTest.java b/src/test/java/local/epul4a/fotosharing/integration/PhotoUploadIntegrationTest.java
new file mode 100644
index 0000000..e1fa27b
--- /dev/null
+++ b/src/test/java/local/epul4a/fotosharing/integration/PhotoUploadIntegrationTest.java
@@ -0,0 +1,288 @@
+package local.epul4a.fotosharing.integration;
+
+import local.epul4a.fotosharing.dto.PhotoDTO;
+import local.epul4a.fotosharing.model.Photo;
+import local.epul4a.fotosharing.model.Utilisateur;
+import local.epul4a.fotosharing.repository.PhotoRepository;
+import local.epul4a.fotosharing.repository.UtilisateurRepository;
+import local.epul4a.fotosharing.service.PhotoService;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests d'intégration pour le flux complet d'upload de photos
+ * Teste : Envoi fichier -> Vérification présence sur disque -> Vérification entrée en BDD
+ */
+@SpringBootTest
+@ActiveProfiles("test")
+class PhotoUploadIntegrationTest {
+
+    @Autowired
+    private PhotoService photoService;
+
+    @Autowired
+    private PhotoRepository photoRepository;
+
+    @Autowired
+    private UtilisateurRepository utilisateurRepository;
+
+    @Autowired
+    private PasswordEncoder passwordEncoder;
+
+    @Value("${file.upload-dir}")
+    private String uploadDir;
+
+    private Utilisateur testUser;
+    private Path uploadPath;
+
+    @BeforeEach
+    void setUp() throws IOException {
+        // Créer le dossier d'upload pour les tests
+        uploadPath = Paths.get(uploadDir);
+        if (!Files.exists(uploadPath)) {
+            Files.createDirectories(uploadPath);
+        }
+
+        // Créer un utilisateur de test
+        testUser = new Utilisateur();
+        testUser.setEmail("testupload@example.com");
+        testUser.setNom("Upload");
+        testUser.setPrenom("Test");
+        testUser.setPassword(passwordEncoder.encode("password"));
+        testUser = utilisateurRepository.save(testUser);
+    }
+
+    @AfterEach
+    void tearDown() throws IOException {
+        // Nettoyer les photos de test
+        photoRepository.findAll().forEach(photo -> {
+            try {
+                // Supprimer les fichiers sur disque
+                Path originalFile = uploadPath.resolve(photo.getUuidFichier());
+                Path thumbFile = uploadPath.resolve(photo.getUuidThumbnail());
+                Files.deleteIfExists(originalFile);
+                Files.deleteIfExists(thumbFile);
+            } catch (IOException e) {
+                // Ignorer les erreurs de suppression
+            }
+        });
+
+        // Supprimer de la BDD
+        photoRepository.deleteAll();
+        utilisateurRepository.deleteAll();
+    }
+
+    @Test
+    void testCompleteUploadFlow_ShouldCreateFileOnDiskAndDatabaseEntry() throws IOException {
+        // Given - Créer un fichier JPEG valide
+        byte[] jpegContent = createValidJpegBytes();
+        MockMultipartFile file = new MockMultipartFile(
+                "file",
+                "test-photo.jpg",
+                "image/jpeg",
+                jpegContent
+        );
+
+        // When - Upload de la photo
+        PhotoDTO uploadedPhoto = photoService.store(file, "PUBLIC", testUser.getEmail());
+
+        // Then - Vérifier que le DTO est retourné
+        assertNotNull(uploadedPhoto, "Le DTO de la photo uploadée ne doit pas être null");
+        assertNotNull(uploadedPhoto.getId(), "L'ID de la photo doit être généré");
+        assertEquals("test-photo.jpg", uploadedPhoto.getNomFichierOriginal());
+        assertEquals("PUBLIC", uploadedPhoto.getVisibilite());
+        assertEquals("image/jpeg", uploadedPhoto.getMimeType());
+        assertEquals(jpegContent.length, uploadedPhoto.getTailleFichier());
+
+        // Then - Vérifier la présence du fichier ORIGINAL sur le disque
+        Path originalFile = uploadPath.resolve(uploadedPhoto.getUuidFichier());
+        assertTrue(Files.exists(originalFile),
+                "Le fichier original doit exister sur le disque : " + originalFile);
+        assertEquals(jpegContent.length, Files.size(originalFile),
+                "La taille du fichier sur disque doit correspondre");
+
+        // Then - Vérifier la présence de la MINIATURE sur le disque
+        Path thumbnailFile = uploadPath.resolve(uploadedPhoto.getUuidThumbnail());
+        assertTrue(Files.exists(thumbnailFile),
+                "La miniature doit exister sur le disque : " + thumbnailFile);
+        assertTrue(Files.size(thumbnailFile) > 0,
+                "La miniature ne doit pas être vide");
+
+        // Then - Vérifier l'entrée en BDD
+        Photo photoInDb = photoRepository.findById(uploadedPhoto.getId()).orElse(null);
+        assertNotNull(photoInDb, "La photo doit être enregistrée en BDD");
+        assertEquals("test-photo.jpg", photoInDb.getNomFichierOriginal());
+        assertEquals(Photo.Visibilite.PUBLIC, photoInDb.getVisibilite());
+        assertEquals(testUser.getId(), photoInDb.getProprietaire().getId());
+        assertEquals("image/jpeg", photoInDb.getMimeType());
+        assertEquals((long) jpegContent.length, photoInDb.getTailleFichier());
+
+        // Then - Vérifier les métadonnées
+        assertNotNull(photoInDb.getLargeur(), "La largeur doit être extraite");
+        assertNotNull(photoInDb.getHauteur(), "La hauteur doit être extraite");
+        assertTrue(photoInDb.getLargeur() > 0, "La largeur doit être positive");
+        assertTrue(photoInDb.getHauteur() > 0, "La hauteur doit être positive");
+    }
+
+    @Test
+    void testUploadPngFile_ShouldDetectCorrectMimeType() {
+        // Given - Créer un fichier PNG valide
+        byte[] pngContent = createValidPngBytes();
+        MockMultipartFile file = new MockMultipartFile(
+                "file",
+                "test-image.png",
+                "image/png",
+                pngContent
+        );
+
+        // When
+        PhotoDTO uploadedPhoto = photoService.store(file, "PRIVATE", testUser.getEmail());
+
+        // Then - Vérifier le type MIME détecté
+        assertNotNull(uploadedPhoto);
+        assertEquals("image/png", uploadedPhoto.getMimeType(),
+                "Le type MIME doit être détecté comme PNG");
+
+        // Then - Vérifier en BDD
+        Photo photoInDb = photoRepository.findById(uploadedPhoto.getId()).orElse(null);
+        assertNotNull(photoInDb);
+        assertEquals("image/png", photoInDb.getMimeType());
+    }
+
+    @Test
+    void testUploadMultiplePhotos_ShouldCreateSeparateFiles() throws IOException {
+        // Given - Uploader plusieurs photos
+        for (int i = 1; i <= 3; i++) {
+            byte[] content = createValidJpegBytes();
+            MockMultipartFile file = new MockMultipartFile(
+                    "file",
+                    "photo-" + i + ".jpg",
+                    "image/jpeg",
+                    content
+            );
+
+            // When
+            photoService.store(file, "PUBLIC", testUser.getEmail());
+        }
+
+        // Then - Vérifier que 3 photos sont en BDD
+        long photoCount = photoRepository.count();
+        assertEquals(3, photoCount, "3 photos doivent être enregistrées");
+
+        // Then - Vérifier que tous les fichiers existent
+        photoRepository.findAll().forEach(photo -> {
+            Path originalFile = uploadPath.resolve(photo.getUuidFichier());
+            Path thumbFile = uploadPath.resolve(photo.getUuidThumbnail());
+
+            assertTrue(Files.exists(originalFile),
+                    "Le fichier original doit exister : " + photo.getUuidFichier());
+            assertTrue(Files.exists(thumbFile),
+                    "La miniature doit exister : " + photo.getUuidThumbnail());
+        });
+    }
+
+    @Test
+    void testUploadWithDifferentVisibilities() {
+        // Test chaque type de visibilité
+        Photo.Visibilite[] visibilities = {Photo.Visibilite.PUBLIC, Photo.Visibilite.PRIVATE, Photo.Visibilite.SHARED};
+
+        for (Photo.Visibilite visibility : visibilities) {
+            // Given
+            byte[] content = createValidJpegBytes();
+            MockMultipartFile file = new MockMultipartFile(
+                    "file",
+                    "photo-" + visibility.name().toLowerCase() + ".jpg",
+                    "image/jpeg",
+                    content
+            );
+
+            // When
+            PhotoDTO uploadedPhoto = photoService.store(file, visibility.name(), testUser.getEmail());
+
+            // Then
+            assertEquals(visibility.name(), uploadedPhoto.getVisibilite(),
+                    "La visibilité doit être " + visibility);
+
+            Photo photoInDb = photoRepository.findById(uploadedPhoto.getId()).orElse(null);
+            assertNotNull(photoInDb);
+            assertEquals(visibility, photoInDb.getVisibilite());
+        }
+    }
+
+    @Test
+    void testUpload_FileNameWithUUID_ShouldBeUnique() {
+        // Given - Uploader deux fichiers avec le même nom
+        byte[] content = createValidJpegBytes();
+
+        MockMultipartFile file1 = new MockMultipartFile("file", "same-name.jpg", "image/jpeg", content);
+        MockMultipartFile file2 = new MockMultipartFile("file", "same-name.jpg", "image/jpeg", content);
+
+        // When
+        PhotoDTO photo1 = photoService.store(file1, "PUBLIC", testUser.getEmail());
+        PhotoDTO photo2 = photoService.store(file2, "PUBLIC", testUser.getEmail());
+
+        // Then - Les UUID doivent être différents
+        assertNotEquals(photo1.getUuidFichier(), photo2.getUuidFichier(),
+                "Les UUID des fichiers doivent être différents même avec le même nom original");
+
+        // Then - Les deux fichiers doivent exister sur le disque
+        assertTrue(Files.exists(uploadPath.resolve(photo1.getUuidFichier())));
+        assertTrue(Files.exists(uploadPath.resolve(photo2.getUuidFichier())));
+    }
+
+    // ===================== Méthodes Utilitaires =====================
+
+    /**
+     * Crée un tableau de bytes représentant un JPEG valide minimal
+     */
+    private byte[] createValidJpegBytes() {
+        // Magic number JPEG + données minimales pour créer une image valide
+        return new byte[]{
+                (byte) 0xFF, (byte) 0xD8, (byte) 0xFF, (byte) 0xE0, // JPEG header
+                0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, // JFIF marker
+                0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00,
+                (byte) 0xFF, (byte) 0xDB, 0x00, 0x43, 0x00, // Quantization table
+                0x08, 0x06, 0x06, 0x07, 0x06, 0x05, 0x08, 0x07,
+                0x07, 0x07, 0x09, 0x09, 0x08, 0x0A, 0x0C, 0x14,
+                0x0D, 0x0C, 0x0B, 0x0B, 0x0C, 0x19, 0x12, 0x13,
+                0x0F, 0x14, 0x1D, 0x1A, 0x1F, 0x1E, 0x1D, 0x1A,
+                0x1C, 0x1C, 0x20, 0x24, 0x2E, 0x27, 0x20, 0x22,
+                0x2C, 0x23, 0x1C, 0x1C, 0x28, 0x37, 0x29, 0x2C,
+                0x30, 0x31, 0x34, 0x34, 0x34, 0x1F, 0x27, 0x39,
+                0x3D, 0x38, 0x32, 0x3C, 0x2E, 0x33, 0x34, 0x32,
+                (byte) 0xFF, (byte) 0xD9 // End of image
+        };
+    }
+
+    /**
+     * Crée un tableau de bytes représentant un PNG valide minimal
+     */
+    private byte[] createValidPngBytes() {
+        // Magic number PNG + données minimales
+        return new byte[]{
+                (byte) 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, // PNG signature
+                0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, // IHDR chunk
+                0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, // 1x1 pixel
+                0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, (byte) 0xC4, (byte) 0x89,
+                0x00, 0x00, 0x00, 0x0A, 0x49, 0x44, 0x41, 0x54, // IDAT chunk
+                0x78, (byte) 0x9C, 0x63, 0x00, 0x01, 0x00, 0x00, 0x05, 0x00, 0x01,
+                0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, // IEND chunk
+                (byte) 0xAE, 0x42, 0x60, (byte) 0x82
+        };
+    }
+}
+
diff --git a/src/test/java/local/epul4a/fotosharing/mapper/PhotoMapperTest.java b/src/test/java/local/epul4a/fotosharing/mapper/PhotoMapperTest.java
new file mode 100644
index 0000000..b67cc20
--- /dev/null
+++ b/src/test/java/local/epul4a/fotosharing/mapper/PhotoMapperTest.java
@@ -0,0 +1,153 @@
+package local.epul4a.fotosharing.mapper;
+
+import local.epul4a.fotosharing.dto.PhotoDTO;
+import local.epul4a.fotosharing.dto.UtilisateurDTO;
+import local.epul4a.fotosharing.model.Photo;
+import local.epul4a.fotosharing.model.Utilisateur;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDateTime;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests unitaires pour PhotoMapper
+ * Teste la conversion bidirectionnelle entre Photo et PhotoDTO
+ */
+class PhotoMapperTest {
+
+    @Test
+    void testToDTO_WithCompletePhoto_ShouldMapAllFields() {
+        // Given - Créer un utilisateur
+        Utilisateur utilisateur = new Utilisateur();
+        utilisateur.setId(1L);
+        utilisateur.setEmail("test@example.com");
+        utilisateur.setNom("Dupont");
+        utilisateur.setPrenom("Jean");
+
+        // Given - Créer une photo complète
+        Photo photo = new Photo();
+        photo.setId(100L);
+        photo.setNomFichierOriginal("vacances.jpg");
+        photo.setUuidFichier("uuid-123-vacances.jpg");
+        photo.setUuidThumbnail("thumb-uuid-123-vacances.jpg");
+        photo.setDateUpload(LocalDateTime.of(2025, 12, 3, 10, 30));
+        photo.setVisibilite(Photo.Visibilite.PUBLIC);
+        photo.setProprietaire(utilisateur);
+        photo.setMimeType("image/jpeg");
+        photo.setTailleFichier(2457600L);
+        photo.setLargeur(1920);
+        photo.setHauteur(1080);
+
+        // When - Convertir en DTO
+        PhotoDTO dto = PhotoMapper.toDTO(photo);
+
+        // Then - Vérifier tous les champs
+        assertNotNull(dto, "Le DTO ne doit pas être null");
+        assertEquals(100L, dto.getId());
+        assertEquals("vacances.jpg", dto.getNomFichierOriginal());
+        assertEquals("uuid-123-vacances.jpg", dto.getUuidFichier());
+        assertEquals("thumb-uuid-123-vacances.jpg", dto.getUuidThumbnail());
+        assertEquals(LocalDateTime.of(2025, 12, 3, 10, 30), dto.getDateUpload());
+        assertEquals("PUBLIC", dto.getVisibilite());
+        assertEquals("image/jpeg", dto.getMimeType());
+        assertEquals(2457600L, dto.getTailleFichier());
+        assertEquals(1920, dto.getLargeur());
+        assertEquals(1080, dto.getHauteur());
+
+        // Then - Vérifier le propriétaire
+        assertNotNull(dto.getProprietaire(), "Le propriétaire ne doit pas être null");
+        assertEquals(1L, dto.getProprietaire().getId());
+        assertEquals("test@example.com", dto.getProprietaire().getEmail());
+        assertEquals("Dupont", dto.getProprietaire().getNom());
+        assertEquals("Jean", dto.getProprietaire().getPrenom());
+    }
+
+    @Test
+    void testToDTO_WithNullPhoto_ShouldReturnNull() {
+        // When - Convertir null
+        PhotoDTO dto = PhotoMapper.toDTO(null);
+
+        // Then
+        assertNull(dto, "Le DTO doit être null quand la photo est null");
+    }
+
+    @Test
+    void testToDTO_WithPhotoWithoutOwner_ShouldNotFail() {
+        // Given - Photo sans propriétaire
+        Photo photo = new Photo();
+        photo.setId(50L);
+        photo.setNomFichierOriginal("test.png");
+        photo.setVisibilite(Photo.Visibilite.PRIVATE);
+
+        // When
+        PhotoDTO dto = PhotoMapper.toDTO(photo);
+
+        // Then
+        assertNotNull(dto);
+        assertEquals(50L, dto.getId());
+        assertNull(dto.getProprietaire(), "Le propriétaire doit être null");
+    }
+
+    @Test
+    void testToDTO_WithMinimalPhoto_ShouldMapBasicFields() {
+        // Given - Photo avec champs minimaux
+        Photo photo = new Photo();
+        photo.setId(25L);
+        photo.setNomFichierOriginal("minimal.jpg");
+        photo.setVisibilite(Photo.Visibilite.SHARED);
+
+        // When
+        PhotoDTO dto = PhotoMapper.toDTO(photo);
+
+        // Then
+        assertNotNull(dto);
+        assertEquals(25L, dto.getId());
+        assertEquals("minimal.jpg", dto.getNomFichierOriginal());
+        assertEquals("SHARED", dto.getVisibilite());
+        assertNull(dto.getMimeType());
+        assertNull(dto.getTailleFichier());
+    }
+
+    @Test
+    void testToDTO_MetadataMapping() {
+        // Given - Photo avec métadonnées
+        Photo photo = new Photo();
+        photo.setId(1L);
+        photo.setNomFichierOriginal("hd-photo.jpg");
+        photo.setVisibilite(Photo.Visibilite.PUBLIC);
+        photo.setMimeType("image/png");
+        photo.setTailleFichier(5242880L); // 5 MB
+        photo.setLargeur(3840);
+        photo.setHauteur(2160);
+
+        // When
+        PhotoDTO dto = PhotoMapper.toDTO(photo);
+
+        // Then - Vérifier les métadonnées
+        assertEquals("image/png", dto.getMimeType());
+        assertEquals(5242880L, dto.getTailleFichier());
+        assertEquals(3840, dto.getLargeur());
+        assertEquals(2160, dto.getHauteur());
+    }
+
+    @Test
+    void testToDTO_AllVisibilityTypes() {
+        // Test pour chaque type de visibilité
+        for (Photo.Visibilite visibilite : Photo.Visibilite.values()) {
+            // Given
+            Photo photo = new Photo();
+            photo.setId(1L);
+            photo.setNomFichierOriginal("test.jpg");
+            photo.setVisibilite(visibilite);
+
+            // When
+            PhotoDTO dto = PhotoMapper.toDTO(photo);
+
+            // Then
+            assertEquals(visibilite.name(), dto.getVisibilite(),
+                    "La visibilité " + visibilite + " doit être correctement mappée");
+        }
+    }
+}
+
diff --git a/src/test/java/local/epul4a/fotosharing/security/SecurityServiceTest.java b/src/test/java/local/epul4a/fotosharing/security/SecurityServiceTest.java
new file mode 100644
index 0000000..5c1a82e
--- /dev/null
+++ b/src/test/java/local/epul4a/fotosharing/security/SecurityServiceTest.java
@@ -0,0 +1,319 @@
+package local.epul4a.fotosharing.security;
+
+import local.epul4a.fotosharing.service.PartageService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.security.core.Authentication;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * Tests unitaires pour SecurityService
+ * Teste les scénarios d'accès aux photos (READ / COMMENT / ADMIN)
+ */
+@ExtendWith(MockitoExtension.class)
+class SecurityServiceTest {
+
+    @Mock
+    private PartageService partageService;
+
+    @Mock
+    private Authentication authentication;
+
+    private SecurityService securityService;
+
+    @BeforeEach
+    void setUp() {
+        securityService = new SecurityService(partageService);
+    }
+
+    // ===================== TESTS canAccessPhoto =====================
+
+    @Test
+    void canAccessPhoto_UserAAccessesPrivatePhotoB_ShouldReturnFalse() {
+        // Given - User A essaie d'accéder à Photo B privée (pas de partage)
+        Long photoId = 100L;
+        String userAEmail = "userA@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userAEmail);
+        when(partageService.canView(photoId, userAEmail)).thenReturn(false);
+
+        // When
+        boolean canAccess = securityService.canAccessPhoto(authentication, photoId);
+
+        // Then
+        assertFalse(canAccess, "User A ne devrait PAS pouvoir accéder à Photo B privée");
+        verify(partageService).canView(photoId, userAEmail);
+    }
+
+    @Test
+    void canAccessPhoto_UserAAccessesSharedPhotoB_ShouldReturnTrue() {
+        // Given - User A accède à Photo B partagée avec lui (READ)
+        Long photoId = 200L;
+        String userAEmail = "userA@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userAEmail);
+        when(partageService.canView(photoId, userAEmail)).thenReturn(true);
+
+        // When
+        boolean canAccess = securityService.canAccessPhoto(authentication, photoId);
+
+        // Then
+        assertTrue(canAccess, "User A DEVRAIT pouvoir accéder à Photo B partagée");
+        verify(partageService).canView(photoId, userAEmail);
+    }
+
+    @Test
+    void canAccessPhoto_UserAAccessesOwnPhoto_ShouldReturnTrue() {
+        // Given - User A accède à sa propre photo
+        Long photoId = 300L;
+        String userAEmail = "userA@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userAEmail);
+        when(partageService.canView(photoId, userAEmail)).thenReturn(true); // Propriétaire = accès
+
+        // When
+        boolean canAccess = securityService.canAccessPhoto(authentication, photoId);
+
+        // Then
+        assertTrue(canAccess, "User A DEVRAIT pouvoir accéder à sa propre photo");
+    }
+
+    @Test
+    void canAccessPhoto_UnauthenticatedUser_ShouldReturnFalse() {
+        // Given - Utilisateur non authentifié
+        when(authentication.isAuthenticated()).thenReturn(false);
+
+        // When
+        boolean canAccess = securityService.canAccessPhoto(authentication, 100L);
+
+        // Then
+        assertFalse(canAccess, "Un utilisateur non authentifié ne devrait PAS avoir accès");
+        verify(partageService, never()).canView(anyLong(), anyString());
+    }
+
+    @Test
+    void canAccessPhoto_NullAuthentication_ShouldReturnFalse() {
+        // When
+        boolean canAccess = securityService.canAccessPhoto(null, 100L);
+
+        // Then
+        assertFalse(canAccess, "Avec authentication null, l'accès devrait être refusé");
+        verify(partageService, never()).canView(anyLong(), anyString());
+    }
+
+    @Test
+    void canAccessPhoto_PublicPhoto_ShouldReturnTrue() {
+        // Given - Photo publique (accessible par tous les utilisateurs authentifiés)
+        Long photoId = 400L;
+        String userEmail = "anyone@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userEmail);
+        when(partageService.canView(photoId, userEmail)).thenReturn(true);
+
+        // When
+        boolean canAccess = securityService.canAccessPhoto(authentication, photoId);
+
+        // Then
+        assertTrue(canAccess, "Une photo publique devrait être accessible");
+    }
+
+    // ===================== TESTS canCommentPhoto =====================
+
+    @Test
+    void canCommentPhoto_UserWithCommentRights_ShouldReturnTrue() {
+        // Given - User A a le droit COMMENT sur Photo B
+        Long photoId = 500L;
+        String userEmail = "userA@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userEmail);
+        when(partageService.canComment(photoId, userEmail)).thenReturn(true);
+
+        // When
+        boolean canComment = securityService.canCommentPhoto(authentication, photoId);
+
+        // Then
+        assertTrue(canComment, "User A DEVRAIT pouvoir commenter Photo B");
+        verify(partageService).canComment(photoId, userEmail);
+    }
+
+    @Test
+    void canCommentPhoto_UserWithoutCommentRights_ShouldReturnFalse() {
+        // Given - User A n'a que READ (pas COMMENT)
+        Long photoId = 600L;
+        String userEmail = "userA@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userEmail);
+        when(partageService.canComment(photoId, userEmail)).thenReturn(false);
+
+        // When
+        boolean canComment = securityService.canCommentPhoto(authentication, photoId);
+
+        // Then
+        assertFalse(canComment, "User A ne devrait PAS pouvoir commenter (pas de droit COMMENT)");
+    }
+
+    @Test
+    void canCommentPhoto_UnauthenticatedUser_ShouldReturnFalse() {
+        // Given
+        when(authentication.isAuthenticated()).thenReturn(false);
+
+        // When
+        boolean canComment = securityService.canCommentPhoto(authentication, 100L);
+
+        // Then
+        assertFalse(canComment);
+        verify(partageService, never()).canComment(anyLong(), anyString());
+    }
+
+    // ===================== TESTS canAdminPhoto =====================
+
+    @Test
+    void canAdminPhoto_OwnerOfPhoto_ShouldReturnTrue() {
+        // Given - Propriétaire de la photo
+        Long photoId = 700L;
+        String ownerEmail = "owner@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(ownerEmail);
+        when(partageService.canAdmin(photoId, ownerEmail)).thenReturn(true);
+
+        // When
+        boolean canAdmin = securityService.canAdminPhoto(authentication, photoId);
+
+        // Then
+        assertTrue(canAdmin, "Le propriétaire DEVRAIT avoir les droits ADMIN");
+    }
+
+    @Test
+    void canAdminPhoto_UserWithAdminRights_ShouldReturnTrue() {
+        // Given - User A a le droit ADMIN sur Photo B (partagé par le propriétaire)
+        Long photoId = 800L;
+        String userEmail = "admin@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userEmail);
+        when(partageService.canAdmin(photoId, userEmail)).thenReturn(true);
+
+        // When
+        boolean canAdmin = securityService.canAdminPhoto(authentication, photoId);
+
+        // Then
+        assertTrue(canAdmin);
+    }
+
+    @Test
+    void canAdminPhoto_UserWithoutAdminRights_ShouldReturnFalse() {
+        // Given - User A n'a que READ ou COMMENT (pas ADMIN)
+        Long photoId = 900L;
+        String userEmail = "user@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userEmail);
+        when(partageService.canAdmin(photoId, userEmail)).thenReturn(false);
+
+        // When
+        boolean canAdmin = securityService.canAdminPhoto(authentication, photoId);
+
+        // Then
+        assertFalse(canAdmin, "User sans droit ADMIN ne devrait PAS pouvoir administrer");
+    }
+
+    @Test
+    void canAdminPhoto_NullAuthentication_ShouldReturnFalse() {
+        // When
+        boolean canAdmin = securityService.canAdminPhoto(null, 100L);
+
+        // Then
+        assertFalse(canAdmin);
+        verify(partageService, never()).canAdmin(anyLong(), anyString());
+    }
+
+    // ===================== TESTS Albums =====================
+
+    @Test
+    void canViewAlbum_UserWithAccess_ShouldReturnTrue() {
+        // Given
+        Long albumId = 1L;
+        String userEmail = "user@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userEmail);
+        when(partageService.canViewAlbum(albumId, userEmail)).thenReturn(true);
+
+        // When
+        boolean canView = securityService.canViewAlbum(authentication, albumId);
+
+        // Then
+        assertTrue(canView);
+        verify(partageService).canViewAlbum(albumId, userEmail);
+    }
+
+    @Test
+    void canCommentAlbum_UserWithoutAccess_ShouldReturnFalse() {
+        // Given
+        Long albumId = 2L;
+        String userEmail = "user@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userEmail);
+        when(partageService.canCommentAlbum(albumId, userEmail)).thenReturn(false);
+
+        // When
+        boolean canComment = securityService.canCommentAlbum(authentication, albumId);
+
+        // Then
+        assertFalse(canComment);
+    }
+
+    @Test
+    void canAdminAlbum_UnauthenticatedUser_ShouldReturnFalse() {
+        // Given
+        when(authentication.isAuthenticated()).thenReturn(false);
+
+        // When
+        boolean canAdmin = securityService.canAdminAlbum(authentication, 1L);
+
+        // Then
+        assertFalse(canAdmin);
+        verify(partageService, never()).canAdminAlbum(anyLong(), anyString());
+    }
+
+    // ===================== TESTS Scénarios Complexes =====================
+
+    @Test
+    void scenarioComplete_UserATriesDifferentActionsOnPhotoB() {
+        // Scénario : User A a seulement READ sur Photo B
+        Long photoId = 1000L;
+        String userAEmail = "userA@example.com";
+
+        when(authentication.isAuthenticated()).thenReturn(true);
+        when(authentication.getName()).thenReturn(userAEmail);
+        when(partageService.canView(photoId, userAEmail)).thenReturn(true);
+        when(partageService.canComment(photoId, userAEmail)).thenReturn(false);
+        when(partageService.canAdmin(photoId, userAEmail)).thenReturn(false);
+
+        // When/Then - User A peut voir
+        assertTrue(securityService.canAccessPhoto(authentication, photoId),
+                "User A devrait pouvoir VOIR la photo");
+
+        // When/Then - User A ne peut pas commenter
+        assertFalse(securityService.canCommentPhoto(authentication, photoId),
+                "User A ne devrait PAS pouvoir COMMENTER");
+
+        // When/Then - User A ne peut pas administrer
+        assertFalse(securityService.canAdminPhoto(authentication, photoId),
+                "User A ne devrait PAS pouvoir ADMINISTRER");
+    }
+}
+
diff --git a/target/FotoSharing-0.0.1-SNAPSHOT.war b/target/FotoSharing-0.0.1-SNAPSHOT.war
index b5deac677cdf012ce66401193c117c029b2f268e..e8e548e516cd6e5ab955f5ec150c221bc5d58182 100644
GIT binary patch
delta 9697
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
M(UEKCE9va@f9m@3!~g&Q

delta 9515
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
U;b8adls@j5W-=LnbsHJ|AA(EojQ{`u

diff --git a/target/FotoSharing-0.0.1-SNAPSHOT.war.original b/target/FotoSharing-0.0.1-SNAPSHOT.war.original
index ae3b6ab84406db1880094f10f2d37c4075c98dd1..9deb4b6ccd745800883f7bbfce4c374936cc74c2 100644
GIT binary patch
delta 8202
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
M9Bn=PyHTO|AG~d-=Kufz

delta 7996
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