297 lines
12 KiB
Java
297 lines
12 KiB
Java
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")
|
|
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.setMotDePasse(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.setMotDePasse(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.deleteById(userA.getId());
|
|
|
|
|
|
// 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.deleteById(userA.getId());
|
|
|
|
|
|
// 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.deleteById(userA.getId());
|
|
|
|
|
|
// 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.deleteById(userA.getId());
|
|
|
|
|
|
// 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.getContenu());
|
|
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.setMotDePasse(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.deleteById(userA.getId());
|
|
|
|
|
|
// 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.deleteById(userA.getId());
|
|
utilisateurRepository.deleteById(userB.getId());
|
|
|
|
|
|
// 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.setContenu(texte);
|
|
commentaire.setAuteur(auteur);
|
|
commentaire.setPhoto(photo);
|
|
commentaire.setDateCommentaire(LocalDateTime.now());
|
|
return commentaire;
|
|
}
|
|
}
|
|
|