lionsdev/unionflow-mobile-apps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean project: remove test files, debug logs, and add documentation

Browse Source
This commit is contained in:
dahoud
2025-10-05 13:41:33 +00:00
parent 96a17eadbd
commit 291847924c
438 changed files with 65754 additions and 32713 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/CompilationTest.java Normal file
View File

@@ -0,0 +1,154 @@
package dev.lions.unionflow.server.api;
import static org.assertj.core.api.Assertions.assertThat;
import dev.lions.unionflow.server.api.dto.evenement.EvenementDTO;
import dev.lions.unionflow.server.api.dto.solidarite.DemandeAideDTO;
import dev.lions.unionflow.server.api.dto.solidarite.PropositionAideDTO;
import dev.lions.unionflow.server.api.dto.solidarite.aide.AideDTO;
import dev.lions.unionflow.server.api.enums.evenement.PrioriteEvenement;
import dev.lions.unionflow.server.api.enums.evenement.StatutEvenement;
import dev.lions.unionflow.server.api.enums.evenement.TypeEvenementMetier;
import dev.lions.unionflow.server.api.validation.ValidationConstants;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.UUID;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
* Test de compilation pour vérifier que tous les DTOs compilent correctement
*
* @author UnionFlow Team
* @version 2.0
* @since 2025-01-16
*/
@DisplayName("Tests de Compilation")
class CompilationTest {
@Test
@DisplayName("Test compilation EvenementDTO")
void testCompilationEvenementDTO() {
EvenementDTO evenement = new EvenementDTO();
evenement.setTitre("Test Formation");
evenement.setStatut(StatutEvenement.PLANIFIE);
evenement.setPriorite(PrioriteEvenement.NORMALE);
evenement.setTypeEvenement(TypeEvenementMetier.FORMATION);
evenement.setDateDebut(LocalDate.now().plusDays(30));
// Test des méthodes métier
assertThat(evenement.estEnCours()).isFalse();
assertThat(evenement.getStatutLibelle()).isEqualTo("Planifié");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Formation");
// Test des setters
evenement.setStatut(StatutEvenement.CONFIRME);
assertThat(evenement.getStatut()).isEqualTo(StatutEvenement.CONFIRME);
}
@Test
@DisplayName("Test compilation DemandeAideDTO")
void testCompilationDemandeAideDTO() {
DemandeAideDTO demande = new DemandeAideDTO();
demande.setTitre("Test Demande");
demande.setMontantDemande(new BigDecimal("50000"));
demande.setDevise("XOF");
// Test des méthodes métier
assertThat(demande.getId()).isNotNull(); // BaseDTO génère automatiquement un UUID
assertThat(demande.getVersion()).isEqualTo(0L);
// Test de la méthode marquerCommeModifie
demande.marquerCommeModifie("testUser");
assertThat(demande.getModifiePar()).isEqualTo("testUser");
}
@Test
@DisplayName("Test compilation PropositionAideDTO")
void testCompilationPropositionAideDTO() {
PropositionAideDTO proposition = new PropositionAideDTO();
proposition.setTitre("Test Proposition");
proposition.setMontantMaximum(new BigDecimal("100000"));
// Vérifier que le type est correct
assertThat(proposition.getMontantMaximum()).isInstanceOf(BigDecimal.class);
}
@Test
@DisplayName("Test compilation AideDTO (deprecated)")
void testCompilationAideDTO() {
@SuppressWarnings("deprecation")
AideDTO aide = new AideDTO();
aide.setTitre("Test Aide");
// Test des méthodes métier
assertThat(aide.getTypeAideLibelle()).isNotNull();
assertThat(aide.getStatutLibelle()).isNotNull();
}
@Test
@DisplayName("Test compilation ValidationConstants")
void testCompilationValidationConstants() {
// Test que les constantes sont accessibles
assertThat(ValidationConstants.TITRE_MIN_LENGTH).isEqualTo(5);
assertThat(ValidationConstants.TITRE_MAX_LENGTH).isEqualTo(100);
assertThat(ValidationConstants.TELEPHONE_PATTERN).isNotNull();
assertThat(ValidationConstants.DEVISE_PATTERN).isNotNull();
}
@Test
@DisplayName("Test compilation énumérations")
void testCompilationEnumerations() {
// Test StatutEvenement
StatutEvenement statut = StatutEvenement.PLANIFIE;
assertThat(statut.getLibelle()).isEqualTo("Planifié");
assertThat(statut.permetModification()).isTrue();
// Test PrioriteEvenement
PrioriteEvenement priorite = PrioriteEvenement.HAUTE;
assertThat(priorite.getLibelle()).isEqualTo("Haute");
assertThat(priorite.isUrgente()).isTrue(); // Amélioration TDD : HAUTE est maintenant urgente
// Test TypeEvenementMetier
TypeEvenementMetier type = TypeEvenementMetier.FORMATION;
assertThat(type.getLibelle()).isEqualTo("Formation");
}
@Test
@DisplayName("Test intégration complète")
void testIntegrationComplete() {
// Créer un événement complet
EvenementDTO evenement =
new EvenementDTO(
"Formation Leadership",
TypeEvenementMetier.FORMATION,
LocalDate.now().plusDays(30),
"Centre de Formation");
evenement.setStatut(StatutEvenement.PLANIFIE);
evenement.setPriorite(PrioriteEvenement.HAUTE);
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(0);
evenement.setBudget(new BigDecimal("500000"));
evenement.setCodeDevise("XOF");
evenement.setAssociationId(UUID.randomUUID());
// Vérifier que tout fonctionne
assertThat(evenement.estEnCours()).isFalse();
assertThat(evenement.estComplet()).isFalse();
assertThat(evenement.sontInscriptionsOuvertes()).isTrue();
// Créer une demande d'aide complète
DemandeAideDTO demande = new DemandeAideDTO();
demande.setTitre("Aide Médicale Urgente");
demande.setDescription("Besoin d'aide pour frais médicaux");
demande.setMontantDemande(new BigDecimal("250000"));
demande.setDevise("XOF");
demande.setMembreDemandeurId(UUID.randomUUID());
demande.setAssociationId(UUID.randomUUID());
// Vérifier que tout fonctionne
assertThat(demande.getId()).isNotNull();
assertThat(demande.getVersion()).isEqualTo(0L);
assertThat(demande.getMontantDemande()).isEqualTo(new BigDecimal("250000"));
}
}

18
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/base/BaseDTOTest.java
View File

@@ -224,10 +224,10 @@ class BaseDTOTest {
void testEqualsMemeId() {
UUID id = UUID.randomUUID();
baseDto.setId(id);
TestableBaseDTO autre = new TestableBaseDTO();
autre.setId(id);
assertThat(baseDto).isEqualTo(autre);
assertThat(baseDto.hashCode()).isEqualTo(autre.hashCode());
}
@@ -236,10 +236,10 @@ class BaseDTOTest {
@DisplayName("Test equals - IDs différents")
void testEqualsIdsDifferents() {
baseDto.setId(UUID.randomUUID());
TestableBaseDTO autre = new TestableBaseDTO();
autre.setId(UUID.randomUUID());
assertThat(baseDto).isNotEqualTo(autre);
}
@@ -247,10 +247,10 @@ class BaseDTOTest {
@DisplayName("Test equals - ID null")
void testEqualsIdNull() {
baseDto.setId(null);
TestableBaseDTO autre = new TestableBaseDTO();
autre.setId(null);
assertThat(baseDto).isNotEqualTo(autre);
}
@@ -299,7 +299,7 @@ class BaseDTOTest {
baseDto.setId(id);
baseDto.setVersion(2L);
baseDto.setActif(true);
String result = baseDto.toString();
assertThat(result).contains("TestableBaseDTO");
assertThat(result).contains("id=" + id.toString());
@@ -308,9 +308,7 @@ class BaseDTOTest {
}
}
/**
* Classe de test concrète pour tester BaseDTO.
*/
/** Classe de test concrète pour tester BaseDTO. */
private static class TestableBaseDTO extends BaseDTO {
private static final long serialVersionUID = 1L;

672
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/evenement/EvenementDTOBasicTest.java
View File

@@ -1,672 +0,0 @@
package dev.lions.unionflow.server.api.dto.evenement;
import static org.assertj.core.api.Assertions.assertThat;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires complets pour EvenementDTO.
*
* @author UnionFlow Team
* @version 1.0
* @since 2025-01-10
*/
@DisplayName("Tests EvenementDTO")
class EvenementDTOBasicTest {
private EvenementDTO evenement;
@BeforeEach
void setUp() {
evenement = new EvenementDTO();
}
@Nested
@DisplayName("Tests de Construction")
class ConstructionTests {
@Test
@DisplayName("Constructeur par défaut - Initialisation correcte")
void testConstructeurParDefaut() {
EvenementDTO newEvenement = new EvenementDTO();
assertThat(newEvenement.getId()).isNotNull();
assertThat(newEvenement.getDateCreation()).isNotNull();
assertThat(newEvenement.isActif()).isTrue();
assertThat(newEvenement.getVersion()).isEqualTo(0L);
assertThat(newEvenement.getStatut()).isEqualTo("PLANIFIE");
assertThat(newEvenement.getPriorite()).isEqualTo("NORMALE");
assertThat(newEvenement.getParticipantsInscrits()).isEqualTo(0);
assertThat(newEvenement.getParticipantsPresents()).isEqualTo(0);
assertThat(newEvenement.getInscriptionObligatoire()).isFalse();
assertThat(newEvenement.getEvenementPublic()).isTrue();
assertThat(newEvenement.getRecurrent()).isFalse();
assertThat(newEvenement.getCodeDevise()).isEqualTo("XOF");
}
@Test
@DisplayName("Constructeur avec paramètres - Initialisation correcte")
void testConstructeurAvecParametres() {
String titre = "Réunion mensuelle";
String typeEvenement = "REUNION_BUREAU";
LocalDate dateDebut = LocalDate.now().plusDays(7);
String lieu = "Salle de conférence";
EvenementDTO newEvenement = new EvenementDTO(titre, typeEvenement, dateDebut, lieu);
assertThat(newEvenement.getTitre()).isEqualTo(titre);
assertThat(newEvenement.getTypeEvenement()).isEqualTo(typeEvenement);
assertThat(newEvenement.getDateDebut()).isEqualTo(dateDebut);
assertThat(newEvenement.getLieu()).isEqualTo(lieu);
assertThat(newEvenement.getStatut()).isEqualTo("PLANIFIE");
}
}
@Nested
@DisplayName("Tests Getters/Setters")
class GettersSettersTests {
@Test
@DisplayName("Test tous les getters/setters")
void testTousLesGettersSetters() {
// Données de test
String titre = "Formation Leadership";
String description = "Formation sur le leadership associatif";
String typeEvenement = "FORMATION";
String statut = "EN_COURS";
String priorite = "HAUTE";
LocalDate dateDebut = LocalDate.now().plusDays(1);
LocalDate dateFin = LocalDate.now().plusDays(2);
LocalTime heureDebut = LocalTime.of(9, 0);
LocalTime heureFin = LocalTime.of(17, 0);
String lieu = "Centre de formation";
String adresse = "123 Avenue de la République";
String ville = "Dakar";
String region = "Dakar";
BigDecimal latitude = new BigDecimal("14.6937");
BigDecimal longitude = new BigDecimal("-17.4441");
UUID associationId = UUID.randomUUID();
String nomAssociation = "Lions Club Dakar";
String organisateur = "Jean Dupont";
String emailOrganisateur = "jean.dupont@example.com";
String telephoneOrganisateur = "+221701234567";
Integer capaciteMax = 50;
Integer participantsInscrits = 25;
Integer participantsPresents = 20;
BigDecimal budget = new BigDecimal("500000.00");
BigDecimal coutReel = new BigDecimal("450000.00");
String codeDevise = "XOF";
Boolean inscriptionObligatoire = true;
LocalDate dateLimiteInscription = LocalDate.now().plusDays(5);
Boolean evenementPublic = false;
Boolean recurrent = true;
String frequenceRecurrence = "MENSUELLE";
String instructions = "Apporter un carnet de notes";
String materielNecessaire = "Projecteur, tableau";
String conditionsMeteo = "Intérieur";
String imageUrl = "https://example.com/image.jpg";
String couleurTheme = "#FF5733";
LocalDateTime dateAnnulation = LocalDateTime.now();
String raisonAnnulation = "Conditions météo";
Long annulePar = 123L;
String nomAnnulateur = "Admin";
// Test des setters
evenement.setTitre(titre);
evenement.setDescription(description);
evenement.setTypeEvenement(typeEvenement);
evenement.setStatut(statut);
evenement.setPriorite(priorite);
evenement.setDateDebut(dateDebut);
evenement.setDateFin(dateFin);
evenement.setHeureDebut(heureDebut);
evenement.setHeureFin(heureFin);
evenement.setLieu(lieu);
evenement.setAdresse(adresse);
evenement.setVille(ville);
evenement.setRegion(region);
evenement.setLatitude(latitude);
evenement.setLongitude(longitude);
evenement.setAssociationId(associationId);
evenement.setNomAssociation(nomAssociation);
evenement.setOrganisateur(organisateur);
evenement.setEmailOrganisateur(emailOrganisateur);
evenement.setTelephoneOrganisateur(telephoneOrganisateur);
evenement.setCapaciteMax(capaciteMax);
evenement.setParticipantsInscrits(participantsInscrits);
evenement.setParticipantsPresents(participantsPresents);
evenement.setBudget(budget);
evenement.setCoutReel(coutReel);
evenement.setCodeDevise(codeDevise);
evenement.setInscriptionObligatoire(inscriptionObligatoire);
evenement.setDateLimiteInscription(dateLimiteInscription);
evenement.setEvenementPublic(evenementPublic);
evenement.setRecurrent(recurrent);
evenement.setFrequenceRecurrence(frequenceRecurrence);
evenement.setInstructions(instructions);
evenement.setMaterielNecessaire(materielNecessaire);
evenement.setConditionsMeteo(conditionsMeteo);
evenement.setImageUrl(imageUrl);
evenement.setCouleurTheme(couleurTheme);
evenement.setDateAnnulation(dateAnnulation);
evenement.setRaisonAnnulation(raisonAnnulation);
evenement.setAnnulePar(annulePar);
evenement.setNomAnnulateur(nomAnnulateur);
// Test des getters
assertThat(evenement.getTitre()).isEqualTo(titre);
assertThat(evenement.getDescription()).isEqualTo(description);
assertThat(evenement.getTypeEvenement()).isEqualTo(typeEvenement);
assertThat(evenement.getStatut()).isEqualTo(statut);
assertThat(evenement.getPriorite()).isEqualTo(priorite);
assertThat(evenement.getDateDebut()).isEqualTo(dateDebut);
assertThat(evenement.getDateFin()).isEqualTo(dateFin);
assertThat(evenement.getHeureDebut()).isEqualTo(heureDebut);
assertThat(evenement.getHeureFin()).isEqualTo(heureFin);
assertThat(evenement.getLieu()).isEqualTo(lieu);
assertThat(evenement.getAdresse()).isEqualTo(adresse);
assertThat(evenement.getVille()).isEqualTo(ville);
assertThat(evenement.getRegion()).isEqualTo(region);
assertThat(evenement.getLatitude()).isEqualTo(latitude);
assertThat(evenement.getLongitude()).isEqualTo(longitude);
assertThat(evenement.getAssociationId()).isEqualTo(associationId);
assertThat(evenement.getNomAssociation()).isEqualTo(nomAssociation);
assertThat(evenement.getOrganisateur()).isEqualTo(organisateur);
assertThat(evenement.getEmailOrganisateur()).isEqualTo(emailOrganisateur);
assertThat(evenement.getTelephoneOrganisateur()).isEqualTo(telephoneOrganisateur);
assertThat(evenement.getCapaciteMax()).isEqualTo(capaciteMax);
assertThat(evenement.getParticipantsInscrits()).isEqualTo(participantsInscrits);
assertThat(evenement.getParticipantsPresents()).isEqualTo(participantsPresents);
assertThat(evenement.getBudget()).isEqualTo(budget);
assertThat(evenement.getCoutReel()).isEqualTo(coutReel);
assertThat(evenement.getCodeDevise()).isEqualTo(codeDevise);
assertThat(evenement.getInscriptionObligatoire()).isEqualTo(inscriptionObligatoire);
assertThat(evenement.getDateLimiteInscription()).isEqualTo(dateLimiteInscription);
assertThat(evenement.getEvenementPublic()).isEqualTo(evenementPublic);
assertThat(evenement.getRecurrent()).isEqualTo(recurrent);
assertThat(evenement.getFrequenceRecurrence()).isEqualTo(frequenceRecurrence);
assertThat(evenement.getInstructions()).isEqualTo(instructions);
assertThat(evenement.getMaterielNecessaire()).isEqualTo(materielNecessaire);
assertThat(evenement.getConditionsMeteo()).isEqualTo(conditionsMeteo);
assertThat(evenement.getImageUrl()).isEqualTo(imageUrl);
assertThat(evenement.getCouleurTheme()).isEqualTo(couleurTheme);
assertThat(evenement.getDateAnnulation()).isEqualTo(dateAnnulation);
assertThat(evenement.getRaisonAnnulation()).isEqualTo(raisonAnnulation);
assertThat(evenement.getAnnulePar()).isEqualTo(annulePar);
assertThat(evenement.getNomAnnulateur()).isEqualTo(nomAnnulateur);
}
}
@Nested
@DisplayName("Tests Méthodes Métier")
class MethodesMetierTests {
@Test
@DisplayName("Test méthodes de statut")
void testMethodesStatut() {
// Test isEnCours
evenement.setStatut("EN_COURS");
assertThat(evenement.isEnCours()).isTrue();
evenement.setStatut("PLANIFIE");
assertThat(evenement.isEnCours()).isFalse();
// Test isTermine
evenement.setStatut("TERMINE");
assertThat(evenement.isTermine()).isTrue();
evenement.setStatut("PLANIFIE");
assertThat(evenement.isTermine()).isFalse();
// Test isAnnule
evenement.setStatut("ANNULE");
assertThat(evenement.isAnnule()).isTrue();
evenement.setStatut("PLANIFIE");
assertThat(evenement.isAnnule()).isFalse();
}
@Test
@DisplayName("Test méthodes de capacité")
void testMethodesCapacite() {
// Test isComplet - cas avec capaciteMax null
evenement.setCapaciteMax(null);
evenement.setParticipantsInscrits(50);
assertThat(evenement.isComplet()).isFalse();
// Test isComplet - cas avec participantsInscrits null (capaciteMax définie)
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(null);
assertThat(evenement.isComplet()).isFalse();
// Test isComplet - cas avec les deux null
evenement.setCapaciteMax(null);
evenement.setParticipantsInscrits(null);
assertThat(evenement.isComplet()).isFalse();
// Test isComplet - cas normal complet
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(50);
assertThat(evenement.isComplet()).isTrue();
// Test isComplet - cas normal non complet
evenement.setParticipantsInscrits(30);
assertThat(evenement.isComplet()).isFalse();
// Test getPlacesDisponibles
assertThat(evenement.getPlacesDisponibles()).isEqualTo(20);
evenement.setCapaciteMax(null);
assertThat(evenement.getPlacesDisponibles()).isEqualTo(0);
// Test getTauxRemplissage
evenement.setCapaciteMax(100);
evenement.setParticipantsInscrits(75);
assertThat(evenement.getTauxRemplissage()).isEqualTo(75);
evenement.setCapaciteMax(0);
assertThat(evenement.getTauxRemplissage()).isEqualTo(0);
}
@Test
@DisplayName("Test isComplet - branches spécifiques")
void testIsCompletBranchesSpecifiques() {
// Test spécifique pour la branche: capaciteMax != null && participantsInscrits == null
// Nous devons nous assurer que capaciteMax est définie ET que participantsInscrits est null
evenement.setCapaciteMax(100); // Défini explicitement
evenement.setParticipantsInscrits(null); // Null explicitement
// Cette condition devrait évaluer:
// capaciteMax != null (true) && participantsInscrits != null (false) && ...
// Donc retourner false à cause du court-circuit sur participantsInscrits != null
assertThat(evenement.isComplet()).isFalse();
// Test pour vérifier que la branche participantsInscrits != null est bien testée
// Maintenant avec participantsInscrits défini
evenement.setParticipantsInscrits(50); // Défini mais < capaciteMax
assertThat(evenement.isComplet()).isFalse();
// Et maintenant avec participantsInscrits >= capaciteMax
evenement.setParticipantsInscrits(100); // Égal à capaciteMax
assertThat(evenement.isComplet()).isTrue();
}
@Test
@DisplayName("Test getTauxPresence")
void testGetTauxPresence() {
evenement.setParticipantsInscrits(100);
evenement.setParticipantsPresents(80);
assertThat(evenement.getTauxPresence()).isEqualTo(80);
evenement.setParticipantsInscrits(0);
assertThat(evenement.getTauxPresence()).isEqualTo(0);
evenement.setParticipantsInscrits(null);
assertThat(evenement.getTauxPresence()).isEqualTo(0);
}
@Test
@DisplayName("Test isInscriptionsOuvertes")
void testIsInscriptionsOuvertes() {
// Événement normal avec places disponibles
evenement.setStatut("PLANIFIE");
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(30);
assertThat(evenement.isInscriptionsOuvertes()).isTrue();
// Événement annulé
evenement.setStatut("ANNULE");
assertThat(evenement.isInscriptionsOuvertes()).isFalse();
// Événement terminé
evenement.setStatut("TERMINE");
assertThat(evenement.isInscriptionsOuvertes()).isFalse();
// Événement complet
evenement.setStatut("PLANIFIE");
evenement.setParticipantsInscrits(50);
assertThat(evenement.isInscriptionsOuvertes()).isFalse();
// Date limite dépassée
evenement.setParticipantsInscrits(30);
evenement.setDateLimiteInscription(LocalDate.now().minusDays(1));
assertThat(evenement.isInscriptionsOuvertes()).isFalse();
}
@Test
@DisplayName("Test getDureeEnHeures")
void testGetDureeEnHeures() {
evenement.setHeureDebut(LocalTime.of(9, 0));
evenement.setHeureFin(LocalTime.of(17, 0));
assertThat(evenement.getDureeEnHeures()).isEqualTo(8);
evenement.setHeureDebut(null);
assertThat(evenement.getDureeEnHeures()).isEqualTo(0);
}
@Test
@DisplayName("Test isEvenementMultiJours")
void testIsEvenementMultiJours() {
LocalDate dateDebut = LocalDate.now();
evenement.setDateDebut(dateDebut);
evenement.setDateFin(dateDebut.plusDays(2));
assertThat(evenement.isEvenementMultiJours()).isTrue();
evenement.setDateFin(dateDebut);
assertThat(evenement.isEvenementMultiJours()).isFalse();
evenement.setDateFin(null);
assertThat(evenement.isEvenementMultiJours()).isFalse();
}
@Test
@DisplayName("Test getTypeEvenementLibelle")
void testGetTypeEvenementLibelle() {
evenement.setTypeEvenement("ASSEMBLEE_GENERALE");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Assemblée Générale");
evenement.setTypeEvenement("FORMATION");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Formation");
evenement.setTypeEvenement("ACTIVITE_SOCIALE");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Activité Sociale");
evenement.setTypeEvenement("ACTION_CARITATIVE");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Action Caritative");
evenement.setTypeEvenement("REUNION_BUREAU");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Réunion de Bureau");
evenement.setTypeEvenement("CONFERENCE");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Conférence");
evenement.setTypeEvenement("ATELIER");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Atelier");
evenement.setTypeEvenement("CEREMONIE");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Cérémonie");
evenement.setTypeEvenement("AUTRE");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Autre");
evenement.setTypeEvenement("INCONNU");
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("INCONNU");
evenement.setTypeEvenement(null);
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Non défini");
}
@Test
@DisplayName("Test getStatutLibelle")
void testGetStatutLibelle() {
evenement.setStatut("PLANIFIE");
assertThat(evenement.getStatutLibelle()).isEqualTo("Planifié");
evenement.setStatut("EN_COURS");
assertThat(evenement.getStatutLibelle()).isEqualTo("En cours");
evenement.setStatut("TERMINE");
assertThat(evenement.getStatutLibelle()).isEqualTo("Terminé");
evenement.setStatut("ANNULE");
assertThat(evenement.getStatutLibelle()).isEqualTo("Annulé");
evenement.setStatut("REPORTE");
assertThat(evenement.getStatutLibelle()).isEqualTo("Reporté");
evenement.setStatut("INCONNU");
assertThat(evenement.getStatutLibelle()).isEqualTo("INCONNU");
evenement.setStatut(null);
assertThat(evenement.getStatutLibelle()).isEqualTo("Non défini");
}
@Test
@DisplayName("Test getPrioriteLibelle")
void testGetPrioriteLibelle() {
evenement.setPriorite("BASSE");
assertThat(evenement.getPrioriteLibelle()).isEqualTo("Basse");
evenement.setPriorite("NORMALE");
assertThat(evenement.getPrioriteLibelle()).isEqualTo("Normale");
evenement.setPriorite("HAUTE");
assertThat(evenement.getPrioriteLibelle()).isEqualTo("Haute");
evenement.setPriorite("CRITIQUE");
assertThat(evenement.getPrioriteLibelle()).isEqualTo("Critique");
evenement.setPriorite("INCONNU");
assertThat(evenement.getPrioriteLibelle()).isEqualTo("INCONNU");
evenement.setPriorite(null);
assertThat(evenement.getPrioriteLibelle()).isEqualTo("Normale");
}
@Test
@DisplayName("Test getAdresseComplete")
void testGetAdresseComplete() {
// Adresse complète
evenement.setLieu("Centre de conférence");
evenement.setAdresse("123 Avenue de la République");
evenement.setVille("Dakar");
evenement.setRegion("Dakar");
assertThat(evenement.getAdresseComplete())
.isEqualTo("Centre de conférence, 123 Avenue de la République, Dakar, Dakar");
// Adresse partielle
evenement.setAdresse(null);
evenement.setRegion(null);
assertThat(evenement.getAdresseComplete()).isEqualTo("Centre de conférence, Dakar");
// Lieu seulement
evenement.setVille(null);
assertThat(evenement.getAdresseComplete()).isEqualTo("Centre de conférence");
// Aucune information
evenement.setLieu(null);
assertThat(evenement.getAdresseComplete()).isEmpty();
}
@Test
@DisplayName("Test hasCoordonnees")
void testHasCoordonnees() {
evenement.setLatitude(new BigDecimal("14.6937"));
evenement.setLongitude(new BigDecimal("-17.4441"));
assertThat(evenement.hasCoordonnees()).isTrue();
evenement.setLatitude(null);
assertThat(evenement.hasCoordonnees()).isFalse();
evenement.setLatitude(new BigDecimal("14.6937"));
evenement.setLongitude(null);
assertThat(evenement.hasCoordonnees()).isFalse();
}
@Test
@DisplayName("Test méthodes budgétaires")
void testMethodesBudgetaires() {
// Test getEcartBudgetaire - économie
evenement.setBudget(new BigDecimal("500000.00"));
evenement.setCoutReel(new BigDecimal("450000.00"));
assertThat(evenement.getEcartBudgetaire()).isEqualTo(new BigDecimal("50000.00"));
assertThat(evenement.isBudgetDepasse()).isFalse();
// Test getEcartBudgetaire - dépassement
evenement.setCoutReel(new BigDecimal("550000.00"));
assertThat(evenement.getEcartBudgetaire()).isEqualTo(new BigDecimal("-50000.00"));
assertThat(evenement.isBudgetDepasse()).isTrue();
// Test avec valeurs nulles
evenement.setBudget(null);
assertThat(evenement.getEcartBudgetaire()).isEqualTo(BigDecimal.ZERO);
assertThat(evenement.isBudgetDepasse()).isFalse();
evenement.setBudget(new BigDecimal("500000.00"));
evenement.setCoutReel(null);
assertThat(evenement.getEcartBudgetaire()).isEqualTo(BigDecimal.ZERO);
assertThat(evenement.isBudgetDepasse()).isFalse();
}
}
@Test
@DisplayName("Test toString")
void testToString() {
evenement.setTitre("Événement test");
evenement.setTypeEvenement("FORMATION");
evenement.setStatut("PLANIFIE");
evenement.setDateDebut(LocalDate.now());
evenement.setLieu("Salle de test");
evenement.setParticipantsInscrits(10);
evenement.setCapaciteMax(50);
String result = evenement.toString();
assertThat(result).isNotNull();
assertThat(result).contains("EvenementDTO");
assertThat(result).contains("titre='Événement test'");
assertThat(result).contains("typeEvenement='FORMATION'");
assertThat(result).contains("statut='PLANIFIE'");
assertThat(result).contains("lieu='Salle de test'");
assertThat(result).contains("participantsInscrits=10");
assertThat(result).contains("capaciteMax=50");
}
@Test
@DisplayName("Test branches supplémentaires getPlacesDisponibles")
void testBranchesSupplementairesPlacesDisponibles() {
// Test avec capaciteMax null
evenement.setCapaciteMax(null);
evenement.setParticipantsInscrits(10);
assertThat(evenement.getPlacesDisponibles()).isEqualTo(0);
// Test avec participantsInscrits null
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(null);
assertThat(evenement.getPlacesDisponibles()).isEqualTo(0);
// Test avec les deux null
evenement.setCapaciteMax(null);
evenement.setParticipantsInscrits(null);
assertThat(evenement.getPlacesDisponibles()).isEqualTo(0);
}
@Test
@DisplayName("Test branches supplémentaires getTauxRemplissage")
void testBranchesSupplementairesTauxRemplissage() {
// Test avec capaciteMax null
evenement.setCapaciteMax(null);
evenement.setParticipantsInscrits(10);
assertThat(evenement.getTauxRemplissage()).isEqualTo(0);
// Test avec capaciteMax zéro
evenement.setCapaciteMax(0);
evenement.setParticipantsInscrits(10);
assertThat(evenement.getTauxRemplissage()).isEqualTo(0);
// Test avec participantsInscrits null
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(null);
assertThat(evenement.getTauxRemplissage()).isEqualTo(0);
}
@Test
@DisplayName("Test branches supplémentaires getTauxPresence")
void testBranchesSupplementairesTauxPresence() {
// Test avec participantsInscrits null
evenement.setParticipantsInscrits(null);
evenement.setParticipantsPresents(5);
assertThat(evenement.getTauxPresence()).isEqualTo(0);
// Test avec participantsInscrits zéro
evenement.setParticipantsInscrits(0);
evenement.setParticipantsPresents(5);
assertThat(evenement.getTauxPresence()).isEqualTo(0);
// Test avec participantsPresents null
evenement.setParticipantsInscrits(10);
evenement.setParticipantsPresents(null);
assertThat(evenement.getTauxPresence()).isEqualTo(0);
}
@Test
@DisplayName("Test branches supplémentaires isInscriptionsOuvertes")
void testBranchesSupplementairesInscriptionsOuvertes() {
// Test avec événement annulé
evenement.setStatut("ANNULE");
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(10);
evenement.setDateLimiteInscription(LocalDate.now().plusDays(5));
assertThat(evenement.isInscriptionsOuvertes()).isFalse();
// Test avec événement terminé
evenement.setStatut("TERMINE");
assertThat(evenement.isInscriptionsOuvertes()).isFalse();
// Test avec date limite dépassée
evenement.setStatut("PLANIFIE");
evenement.setDateLimiteInscription(LocalDate.now().minusDays(1));
assertThat(evenement.isInscriptionsOuvertes()).isFalse();
// Test avec événement complet
evenement.setDateLimiteInscription(LocalDate.now().plusDays(5));
evenement.setCapaciteMax(10);
evenement.setParticipantsInscrits(10);
assertThat(evenement.isInscriptionsOuvertes()).isFalse();
}
@Test
@DisplayName("Test branches supplémentaires getDureeEnHeures")
void testBranchesSupplementairesDureeEnHeures() {
// Test avec heureDebut null
evenement.setHeureDebut(null);
evenement.setHeureFin(LocalTime.of(17, 0));
assertThat(evenement.getDureeEnHeures()).isEqualTo(0);
// Test avec heureFin null
evenement.setHeureDebut(LocalTime.of(9, 0));
evenement.setHeureFin(null);
assertThat(evenement.getDureeEnHeures()).isEqualTo(0);
// Test avec les deux null
evenement.setHeureDebut(null);
evenement.setHeureFin(null);
assertThat(evenement.getDureeEnHeures()).isEqualTo(0);
}
@Test
@DisplayName("Test branches supplémentaires getAdresseComplete")
void testBranchesSupplementairesAdresseComplete() {
// Test avec adresse seulement (sans lieu)
evenement.setLieu(null);
evenement.setAdresse("123 Avenue Test");
evenement.setVille(null);
evenement.setRegion(null);
assertThat(evenement.getAdresseComplete()).isEqualTo("123 Avenue Test");
// Test avec ville seulement (sans lieu ni adresse)
evenement.setLieu(null);
evenement.setAdresse(null);
evenement.setVille("Dakar");
evenement.setRegion(null);
assertThat(evenement.getAdresseComplete()).isEqualTo("Dakar");
// Test avec région seulement
evenement.setLieu(null);
evenement.setAdresse(null);
evenement.setVille(null);
evenement.setRegion("Dakar");
assertThat(evenement.getAdresseComplete()).isEqualTo("Dakar");
// Test avec adresse et ville (sans lieu)
evenement.setLieu(null);
evenement.setAdresse("123 Avenue Test");
evenement.setVille("Dakar");
evenement.setRegion(null);
assertThat(evenement.getAdresseComplete()).isEqualTo("123 Avenue Test, Dakar");
}
}

144
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/evenement/EvenementDTOSimpleTest.java Normal file
View File

@@ -0,0 +1,144 @@
package dev.lions.unionflow.server.api.dto.evenement;
import static org.assertj.core.api.Assertions.assertThat;
import dev.lions.unionflow.server.api.enums.evenement.PrioriteEvenement;
import dev.lions.unionflow.server.api.enums.evenement.StatutEvenement;
import dev.lions.unionflow.server.api.enums.evenement.TypeEvenementMetier;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalTime;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires simples pour EvenementDTO
*
* @author UnionFlow Team
* @version 2.0
* @since 2025-01-16
*/
@DisplayName("Tests EvenementDTO")
class EvenementDTOSimpleTest {
private EvenementDTO evenement;
@BeforeEach
void setUp() {
evenement = new EvenementDTO();
}
@Test
@DisplayName("Test création et getters/setters de base")
void testCreationEtGettersSetters() {
// Données de test
String titre = "Formation Leadership";
String description = "Formation sur les techniques de leadership";
TypeEvenementMetier typeEvenement = TypeEvenementMetier.FORMATION;
StatutEvenement statut = StatutEvenement.PLANIFIE;
PrioriteEvenement priorite = PrioriteEvenement.NORMALE;
LocalDate dateDebut = LocalDate.now().plusDays(30);
LocalDate dateFin = LocalDate.now().plusDays(30);
LocalTime heureDebut = LocalTime.of(9, 0);
LocalTime heureFin = LocalTime.of(17, 0);
String lieu = "Centre de Formation";
Integer capaciteMax = 50;
BigDecimal budget = new BigDecimal("500000");
// Test des setters
evenement.setTitre(titre);
evenement.setDescription(description);
evenement.setTypeEvenement(typeEvenement);
evenement.setStatut(statut);
evenement.setPriorite(priorite);
evenement.setDateDebut(dateDebut);
evenement.setDateFin(dateFin);
evenement.setHeureDebut(heureDebut);
evenement.setHeureFin(heureFin);
evenement.setLieu(lieu);
evenement.setCapaciteMax(capaciteMax);
evenement.setBudget(budget);
// Test des getters
assertThat(evenement.getTitre()).isEqualTo(titre);
assertThat(evenement.getDescription()).isEqualTo(description);
assertThat(evenement.getTypeEvenement()).isEqualTo(typeEvenement);
assertThat(evenement.getStatut()).isEqualTo(statut);
assertThat(evenement.getPriorite()).isEqualTo(priorite);
assertThat(evenement.getDateDebut()).isEqualTo(dateDebut);
assertThat(evenement.getDateFin()).isEqualTo(dateFin);
assertThat(evenement.getHeureDebut()).isEqualTo(heureDebut);
assertThat(evenement.getHeureFin()).isEqualTo(heureFin);
assertThat(evenement.getLieu()).isEqualTo(lieu);
assertThat(evenement.getCapaciteMax()).isEqualTo(capaciteMax);
assertThat(evenement.getBudget()).isEqualTo(budget);
}
@Test
@DisplayName("Test constructeur avec paramètres")
void testConstructeurAvecParametres() {
String titre = "Assemblée Générale";
TypeEvenementMetier type = TypeEvenementMetier.ASSEMBLEE_GENERALE;
LocalDate date = LocalDate.now().plusDays(15);
String lieu = "Salle de conférence";
EvenementDTO newEvenement = new EvenementDTO(titre, type, date, lieu);
assertThat(newEvenement.getTitre()).isEqualTo(titre);
assertThat(newEvenement.getTypeEvenement()).isEqualTo(type);
assertThat(newEvenement.getDateDebut()).isEqualTo(date);
assertThat(newEvenement.getLieu()).isEqualTo(lieu);
assertThat(newEvenement.getStatut()).isEqualTo(StatutEvenement.PLANIFIE);
}
@Test
@DisplayName("Test méthodes utilitaires existantes")
void testMethodesUtilitaires() {
// Test des méthodes qui existent réellement
evenement.setStatut(StatutEvenement.EN_COURS);
assertThat(evenement.estEnCours()).isTrue();
evenement.setStatut(StatutEvenement.TERMINE);
assertThat(evenement.estTermine()).isTrue();
evenement.setStatut(StatutEvenement.ANNULE);
assertThat(evenement.estAnnule()).isTrue();
// Test capacité
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(25);
assertThat(evenement.estComplet()).isFalse();
assertThat(evenement.getPlacesDisponibles()).isEqualTo(25);
assertThat(evenement.getTauxRemplissage()).isEqualTo(50);
}
@Test
@DisplayName("Test validation des énumérations")
void testValidationEnumerations() {
// Test que toutes les énumérations sont bien supportées
for (TypeEvenementMetier type : TypeEvenementMetier.values()) {
evenement.setTypeEvenement(type);
assertThat(evenement.getTypeEvenement()).isEqualTo(type);
}
for (StatutEvenement statut : StatutEvenement.values()) {
evenement.setStatut(statut);
assertThat(evenement.getStatut()).isEqualTo(statut);
}
for (PrioriteEvenement priorite : PrioriteEvenement.values()) {
evenement.setPriorite(priorite);
assertThat(evenement.getPriorite()).isEqualTo(priorite);
}
}
@Test
@DisplayName("Test héritage BaseDTO")
void testHeritageBaseDTO() {
assertThat(evenement.getId()).isNotNull();
assertThat(evenement.getDateCreation()).isNotNull();
assertThat(evenement.isActif()).isTrue();
assertThat(evenement.getVersion()).isEqualTo(0L);
}
}

270
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/evenement/EvenementDTOTest.java Normal file
View File

@@ -0,0 +1,270 @@
package dev.lions.unionflow.server.api.dto.evenement;
import static org.assertj.core.api.Assertions.assertThat;
import dev.lions.unionflow.server.api.enums.evenement.PrioriteEvenement;
import dev.lions.unionflow.server.api.enums.evenement.StatutEvenement;
import dev.lions.unionflow.server.api.enums.evenement.TypeEvenementMetier;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires pour EvenementDTO
*
* @author UnionFlow Team
* @version 2.0
* @since 2025-01-16
*/
@DisplayName("Tests EvenementDTO")
class EvenementDTOTest {
private EvenementDTO evenement;
@BeforeEach
void setUp() {
evenement = new EvenementDTO();
evenement.setTitre("Formation Leadership");
evenement.setStatut(StatutEvenement.PLANIFIE);
evenement.setPriorite(PrioriteEvenement.NORMALE);
evenement.setTypeEvenement(TypeEvenementMetier.FORMATION);
evenement.setDateDebut(LocalDate.now().plusDays(30));
evenement.setDateFin(LocalDate.now().plusDays(30));
evenement.setHeureDebut(LocalTime.of(9, 0));
evenement.setHeureFin(LocalTime.of(17, 0));
evenement.setLieu("Centre de Formation");
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(25);
evenement.setBudget(new BigDecimal("500000"));
evenement.setCoutReel(new BigDecimal("450000"));
evenement.setCodeDevise("XOF");
evenement.setAssociationId(UUID.randomUUID());
}
@Nested
@DisplayName("Tests de Construction")
class ConstructionTests {
@Test
@DisplayName("Test constructeur par défaut")
void testConstructeurParDefaut() {
EvenementDTO newEvenement = new EvenementDTO();
assertThat(newEvenement.getId()).isNotNull();
assertThat(newEvenement.getDateCreation()).isNotNull();
assertThat(newEvenement.isActif()).isTrue();
assertThat(newEvenement.getVersion()).isEqualTo(0L);
assertThat(newEvenement.getStatut()).isEqualTo(StatutEvenement.PLANIFIE);
assertThat(newEvenement.getPriorite()).isEqualTo(PrioriteEvenement.NORMALE);
assertThat(newEvenement.getParticipantsInscrits()).isEqualTo(0);
assertThat(newEvenement.getParticipantsPresents()).isEqualTo(0);
assertThat(newEvenement.getCodeDevise()).isEqualTo("XOF");
}
@Test
@DisplayName("Test constructeur avec paramètres")
void testConstructeurAvecParametres() {
String titre = "Assemblée Générale";
TypeEvenementMetier type = TypeEvenementMetier.ASSEMBLEE_GENERALE;
LocalDate date = LocalDate.now().plusDays(15);
EvenementDTO newEvenement = new EvenementDTO(titre, type, date, "Lieu par défaut");
assertThat(newEvenement.getTitre()).isEqualTo(titre);
assertThat(newEvenement.getTypeEvenement()).isEqualTo(type);
assertThat(newEvenement.getDateDebut()).isEqualTo(date);
assertThat(newEvenement.getStatut()).isEqualTo(StatutEvenement.PLANIFIE);
}
}
@Nested
@DisplayName("Tests des Méthodes Métier")
class MethodesMetierTests {
@Test
@DisplayName("Test estEnCours")
void testEstEnCours() {
evenement.setStatut(StatutEvenement.EN_COURS);
assertThat(evenement.estEnCours()).isTrue();
evenement.setStatut(StatutEvenement.PLANIFIE);
assertThat(evenement.estEnCours()).isFalse();
}
@Test
@DisplayName("Test estTermine")
void testEstTermine() {
evenement.setStatut(StatutEvenement.TERMINE);
assertThat(evenement.estTermine()).isTrue();
evenement.setStatut(StatutEvenement.EN_COURS);
assertThat(evenement.estTermine()).isFalse();
}
@Test
@DisplayName("Test estAnnule")
void testEstAnnule() {
evenement.setStatut(StatutEvenement.ANNULE);
assertThat(evenement.estAnnule()).isTrue();
evenement.setStatut(StatutEvenement.PLANIFIE);
assertThat(evenement.estAnnule()).isFalse();
}
@Test
@DisplayName("Test estComplet")
void testEstComplet() {
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(50);
assertThat(evenement.estComplet()).isTrue();
evenement.setParticipantsInscrits(49);
assertThat(evenement.estComplet()).isFalse();
evenement.setCapaciteMax(null);
assertThat(evenement.estComplet()).isFalse();
}
@Test
@DisplayName("Test getPlacesDisponibles")
void testGetPlacesDisponibles() {
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(25);
assertThat(evenement.getPlacesDisponibles()).isEqualTo(25);
evenement.setParticipantsInscrits(60); // Plus que la capacité
assertThat(evenement.getPlacesDisponibles()).isEqualTo(0);
evenement.setCapaciteMax(null);
assertThat(evenement.getPlacesDisponibles()).isEqualTo(0);
}
@Test
@DisplayName("Test getTauxRemplissage")
void testGetTauxRemplissage() {
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(25);
assertThat(evenement.getTauxRemplissage()).isEqualTo(50);
evenement.setParticipantsInscrits(50);
assertThat(evenement.getTauxRemplissage()).isEqualTo(100);
evenement.setCapaciteMax(0);
assertThat(evenement.getTauxRemplissage()).isEqualTo(0);
evenement.setCapaciteMax(null);
assertThat(evenement.getTauxRemplissage()).isEqualTo(0);
}
@Test
@DisplayName("Test sontInscriptionsOuvertes")
void testSontInscriptionsOuvertes() {
// Événement normal avec places disponibles
evenement.setStatut(StatutEvenement.PLANIFIE);
evenement.setCapaciteMax(50);
evenement.setParticipantsInscrits(25);
evenement.setDateLimiteInscription(LocalDate.now().plusDays(5));
assertThat(evenement.sontInscriptionsOuvertes()).isTrue();
// Événement annulé
evenement.setStatut(StatutEvenement.ANNULE);
assertThat(evenement.sontInscriptionsOuvertes()).isFalse();
// Événement terminé
evenement.setStatut(StatutEvenement.TERMINE);
assertThat(evenement.sontInscriptionsOuvertes()).isFalse();
// Événement complet
evenement.setStatut(StatutEvenement.PLANIFIE);
evenement.setParticipantsInscrits(50);
assertThat(evenement.sontInscriptionsOuvertes()).isFalse();
// Date limite dépassée
evenement.setParticipantsInscrits(25);
evenement.setDateLimiteInscription(LocalDate.now().minusDays(1));
assertThat(evenement.sontInscriptionsOuvertes()).isFalse();
}
@Test
@DisplayName("Test estEvenementMultiJours")
void testEstEvenementMultiJours() {
evenement.setDateDebut(LocalDate.now().plusDays(1));
evenement.setDateFin(LocalDate.now().plusDays(3));
assertThat(evenement.estEvenementMultiJours()).isTrue();
evenement.setDateFin(LocalDate.now().plusDays(1));
assertThat(evenement.estEvenementMultiJours()).isFalse();
evenement.setDateFin(null);
assertThat(evenement.estEvenementMultiJours()).isFalse();
}
@Test
@DisplayName("Test estBudgetDepasse")
void testEstBudgetDepasse() {
evenement.setBudget(new BigDecimal("500000"));
evenement.setCoutReel(new BigDecimal("600000"));
assertThat(evenement.estBudgetDepasse()).isTrue();
evenement.setCoutReel(new BigDecimal("400000"));
assertThat(evenement.estBudgetDepasse()).isFalse();
evenement.setCoutReel(new BigDecimal("500000"));
assertThat(evenement.estBudgetDepasse()).isFalse();
}
}
@Nested
@DisplayName("Tests des Méthodes Utilitaires")
class MethodesUtilitairesTests {
@Test
@DisplayName("Test getStatutLibelle")
void testGetStatutLibelle() {
evenement.setStatut(StatutEvenement.PLANIFIE);
assertThat(evenement.getStatutLibelle()).isEqualTo("Planifié");
evenement.setStatut(null);
assertThat(evenement.getStatutLibelle()).isEqualTo("Non défini");
}
@Test
@DisplayName("Test getPrioriteLibelle")
void testGetPrioriteLibelle() {
evenement.setPriorite(PrioriteEvenement.HAUTE);
assertThat(evenement.getPrioriteLibelle()).isEqualTo("Haute");
evenement.setPriorite(null);
assertThat(evenement.getPrioriteLibelle()).isEqualTo("Normale");
}
@Test
@DisplayName("Test getTypeEvenementLibelle")
void testGetTypeEvenementLibelle() {
evenement.setTypeEvenement(TypeEvenementMetier.FORMATION);
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Formation");
evenement.setTypeEvenement(null);
assertThat(evenement.getTypeEvenementLibelle()).isEqualTo("Non défini");
}
@Test
@DisplayName("Test getEcartBudgetaire")
void testGetEcartBudgetaire() {
evenement.setBudget(new BigDecimal("500000"));
evenement.setCoutReel(new BigDecimal("450000"));
assertThat(evenement.getEcartBudgetaire()).isEqualTo(new BigDecimal("50000"));
evenement.setCoutReel(new BigDecimal("550000"));
assertThat(evenement.getEcartBudgetaire()).isEqualTo(new BigDecimal("-50000"));
evenement.setBudget(null);
assertThat(evenement.getEcartBudgetaire()).isEqualTo(BigDecimal.ZERO);
}
}
}

11
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/finance/CotisationDTOBasicTest.java
View File

@@ -121,8 +121,6 @@ class CotisationDTOBasicTest {
assertThat(cotisation.getDatePaiement()).isNotNull();
}
@Test
@DisplayName("Test méthodes métier avancées")
void testMethodesMetierAvancees() {
@@ -276,7 +274,8 @@ class CotisationDTOBasicTest {
BigDecimal montantDu = new BigDecimal("25000.00");
LocalDate dateEcheance = LocalDate.of(2025, 1, 31);
CotisationDTO newCotisation = new CotisationDTO(membreId, typeCotisation, montantDu, dateEcheance);
CotisationDTO newCotisation =
new CotisationDTO(membreId, typeCotisation, montantDu, dateEcheance);
assertThat(newCotisation.getMembreId()).isEqualTo(membreId);
assertThat(newCotisation.getTypeCotisation()).isEqualTo(typeCotisation);
@@ -284,7 +283,8 @@ class CotisationDTOBasicTest {
assertThat(newCotisation.getDateEcheance()).isEqualTo(dateEcheance);
assertThat(newCotisation.getNumeroReference()).isNotNull();
assertThat(newCotisation.getNumeroReference()).startsWith("COT-");
assertThat(newCotisation.getNumeroReference()).contains(String.valueOf(LocalDate.now().getYear()));
assertThat(newCotisation.getNumeroReference())
.contains(String.valueOf(LocalDate.now().getYear()));
// Vérifier que les valeurs par défaut sont toujours appliquées
assertThat(newCotisation.getMontantPaye()).isEqualByComparingTo(BigDecimal.ZERO);
assertThat(newCotisation.getCodeDevise()).isEqualTo("XOF");
@@ -474,7 +474,8 @@ class CotisationDTOBasicTest {
cotisation.setDatePaiement(datePaiementExistante);
cotisation.mettreAJourStatut();
assertThat(cotisation.getStatut()).isEqualTo("PAYEE");
assertThat(cotisation.getDatePaiement()).isEqualTo(datePaiementExistante); // Ne doit pas changer
assertThat(cotisation.getDatePaiement())
.isEqualTo(datePaiementExistante); // Ne doit pas changer
// Test avec paiement partiel
cotisation.setMontantDu(BigDecimal.valueOf(1000));

9
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/formuleabonnement/FormuleAbonnementDTOBasicTest.java
View File

@@ -300,7 +300,8 @@ class FormuleAbonnementDTOBasicTest {
formule.setPrixAnnuel(new BigDecimal("100000.00"));
BigDecimal economieAttendue = new BigDecimal("20000.00"); // 12*10000 - 100000
assertThat(formule.getEconomieAnnuelle()).isEqualTo(economieAttendue);
assertThat(formule.getPourcentageEconomieAnnuelle()).isEqualTo(17); // 20000/120000 * 100 = 16.67 arrondi à 17
assertThat(formule.getPourcentageEconomieAnnuelle())
.isEqualTo(17); // 20000/120000 * 100 = 16.67 arrondi à 17
// Cas sans économie
formule.setPrixMensuel(new BigDecimal("10000.00"));
@@ -422,9 +423,9 @@ class FormuleAbonnementDTOBasicTest {
assertThat(formule.getScoreFonctionnalites()).isEqualTo(100);
// Test cas intermédiaire : seulement quelques fonctionnalités
formule.setSupportTechnique(true); // +10
formule.setSupportTechnique(true); // +10
formule.setSauvegardeAutomatique(false);
formule.setFonctionnalitesAvancees(true); // +15
formule.setFonctionnalitesAvancees(true); // +15
formule.setApiAccess(false);
formule.setRapportsPersonnalises(false);
formule.setIntegrationsTierces(false);
@@ -447,7 +448,7 @@ class FormuleAbonnementDTOBasicTest {
assertThat(formule.getScoreFonctionnalites()).isEqualTo(0);
// Test avec un seul élément activé pour vérifier la division
formule.setSupportTechnique(true); // score = 10, total = 100
formule.setSupportTechnique(true); // score = 10, total = 100
formule.setSauvegardeAutomatique(false);
formule.setFonctionnalitesAvancees(false);
formule.setApiAccess(false);

442
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/membre/MembreDTOBasicTest.java
View File

@@ -1,442 +0,0 @@
package dev.lions.unionflow.server.api.dto.membre;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.LocalDate;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires complets pour MembreDTO.
*
* @author UnionFlow Team
* @version 1.0
* @since 2025-01-10
*/
@DisplayName("Tests MembreDTO")
class MembreDTOBasicTest {
private MembreDTO membre;
@BeforeEach
void setUp() {
membre = new MembreDTO();
}
@Test
@DisplayName("Constructeur par défaut - Initialisation correcte")
void testConstructeurParDefaut() {
MembreDTO newMembre = new MembreDTO();
assertThat(newMembre.getId()).isNotNull();
assertThat(newMembre.getDateCreation()).isNotNull();
assertThat(newMembre.isActif()).isTrue();
assertThat(newMembre.getVersion()).isEqualTo(0L);
}
@Test
@DisplayName("Test getters/setters principaux")
void testGettersSettersPrincipaux() {
// Données de test
String numeroMembre = "M001";
String prenom = "Jean";
String nom = "Dupont";
String email = "jean.dupont@example.com";
String telephone = "+221701234567";
LocalDate dateNaissance = LocalDate.of(1980, 5, 15);
String adresse = "123 Rue de la Paix";
String ville = "Dakar";
String profession = "Ingénieur";
LocalDate dateAdhesion = LocalDate.now().minusYears(2);
String statut = "ACTIF";
Long associationId = 123L;
String associationNom = "Lions Club Dakar";
String region = "Dakar";
String quartier = "Plateau";
String role = "Membre";
Boolean membreBureau = true;
Boolean responsable = false;
String photoUrl = "https://example.com/photo.jpg";
// Test des setters
membre.setNumeroMembre(numeroMembre);
membre.setPrenom(prenom);
membre.setNom(nom);
membre.setEmail(email);
membre.setTelephone(telephone);
membre.setDateNaissance(dateNaissance);
membre.setAdresse(adresse);
membre.setVille(ville);
membre.setProfession(profession);
membre.setDateAdhesion(dateAdhesion);
membre.setStatut(statut);
membre.setAssociationId(associationId);
membre.setAssociationNom(associationNom);
membre.setRegion(region);
membre.setQuartier(quartier);
membre.setRole(role);
membre.setMembreBureau(membreBureau);
membre.setResponsable(responsable);
membre.setPhotoUrl(photoUrl);
// Test des getters
assertThat(membre.getNumeroMembre()).isEqualTo(numeroMembre);
assertThat(membre.getPrenom()).isEqualTo(prenom);
assertThat(membre.getNom()).isEqualTo(nom);
assertThat(membre.getEmail()).isEqualTo(email);
assertThat(membre.getTelephone()).isEqualTo(telephone);
assertThat(membre.getDateNaissance()).isEqualTo(dateNaissance);
assertThat(membre.getAdresse()).isEqualTo(adresse);
assertThat(membre.getVille()).isEqualTo(ville);
assertThat(membre.getProfession()).isEqualTo(profession);
assertThat(membre.getDateAdhesion()).isEqualTo(dateAdhesion);
assertThat(membre.getStatut()).isEqualTo(statut);
assertThat(membre.getAssociationId()).isEqualTo(associationId);
assertThat(membre.getAssociationNom()).isEqualTo(associationNom);
assertThat(membre.getRegion()).isEqualTo(region);
assertThat(membre.getQuartier()).isEqualTo(quartier);
assertThat(membre.getRole()).isEqualTo(role);
assertThat(membre.getMembreBureau()).isEqualTo(membreBureau);
assertThat(membre.getResponsable()).isEqualTo(responsable);
assertThat(membre.getPhotoUrl()).isEqualTo(photoUrl);
}
@Test
@DisplayName("Test méthodes métier")
void testMethodesMetier() {
// Test getNomComplet
membre.setPrenom("Jean");
membre.setNom("Dupont");
assertThat(membre.getNomComplet()).isEqualTo("Jean Dupont");
// Test avec prenom null
membre.setPrenom(null);
assertThat(membre.getNomComplet()).isEqualTo("Dupont");
// Test avec nom null
membre.setPrenom("Jean");
membre.setNom(null);
assertThat(membre.getNomComplet()).isEqualTo("Jean");
// Test getAge
membre.setDateNaissance(LocalDate.now().minusYears(30));
int age = membre.getAge();
assertThat(age).isEqualTo(30);
// Test avec date null
membre.setDateNaissance(null);
assertThat(membre.getAge()).isEqualTo(-1);
// Test isMajeur
membre.setDateNaissance(LocalDate.now().minusYears(25));
assertThat(membre.isMajeur()).isTrue();
membre.setDateNaissance(LocalDate.now().minusYears(15));
assertThat(membre.isMajeur()).isFalse();
membre.setDateNaissance(null);
assertThat(membre.isMajeur()).isFalse();
// Test isActif
membre.setStatut("ACTIF");
assertThat(membre.isActif()).isTrue();
membre.setStatut("INACTIF");
assertThat(membre.isActif()).isFalse();
// Test hasRoleDirection
membre.setMembreBureau(true);
membre.setResponsable(false);
assertThat(membre.hasRoleDirection()).isTrue();
membre.setMembreBureau(false);
membre.setResponsable(true);
assertThat(membre.hasRoleDirection()).isTrue();
membre.setMembreBureau(false);
membre.setResponsable(false);
assertThat(membre.hasRoleDirection()).isFalse();
// Test getStatutLibelle
membre.setStatut("ACTIF");
assertThat(membre.getStatutLibelle()).isEqualTo("Actif");
membre.setStatut("INACTIF");
assertThat(membre.getStatutLibelle()).isEqualTo("Inactif");
membre.setStatut("SUSPENDU");
assertThat(membre.getStatutLibelle()).isEqualTo("Suspendu");
membre.setStatut("RADIE");
assertThat(membre.getStatutLibelle()).isEqualTo("Radié");
membre.setStatut(null);
assertThat(membre.getStatutLibelle()).isEqualTo("Non défini");
// Test isDataValid - cas valide (selon l'implémentation réelle)
membre.setNumeroMembre("UF-2025-12345678");
membre.setNom("Dupont");
membre.setPrenom("Jean");
membre.setEmail("jean.dupont@example.com");
// Vérifier d'abord si la méthode existe et ce qu'elle teste réellement
boolean isValid = membre.isDataValid();
assertThat(isValid).isNotNull(); // Au moins vérifier qu'elle ne plante pas
// Test isDataValid - numéro membre null
membre.setNumeroMembre(null);
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - numéro membre vide
membre.setNumeroMembre("");
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - numéro membre avec espaces
membre.setNumeroMembre(" ");
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - nom null
membre.setNumeroMembre("UF-2025-12345678");
membre.setNom(null);
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - nom vide
membre.setNom("");
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - nom avec espaces
membre.setNom(" ");
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - prénom null
membre.setNom("Dupont");
membre.setPrenom(null);
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - prénom vide
membre.setPrenom("");
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - prénom avec espaces
membre.setPrenom(" ");
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - email null
membre.setPrenom("Jean");
membre.setEmail(null);
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - email vide
membre.setEmail("");
assertThat(membre.isDataValid()).isFalse();
// Test isDataValid - email avec espaces
membre.setEmail(" ");
assertThat(membre.isDataValid()).isFalse();
}
@Test
@DisplayName("Test constructeur avec paramètres")
void testConstructeurAvecParametres() {
String numeroMembre = "UF-2025-001";
String nom = "Dupont";
String prenom = "Jean";
String email = "jean.dupont@example.com";
MembreDTO nouveauMembre = new MembreDTO(numeroMembre, nom, prenom, email);
assertThat(nouveauMembre.getNumeroMembre()).isEqualTo(numeroMembre);
assertThat(nouveauMembre.getNom()).isEqualTo(nom);
assertThat(nouveauMembre.getPrenom()).isEqualTo(prenom);
assertThat(nouveauMembre.getEmail()).isEqualTo(email);
// Vérifier les valeurs par défaut
assertThat(nouveauMembre.getStatut()).isEqualTo("ACTIF");
assertThat(nouveauMembre.getDateAdhesion()).isEqualTo(LocalDate.now());
assertThat(nouveauMembre.getMembreBureau()).isFalse();
assertThat(nouveauMembre.getResponsable()).isFalse();
}
@Test
@DisplayName("Test tous les statuts")
void testTousLesStatuts() {
// Test tous les statuts possibles (selon le switch dans la classe)
membre.setStatut("EXCLU");
assertThat(membre.getStatutLibelle()).isEqualTo("EXCLU"); // Valeur par défaut car non dans le switch
membre.setStatut("DEMISSIONNAIRE");
assertThat(membre.getStatutLibelle()).isEqualTo("DEMISSIONNAIRE"); // Valeur par défaut car non dans le switch
membre.setStatut("STATUT_INCONNU");
assertThat(membre.getStatutLibelle()).isEqualTo("STATUT_INCONNU");
}
@Test
@DisplayName("Test getNomComplet cas limites")
void testGetNomCompletCasLimites() {
// Test avec les deux null - retourne chaîne vide selon l'implémentation
membre.setPrenom(null);
membre.setNom(null);
assertThat(membre.getNomComplet()).isEqualTo("");
// Test avec prénom vide - l'implémentation concatène quand même
membre.setPrenom("");
membre.setNom("Dupont");
assertThat(membre.getNomComplet()).isEqualTo(" Dupont");
// Test avec nom vide - l'implémentation concatène quand même
membre.setPrenom("Jean");
membre.setNom("");
assertThat(membre.getNomComplet()).isEqualTo("Jean ");
}
@Test
@DisplayName("Test hasRoleDirection cas limites")
void testHasRoleDirectionCasLimites() {
// Test avec null
membre.setMembreBureau(null);
membre.setResponsable(null);
assertThat(membre.hasRoleDirection()).isFalse();
// Test avec Boolean.FALSE explicite
membre.setMembreBureau(Boolean.FALSE);
membre.setResponsable(Boolean.FALSE);
assertThat(membre.hasRoleDirection()).isFalse();
// Test avec Boolean.TRUE explicite
membre.setMembreBureau(Boolean.TRUE);
membre.setResponsable(Boolean.FALSE);
assertThat(membre.hasRoleDirection()).isTrue();
membre.setMembreBureau(Boolean.FALSE);
membre.setResponsable(Boolean.TRUE);
assertThat(membre.hasRoleDirection()).isTrue();
}
@Test
@DisplayName("Test toString complet")
void testToStringComplet() {
membre.setNumeroMembre("UF-2025-001");
membre.setPrenom("Jean");
membre.setNom("Dupont");
membre.setEmail("jean.dupont@example.com");
membre.setStatut("ACTIF");
membre.setAssociationId(123L);
String result = membre.toString();
assertThat(result).isNotNull();
assertThat(result).contains("MembreDTO");
assertThat(result).contains("numeroMembre='UF-2025-001'");
assertThat(result).contains("nom='Dupont'");
assertThat(result).contains("prenom='Jean'");
assertThat(result).contains("email='jean.dupont@example.com'");
assertThat(result).contains("statut='ACTIF'");
assertThat(result).contains("associationId=123");
}
@Test
@DisplayName("Test propriétés supplémentaires")
void testProprietesSupplementaires() {
// Test des propriétés qui pourraient ne pas être couvertes
String statutMatrimonial = "MARIE";
String nationalite = "Sénégalaise";
String numeroIdentite = "1234567890123";
String typeIdentite = "CNI";
LocalDate dateAdhesion = LocalDate.of(2020, 1, 15);
membre.setStatutMatrimonial(statutMatrimonial);
membre.setNationalite(nationalite);
membre.setNumeroIdentite(numeroIdentite);
membre.setTypeIdentite(typeIdentite);
membre.setDateAdhesion(dateAdhesion);
assertThat(membre.getStatutMatrimonial()).isEqualTo(statutMatrimonial);
assertThat(membre.getNationalite()).isEqualTo(nationalite);
assertThat(membre.getNumeroIdentite()).isEqualTo(numeroIdentite);
assertThat(membre.getTypeIdentite()).isEqualTo(typeIdentite);
assertThat(membre.getDateAdhesion()).isEqualTo(dateAdhesion);
}
@Test
@DisplayName("Test branches supplémentaires isDataValid")
void testBranchesSupplementairesIsDataValid() {
// Test avec tous les champs valides
membre.setNumeroMembre("UF-2025-001");
membre.setNom("Dupont");
membre.setPrenom("Jean");
membre.setStatut("ACTIF");
membre.setAssociationId(123L);
assertThat(membre.isDataValid()).isTrue();
// Test avec numéro membre avec espaces seulement
membre.setNumeroMembre(" ");
assertThat(membre.isDataValid()).isFalse();
// Test avec nom avec espaces seulement
membre.setNumeroMembre("UF-2025-001");
membre.setNom(" ");
assertThat(membre.isDataValid()).isFalse();
// Test avec prénom avec espaces seulement
membre.setNom("Dupont");
membre.setPrenom(" ");
assertThat(membre.isDataValid()).isFalse();
// Test avec statut avec espaces seulement
membre.setPrenom("Jean");
membre.setStatut(" ");
assertThat(membre.isDataValid()).isFalse();
// Test avec statut null
membre.setStatut(null);
assertThat(membre.isDataValid()).isFalse();
// Test avec associationId null
membre.setStatut("ACTIF");
membre.setAssociationId(null);
assertThat(membre.isDataValid()).isFalse();
}
@Test
@DisplayName("Test branches supplémentaires isMajeur")
void testBranchesSupplementairesIsMajeur() {
// Test avec date exactement 18 ans
LocalDate dateExactement18Ans = LocalDate.now().minusYears(18);
membre.setDateNaissance(dateExactement18Ans);
assertThat(membre.isMajeur()).isTrue();
// Test avec date plus de 18 ans
LocalDate datePlus18Ans = LocalDate.now().minusYears(25);
membre.setDateNaissance(datePlus18Ans);
assertThat(membre.isMajeur()).isTrue();
// Test avec date moins de 18 ans
LocalDate dateMoins18Ans = LocalDate.now().minusYears(15);
membre.setDateNaissance(dateMoins18Ans);
assertThat(membre.isMajeur()).isFalse();
}
@Test
@DisplayName("Test branches supplémentaires hasRoleDirection")
void testBranchesSupplementairesHasRoleDirection() {
// Test avec membreBureau true et responsable false
membre.setMembreBureau(Boolean.TRUE);
membre.setResponsable(Boolean.FALSE);
assertThat(membre.hasRoleDirection()).isTrue();
// Test avec membreBureau false et responsable true
membre.setMembreBureau(Boolean.FALSE);
membre.setResponsable(Boolean.TRUE);
assertThat(membre.hasRoleDirection()).isTrue();
// Test avec les deux false
membre.setMembreBureau(Boolean.FALSE);
membre.setResponsable(Boolean.FALSE);
assertThat(membre.hasRoleDirection()).isFalse();
// Test avec les deux null
membre.setMembreBureau(null);
membre.setResponsable(null);
assertThat(membre.hasRoleDirection()).isFalse();
}
}

611
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/organisation/OrganisationDTOBasicTest.java
View File

@@ -1,611 +0,0 @@
package dev.lions.unionflow.server.api.dto.organisation;
import static org.assertj.core.api.Assertions.assertThat;
import dev.lions.unionflow.server.api.enums.organisation.StatutOrganisation;
import dev.lions.unionflow.server.api.enums.organisation.TypeOrganisation;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires complets pour OrganisationDTO.
*
* @author UnionFlow Team
* @version 1.0
* @since 2025-01-10
*/
@DisplayName("Tests OrganisationDTO")
class OrganisationDTOBasicTest {
private OrganisationDTO organisation;
@BeforeEach
void setUp() {
organisation = new OrganisationDTO();
}
@Nested
@DisplayName("Tests de Construction")
class ConstructionTests {
@Test
@DisplayName("Constructeur par défaut - Initialisation correcte")
void testConstructeurParDefaut() {
OrganisationDTO newOrganisation = new OrganisationDTO();
assertThat(newOrganisation.getId()).isNotNull();
assertThat(newOrganisation.getDateCreation()).isNotNull();
assertThat(newOrganisation.isActif()).isTrue();
assertThat(newOrganisation.getVersion()).isEqualTo(0L);
assertThat(newOrganisation.getStatut()).isEqualTo(StatutOrganisation.ACTIVE);
assertThat(newOrganisation.getNombreMembres()).isEqualTo(0);
assertThat(newOrganisation.getNombreAdministrateurs()).isEqualTo(0);
assertThat(newOrganisation.getBudgetAnnuel()).isNull();
}
@Test
@DisplayName("Constructeur avec paramètres - Initialisation correcte")
void testConstructeurAvecParametres() {
String nom = "Lions Club Dakar";
TypeOrganisation type = TypeOrganisation.LIONS_CLUB;
OrganisationDTO newOrganisation = new OrganisationDTO(nom, type);
assertThat(newOrganisation.getNom()).isEqualTo(nom);
assertThat(newOrganisation.getTypeOrganisation()).isEqualTo(type);
assertThat(newOrganisation.getStatut()).isEqualTo(StatutOrganisation.ACTIVE);
}
}
@Nested
@DisplayName("Tests Getters/Setters")
class GettersSettersTests {
@Test
@DisplayName("Test tous les getters/setters - Partie 1")
void testTousLesGettersSettersPart1() {
// Données de test
String nom = "Lions Club Dakar";
String nomCourt = "LCD";
TypeOrganisation typeOrganisation = TypeOrganisation.LIONS_CLUB;
StatutOrganisation statut = StatutOrganisation.ACTIVE;
String numeroEnregistrement = "REG-2025-001";
LocalDate dateFondation = LocalDate.of(2020, 1, 15);
String description = "Club service Lions de Dakar";
String adresse = "123 Avenue Bourguiba";
String ville = "Dakar";
String region = "Dakar";
String pays = "Sénégal";
String codePostal = "10000";
String telephone = "+221338234567";
String email = "contact@lionsclubdakar.sn";
String siteWeb = "https://lionsclubdakar.sn";
// Test des setters
organisation.setNom(nom);
organisation.setNomCourt(nomCourt);
organisation.setTypeOrganisation(typeOrganisation);
organisation.setStatut(statut);
organisation.setNumeroEnregistrement(numeroEnregistrement);
organisation.setDateFondation(dateFondation);
organisation.setDescription(description);
organisation.setAdresse(adresse);
organisation.setVille(ville);
organisation.setRegion(region);
organisation.setPays(pays);
organisation.setCodePostal(codePostal);
organisation.setTelephone(telephone);
organisation.setEmail(email);
organisation.setSiteWeb(siteWeb);
// Test des getters
assertThat(organisation.getNom()).isEqualTo(nom);
assertThat(organisation.getNomCourt()).isEqualTo(nomCourt);
assertThat(organisation.getTypeOrganisation()).isEqualTo(typeOrganisation);
assertThat(organisation.getStatut()).isEqualTo(statut);
assertThat(organisation.getNumeroEnregistrement()).isEqualTo(numeroEnregistrement);
assertThat(organisation.getDateFondation()).isEqualTo(dateFondation);
assertThat(organisation.getDescription()).isEqualTo(description);
assertThat(organisation.getAdresse()).isEqualTo(adresse);
assertThat(organisation.getVille()).isEqualTo(ville);
assertThat(organisation.getRegion()).isEqualTo(region);
assertThat(organisation.getPays()).isEqualTo(pays);
assertThat(organisation.getCodePostal()).isEqualTo(codePostal);
assertThat(organisation.getTelephone()).isEqualTo(telephone);
assertThat(organisation.getEmail()).isEqualTo(email);
assertThat(organisation.getSiteWeb()).isEqualTo(siteWeb);
}
@Test
@DisplayName("Test getters/setters - Géolocalisation et hiérarchie")
void testGettersSettersGeolocalisationHierarchie() {
// Données de test
BigDecimal latitude = new BigDecimal("14.6937");
BigDecimal longitude = new BigDecimal("-17.4441");
UUID organisationParenteId = UUID.randomUUID();
String nomOrganisationParente = "Lions District 403";
Integer niveauHierarchique = 2;
Integer nombreMembres = 50;
Integer nombreAdministrateurs = 5;
BigDecimal budgetAnnuel = new BigDecimal("5000000.00");
String devise = "XOF";
// Test des setters
organisation.setLatitude(latitude);
organisation.setLongitude(longitude);
organisation.setOrganisationParenteId(organisationParenteId);
organisation.setNomOrganisationParente(nomOrganisationParente);
organisation.setNiveauHierarchique(niveauHierarchique);
organisation.setNombreMembres(nombreMembres);
organisation.setNombreAdministrateurs(nombreAdministrateurs);
organisation.setBudgetAnnuel(budgetAnnuel);
organisation.setDevise(devise);
// Test des getters
assertThat(organisation.getLatitude()).isEqualTo(latitude);
assertThat(organisation.getLongitude()).isEqualTo(longitude);
assertThat(organisation.getOrganisationParenteId()).isEqualTo(organisationParenteId);
assertThat(organisation.getNomOrganisationParente()).isEqualTo(nomOrganisationParente);
assertThat(organisation.getNiveauHierarchique()).isEqualTo(niveauHierarchique);
assertThat(organisation.getNombreMembres()).isEqualTo(nombreMembres);
assertThat(organisation.getNombreAdministrateurs()).isEqualTo(nombreAdministrateurs);
assertThat(organisation.getBudgetAnnuel()).isEqualTo(budgetAnnuel);
assertThat(organisation.getDevise()).isEqualTo(devise);
}
@Test
@DisplayName("Test getters/setters - Informations complémentaires")
void testGettersSettersInformationsComplementaires() {
// Données de test
String objectifs = "Servir la communauté";
String activitesPrincipales = "Actions sociales, environnement";
String reseauxSociaux = "{\"facebook\":\"@lionsclub\"}";
String certifications = "ISO 9001";
String partenaires = "UNICEF, Croix-Rouge";
String notes = "Notes administratives";
Boolean organisationPublique = true;
Boolean accepteNouveauxMembres = true;
Boolean cotisationObligatoire = true;
BigDecimal montantCotisationAnnuelle = new BigDecimal("50000.00");
// Test des setters
organisation.setObjectifs(objectifs);
organisation.setActivitesPrincipales(activitesPrincipales);
organisation.setReseauxSociaux(reseauxSociaux);
organisation.setCertifications(certifications);
organisation.setPartenaires(partenaires);
organisation.setNotes(notes);
organisation.setOrganisationPublique(organisationPublique);
organisation.setAccepteNouveauxMembres(accepteNouveauxMembres);
organisation.setCotisationObligatoire(cotisationObligatoire);
organisation.setMontantCotisationAnnuelle(montantCotisationAnnuelle);
// Test des getters
assertThat(organisation.getObjectifs()).isEqualTo(objectifs);
assertThat(organisation.getActivitesPrincipales()).isEqualTo(activitesPrincipales);
assertThat(organisation.getReseauxSociaux()).isEqualTo(reseauxSociaux);
assertThat(organisation.getCertifications()).isEqualTo(certifications);
assertThat(organisation.getPartenaires()).isEqualTo(partenaires);
assertThat(organisation.getNotes()).isEqualTo(notes);
assertThat(organisation.getOrganisationPublique()).isEqualTo(organisationPublique);
assertThat(organisation.getAccepteNouveauxMembres()).isEqualTo(accepteNouveauxMembres);
assertThat(organisation.getCotisationObligatoire()).isEqualTo(cotisationObligatoire);
assertThat(organisation.getMontantCotisationAnnuelle()).isEqualTo(montantCotisationAnnuelle);
}
@Test
@DisplayName("Test tous les getters/setters - Partie 2")
void testTousLesGettersSettersPart2() {
// Données de test
UUID organisationParenteId = UUID.randomUUID();
String nomOrganisationParente = "Lions District 403";
Integer nombreMembres = 45;
Integer nombreAdministrateurs = 7;
BigDecimal budgetAnnuel = new BigDecimal("5000000.00");
String devise = "XOF";
BigDecimal latitude = new BigDecimal("14.6937");
BigDecimal longitude = new BigDecimal("-17.4441");
String telephoneSecondaire = "+221338765432";
String emailSecondaire = "info@lionsclubdakar.sn";
String logo = "logo_lions_dakar.png";
Integer niveauHierarchique = 2;
// Test des setters
organisation.setOrganisationParenteId(organisationParenteId);
organisation.setNomOrganisationParente(nomOrganisationParente);
organisation.setNombreMembres(nombreMembres);
organisation.setNombreAdministrateurs(nombreAdministrateurs);
organisation.setBudgetAnnuel(budgetAnnuel);
organisation.setDevise(devise);
organisation.setLatitude(latitude);
organisation.setLongitude(longitude);
organisation.setTelephoneSecondaire(telephoneSecondaire);
organisation.setEmailSecondaire(emailSecondaire);
organisation.setLogo(logo);
organisation.setNiveauHierarchique(niveauHierarchique);
// Test des getters
assertThat(organisation.getOrganisationParenteId()).isEqualTo(organisationParenteId);
assertThat(organisation.getNomOrganisationParente()).isEqualTo(nomOrganisationParente);
assertThat(organisation.getNombreMembres()).isEqualTo(nombreMembres);
assertThat(organisation.getNombreAdministrateurs()).isEqualTo(nombreAdministrateurs);
assertThat(organisation.getBudgetAnnuel()).isEqualTo(budgetAnnuel);
assertThat(organisation.getDevise()).isEqualTo(devise);
assertThat(organisation.getLatitude()).isEqualTo(latitude);
assertThat(organisation.getLongitude()).isEqualTo(longitude);
assertThat(organisation.getTelephoneSecondaire()).isEqualTo(telephoneSecondaire);
assertThat(organisation.getEmailSecondaire()).isEqualTo(emailSecondaire);
assertThat(organisation.getLogo()).isEqualTo(logo);
assertThat(organisation.getNiveauHierarchique()).isEqualTo(niveauHierarchique);
}
}
@Nested
@DisplayName("Tests des méthodes métier")
class MethodesMetierTests {
@Test
@DisplayName("Test méthodes de statut")
void testMethodesStatut() {
// Test isActive
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.isActive()).isTrue();
organisation.setStatut(StatutOrganisation.INACTIVE);
assertThat(organisation.isActive()).isFalse();
// Test isInactive
organisation.setStatut(StatutOrganisation.INACTIVE);
assertThat(organisation.isInactive()).isTrue();
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.isInactive()).isFalse();
// Test isSuspendue
organisation.setStatut(StatutOrganisation.SUSPENDUE);
assertThat(organisation.isSuspendue()).isTrue();
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.isSuspendue()).isFalse();
// Test isEnCreation
organisation.setStatut(StatutOrganisation.EN_CREATION);
assertThat(organisation.isEnCreation()).isTrue();
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.isEnCreation()).isFalse();
// Test isDissoute
organisation.setStatut(StatutOrganisation.DISSOUTE);
assertThat(organisation.isDissoute()).isTrue();
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.isDissoute()).isFalse();
}
@Test
@DisplayName("Test calculs d'ancienneté")
void testCalculsAnciennete() {
// Cas sans date de fondation
organisation.setDateFondation(null);
assertThat(organisation.getAncienneteAnnees()).isEqualTo(0);
assertThat(organisation.getAncienneteMois()).isEqualTo(0);
// Cas avec date de fondation il y a 5 ans
LocalDate dateFondation = LocalDate.now().minusYears(5).minusMonths(3);
organisation.setDateFondation(dateFondation);
assertThat(organisation.getAncienneteAnnees()).isEqualTo(5);
assertThat(organisation.getAncienneteMois()).isEqualTo(63); // 5*12 + 3
// Cas avec date de fondation récente (moins d'un an)
dateFondation = LocalDate.now().minusMonths(8);
organisation.setDateFondation(dateFondation);
assertThat(organisation.getAncienneteAnnees()).isEqualTo(0);
assertThat(organisation.getAncienneteMois()).isEqualTo(8);
}
@Test
@DisplayName("Test hasGeolocalisation")
void testHasGeolocalisation() {
// Cas sans géolocalisation
organisation.setLatitude(null);
organisation.setLongitude(null);
assertThat(organisation.hasGeolocalisation()).isFalse();
// Cas avec latitude seulement
organisation.setLatitude(new BigDecimal("14.6937"));
organisation.setLongitude(null);
assertThat(organisation.hasGeolocalisation()).isFalse();
// Cas avec longitude seulement
organisation.setLatitude(null);
organisation.setLongitude(new BigDecimal("-17.4441"));
assertThat(organisation.hasGeolocalisation()).isFalse();
// Cas avec géolocalisation complète
organisation.setLatitude(new BigDecimal("14.6937"));
organisation.setLongitude(new BigDecimal("-17.4441"));
assertThat(organisation.hasGeolocalisation()).isTrue();
}
@Test
@DisplayName("Test hiérarchie")
void testHierarchie() {
// Test isOrganisationRacine
organisation.setOrganisationParenteId(null);
assertThat(organisation.isOrganisationRacine()).isTrue();
organisation.setOrganisationParenteId(UUID.randomUUID());
assertThat(organisation.isOrganisationRacine()).isFalse();
// Test hasSousOrganisations
organisation.setNiveauHierarchique(null);
assertThat(organisation.hasSousOrganisations()).isFalse();
organisation.setNiveauHierarchique(0);
assertThat(organisation.hasSousOrganisations()).isFalse();
organisation.setNiveauHierarchique(1);
assertThat(organisation.hasSousOrganisations()).isTrue();
organisation.setNiveauHierarchique(3);
assertThat(organisation.hasSousOrganisations()).isTrue();
}
@Test
@DisplayName("Test getNomAffichage")
void testGetNomAffichage() {
String nomComplet = "Lions Club Dakar Plateau";
String nomCourt = "LCD Plateau";
// Cas avec nom court
organisation.setNom(nomComplet);
organisation.setNomCourt(nomCourt);
assertThat(organisation.getNomAffichage()).isEqualTo(nomCourt);
// Cas avec nom court vide
organisation.setNomCourt("");
assertThat(organisation.getNomAffichage()).isEqualTo(nomComplet);
// Cas avec nom court null
organisation.setNomCourt(null);
assertThat(organisation.getNomAffichage()).isEqualTo(nomComplet);
// Cas avec nom court contenant seulement des espaces
organisation.setNomCourt(" ");
assertThat(organisation.getNomAffichage()).isEqualTo(nomComplet);
}
@Test
@DisplayName("Test getAdresseComplete")
void testGetAdresseComplete() {
// Cas avec adresse complète
organisation.setAdresse("123 Avenue Bourguiba");
organisation.setVille("Dakar");
organisation.setCodePostal("10000");
organisation.setRegion("Dakar");
organisation.setPays("Sénégal");
String adresseComplete = organisation.getAdresseComplete();
assertThat(adresseComplete).contains("123 Avenue Bourguiba");
assertThat(adresseComplete).contains("Dakar");
assertThat(adresseComplete).contains("10000");
assertThat(adresseComplete).contains("Sénégal");
// Cas avec adresse partielle
organisation.setAdresse("123 Avenue Bourguiba");
organisation.setVille("Dakar");
organisation.setCodePostal(null);
organisation.setRegion(null);
organisation.setPays(null);
adresseComplete = organisation.getAdresseComplete();
assertThat(adresseComplete).isEqualTo("123 Avenue Bourguiba, Dakar");
// Cas avec adresse vide
organisation.setAdresse(null);
organisation.setVille(null);
organisation.setCodePostal(null);
organisation.setRegion(null);
organisation.setPays(null);
adresseComplete = organisation.getAdresseComplete();
assertThat(adresseComplete).isEmpty();
}
@Test
@DisplayName("Test getRatioAdministrateurs")
void testGetRatioAdministrateurs() {
// Cas sans membres
organisation.setNombreMembres(null);
organisation.setNombreAdministrateurs(5);
assertThat(organisation.getRatioAdministrateurs()).isEqualTo(0.0);
organisation.setNombreMembres(0);
organisation.setNombreAdministrateurs(5);
assertThat(organisation.getRatioAdministrateurs()).isEqualTo(0.0);
// Cas sans administrateurs
organisation.setNombreMembres(100);
organisation.setNombreAdministrateurs(null);
assertThat(organisation.getRatioAdministrateurs()).isEqualTo(0.0);
// Cas normal
organisation.setNombreMembres(100);
organisation.setNombreAdministrateurs(10);
assertThat(organisation.getRatioAdministrateurs()).isEqualTo(10.0);
organisation.setNombreMembres(50);
organisation.setNombreAdministrateurs(5);
assertThat(organisation.getRatioAdministrateurs()).isEqualTo(10.0);
}
@Test
@DisplayName("Test hasBudget")
void testHasBudget() {
// Cas sans budget
organisation.setBudgetAnnuel(null);
assertThat(organisation.hasBudget()).isFalse();
// Cas avec budget zéro
organisation.setBudgetAnnuel(BigDecimal.ZERO);
assertThat(organisation.hasBudget()).isFalse();
// Cas avec budget négatif
organisation.setBudgetAnnuel(new BigDecimal("-1000.00"));
assertThat(organisation.hasBudget()).isFalse();
// Cas avec budget positif
organisation.setBudgetAnnuel(new BigDecimal("5000000.00"));
assertThat(organisation.hasBudget()).isTrue();
}
@Test
@DisplayName("Test méthodes d'action")
void testMethodesAction() {
String utilisateur = "admin";
// Test activer
organisation.setStatut(StatutOrganisation.INACTIVE);
organisation.activer(utilisateur);
assertThat(organisation.getStatut()).isEqualTo(StatutOrganisation.ACTIVE);
// Test suspendre
organisation.setStatut(StatutOrganisation.ACTIVE);
organisation.suspendre(utilisateur);
assertThat(organisation.getStatut()).isEqualTo(StatutOrganisation.SUSPENDUE);
// Test dissoudre
organisation.setStatut(StatutOrganisation.ACTIVE);
organisation.setAccepteNouveauxMembres(true);
organisation.dissoudre(utilisateur);
assertThat(organisation.getStatut()).isEqualTo(StatutOrganisation.DISSOUTE);
assertThat(organisation.getAccepteNouveauxMembres()).isFalse();
}
@Test
@DisplayName("Test gestion des membres")
void testGestionMembres() {
String utilisateur = "admin";
// Test mettreAJourNombreMembres
organisation.mettreAJourNombreMembres(50, utilisateur);
assertThat(organisation.getNombreMembres()).isEqualTo(50);
// Test ajouterMembre
organisation.setNombreMembres(null);
organisation.ajouterMembre(utilisateur);
assertThat(organisation.getNombreMembres()).isEqualTo(1);
organisation.ajouterMembre(utilisateur);
assertThat(organisation.getNombreMembres()).isEqualTo(2);
// Test retirerMembre
organisation.setNombreMembres(5);
organisation.retirerMembre(utilisateur);
assertThat(organisation.getNombreMembres()).isEqualTo(4);
// Test retirerMembre avec 0 membres
organisation.setNombreMembres(0);
organisation.retirerMembre(utilisateur);
assertThat(organisation.getNombreMembres()).isEqualTo(0);
// Test retirerMembre avec null
organisation.setNombreMembres(null);
organisation.retirerMembre(utilisateur);
assertThat(organisation.getNombreMembres()).isNull();
}
@Test
@DisplayName("Test toString")
void testToString() {
organisation.setNom("Lions Club Dakar");
organisation.setNomCourt("LCD");
organisation.setTypeOrganisation(TypeOrganisation.LIONS_CLUB);
organisation.setStatut(StatutOrganisation.ACTIVE);
organisation.setVille("Dakar");
organisation.setPays("Sénégal");
organisation.setNombreMembres(50);
organisation.setDateFondation(LocalDate.of(2020, 1, 15));
String result = organisation.toString();
assertThat(result).isNotNull();
assertThat(result).contains("OrganisationDTO");
assertThat(result).contains("nom='Lions Club Dakar'");
assertThat(result).contains("nomCourt='LCD'");
assertThat(result).contains("typeOrganisation=LIONS_CLUB");
assertThat(result).contains("statut=ACTIVE");
assertThat(result).contains("ville='Dakar'");
assertThat(result).contains("pays='Sénégal'");
assertThat(result).contains("nombreMembres=50");
assertThat(result).contains("anciennete=" + organisation.getAncienneteAnnees() + " ans");
}
@Test
@DisplayName("Test branches supplémentaires getAdresseComplete")
void testBranchesSupplementairesAdresseComplete() {
// Test avec ville seulement (sans adresse)
organisation.setAdresse(null);
organisation.setVille("Dakar");
organisation.setCodePostal(null);
organisation.setRegion(null);
organisation.setPays(null);
assertThat(organisation.getAdresseComplete()).isEqualTo("Dakar");
// Test avec code postal seulement (sans adresse ni ville)
organisation.setAdresse(null);
organisation.setVille(null);
organisation.setCodePostal("12000");
organisation.setRegion(null);
organisation.setPays(null);
assertThat(organisation.getAdresseComplete()).isEqualTo("12000");
// Test avec région seulement
organisation.setAdresse(null);
organisation.setVille(null);
organisation.setCodePostal(null);
organisation.setRegion("Dakar");
organisation.setPays(null);
assertThat(organisation.getAdresseComplete()).isEqualTo("Dakar");
// Test avec pays seulement
organisation.setAdresse(null);
organisation.setVille(null);
organisation.setCodePostal(null);
organisation.setRegion(null);
organisation.setPays("Sénégal");
assertThat(organisation.getAdresseComplete()).isEqualTo("Sénégal");
// Test avec ville et code postal (sans adresse)
organisation.setAdresse(null);
organisation.setVille("Dakar");
organisation.setCodePostal("12000");
organisation.setRegion(null);
organisation.setPays(null);
assertThat(organisation.getAdresseComplete()).isEqualTo("Dakar 12000");
// Test avec ville et région (sans adresse)
organisation.setAdresse(null);
organisation.setVille("Dakar");
organisation.setCodePostal(null);
organisation.setRegion("Dakar");
organisation.setPays(null);
assertThat(organisation.getAdresseComplete()).isEqualTo("Dakar, Dakar");
// Test avec ville et pays (sans adresse)
organisation.setAdresse(null);
organisation.setVille("Dakar");
organisation.setCodePostal(null);
organisation.setRegion(null);
organisation.setPays("Sénégal");
assertThat(organisation.getAdresseComplete()).isEqualTo("Dakar, Sénégal");
}
}
}

96
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/organisation/OrganisationDTOSimpleTest.java Normal file
View File

@@ -0,0 +1,96 @@
package dev.lions.unionflow.server.api.dto.organisation;
import static org.assertj.core.api.Assertions.assertThat;
import dev.lions.unionflow.server.api.enums.organisation.StatutOrganisation;
import dev.lions.unionflow.server.api.enums.organisation.TypeOrganisation;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires simples pour OrganisationDTO
*
* @author UnionFlow Team
* @version 2.0
* @since 2025-01-16
*/
@DisplayName("Tests OrganisationDTO")
class OrganisationDTOSimpleTest {
private OrganisationDTO organisation;
@BeforeEach
void setUp() {
organisation = new OrganisationDTO();
}
@Test
@DisplayName("Test création et getters/setters de base")
void testCreationEtGettersSetters() {
// Données de test
String nom = "Lions Club Dakar";
String nomCourt = "LCD";
String description = "Club service de Dakar";
StatutOrganisation statut = StatutOrganisation.ACTIVE;
TypeOrganisation typeOrganisation = TypeOrganisation.LIONS_CLUB;
String adresse = "Avenue Bourguiba, Dakar";
String telephone = "+221 33 123 45 67";
String email = "contact@lionsclubdakar.sn";
// Test des setters
organisation.setNom(nom);
organisation.setNomCourt(nomCourt);
organisation.setDescription(description);
organisation.setStatut(statut);
organisation.setTypeOrganisation(typeOrganisation);
organisation.setAdresse(adresse);
organisation.setTelephone(telephone);
organisation.setEmail(email);
// Test des getters
assertThat(organisation.getNom()).isEqualTo(nom);
assertThat(organisation.getNomCourt()).isEqualTo(nomCourt);
assertThat(organisation.getDescription()).isEqualTo(description);
assertThat(organisation.getStatut()).isEqualTo(statut);
assertThat(organisation.getTypeOrganisation()).isEqualTo(typeOrganisation);
assertThat(organisation.getAdresse()).isEqualTo(adresse);
assertThat(organisation.getTelephone()).isEqualTo(telephone);
assertThat(organisation.getEmail()).isEqualTo(email);
}
@Test
@DisplayName("Test méthodes utilitaires ajoutées")
void testMethodesUtilitaires() {
organisation.setStatut(StatutOrganisation.ACTIVE);
organisation.setTypeOrganisation(TypeOrganisation.LIONS_CLUB);
// Test des méthodes getLibelle
assertThat(organisation.getStatutLibelle()).isNotNull();
assertThat(organisation.getTypeLibelle()).isNotNull();
}
@Test
@DisplayName("Test validation des énumérations")
void testValidationEnumerations() {
// Test que toutes les énumérations sont bien supportées
for (StatutOrganisation statut : StatutOrganisation.values()) {
organisation.setStatut(statut);
assertThat(organisation.getStatut()).isEqualTo(statut);
}
for (TypeOrganisation type : TypeOrganisation.values()) {
organisation.setTypeOrganisation(type);
assertThat(organisation.getTypeOrganisation()).isEqualTo(type);
}
}
@Test
@DisplayName("Test héritage BaseDTO")
void testHeritageBaseDTO() {
assertThat(organisation.getId()).isNotNull();
assertThat(organisation.getDateCreation()).isNotNull();
assertThat(organisation.isActif()).isTrue();
assertThat(organisation.getVersion()).isEqualTo(0L);
}
}

371
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/organisation/OrganisationDTOTest.java Normal file
View File

@@ -0,0 +1,371 @@
package dev.lions.unionflow.server.api.dto.organisation;
import static org.assertj.core.api.Assertions.assertThat;
import dev.lions.unionflow.server.api.enums.organisation.StatutOrganisation;
import dev.lions.unionflow.server.api.enums.organisation.TypeOrganisation;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires pour OrganisationDTO
*
* @author UnionFlow Team
* @version 2.0
* @since 2025-01-16
*/
@DisplayName("Tests OrganisationDTO")
class OrganisationDTOTest {
private OrganisationDTO organisation;
@BeforeEach
void setUp() {
organisation = new OrganisationDTO();
organisation.setNom("Lions Club Dakar");
organisation.setNomCourt("LCD");
organisation.setTypeOrganisation(TypeOrganisation.LIONS_CLUB);
organisation.setStatut(StatutOrganisation.ACTIVE);
organisation.setVille("Dakar");
organisation.setPays("Sénégal");
organisation.setDateCreation(LocalDateTime.now().minusYears(5));
organisation.setNombreMembres(150);
organisation.setNombreAdministrateurs(10);
organisation.setLatitude(new BigDecimal("14.6937"));
organisation.setLongitude(new BigDecimal("-17.4441"));
}
@Nested
@DisplayName("Tests de Construction")
class ConstructionTests {
@Test
@DisplayName("Test constructeur par défaut")
void testConstructeurParDefaut() {
OrganisationDTO newOrganisation = new OrganisationDTO();
assertThat(newOrganisation.getId()).isNotNull();
assertThat(newOrganisation.getDateCreation()).isNotNull();
assertThat(newOrganisation.isActif()).isTrue();
assertThat(newOrganisation.getVersion()).isEqualTo(0L);
assertThat(newOrganisation.getStatut()).isEqualTo(StatutOrganisation.ACTIVE);
assertThat(newOrganisation.getTypeOrganisation()).isEqualTo(TypeOrganisation.ASSOCIATION);
assertThat(newOrganisation.getDevise()).isEqualTo("XOF");
assertThat(newOrganisation.getNiveauHierarchique()).isEqualTo(0);
assertThat(newOrganisation.getNombreMembres()).isEqualTo(0);
assertThat(newOrganisation.getNombreAdministrateurs()).isEqualTo(0);
assertThat(newOrganisation.getOrganisationPublique()).isTrue();
assertThat(newOrganisation.getAccepteNouveauxMembres()).isTrue();
assertThat(newOrganisation.getCotisationObligatoire()).isFalse();
}
@Test
@DisplayName("Test constructeur avec paramètres")
void testConstructeurAvecParametres() {
String nom = "Association des Jeunes";
TypeOrganisation type = TypeOrganisation.ASSOCIATION;
OrganisationDTO newOrganisation = new OrganisationDTO(nom, type);
assertThat(newOrganisation.getNom()).isEqualTo(nom);
assertThat(newOrganisation.getTypeOrganisation()).isEqualTo(type);
assertThat(newOrganisation.getStatut()).isEqualTo(StatutOrganisation.ACTIVE);
}
}
@Nested
@DisplayName("Tests des Méthodes de Statut")
class MethodesStatutTests {
@Test
@DisplayName("Test estActive")
void testEstActive() {
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.estActive()).isTrue();
organisation.setStatut(StatutOrganisation.INACTIVE);
assertThat(organisation.estActive()).isFalse();
}
@Test
@DisplayName("Test estInactive")
void testEstInactive() {
organisation.setStatut(StatutOrganisation.INACTIVE);
assertThat(organisation.estInactive()).isTrue();
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.estInactive()).isFalse();
}
@Test
@DisplayName("Test estSuspendue")
void testEstSuspendue() {
organisation.setStatut(StatutOrganisation.SUSPENDUE);
assertThat(organisation.estSuspendue()).isTrue();
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.estSuspendue()).isFalse();
}
@Test
@DisplayName("Test estEnCreation")
void testEstEnCreation() {
organisation.setStatut(StatutOrganisation.EN_CREATION);
assertThat(organisation.estEnCreation()).isTrue();
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.estEnCreation()).isFalse();
}
@Test
@DisplayName("Test estDissoute")
void testEstDissoute() {
organisation.setStatut(StatutOrganisation.DISSOUTE);
assertThat(organisation.estDissoute()).isTrue();
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.estDissoute()).isFalse();
}
}
@Nested
@DisplayName("Tests des Méthodes Utilitaires")
class MethodesUtilitairesTests {
@Test
@DisplayName("Test getAncienneteAnnees")
void testGetAncienneteAnnees() {
organisation.setDateFondation(LocalDate.now().minusYears(5));
assertThat(organisation.getAncienneteAnnees()).isEqualTo(5);
organisation.setDateFondation(LocalDate.now().minusMonths(6));
assertThat(organisation.getAncienneteAnnees()).isEqualTo(0);
organisation.setDateCreation(null);
assertThat(organisation.getAncienneteAnnees()).isEqualTo(0);
}
@Test
@DisplayName("Test possedGeolocalisation")
void testPossedGeolocalisation() {
organisation.setLatitude(new BigDecimal("14.6937"));
organisation.setLongitude(new BigDecimal("-17.4441"));
assertThat(organisation.possedGeolocalisation()).isTrue();
organisation.setLatitude(null);
assertThat(organisation.possedGeolocalisation()).isFalse();
organisation.setLatitude(new BigDecimal("14.6937"));
organisation.setLongitude(null);
assertThat(organisation.possedGeolocalisation()).isFalse();
}
@Test
@DisplayName("Test estOrganisationRacine")
void testEstOrganisationRacine() {
organisation.setOrganisationParenteId(null);
assertThat(organisation.estOrganisationRacine()).isTrue();
organisation.setOrganisationParenteId(UUID.randomUUID());
assertThat(organisation.estOrganisationRacine()).isFalse();
}
@Test
@DisplayName("Test possedeSousOrganisations")
void testPossedeSousOrganisations() {
organisation.setNiveauHierarchique(2);
assertThat(organisation.possedeSousOrganisations()).isTrue();
organisation.setNiveauHierarchique(0);
assertThat(organisation.possedeSousOrganisations()).isFalse();
organisation.setNiveauHierarchique(null);
assertThat(organisation.possedeSousOrganisations()).isFalse();
}
@Test
@DisplayName("Test getNomAffichage")
void testGetNomAffichage() {
organisation.setNom("Lions Club Dakar");
organisation.setNomCourt("LCD");
assertThat(organisation.getNomAffichage()).isEqualTo("LCD");
organisation.setNomCourt(null);
assertThat(organisation.getNomAffichage()).isEqualTo("Lions Club Dakar");
organisation.setNomCourt("");
assertThat(organisation.getNomAffichage()).isEqualTo("Lions Club Dakar");
}
@Test
@DisplayName("Test getStatutLibelle")
void testGetStatutLibelle() {
organisation.setStatut(StatutOrganisation.ACTIVE);
assertThat(organisation.getStatutLibelle()).isEqualTo("Active");
organisation.setStatut(null);
assertThat(organisation.getStatutLibelle()).isEqualTo("Non défini");
}
@Test
@DisplayName("Test getTypeLibelle")
void testGetTypeLibelle() {
organisation.setTypeOrganisation(TypeOrganisation.LIONS_CLUB);
assertThat(organisation.getTypeLibelle()).isEqualTo("Lions Club");
organisation.setTypeOrganisation(null);
assertThat(organisation.getTypeLibelle()).isEqualTo("Non défini");
}
@Test
@DisplayName("Test getRatioAdministrateurs")
void testGetRatioAdministrateurs() {
organisation.setNombreMembres(100);
organisation.setNombreAdministrateurs(10);
assertThat(organisation.getRatioAdministrateurs()).isEqualTo(10.0);
organisation.setNombreMembres(0);
assertThat(organisation.getRatioAdministrateurs()).isEqualTo(0.0);
organisation.setNombreMembres(null);
assertThat(organisation.getRatioAdministrateurs()).isEqualTo(0.0);
organisation.setNombreMembres(100);
organisation.setNombreAdministrateurs(null);
assertThat(organisation.getRatioAdministrateurs()).isEqualTo(0.0);
}
}
@Nested
@DisplayName("Tests des Méthodes d'Action")
class MethodesActionTests {
@Test
@DisplayName("Test activer")
void testActiver() {
String utilisateur = "admin";
organisation.activer(utilisateur);
assertThat(organisation.getStatut()).isEqualTo(StatutOrganisation.ACTIVE);
assertThat(organisation.getModifiePar()).isEqualTo(utilisateur);
}
@Test
@DisplayName("Test suspendre")
void testSuspendre() {
String utilisateur = "admin";
organisation.suspendre(utilisateur);
assertThat(organisation.getStatut()).isEqualTo(StatutOrganisation.SUSPENDUE);
assertThat(organisation.getModifiePar()).isEqualTo(utilisateur);
}
@Test
@DisplayName("Test dissoudre")
void testDissoudre() {
String utilisateur = "admin";
organisation.dissoudre(utilisateur);
assertThat(organisation.getStatut()).isEqualTo(StatutOrganisation.DISSOUTE);
assertThat(organisation.getModifiePar()).isEqualTo(utilisateur);
}
@Test
@DisplayName("Test desactiver")
void testDesactiver() {
String utilisateur = "admin";
organisation.desactiver(utilisateur);
assertThat(organisation.getStatut()).isEqualTo(StatutOrganisation.INACTIVE);
assertThat(organisation.getAccepteNouveauxMembres()).isFalse();
assertThat(organisation.getModifiePar()).isEqualTo(utilisateur);
}
@Test
@DisplayName("Test ajouterMembre")
void testAjouterMembre() {
String utilisateur = "secretaire";
organisation.setNombreMembres(100);
organisation.ajouterMembre(utilisateur);
assertThat(organisation.getNombreMembres()).isEqualTo(101);
assertThat(organisation.getModifiePar()).isEqualTo(utilisateur);
}
@Test
@DisplayName("Test retirerMembre")
void testRetirerMembre() {
String utilisateur = "secretaire";
organisation.setNombreMembres(100);
organisation.retirerMembre(utilisateur);
assertThat(organisation.getNombreMembres()).isEqualTo(99);
assertThat(organisation.getModifiePar()).isEqualTo(utilisateur);
// Test avec 0 membres
organisation.setNombreMembres(0);
organisation.retirerMembre(utilisateur);
assertThat(organisation.getNombreMembres()).isEqualTo(0);
}
@Test
@DisplayName("Test ajouterAdministrateur")
void testAjouterAdministrateur() {
String utilisateur = "president";
organisation.setNombreAdministrateurs(5);
organisation.ajouterAdministrateur(utilisateur);
assertThat(organisation.getNombreAdministrateurs()).isEqualTo(6);
assertThat(organisation.getModifiePar()).isEqualTo(utilisateur);
}
@Test
@DisplayName("Test retirerAdministrateur")
void testRetirerAdministrateur() {
String utilisateur = "president";
organisation.setNombreAdministrateurs(5);
organisation.retirerAdministrateur(utilisateur);
assertThat(organisation.getNombreAdministrateurs()).isEqualTo(4);
assertThat(organisation.getModifiePar()).isEqualTo(utilisateur);
// Test avec 0 administrateurs
organisation.setNombreAdministrateurs(0);
organisation.retirerAdministrateur(utilisateur);
assertThat(organisation.getNombreAdministrateurs()).isEqualTo(0);
}
}
@Nested
@DisplayName("Tests de Validation")
class ValidationTests {
@Test
@DisplayName("Test toString")
void testToString() {
organisation.setDateFondation(LocalDate.now().minusYears(5));
String result = organisation.toString();
assertThat(result).contains("Lions Club Dakar");
assertThat(result).contains("LCD");
assertThat(result).contains("LIONS_CLUB");
assertThat(result).contains("ACTIVE");
assertThat(result).contains("Dakar");
assertThat(result).contains("Sénégal");
assertThat(result).contains("150");
assertThat(result).contains("5 ans");
}
}
}

27
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/paiement/WaveBalanceDTOBasicTest.java
View File

@@ -68,28 +68,33 @@ class WaveBalanceDTOBasicTest {
balanceAvecSoldeDisponibleNull.setSoldeDisponible(new BigDecimal("100000.00"));
balanceAvecSoldeDisponibleNull.setSoldeEnAttente(new BigDecimal("25000.00"));
// Vérifier que le total est calculé
assertThat(balanceAvecSoldeDisponibleNull.getSoldeTotal()).isEqualByComparingTo(new BigDecimal("125000.00"));
assertThat(balanceAvecSoldeDisponibleNull.getSoldeTotal())
.isEqualByComparingTo(new BigDecimal("125000.00"));
// Maintenant mettre soldeDisponible à null - le total ne devrait pas être recalculé
balanceAvecSoldeDisponibleNull.setSoldeDisponible(null);
assertThat(balanceAvecSoldeDisponibleNull.getSoldeTotal()).isEqualByComparingTo(new BigDecimal("125000.00")); // Garde l'ancienne valeur
assertThat(balanceAvecSoldeDisponibleNull.getSoldeTotal())
.isEqualByComparingTo(new BigDecimal("125000.00")); // Garde l'ancienne valeur
// Test avec soldeEnAttente null - même principe
WaveBalanceDTO balanceAvecSoldeEnAttenteNull = new WaveBalanceDTO();
balanceAvecSoldeEnAttenteNull.setSoldeDisponible(new BigDecimal("150000.00"));
balanceAvecSoldeEnAttenteNull.setSoldeEnAttente(new BigDecimal("30000.00"));
// Vérifier que le total est calculé
assertThat(balanceAvecSoldeEnAttenteNull.getSoldeTotal()).isEqualByComparingTo(new BigDecimal("180000.00"));
assertThat(balanceAvecSoldeEnAttenteNull.getSoldeTotal())
.isEqualByComparingTo(new BigDecimal("180000.00"));
// Maintenant mettre soldeEnAttente à null - le total ne devrait pas être recalculé
balanceAvecSoldeEnAttenteNull.setSoldeEnAttente(null);
assertThat(balanceAvecSoldeEnAttenteNull.getSoldeTotal()).isEqualByComparingTo(new BigDecimal("180000.00")); // Garde l'ancienne valeur
assertThat(balanceAvecSoldeEnAttenteNull.getSoldeTotal())
.isEqualByComparingTo(new BigDecimal("180000.00")); // Garde l'ancienne valeur
// Test avec les deux null dès le début
WaveBalanceDTO balanceAvecLesDeuxNull = new WaveBalanceDTO();
balanceAvecLesDeuxNull.setSoldeDisponible(null);
balanceAvecLesDeuxNull.setSoldeEnAttente(null);
assertThat(balanceAvecLesDeuxNull.getSoldeTotal()).isNull(); // Pas calculé car les deux sont null dès le début
assertThat(balanceAvecLesDeuxNull.getSoldeTotal())
.isNull(); // Pas calculé car les deux sont null dès le début
}
}
@@ -146,7 +151,8 @@ class WaveBalanceDTOBasicTest {
assertThat(balance.getDateDerniereSynchronisation()).isEqualTo(dateDerniereSynchronisation);
assertThat(balance.getStatutWallet()).isEqualTo(statutWallet);
assertThat(balance.getLimiteQuotidienne()).isEqualByComparingTo(limiteQuotidienne);
assertThat(balance.getMontantUtiliseAujourdhui()).isEqualByComparingTo(montantUtiliseAujourdhui);
assertThat(balance.getMontantUtiliseAujourdhui())
.isEqualByComparingTo(montantUtiliseAujourdhui);
assertThat(balance.getLimiteMensuelle()).isEqualByComparingTo(limiteMensuelle);
assertThat(balance.getMontantUtiliseCeMois()).isEqualByComparingTo(montantUtiliseCeMois);
assertThat(balance.getNombreTransactionsAujourdhui()).isEqualTo(nombreTransactionsAujourdhui);
@@ -239,7 +245,8 @@ class WaveBalanceDTOBasicTest {
// Limite restante = 100000 - 30000 = 70000
// Solde disponible aujourd'hui = min(200000, 70000) = 70000
assertThat(balance.getSoldeDisponibleAujourdhui()).isEqualByComparingTo(new BigDecimal("70000.00"));
assertThat(balance.getSoldeDisponibleAujourdhui())
.isEqualByComparingTo(new BigDecimal("70000.00"));
// Test sans limite
balance.setLimiteQuotidienne(null);
@@ -271,8 +278,10 @@ class WaveBalanceDTOBasicTest {
balance.mettreAJourApresTransaction(montantTransaction);
assertThat(balance.getMontantUtiliseAujourdhui()).isEqualByComparingTo(new BigDecimal("75000.00"));
assertThat(balance.getMontantUtiliseCeMois()).isEqualByComparingTo(new BigDecimal("525000.00"));
assertThat(balance.getMontantUtiliseAujourdhui())
.isEqualByComparingTo(new BigDecimal("75000.00"));
assertThat(balance.getMontantUtiliseCeMois())
.isEqualByComparingTo(new BigDecimal("525000.00"));
assertThat(balance.getNombreTransactionsAujourdhui()).isEqualTo(6);
assertThat(balance.getNombreTransactionsCeMois()).isEqualTo(46);
assertThat(balance.getDateDerniereMiseAJour()).isNotNull();

12
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/paiement/WaveCheckoutSessionDTOBasicTest.java
View File

@@ -170,7 +170,7 @@ class WaveCheckoutSessionDTOBasicTest {
@DisplayName("Test types de paiement valides")
void testTypesPaiementValides() {
String[] typesValides = {"COTISATION", "ABONNEMENT", "DON", "EVENEMENT", "FORMATION", "AUTRE"};
for (String type : typesValides) {
session.setTypePaiement(type);
assertThat(session.getTypePaiement()).isEqualTo(type);
@@ -181,7 +181,7 @@ class WaveCheckoutSessionDTOBasicTest {
@DisplayName("Test statuts de session")
void testStatutsSession() {
StatutSession[] statuts = StatutSession.values();
for (StatutSession statut : statuts) {
session.setStatut(statut);
assertThat(session.getStatut()).isEqualTo(statut);
@@ -192,7 +192,7 @@ class WaveCheckoutSessionDTOBasicTest {
@DisplayName("Test valeurs par défaut")
void testValeursParDefaut() {
WaveCheckoutSessionDTO newSession = new WaveCheckoutSessionDTO();
assertThat(newSession.getDevise()).isEqualTo("XOF");
assertThat(newSession.getStatut()).isEqualTo(StatutSession.PENDING);
assertThat(newSession.getNombreTentatives()).isEqualTo(0);
@@ -205,7 +205,7 @@ class WaveCheckoutSessionDTOBasicTest {
session.setCodeErreurWave("E001");
session.setMessageErreurWave("Paiement échoué");
session.setStatut(StatutSession.FAILED);
assertThat(session.getCodeErreurWave()).isEqualTo("E001");
assertThat(session.getMessageErreurWave()).isEqualTo("Paiement échoué");
assertThat(session.getStatut()).isEqualTo(StatutSession.FAILED);
@@ -216,11 +216,11 @@ class WaveCheckoutSessionDTOBasicTest {
void testGestionWebhook() {
LocalDateTime dateWebhook = LocalDateTime.now();
String donneesWebhook = "{\"event\":\"payment.completed\"}";
session.setWebhookRecu(true);
session.setDateWebhook(dateWebhook);
session.setDonneesWebhook(donneesWebhook);
assertThat(session.getWebhookRecu()).isTrue();
assertThat(session.getDateWebhook()).isEqualTo(dateWebhook);
assertThat(session.getDonneesWebhook()).isEqualTo(donneesWebhook);

9
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/paiement/WaveWebhookDTOBasicTest.java
View File

@@ -212,16 +212,17 @@ class WaveWebhookDTOBasicTest {
webhook.setTypeEvenement(null);
assertThat(webhook.getTypeEvenement()).isNull();
assertThat(webhook.getCodeEvenement()).isEqualTo("checkout.complete"); // Garde l'ancienne valeur
assertThat(webhook.getCodeEvenement())
.isEqualTo("checkout.complete"); // Garde l'ancienne valeur
}
@Test
@DisplayName("Test setCodeEvenement avec mise à jour du type")
void testSetCodeEvenementAvecMiseAJourType() {
String codeEvenement = "checkout.completed";
webhook.setCodeEvenement(codeEvenement);
assertThat(webhook.getCodeEvenement()).isEqualTo(codeEvenement);
assertThat(webhook.getTypeEvenement()).isEqualTo(TypeEvenement.fromCode(codeEvenement));
}
@@ -308,7 +309,7 @@ class WaveWebhookDTOBasicTest {
webhook.setMontantTransaction(new BigDecimal("25000.00"));
String result = webhook.toString();
assertThat(result).isNotNull();
assertThat(result).contains("WaveWebhookDTO");
assertThat(result).contains("webhook_123");

143
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/solidarite/DemandeAideDTOTest.java Normal file
View File

@@ -0,0 +1,143 @@
package dev.lions.unionflow.server.api.dto.solidarite;
import static org.assertj.core.api.Assertions.assertThat;
import dev.lions.unionflow.server.api.enums.solidarite.PrioriteAide;
import dev.lions.unionflow.server.api.enums.solidarite.StatutAide;
import dev.lions.unionflow.server.api.enums.solidarite.TypeAide;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires pour DemandeAideDTO
*
* @author UnionFlow Team
* @version 2.0
* @since 2025-01-16
*/
@DisplayName("Tests DemandeAideDTO")
class DemandeAideDTOTest {
private DemandeAideDTO demandeAide;
@BeforeEach
void setUp() {
demandeAide = new DemandeAideDTO();
}
@Test
@DisplayName("Test création et getters/setters de base")
void testCreationEtGettersSetters() {
// Données de test
String numeroReference = "DA-2025-001";
UUID membreDemandeurId = UUID.randomUUID();
String nomDemandeur = "Jean Dupont";
UUID associationId = UUID.randomUUID();
TypeAide typeAide = TypeAide.AIDE_FINANCIERE_URGENTE;
String titre = "Aide pour frais médicaux";
String description = "Demande d'aide pour couvrir les frais d'hospitalisation";
BigDecimal montantDemande = new BigDecimal("500000.00");
StatutAide statut = StatutAide.EN_ATTENTE;
PrioriteAide priorite = PrioriteAide.ELEVEE;
// Test des setters
demandeAide.setNumeroReference(numeroReference);
demandeAide.setMembreDemandeurId(membreDemandeurId);
demandeAide.setNomDemandeur(nomDemandeur);
demandeAide.setAssociationId(associationId);
demandeAide.setTypeAide(typeAide);
demandeAide.setTitre(titre);
demandeAide.setDescription(description);
demandeAide.setMontantDemande(montantDemande);
demandeAide.setStatut(statut);
demandeAide.setPriorite(priorite);
// Test des getters
assertThat(demandeAide.getNumeroReference()).isEqualTo(numeroReference);
assertThat(demandeAide.getMembreDemandeurId()).isEqualTo(membreDemandeurId);
assertThat(demandeAide.getNomDemandeur()).isEqualTo(nomDemandeur);
assertThat(demandeAide.getAssociationId()).isEqualTo(associationId);
assertThat(demandeAide.getTypeAide()).isEqualTo(typeAide);
assertThat(demandeAide.getTitre()).isEqualTo(titre);
assertThat(demandeAide.getDescription()).isEqualTo(description);
assertThat(demandeAide.getMontantDemande()).isEqualTo(montantDemande);
assertThat(demandeAide.getStatut()).isEqualTo(statut);
assertThat(demandeAide.getPriorite()).isEqualTo(priorite);
}
@Test
@DisplayName("Test méthode marquerCommeModifie")
void testMarquerCommeModifie() {
String utilisateur = "admin@unionflow.dev";
LocalDateTime avant = LocalDateTime.now();
demandeAide.marquerCommeModifie(utilisateur);
LocalDateTime apres = LocalDateTime.now();
assertThat(demandeAide.getDateModification()).isBetween(avant, apres);
}
@Test
@DisplayName("Test constructeur et setters")
void testConstructeurEtSetters() {
DemandeAideDTO demande = new DemandeAideDTO();
demande.setNumeroReference("DA-2025-002");
demande.setTitre("Test Constructeur");
demande.setTypeAide(TypeAide.DON_MATERIEL);
demande.setStatut(StatutAide.BROUILLON);
demande.setPriorite(PrioriteAide.NORMALE);
assertThat(demande.getNumeroReference()).isEqualTo("DA-2025-002");
assertThat(demande.getTitre()).isEqualTo("Test Constructeur");
assertThat(demande.getTypeAide()).isEqualTo(TypeAide.DON_MATERIEL);
assertThat(demande.getStatut()).isEqualTo(StatutAide.BROUILLON);
assertThat(demande.getPriorite()).isEqualTo(PrioriteAide.NORMALE);
}
@Test
@DisplayName("Test champs spécifiques à DemandeAideDTO")
void testChampsSpecifiques() {
// Données de test
String raisonRejet = "Dossier incomplet";
LocalDateTime dateRejet = LocalDateTime.now().minusDays(2);
UUID rejeteParId = UUID.randomUUID();
String rejetePar = "Admin System";
// Test des setters
demandeAide.setRaisonRejet(raisonRejet);
demandeAide.setDateRejet(dateRejet);
demandeAide.setRejeteParId(rejeteParId);
demandeAide.setRejetePar(rejetePar);
// Test des getters
assertThat(demandeAide.getRaisonRejet()).isEqualTo(raisonRejet);
assertThat(demandeAide.getDateRejet()).isEqualTo(dateRejet);
assertThat(demandeAide.getRejeteParId()).isEqualTo(rejeteParId);
assertThat(demandeAide.getRejetePar()).isEqualTo(rejetePar);
}
@Test
@DisplayName("Test validation des énumérations")
void testValidationEnumerations() {
// Test que toutes les énumérations sont bien supportées
for (TypeAide type : TypeAide.values()) {
demandeAide.setTypeAide(type);
assertThat(demandeAide.getTypeAide()).isEqualTo(type);
}
for (StatutAide statut : StatutAide.values()) {
demandeAide.setStatut(statut);
assertThat(demandeAide.getStatut()).isEqualTo(statut);
}
for (PrioriteAide priorite : PrioriteAide.values()) {
demandeAide.setPriorite(priorite);
assertThat(demandeAide.getPriorite()).isEqualTo(priorite);
}
}
}

559
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/dto/solidarite/aide/AideDTOBasicTest.java
View File

@@ -1,559 +0,0 @@
package dev.lions.unionflow.server.api.dto.solidarite.aide;
import static org.assertj.core.api.Assertions.assertThat;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires complets pour AideDTO.
*
* @author UnionFlow Team
* @version 1.0
* @since 2025-01-10
*/
@DisplayName("Tests AideDTO")
class AideDTOBasicTest {
private AideDTO aide;
@BeforeEach
void setUp() {
aide = new AideDTO();
}
@Nested
@DisplayName("Tests de Construction")
class ConstructionTests {
@Test
@DisplayName("Constructeur par défaut - Initialisation correcte")
void testConstructeurParDefaut() {
AideDTO newAide = new AideDTO();
assertThat(newAide.getId()).isNotNull();
assertThat(newAide.getDateCreation()).isNotNull();
assertThat(newAide.isActif()).isTrue();
assertThat(newAide.getVersion()).isEqualTo(0L);
assertThat(newAide.getStatut()).isEqualTo("EN_ATTENTE");
assertThat(newAide.getDevise()).isEqualTo("XOF");
assertThat(newAide.getPriorite()).isEqualTo("NORMALE");
assertThat(newAide.getNumeroReference()).isNotNull();
assertThat(newAide.getNumeroReference()).matches("^AIDE-\\d{4}-[A-Z0-9]{6}$");
}
@Test
@DisplayName("Constructeur avec paramètres - Initialisation correcte")
void testConstructeurAvecParametres() {
UUID membreDemandeurId = UUID.randomUUID();
UUID associationId = UUID.randomUUID();
String typeAide = "FINANCIERE";
String titre = "Aide pour frais médicaux";
AideDTO newAide = new AideDTO(membreDemandeurId, associationId, typeAide, titre);
assertThat(newAide.getMembreDemandeurId()).isEqualTo(membreDemandeurId);
assertThat(newAide.getAssociationId()).isEqualTo(associationId);
assertThat(newAide.getTypeAide()).isEqualTo(typeAide);
assertThat(newAide.getTitre()).isEqualTo(titre);
assertThat(newAide.getStatut()).isEqualTo("EN_ATTENTE");
}
}
@Nested
@DisplayName("Tests Getters/Setters")
class GettersSettersTests {
@Test
@DisplayName("Test tous les getters/setters - Partie 1")
void testTousLesGettersSettersPart1() {
// Données de test
String numeroReference = "AIDE-2025-ABC123";
UUID membreDemandeurId = UUID.randomUUID();
String nomDemandeur = "Jean Dupont";
String numeroMembreDemandeur = "UF-2025-12345678";
UUID associationId = UUID.randomUUID();
String nomAssociation = "Lions Club Dakar";
String typeAide = "FINANCIERE";
String titre = "Aide pour frais médicaux";
String description = "Demande d'aide pour couvrir les frais d'hospitalisation";
BigDecimal montantDemande = new BigDecimal("500000.00");
String devise = "XOF";
String statut = "EN_COURS_EVALUATION";
String priorite = "HAUTE";
// Test des setters
aide.setNumeroReference(numeroReference);
aide.setMembreDemandeurId(membreDemandeurId);
aide.setNomDemandeur(nomDemandeur);
aide.setNumeroMembreDemandeur(numeroMembreDemandeur);
aide.setAssociationId(associationId);
aide.setNomAssociation(nomAssociation);
aide.setTypeAide(typeAide);
aide.setTitre(titre);
aide.setDescription(description);
aide.setMontantDemande(montantDemande);
aide.setDevise(devise);
aide.setStatut(statut);
aide.setPriorite(priorite);
// Test des getters
assertThat(aide.getNumeroReference()).isEqualTo(numeroReference);
assertThat(aide.getMembreDemandeurId()).isEqualTo(membreDemandeurId);
assertThat(aide.getNomDemandeur()).isEqualTo(nomDemandeur);
assertThat(aide.getNumeroMembreDemandeur()).isEqualTo(numeroMembreDemandeur);
assertThat(aide.getAssociationId()).isEqualTo(associationId);
assertThat(aide.getNomAssociation()).isEqualTo(nomAssociation);
assertThat(aide.getTypeAide()).isEqualTo(typeAide);
assertThat(aide.getTitre()).isEqualTo(titre);
assertThat(aide.getDescription()).isEqualTo(description);
assertThat(aide.getMontantDemande()).isEqualTo(montantDemande);
assertThat(aide.getDevise()).isEqualTo(devise);
assertThat(aide.getStatut()).isEqualTo(statut);
assertThat(aide.getPriorite()).isEqualTo(priorite);
}
@Test
@DisplayName("Test tous les getters/setters - Partie 2")
void testTousLesGettersSettersPart2() {
// Données de test
LocalDate dateLimite = LocalDate.now().plusMonths(3);
Boolean justificatifsFournis = true;
String documentsJoints = "certificat_medical.pdf,facture_hopital.pdf";
UUID membreEvaluateurId = UUID.randomUUID();
String nomEvaluateur = "Marie Martin";
LocalDateTime dateEvaluation = LocalDateTime.now();
String commentairesEvaluateur = "Dossier complet, situation vérifiée";
BigDecimal montantApprouve = new BigDecimal("400000.00");
LocalDateTime dateApprobation = LocalDateTime.now();
UUID membreAidantId = UUID.randomUUID();
String nomAidant = "Paul Durand";
LocalDate dateDebutAide = LocalDate.now();
LocalDate dateFinAide = LocalDate.now().plusMonths(6);
BigDecimal montantVerse = new BigDecimal("400000.00");
String modeVersement = "WAVE_MONEY";
String numeroTransaction = "TXN123456789";
LocalDateTime dateVersement = LocalDateTime.now();
// Test des setters
aide.setDateLimite(dateLimite);
aide.setJustificatifsFournis(justificatifsFournis);
aide.setDocumentsJoints(documentsJoints);
aide.setMembreEvaluateurId(membreEvaluateurId);
aide.setNomEvaluateur(nomEvaluateur);
aide.setDateEvaluation(dateEvaluation);
aide.setCommentairesEvaluateur(commentairesEvaluateur);
aide.setMontantApprouve(montantApprouve);
aide.setDateApprobation(dateApprobation);
aide.setMembreAidantId(membreAidantId);
aide.setNomAidant(nomAidant);
aide.setDateDebutAide(dateDebutAide);
aide.setDateFinAide(dateFinAide);
aide.setMontantVerse(montantVerse);
aide.setModeVersement(modeVersement);
aide.setNumeroTransaction(numeroTransaction);
aide.setDateVersement(dateVersement);
// Test des getters
assertThat(aide.getDateLimite()).isEqualTo(dateLimite);
assertThat(aide.getJustificatifsFournis()).isEqualTo(justificatifsFournis);
assertThat(aide.getDocumentsJoints()).isEqualTo(documentsJoints);
assertThat(aide.getMembreEvaluateurId()).isEqualTo(membreEvaluateurId);
assertThat(aide.getNomEvaluateur()).isEqualTo(nomEvaluateur);
assertThat(aide.getDateEvaluation()).isEqualTo(dateEvaluation);
assertThat(aide.getCommentairesEvaluateur()).isEqualTo(commentairesEvaluateur);
assertThat(aide.getMontantApprouve()).isEqualTo(montantApprouve);
assertThat(aide.getDateApprobation()).isEqualTo(dateApprobation);
assertThat(aide.getMembreAidantId()).isEqualTo(membreAidantId);
assertThat(aide.getNomAidant()).isEqualTo(nomAidant);
assertThat(aide.getDateDebutAide()).isEqualTo(dateDebutAide);
assertThat(aide.getDateFinAide()).isEqualTo(dateFinAide);
assertThat(aide.getMontantVerse()).isEqualTo(montantVerse);
assertThat(aide.getModeVersement()).isEqualTo(modeVersement);
assertThat(aide.getNumeroTransaction()).isEqualTo(numeroTransaction);
assertThat(aide.getDateVersement()).isEqualTo(dateVersement);
}
@Test
@DisplayName("Test tous les getters/setters - Partie 3")
void testTousLesGettersSettersPart3() {
// Données de test
String commentairesBeneficiaire = "Merci beaucoup pour cette aide";
Integer noteSatisfaction = 5;
Boolean aidePublique = false;
Boolean aideAnonyme = true;
Integer nombreVues = 25;
String raisonRejet = "Dossier incomplet";
LocalDateTime dateRejet = LocalDateTime.now();
UUID rejeteParId = UUID.randomUUID();
String rejetePar = "Admin System";
// Test des setters
aide.setCommentairesBeneficiaire(commentairesBeneficiaire);
aide.setNoteSatisfaction(noteSatisfaction);
aide.setAidePublique(aidePublique);
aide.setAideAnonyme(aideAnonyme);
aide.setNombreVues(nombreVues);
aide.setRaisonRejet(raisonRejet);
aide.setDateRejet(dateRejet);
aide.setRejeteParId(rejeteParId);
aide.setRejetePar(rejetePar);
// Test des getters
assertThat(aide.getCommentairesBeneficiaire()).isEqualTo(commentairesBeneficiaire);
assertThat(aide.getNoteSatisfaction()).isEqualTo(noteSatisfaction);
assertThat(aide.getAidePublique()).isEqualTo(aidePublique);
assertThat(aide.getAideAnonyme()).isEqualTo(aideAnonyme);
assertThat(aide.getNombreVues()).isEqualTo(nombreVues);
assertThat(aide.getRaisonRejet()).isEqualTo(raisonRejet);
assertThat(aide.getDateRejet()).isEqualTo(dateRejet);
assertThat(aide.getRejeteParId()).isEqualTo(rejeteParId);
assertThat(aide.getRejetePar()).isEqualTo(rejetePar);
}
}
@Nested
@DisplayName("Tests Méthodes Métier")
class MethodesMetierTests {
@Test
@DisplayName("Test méthodes de statut")
void testMethodesStatut() {
// Test isEnAttente
aide.setStatut("EN_ATTENTE");
assertThat(aide.isEnAttente()).isTrue();
aide.setStatut("APPROUVEE");
assertThat(aide.isEnAttente()).isFalse();
// Test isApprouvee
aide.setStatut("APPROUVEE");
assertThat(aide.isApprouvee()).isTrue();
aide.setStatut("REJETEE");
assertThat(aide.isApprouvee()).isFalse();
// Test isRejetee
aide.setStatut("REJETEE");
assertThat(aide.isRejetee()).isTrue();
aide.setStatut("EN_ATTENTE");
assertThat(aide.isRejetee()).isFalse();
// Test isTerminee
aide.setStatut("TERMINEE");
assertThat(aide.isTerminee()).isTrue();
aide.setStatut("EN_COURS_AIDE");
assertThat(aide.isTerminee()).isFalse();
}
@Test
@DisplayName("Test méthodes de libellé")
void testMethodesLibelle() {
// Test getTypeAideLibelle
aide.setTypeAide("FINANCIERE");
assertThat(aide.getTypeAideLibelle()).isEqualTo("Aide Financière");
aide.setTypeAide("MEDICALE");
assertThat(aide.getTypeAideLibelle()).isEqualTo("Aide Médicale");
aide.setTypeAide(null);
assertThat(aide.getTypeAideLibelle()).isEqualTo("Non défini");
// Test getStatutLibelle
aide.setStatut("EN_ATTENTE");
assertThat(aide.getStatutLibelle()).isEqualTo("En Attente");
aide.setStatut("APPROUVEE");
assertThat(aide.getStatutLibelle()).isEqualTo("Approuvée");
aide.setStatut(null);
assertThat(aide.getStatutLibelle()).isEqualTo("Non défini");
// Test getPrioriteLibelle
aide.setPriorite("URGENTE");
assertThat(aide.getPrioriteLibelle()).isEqualTo("Urgente");
aide.setPriorite("HAUTE");
assertThat(aide.getPrioriteLibelle()).isEqualTo("Haute");
aide.setPriorite(null);
assertThat(aide.getPrioriteLibelle()).isEqualTo("Normale");
}
@Test
@DisplayName("Test méthodes de calcul")
void testMethodesCalcul() {
// Test getPourcentageApprobation
aide.setMontantDemande(new BigDecimal("1000.00"));
aide.setMontantApprouve(new BigDecimal("800.00"));
assertThat(aide.getPourcentageApprobation()).isEqualTo(80);
// Test avec montant demandé null
aide.setMontantDemande(null);
assertThat(aide.getPourcentageApprobation()).isEqualTo(0);
// Test getEcartMontant
aide.setMontantDemande(new BigDecimal("1000.00"));
aide.setMontantApprouve(new BigDecimal("800.00"));
assertThat(aide.getEcartMontant()).isEqualTo(new BigDecimal("200.00"));
// Test avec montants null
aide.setMontantDemande(null);
aide.setMontantApprouve(null);
assertThat(aide.getEcartMontant()).isEqualTo(BigDecimal.ZERO);
}
@Test
@DisplayName("Test méthodes métier")
void testMethodesMetier() {
// Test approuver
UUID evaluateurId = UUID.randomUUID();
String nomEvaluateur = "Marie Martin";
BigDecimal montantApprouve = new BigDecimal("800.00");
String commentaires = "Dossier approuvé";
aide.approuver(evaluateurId, nomEvaluateur, montantApprouve, commentaires);
assertThat(aide.getStatut()).isEqualTo("APPROUVEE");
assertThat(aide.getMembreEvaluateurId()).isEqualTo(evaluateurId);
assertThat(aide.getNomEvaluateur()).isEqualTo(nomEvaluateur);
assertThat(aide.getMontantApprouve()).isEqualTo(montantApprouve);
assertThat(aide.getCommentairesEvaluateur()).isEqualTo(commentaires);
assertThat(aide.getDateEvaluation()).isNotNull();
assertThat(aide.getDateApprobation()).isNotNull();
// Test rejeter
aide.setStatut("EN_ATTENTE"); // Reset
UUID rejeteurId = UUID.randomUUID();
String nomRejeteur = "Paul Durand";
String raisonRejet = "Dossier incomplet";
aide.rejeter(rejeteurId, nomRejeteur, raisonRejet);
assertThat(aide.getStatut()).isEqualTo("REJETEE");
assertThat(aide.getRejeteParId()).isEqualTo(rejeteurId);
assertThat(aide.getRejetePar()).isEqualTo(nomRejeteur);
assertThat(aide.getRaisonRejet()).isEqualTo(raisonRejet);
assertThat(aide.getDateRejet()).isNotNull();
// Test demarrerAide
aide.setStatut("APPROUVEE"); // Reset
UUID aidantId = UUID.randomUUID();
String nomAidant = "Jean Dupont";
aide.demarrerAide(aidantId, nomAidant);
assertThat(aide.getStatut()).isEqualTo("EN_COURS_AIDE");
assertThat(aide.getMembreAidantId()).isEqualTo(aidantId);
assertThat(aide.getNomAidant()).isEqualTo(nomAidant);
assertThat(aide.getDateDebutAide()).isNotNull();
// Test terminerAvecVersement
BigDecimal montantVerse = new BigDecimal("800.00");
String modeVersement = "WAVE_MONEY";
String numeroTransaction = "TXN123456789";
aide.terminerAvecVersement(montantVerse, modeVersement, numeroTransaction);
assertThat(aide.getStatut()).isEqualTo("TERMINEE");
assertThat(aide.getMontantVerse()).isEqualTo(montantVerse);
assertThat(aide.getModeVersement()).isEqualTo(modeVersement);
assertThat(aide.getNumeroTransaction()).isEqualTo(numeroTransaction);
assertThat(aide.getDateVersement()).isNotNull();
assertThat(aide.getDateFinAide()).isNotNull();
// Test incrementerVues
aide.setNombreVues(null);
aide.incrementerVues();
assertThat(aide.getNombreVues()).isEqualTo(1);
aide.incrementerVues();
assertThat(aide.getNombreVues()).isEqualTo(2);
}
@Test
@DisplayName("Test méthodes métier complémentaires")
void testMethodesMetierComplementaires() {
// Test tous les statuts
aide.setStatut("EN_COURS_EVALUATION");
assertThat(aide.isEnCoursEvaluation()).isTrue();
assertThat(aide.isEnAttente()).isFalse();
aide.setStatut("EN_COURS_AIDE");
assertThat(aide.isEnCoursAide()).isTrue();
assertThat(aide.isTerminee()).isFalse();
aide.setStatut("ANNULEE");
assertThat(aide.isAnnulee()).isTrue();
// Test priorité urgente
aide.setPriorite("URGENTE");
assertThat(aide.isUrgente()).isTrue();
aide.setPriorite("NORMALE");
assertThat(aide.isUrgente()).isFalse();
// Test date limite
aide.setDateLimite(LocalDate.now().plusDays(5));
assertThat(aide.isDateLimiteDepassee()).isFalse();
assertThat(aide.getJoursRestants()).isEqualTo(5);
aide.setDateLimite(LocalDate.now().minusDays(3));
assertThat(aide.isDateLimiteDepassee()).isTrue();
assertThat(aide.getJoursRestants()).isEqualTo(0);
// Test avec date limite null
aide.setDateLimite(null);
assertThat(aide.isDateLimiteDepassee()).isFalse();
assertThat(aide.getJoursRestants()).isEqualTo(0);
// Test aide financière
aide.setTypeAide("FINANCIERE");
aide.setMontantDemande(new BigDecimal("50000.00"));
assertThat(aide.isAideFinanciere()).isTrue();
aide.setMontantDemande(null);
assertThat(aide.isAideFinanciere()).isFalse();
aide.setTypeAide("MATERIELLE");
aide.setMontantDemande(new BigDecimal("50000.00"));
assertThat(aide.isAideFinanciere()).isFalse();
// Test getEcartMontant avec différents cas
aide.setMontantDemande(new BigDecimal("100000.00"));
aide.setMontantApprouve(new BigDecimal("80000.00"));
assertThat(aide.getEcartMontant()).isEqualByComparingTo(new BigDecimal("20000.00"));
// Test avec montantDemande null
aide.setMontantDemande(null);
aide.setMontantApprouve(new BigDecimal("80000.00"));
assertThat(aide.getEcartMontant()).isEqualByComparingTo(BigDecimal.ZERO);
// Test avec montantApprouve null
aide.setMontantDemande(new BigDecimal("100000.00"));
aide.setMontantApprouve(null);
assertThat(aide.getEcartMontant()).isEqualByComparingTo(BigDecimal.ZERO);
// Test avec les deux null
aide.setMontantDemande(null);
aide.setMontantApprouve(null);
assertThat(aide.getEcartMontant()).isEqualByComparingTo(BigDecimal.ZERO);
}
@Test
@DisplayName("Test libellés complets")
void testLibellesComplets() {
// Test tous les types d'aide
aide.setTypeAide("MATERIELLE");
assertThat(aide.getTypeAideLibelle()).isEqualTo("Aide Matérielle");
aide.setTypeAide("LOGEMENT");
assertThat(aide.getTypeAideLibelle()).isEqualTo("Aide au Logement");
aide.setTypeAide("MEDICALE");
assertThat(aide.getTypeAideLibelle()).isEqualTo("Aide Médicale");
aide.setTypeAide("JURIDIQUE");
assertThat(aide.getTypeAideLibelle()).isEqualTo("Aide Juridique");
aide.setTypeAide("EDUCATION");
assertThat(aide.getTypeAideLibelle()).isEqualTo("Aide à l'Éducation");
aide.setTypeAide("SANTE");
assertThat(aide.getTypeAideLibelle()).isEqualTo("SANTE"); // Valeur par défaut car non définie dans le switch
aide.setTypeAide("AUTRE");
assertThat(aide.getTypeAideLibelle()).isEqualTo("Autre");
aide.setTypeAide("TYPE_INCONNU");
assertThat(aide.getTypeAideLibelle()).isEqualTo("TYPE_INCONNU");
// Test tous les statuts
aide.setStatut("EN_COURS_EVALUATION");
assertThat(aide.getStatutLibelle()).isEqualTo("En Cours d'Évaluation");
aide.setStatut("REJETEE");
assertThat(aide.getStatutLibelle()).isEqualTo("Rejetée");
aide.setStatut("EN_COURS_AIDE");
assertThat(aide.getStatutLibelle()).isEqualTo("En Cours d'Aide");
aide.setStatut("TERMINEE");
assertThat(aide.getStatutLibelle()).isEqualTo("Terminée");
aide.setStatut("ANNULEE");
assertThat(aide.getStatutLibelle()).isEqualTo("Annulée");
aide.setStatut("STATUT_INCONNU");
assertThat(aide.getStatutLibelle()).isEqualTo("STATUT_INCONNU");
// Test toutes les priorités
aide.setPriorite("BASSE");
assertThat(aide.getPrioriteLibelle()).isEqualTo("Basse");
aide.setPriorite("NORMALE");
assertThat(aide.getPrioriteLibelle()).isEqualTo("Normale");
aide.setPriorite("HAUTE");
assertThat(aide.getPrioriteLibelle()).isEqualTo("Haute");
aide.setPriorite("PRIORITE_INCONNUE");
assertThat(aide.getPrioriteLibelle()).isEqualTo("PRIORITE_INCONNUE");
}
@Test
@DisplayName("Test constructeur avec paramètres")
void testConstructeurAvecParametres() {
UUID membreDemandeurId = UUID.randomUUID();
UUID associationId = UUID.randomUUID();
String typeAide = "FINANCIERE";
String titre = "Aide médicale urgente";
AideDTO nouvelleAide = new AideDTO(membreDemandeurId, associationId, typeAide, titre);
assertThat(nouvelleAide.getMembreDemandeurId()).isEqualTo(membreDemandeurId);
assertThat(nouvelleAide.getAssociationId()).isEqualTo(associationId);
assertThat(nouvelleAide.getTypeAide()).isEqualTo(typeAide);
assertThat(nouvelleAide.getTitre()).isEqualTo(titre);
assertThat(nouvelleAide.getNumeroReference()).isNotNull();
assertThat(nouvelleAide.getNumeroReference()).startsWith("AIDE-");
// Vérifier les valeurs par défaut
assertThat(nouvelleAide.getStatut()).isEqualTo("EN_ATTENTE");
assertThat(nouvelleAide.getPriorite()).isEqualTo("NORMALE");
assertThat(nouvelleAide.getDevise()).isEqualTo("XOF");
assertThat(nouvelleAide.getJustificatifsFournis()).isFalse();
assertThat(nouvelleAide.getAidePublique()).isTrue();
assertThat(nouvelleAide.getAideAnonyme()).isFalse();
assertThat(nouvelleAide.getNombreVues()).isEqualTo(0);
}
}
@Test
@DisplayName("Test toString complet")
void testToStringComplet() {
aide.setNumeroReference("AIDE-2025-ABC123");
aide.setTitre("Aide médicale");
aide.setStatut("EN_ATTENTE");
aide.setTypeAide("FINANCIERE");
aide.setMontantDemande(new BigDecimal("100000.00"));
aide.setPriorite("URGENTE");
String result = aide.toString();
assertThat(result).isNotNull();
assertThat(result).contains("AideDTO");
assertThat(result).contains("numeroReference='AIDE-2025-ABC123'");
assertThat(result).contains("typeAide='FINANCIERE'");
assertThat(result).contains("titre='Aide médicale'");
assertThat(result).contains("statut='EN_ATTENTE'");
assertThat(result).contains("montantDemande=100000.00");
assertThat(result).contains("priorite='URGENTE'");
}
}

39
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/enums/EnumsRefactoringTest.java
View File

@@ -5,6 +5,8 @@ import static org.assertj.core.api.Assertions.assertThat;
import dev.lions.unionflow.server.api.enums.abonnement.StatutAbonnement;
import dev.lions.unionflow.server.api.enums.abonnement.StatutFormule;
import dev.lions.unionflow.server.api.enums.abonnement.TypeFormule;
import dev.lions.unionflow.server.api.enums.evenement.PrioriteEvenement;
import dev.lions.unionflow.server.api.enums.evenement.StatutEvenement;
import dev.lions.unionflow.server.api.enums.evenement.TypeEvenementMetier;
import dev.lions.unionflow.server.api.enums.finance.StatutCotisation;
import dev.lions.unionflow.server.api.enums.membre.StatutMembre;
@@ -13,6 +15,7 @@ import dev.lions.unionflow.server.api.enums.organisation.TypeOrganisation;
import dev.lions.unionflow.server.api.enums.paiement.StatutSession;
import dev.lions.unionflow.server.api.enums.paiement.StatutTraitement;
import dev.lions.unionflow.server.api.enums.paiement.TypeEvenement;
import dev.lions.unionflow.server.api.enums.solidarite.PrioriteAide;
import dev.lions.unionflow.server.api.enums.solidarite.StatutAide;
import dev.lions.unionflow.server.api.enums.solidarite.TypeAide;
import org.junit.jupiter.api.DisplayName;
@@ -170,6 +173,28 @@ class EnumsRefactoringTest {
assertThat(TypeEvenementMetier.CEREMONIE.getLibelle()).isEqualTo("Cérémonie");
assertThat(TypeEvenementMetier.AUTRE.getLibelle()).isEqualTo("Autre");
}
@Test
@DisplayName("StatutEvenement - Tous les statuts disponibles")
void testStatutEvenementTousLesStatuts() {
// Given & When & Then
assertThat(StatutEvenement.PLANIFIE.getLibelle()).isEqualTo("Planifié");
assertThat(StatutEvenement.CONFIRME.getLibelle()).isEqualTo("Confirmé");
assertThat(StatutEvenement.EN_COURS.getLibelle()).isEqualTo("En cours");
assertThat(StatutEvenement.TERMINE.getLibelle()).isEqualTo("Terminé");
assertThat(StatutEvenement.ANNULE.getLibelle()).isEqualTo("Annulé");
assertThat(StatutEvenement.REPORTE.getLibelle()).isEqualTo("Reporté");
}
@Test
@DisplayName("PrioriteEvenement - Toutes les priorités disponibles")
void testPrioriteEvenementToutesLesPriorites() {
// Given & When & Then
assertThat(PrioriteEvenement.CRITIQUE.getLibelle()).isEqualTo("Critique");
assertThat(PrioriteEvenement.HAUTE.getLibelle()).isEqualTo("Haute");
assertThat(PrioriteEvenement.NORMALE.getLibelle()).isEqualTo("Normale");
assertThat(PrioriteEvenement.BASSE.getLibelle()).isEqualTo("Basse");
}
}
@Nested
@@ -198,7 +223,8 @@ class EnumsRefactoringTest {
@DisplayName("TypeAide - Tous les types disponibles")
void testTypeAideTousLesTypes() {
// Given & When & Then
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getLibelle()).isEqualTo("Aide financière urgente");
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getLibelle())
.isEqualTo("Aide financière urgente");
assertThat(TypeAide.AIDE_FRAIS_MEDICAUX.getLibelle()).isEqualTo("Aide frais médicaux");
assertThat(TypeAide.AIDE_FRAIS_SCOLARITE.getLibelle()).isEqualTo("Aide frais de scolarité");
assertThat(TypeAide.HEBERGEMENT_URGENCE.getLibelle()).isEqualTo("Hébergement d'urgence");
@@ -222,6 +248,17 @@ class EnumsRefactoringTest {
assertThat(StatutAide.ANNULEE.getLibelle()).isEqualTo("Annulée");
assertThat(StatutAide.SUSPENDUE.getLibelle()).isEqualTo("Suspendue");
}
@Test
@DisplayName("PrioriteAide - Toutes les priorités disponibles")
void testPrioriteAideToutesLesPriorites() {
// Given & When & Then
assertThat(PrioriteAide.CRITIQUE.getLibelle()).isEqualTo("Critique");
assertThat(PrioriteAide.URGENTE.getLibelle()).isEqualTo("Urgente");
assertThat(PrioriteAide.ELEVEE.getLibelle()).isEqualTo("Élevée");
assertThat(PrioriteAide.NORMALE.getLibelle()).isEqualTo("Normale");
assertThat(PrioriteAide.FAIBLE.getLibelle()).isEqualTo("Faible");
}
}
@Nested

303
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/enums/evenement/PrioriteEvenementTest.java Normal file
View File

@@ -0,0 +1,303 @@
package dev.lions.unionflow.server.api.enums.evenement;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires EXHAUSTIFS pour PrioriteEvenement - Couverture 100%
*
* @author UnionFlow Team
* @version 1.0
* @since 2025-01-16
*/
@DisplayName("Tests EXHAUSTIFS PrioriteEvenement")
class PrioriteEvenementTest {
@Nested
@DisplayName("Tests des valeurs enum et constructeur")
class TestsValeursEnum {
@Test
@DisplayName("Test valueOf et values")
void testValueOfEtValues() {
PrioriteEvenement[] values = PrioriteEvenement.values();
assertThat(values).hasSize(4);
assertThat(values).containsExactly(
PrioriteEvenement.CRITIQUE,
PrioriteEvenement.HAUTE,
PrioriteEvenement.NORMALE,
PrioriteEvenement.BASSE);
// Test valueOf pour toutes les valeurs
assertThat(PrioriteEvenement.valueOf("CRITIQUE")).isEqualTo(PrioriteEvenement.CRITIQUE);
assertThat(PrioriteEvenement.valueOf("HAUTE")).isEqualTo(PrioriteEvenement.HAUTE);
assertThat(PrioriteEvenement.valueOf("NORMALE")).isEqualTo(PrioriteEvenement.NORMALE);
assertThat(PrioriteEvenement.valueOf("BASSE")).isEqualTo(PrioriteEvenement.BASSE);
assertThatThrownBy(() -> PrioriteEvenement.valueOf("INEXISTANT"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("Test ordinal, name et toString")
void testOrdinalNameToString() {
assertThat(PrioriteEvenement.CRITIQUE.ordinal()).isEqualTo(0);
assertThat(PrioriteEvenement.HAUTE.ordinal()).isEqualTo(1);
assertThat(PrioriteEvenement.NORMALE.ordinal()).isEqualTo(2);
assertThat(PrioriteEvenement.BASSE.ordinal()).isEqualTo(3);
assertThat(PrioriteEvenement.CRITIQUE.name()).isEqualTo("CRITIQUE");
assertThat(PrioriteEvenement.HAUTE.name()).isEqualTo("HAUTE");
assertThat(PrioriteEvenement.NORMALE.name()).isEqualTo("NORMALE");
assertThat(PrioriteEvenement.BASSE.name()).isEqualTo("BASSE");
assertThat(PrioriteEvenement.CRITIQUE.toString()).isEqualTo("CRITIQUE");
assertThat(PrioriteEvenement.HAUTE.toString()).isEqualTo("HAUTE");
}
@Test
@DisplayName("Test propriétés CRITIQUE")
void testProprieteCritique() {
PrioriteEvenement priorite = PrioriteEvenement.CRITIQUE;
assertThat(priorite.getLibelle()).isEqualTo("Critique");
assertThat(priorite.getCode()).isEqualTo("critical");
assertThat(priorite.getNiveau()).isEqualTo(1);
assertThat(priorite.getDescription()).isEqualTo("Événement critique nécessitant une attention immédiate");
assertThat(priorite.getCouleur()).isEqualTo("#F44336");
assertThat(priorite.getIcone()).isEqualTo("priority_high");
assertThat(priorite.isNotificationImmediate()).isTrue();
assertThat(priorite.isEscaladeAutomatique()).isTrue();
}
@Test
@DisplayName("Test propriétés HAUTE")
void testProprieteHaute() {
PrioriteEvenement priorite = PrioriteEvenement.HAUTE;
assertThat(priorite.getLibelle()).isEqualTo("Haute");
assertThat(priorite.getCode()).isEqualTo("high");
assertThat(priorite.getNiveau()).isEqualTo(2);
assertThat(priorite.getDescription()).isEqualTo("Événement de haute priorité");
assertThat(priorite.getCouleur()).isEqualTo("#FF9800");
assertThat(priorite.getIcone()).isEqualTo("keyboard_arrow_up");
assertThat(priorite.isNotificationImmediate()).isTrue();
assertThat(priorite.isEscaladeAutomatique()).isFalse();
}
@Test
@DisplayName("Test propriétés NORMALE")
void testProprieteNormale() {
PrioriteEvenement priorite = PrioriteEvenement.NORMALE;
assertThat(priorite.getLibelle()).isEqualTo("Normale");
assertThat(priorite.getCode()).isEqualTo("normal");
assertThat(priorite.getNiveau()).isEqualTo(3);
assertThat(priorite.getDescription()).isEqualTo("Événement de priorité normale");
assertThat(priorite.getCouleur()).isEqualTo("#2196F3");
assertThat(priorite.getIcone()).isEqualTo("remove");
assertThat(priorite.isNotificationImmediate()).isFalse();
assertThat(priorite.isEscaladeAutomatique()).isFalse();
}
@Test
@DisplayName("Test propriétés BASSE")
void testProprieteBasse() {
PrioriteEvenement priorite = PrioriteEvenement.BASSE;
assertThat(priorite.getLibelle()).isEqualTo("Basse");
assertThat(priorite.getCode()).isEqualTo("low");
assertThat(priorite.getNiveau()).isEqualTo(4);
assertThat(priorite.getDescription()).isEqualTo("Événement de priorité basse");
assertThat(priorite.getCouleur()).isEqualTo("#4CAF50");
assertThat(priorite.getIcone()).isEqualTo("keyboard_arrow_down");
assertThat(priorite.isNotificationImmediate()).isFalse();
assertThat(priorite.isEscaladeAutomatique()).isFalse();
}
}
@Nested
@DisplayName("Tests des méthodes métier")
class TestsMethodesMetier {
@Test
@DisplayName("Test isElevee - toutes les branches")
void testIsElevee() {
// Priorités élevées (this == CRITIQUE || this == HAUTE)
assertThat(PrioriteEvenement.CRITIQUE.isElevee()).isTrue();
assertThat(PrioriteEvenement.HAUTE.isElevee()).isTrue();
// Priorités non élevées
assertThat(PrioriteEvenement.NORMALE.isElevee()).isFalse();
assertThat(PrioriteEvenement.BASSE.isElevee()).isFalse();
}
@Test
@DisplayName("Test isUrgente - toutes les branches")
void testIsUrgente() {
// Priorités urgentes (this == CRITIQUE || this == HAUTE)
assertThat(PrioriteEvenement.CRITIQUE.isUrgente()).isTrue();
assertThat(PrioriteEvenement.HAUTE.isUrgente()).isTrue();
// Priorités non urgentes
assertThat(PrioriteEvenement.NORMALE.isUrgente()).isFalse();
assertThat(PrioriteEvenement.BASSE.isUrgente()).isFalse();
}
@Test
@DisplayName("Test isSuperieurA - toutes les comparaisons")
void testIsSuperieurA() {
// CRITIQUE (niveau 1) est supérieur à tous les autres
assertThat(PrioriteEvenement.CRITIQUE.isSuperieurA(PrioriteEvenement.HAUTE)).isTrue();
assertThat(PrioriteEvenement.CRITIQUE.isSuperieurA(PrioriteEvenement.NORMALE)).isTrue();
assertThat(PrioriteEvenement.CRITIQUE.isSuperieurA(PrioriteEvenement.BASSE)).isTrue();
assertThat(PrioriteEvenement.CRITIQUE.isSuperieurA(PrioriteEvenement.CRITIQUE)).isFalse();
// HAUTE (niveau 2) est supérieur à NORMALE et BASSE
assertThat(PrioriteEvenement.HAUTE.isSuperieurA(PrioriteEvenement.CRITIQUE)).isFalse();
assertThat(PrioriteEvenement.HAUTE.isSuperieurA(PrioriteEvenement.NORMALE)).isTrue();
assertThat(PrioriteEvenement.HAUTE.isSuperieurA(PrioriteEvenement.BASSE)).isTrue();
assertThat(PrioriteEvenement.HAUTE.isSuperieurA(PrioriteEvenement.HAUTE)).isFalse();
// NORMALE (niveau 3) est supérieur à BASSE seulement
assertThat(PrioriteEvenement.NORMALE.isSuperieurA(PrioriteEvenement.CRITIQUE)).isFalse();
assertThat(PrioriteEvenement.NORMALE.isSuperieurA(PrioriteEvenement.HAUTE)).isFalse();
assertThat(PrioriteEvenement.NORMALE.isSuperieurA(PrioriteEvenement.BASSE)).isTrue();
assertThat(PrioriteEvenement.NORMALE.isSuperieurA(PrioriteEvenement.NORMALE)).isFalse();
// BASSE (niveau 4) n'est supérieur à aucun
assertThat(PrioriteEvenement.BASSE.isSuperieurA(PrioriteEvenement.CRITIQUE)).isFalse();
assertThat(PrioriteEvenement.BASSE.isSuperieurA(PrioriteEvenement.HAUTE)).isFalse();
assertThat(PrioriteEvenement.BASSE.isSuperieurA(PrioriteEvenement.NORMALE)).isFalse();
assertThat(PrioriteEvenement.BASSE.isSuperieurA(PrioriteEvenement.BASSE)).isFalse();
}
}
@Nested
@DisplayName("Tests des méthodes statiques")
class TestsMethodesStatiques {
@Test
@DisplayName("Test getPrioritesElevees")
void testGetPrioritesElevees() {
List<PrioriteEvenement> elevees = PrioriteEvenement.getPrioritesElevees();
// Vérifier que toutes les priorités élevées sont incluses
assertThat(elevees).contains(
PrioriteEvenement.CRITIQUE,
PrioriteEvenement.HAUTE);
// Vérifier qu'aucune priorité non élevée n'est incluse
assertThat(elevees).doesNotContain(
PrioriteEvenement.NORMALE,
PrioriteEvenement.BASSE);
// Vérifier que toutes les priorités retournées sont bien élevées
elevees.forEach(priorite -> assertThat(priorite.isElevee()).isTrue());
}
@Test
@DisplayName("Test getPrioritesUrgentes")
void testGetPrioritesUrgentes() {
List<PrioriteEvenement> urgentes = PrioriteEvenement.getPrioritesUrgentes();
// Vérifier que toutes les priorités urgentes sont incluses
assertThat(urgentes).contains(
PrioriteEvenement.CRITIQUE,
PrioriteEvenement.HAUTE);
// Vérifier qu'aucune priorité non urgente n'est incluse
assertThat(urgentes).doesNotContain(
PrioriteEvenement.NORMALE,
PrioriteEvenement.BASSE);
// Vérifier que toutes les priorités retournées sont bien urgentes
urgentes.forEach(priorite -> assertThat(priorite.isUrgente()).isTrue());
}
@Test
@DisplayName("Test determinerPriorite - toutes les branches du switch")
void testDeterminerPriorite() {
// ASSEMBLEE_GENERALE -> HAUTE
assertThat(PrioriteEvenement.determinerPriorite(TypeEvenementMetier.ASSEMBLEE_GENERALE))
.isEqualTo(PrioriteEvenement.HAUTE);
// REUNION_BUREAU -> HAUTE
assertThat(PrioriteEvenement.determinerPriorite(TypeEvenementMetier.REUNION_BUREAU))
.isEqualTo(PrioriteEvenement.HAUTE);
// ACTION_CARITATIVE -> NORMALE
assertThat(PrioriteEvenement.determinerPriorite(TypeEvenementMetier.ACTION_CARITATIVE))
.isEqualTo(PrioriteEvenement.NORMALE);
// FORMATION -> NORMALE
assertThat(PrioriteEvenement.determinerPriorite(TypeEvenementMetier.FORMATION))
.isEqualTo(PrioriteEvenement.NORMALE);
// CONFERENCE -> NORMALE
assertThat(PrioriteEvenement.determinerPriorite(TypeEvenementMetier.CONFERENCE))
.isEqualTo(PrioriteEvenement.NORMALE);
// ACTIVITE_SOCIALE -> BASSE
assertThat(PrioriteEvenement.determinerPriorite(TypeEvenementMetier.ACTIVITE_SOCIALE))
.isEqualTo(PrioriteEvenement.BASSE);
// ATELIER -> BASSE
assertThat(PrioriteEvenement.determinerPriorite(TypeEvenementMetier.ATELIER))
.isEqualTo(PrioriteEvenement.BASSE);
// CEREMONIE -> NORMALE
assertThat(PrioriteEvenement.determinerPriorite(TypeEvenementMetier.CEREMONIE))
.isEqualTo(PrioriteEvenement.NORMALE);
// AUTRE -> NORMALE
assertThat(PrioriteEvenement.determinerPriorite(TypeEvenementMetier.AUTRE))
.isEqualTo(PrioriteEvenement.NORMALE);
}
@Test
@DisplayName("Test getDefaut")
void testGetDefaut() {
assertThat(PrioriteEvenement.getDefaut()).isEqualTo(PrioriteEvenement.NORMALE);
}
}
@Test
@DisplayName("Test cohérence globale des données")
void testCoherenceGlobale() {
for (PrioriteEvenement priorite : PrioriteEvenement.values()) {
// Tous les champs obligatoires non null
assertThat(priorite.getLibelle()).isNotNull().isNotEmpty();
assertThat(priorite.getCode()).isNotNull().isNotEmpty();
assertThat(priorite.getDescription()).isNotNull().isNotEmpty();
assertThat(priorite.getCouleur()).isNotNull().matches("#[0-9A-Fa-f]{6}");
assertThat(priorite.getIcone()).isNotNull().isNotEmpty();
assertThat(priorite.getNiveau()).isPositive();
// Cohérence logique
if (priorite.isElevee()) {
// Les priorités élevées sont aussi urgentes
assertThat(priorite.isUrgente()).isTrue();
// Les priorités élevées ont notification immédiate
assertThat(priorite.isNotificationImmediate()).isTrue();
}
if (priorite.isEscaladeAutomatique()) {
// Seule CRITIQUE a escalade automatique
assertThat(priorite).isEqualTo(PrioriteEvenement.CRITIQUE);
}
// Niveaux cohérents (plus bas = plus prioritaire)
if (priorite == PrioriteEvenement.CRITIQUE) {
assertThat(priorite.getNiveau()).isEqualTo(1);
}
if (priorite == PrioriteEvenement.BASSE) {
assertThat(priorite.getNiveau()).isEqualTo(4);
}
// Comparaisons cohérentes
assertThat(priorite.isSuperieurA(priorite)).isFalse(); // Pas supérieur à soi-même
}
}
}

468
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/enums/evenement/StatutEvenementTest.java Normal file
View File

@@ -0,0 +1,468 @@
package dev.lions.unionflow.server.api.enums.evenement;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires EXHAUSTIFS pour StatutEvenement - Couverture 100%
*
* @author UnionFlow Team
* @version 1.0
* @since 2025-01-16
*/
@DisplayName("Tests EXHAUSTIFS StatutEvenement")
class StatutEvenementTest {
@Nested
@DisplayName("Tests des valeurs enum et constructeur")
class TestsValeursEnum {
@Test
@DisplayName("Test valueOf et values")
void testValueOfEtValues() {
StatutEvenement[] values = StatutEvenement.values();
assertThat(values).hasSize(6);
assertThat(values).containsExactly(
StatutEvenement.PLANIFIE,
StatutEvenement.CONFIRME,
StatutEvenement.EN_COURS,
StatutEvenement.TERMINE,
StatutEvenement.ANNULE,
StatutEvenement.REPORTE);
// Test valueOf pour toutes les valeurs
assertThat(StatutEvenement.valueOf("PLANIFIE")).isEqualTo(StatutEvenement.PLANIFIE);
assertThat(StatutEvenement.valueOf("CONFIRME")).isEqualTo(StatutEvenement.CONFIRME);
assertThat(StatutEvenement.valueOf("EN_COURS")).isEqualTo(StatutEvenement.EN_COURS);
assertThat(StatutEvenement.valueOf("TERMINE")).isEqualTo(StatutEvenement.TERMINE);
assertThat(StatutEvenement.valueOf("ANNULE")).isEqualTo(StatutEvenement.ANNULE);
assertThat(StatutEvenement.valueOf("REPORTE")).isEqualTo(StatutEvenement.REPORTE);
assertThatThrownBy(() -> StatutEvenement.valueOf("INEXISTANT"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("Test ordinal, name et toString")
void testOrdinalNameToString() {
assertThat(StatutEvenement.PLANIFIE.ordinal()).isEqualTo(0);
assertThat(StatutEvenement.CONFIRME.ordinal()).isEqualTo(1);
assertThat(StatutEvenement.EN_COURS.ordinal()).isEqualTo(2);
assertThat(StatutEvenement.TERMINE.ordinal()).isEqualTo(3);
assertThat(StatutEvenement.ANNULE.ordinal()).isEqualTo(4);
assertThat(StatutEvenement.REPORTE.ordinal()).isEqualTo(5);
assertThat(StatutEvenement.PLANIFIE.name()).isEqualTo("PLANIFIE");
assertThat(StatutEvenement.EN_COURS.name()).isEqualTo("EN_COURS");
assertThat(StatutEvenement.PLANIFIE.toString()).isEqualTo("PLANIFIE");
assertThat(StatutEvenement.TERMINE.toString()).isEqualTo("TERMINE");
}
@Test
@DisplayName("Test propriétés PLANIFIE")
void testProprietePlanifie() {
StatutEvenement statut = StatutEvenement.PLANIFIE;
assertThat(statut.getLibelle()).isEqualTo("Planifié");
assertThat(statut.getCode()).isEqualTo("planned");
assertThat(statut.getDescription()).isEqualTo("L'événement est planifié et en préparation");
assertThat(statut.getCouleur()).isEqualTo("#2196F3");
assertThat(statut.getIcone()).isEqualTo("event");
assertThat(statut.isEstFinal()).isFalse();
assertThat(statut.isEstEchec()).isFalse();
}
@Test
@DisplayName("Test propriétés CONFIRME")
void testProprieteConfirme() {
StatutEvenement statut = StatutEvenement.CONFIRME;
assertThat(statut.getLibelle()).isEqualTo("Confirmé");
assertThat(statut.getCode()).isEqualTo("confirmed");
assertThat(statut.getDescription()).isEqualTo("L'événement est confirmé et les inscriptions sont ouvertes");
assertThat(statut.getCouleur()).isEqualTo("#4CAF50");
assertThat(statut.getIcone()).isEqualTo("event_available");
assertThat(statut.isEstFinal()).isFalse();
assertThat(statut.isEstEchec()).isFalse();
}
@Test
@DisplayName("Test propriétés EN_COURS")
void testProprieteEnCours() {
StatutEvenement statut = StatutEvenement.EN_COURS;
assertThat(statut.getLibelle()).isEqualTo("En cours");
assertThat(statut.getCode()).isEqualTo("ongoing");
assertThat(statut.getDescription()).isEqualTo("L'événement est actuellement en cours");
assertThat(statut.getCouleur()).isEqualTo("#FF9800");
assertThat(statut.getIcone()).isEqualTo("play_circle");
assertThat(statut.isEstFinal()).isFalse();
assertThat(statut.isEstEchec()).isFalse();
}
@Test
@DisplayName("Test propriétés TERMINE")
void testProprieteTermine() {
StatutEvenement statut = StatutEvenement.TERMINE;
assertThat(statut.getLibelle()).isEqualTo("Terminé");
assertThat(statut.getCode()).isEqualTo("completed");
assertThat(statut.getDescription()).isEqualTo("L'événement s'est terminé avec succès");
assertThat(statut.getCouleur()).isEqualTo("#4CAF50");
assertThat(statut.getIcone()).isEqualTo("check_circle");
assertThat(statut.isEstFinal()).isTrue();
assertThat(statut.isEstEchec()).isFalse();
}
@Test
@DisplayName("Test propriétés ANNULE")
void testProprieteAnnule() {
StatutEvenement statut = StatutEvenement.ANNULE;
assertThat(statut.getLibelle()).isEqualTo("Annulé");
assertThat(statut.getCode()).isEqualTo("cancelled");
assertThat(statut.getDescription()).isEqualTo("L'événement a été annulé");
assertThat(statut.getCouleur()).isEqualTo("#F44336");
assertThat(statut.getIcone()).isEqualTo("cancel");
assertThat(statut.isEstFinal()).isTrue();
assertThat(statut.isEstEchec()).isTrue();
}
@Test
@DisplayName("Test propriétés REPORTE")
void testProprieteReporte() {
StatutEvenement statut = StatutEvenement.REPORTE;
assertThat(statut.getLibelle()).isEqualTo("Reporté");
assertThat(statut.getCode()).isEqualTo("postponed");
assertThat(statut.getDescription()).isEqualTo("L'événement a été reporté à une date ultérieure");
assertThat(statut.getCouleur()).isEqualTo("#FF5722");
assertThat(statut.getIcone()).isEqualTo("schedule");
assertThat(statut.isEstFinal()).isFalse();
assertThat(statut.isEstEchec()).isFalse();
}
}
@Nested
@DisplayName("Tests des méthodes métier")
class TestsMethodesMetier {
@Test
@DisplayName("Test permetModification - toutes les branches du switch")
void testPermetModification() {
// PLANIFIE, CONFIRME, REPORTE -> true
assertThat(StatutEvenement.PLANIFIE.permetModification()).isTrue();
assertThat(StatutEvenement.CONFIRME.permetModification()).isTrue();
assertThat(StatutEvenement.REPORTE.permetModification()).isTrue();
// EN_COURS, TERMINE, ANNULE -> false
assertThat(StatutEvenement.EN_COURS.permetModification()).isFalse();
assertThat(StatutEvenement.TERMINE.permetModification()).isFalse();
assertThat(StatutEvenement.ANNULE.permetModification()).isFalse();
}
@Test
@DisplayName("Test permetAnnulation - toutes les branches du switch")
void testPermetAnnulation() {
// PLANIFIE, CONFIRME, EN_COURS, REPORTE -> true
assertThat(StatutEvenement.PLANIFIE.permetAnnulation()).isTrue();
assertThat(StatutEvenement.CONFIRME.permetAnnulation()).isTrue();
assertThat(StatutEvenement.EN_COURS.permetAnnulation()).isTrue();
assertThat(StatutEvenement.REPORTE.permetAnnulation()).isTrue();
// TERMINE, ANNULE -> false
assertThat(StatutEvenement.TERMINE.permetAnnulation()).isFalse();
assertThat(StatutEvenement.ANNULE.permetAnnulation()).isFalse();
}
@Test
@DisplayName("Test isEnCours - toutes les branches")
void testIsEnCours() {
// Seul EN_COURS retourne true
assertThat(StatutEvenement.EN_COURS.isEnCours()).isTrue();
// Tous les autres retournent false
assertThat(StatutEvenement.PLANIFIE.isEnCours()).isFalse();
assertThat(StatutEvenement.CONFIRME.isEnCours()).isFalse();
assertThat(StatutEvenement.TERMINE.isEnCours()).isFalse();
assertThat(StatutEvenement.ANNULE.isEnCours()).isFalse();
assertThat(StatutEvenement.REPORTE.isEnCours()).isFalse();
}
@Test
@DisplayName("Test isSucces - toutes les branches")
void testIsSucces() {
// Seul TERMINE retourne true
assertThat(StatutEvenement.TERMINE.isSucces()).isTrue();
// Tous les autres retournent false
assertThat(StatutEvenement.PLANIFIE.isSucces()).isFalse();
assertThat(StatutEvenement.CONFIRME.isSucces()).isFalse();
assertThat(StatutEvenement.EN_COURS.isSucces()).isFalse();
assertThat(StatutEvenement.ANNULE.isSucces()).isFalse();
assertThat(StatutEvenement.REPORTE.isSucces()).isFalse();
}
@Test
@DisplayName("Test getNiveauPriorite - toutes les branches du switch")
void testGetNiveauPriorite() {
// EN_COURS -> 1
assertThat(StatutEvenement.EN_COURS.getNiveauPriorite()).isEqualTo(1);
// CONFIRME -> 2
assertThat(StatutEvenement.CONFIRME.getNiveauPriorite()).isEqualTo(2);
// PLANIFIE -> 3
assertThat(StatutEvenement.PLANIFIE.getNiveauPriorite()).isEqualTo(3);
// REPORTE -> 4
assertThat(StatutEvenement.REPORTE.getNiveauPriorite()).isEqualTo(4);
// TERMINE -> 5
assertThat(StatutEvenement.TERMINE.getNiveauPriorite()).isEqualTo(5);
// ANNULE -> 6
assertThat(StatutEvenement.ANNULE.getNiveauPriorite()).isEqualTo(6);
}
}
@Nested
@DisplayName("Tests des méthodes statiques")
class TestsMethodesStatiques {
@Test
@DisplayName("Test getStatutsFinaux")
void testGetStatutsFinaux() {
List<StatutEvenement> finaux = StatutEvenement.getStatutsFinaux();
// Vérifier que tous les statuts finaux sont inclus
assertThat(finaux).contains(
StatutEvenement.TERMINE,
StatutEvenement.ANNULE);
// Vérifier qu'aucun statut non final n'est inclus
assertThat(finaux).doesNotContain(
StatutEvenement.PLANIFIE,
StatutEvenement.CONFIRME,
StatutEvenement.EN_COURS,
StatutEvenement.REPORTE);
// Vérifier que tous les statuts retournés sont bien finaux
finaux.forEach(statut -> assertThat(statut.isEstFinal()).isTrue());
}
@Test
@DisplayName("Test getStatutsEchec")
void testGetStatutsEchec() {
List<StatutEvenement> echecs = StatutEvenement.getStatutsEchec();
// Vérifier que tous les statuts d'échec sont inclus
assertThat(echecs).contains(StatutEvenement.ANNULE);
// Vérifier qu'aucun statut non échec n'est inclus
assertThat(echecs).doesNotContain(
StatutEvenement.PLANIFIE,
StatutEvenement.CONFIRME,
StatutEvenement.EN_COURS,
StatutEvenement.TERMINE,
StatutEvenement.REPORTE);
// Vérifier que tous les statuts retournés sont bien des échecs
echecs.forEach(statut -> assertThat(statut.isEstEchec()).isTrue());
}
@Test
@DisplayName("Test getStatutsActifs")
void testGetStatutsActifs() {
StatutEvenement[] actifs = StatutEvenement.getStatutsActifs();
// Vérifier le contenu exact
assertThat(actifs).containsExactly(
StatutEvenement.PLANIFIE,
StatutEvenement.CONFIRME,
StatutEvenement.EN_COURS,
StatutEvenement.REPORTE);
// Vérifier qu'aucun statut final n'est inclus
assertThat(actifs).doesNotContain(
StatutEvenement.TERMINE,
StatutEvenement.ANNULE);
}
@Test
@DisplayName("Test fromCode - toutes les branches")
void testFromCode() {
// Codes valides
assertThat(StatutEvenement.fromCode("planned")).isEqualTo(StatutEvenement.PLANIFIE);
assertThat(StatutEvenement.fromCode("confirmed")).isEqualTo(StatutEvenement.CONFIRME);
assertThat(StatutEvenement.fromCode("ongoing")).isEqualTo(StatutEvenement.EN_COURS);
assertThat(StatutEvenement.fromCode("completed")).isEqualTo(StatutEvenement.TERMINE);
assertThat(StatutEvenement.fromCode("cancelled")).isEqualTo(StatutEvenement.ANNULE);
assertThat(StatutEvenement.fromCode("postponed")).isEqualTo(StatutEvenement.REPORTE);
// Code inexistant
assertThat(StatutEvenement.fromCode("inexistant")).isNull();
// Cas limites
assertThat(StatutEvenement.fromCode(null)).isNull();
assertThat(StatutEvenement.fromCode("")).isNull();
assertThat(StatutEvenement.fromCode(" ")).isNull();
}
@Test
@DisplayName("Test fromLibelle - toutes les branches")
void testFromLibelle() {
// Libellés valides
assertThat(StatutEvenement.fromLibelle("Planifié")).isEqualTo(StatutEvenement.PLANIFIE);
assertThat(StatutEvenement.fromLibelle("Confirmé")).isEqualTo(StatutEvenement.CONFIRME);
assertThat(StatutEvenement.fromLibelle("En cours")).isEqualTo(StatutEvenement.EN_COURS);
assertThat(StatutEvenement.fromLibelle("Terminé")).isEqualTo(StatutEvenement.TERMINE);
assertThat(StatutEvenement.fromLibelle("Annulé")).isEqualTo(StatutEvenement.ANNULE);
assertThat(StatutEvenement.fromLibelle("Reporté")).isEqualTo(StatutEvenement.REPORTE);
// Libellé inexistant
assertThat(StatutEvenement.fromLibelle("Inexistant")).isNull();
// Cas limites
assertThat(StatutEvenement.fromLibelle(null)).isNull();
assertThat(StatutEvenement.fromLibelle("")).isNull();
assertThat(StatutEvenement.fromLibelle(" ")).isNull();
}
}
@Nested
@DisplayName("Tests des méthodes complexes")
class TestsMethodesComplexes {
@Test
@DisplayName("Test peutTransitionnerVers - toutes les branches")
void testPeutTransitionnerVers() {
// Règles générales
// this == nouveauStatut -> false
assertThat(StatutEvenement.PLANIFIE.peutTransitionnerVers(StatutEvenement.PLANIFIE)).isFalse();
assertThat(StatutEvenement.CONFIRME.peutTransitionnerVers(StatutEvenement.CONFIRME)).isFalse();
// estFinal && nouveauStatut != REPORTE -> false
assertThat(StatutEvenement.TERMINE.peutTransitionnerVers(StatutEvenement.PLANIFIE)).isFalse();
assertThat(StatutEvenement.ANNULE.peutTransitionnerVers(StatutEvenement.CONFIRME)).isFalse();
// estFinal && nouveauStatut == REPORTE -> mais default false dans switch
// TERMINE et ANNULE ne sont pas dans le switch, donc default -> false
assertThat(StatutEvenement.TERMINE.peutTransitionnerVers(StatutEvenement.REPORTE)).isFalse();
assertThat(StatutEvenement.ANNULE.peutTransitionnerVers(StatutEvenement.REPORTE)).isFalse();
// PLANIFIE -> CONFIRME || ANNULE || REPORTE
assertThat(StatutEvenement.PLANIFIE.peutTransitionnerVers(StatutEvenement.CONFIRME)).isTrue();
assertThat(StatutEvenement.PLANIFIE.peutTransitionnerVers(StatutEvenement.ANNULE)).isTrue();
assertThat(StatutEvenement.PLANIFIE.peutTransitionnerVers(StatutEvenement.REPORTE)).isTrue();
assertThat(StatutEvenement.PLANIFIE.peutTransitionnerVers(StatutEvenement.EN_COURS)).isFalse();
assertThat(StatutEvenement.PLANIFIE.peutTransitionnerVers(StatutEvenement.TERMINE)).isFalse();
// CONFIRME -> EN_COURS || ANNULE || REPORTE
assertThat(StatutEvenement.CONFIRME.peutTransitionnerVers(StatutEvenement.EN_COURS)).isTrue();
assertThat(StatutEvenement.CONFIRME.peutTransitionnerVers(StatutEvenement.ANNULE)).isTrue();
assertThat(StatutEvenement.CONFIRME.peutTransitionnerVers(StatutEvenement.REPORTE)).isTrue();
assertThat(StatutEvenement.CONFIRME.peutTransitionnerVers(StatutEvenement.PLANIFIE)).isFalse();
assertThat(StatutEvenement.CONFIRME.peutTransitionnerVers(StatutEvenement.TERMINE)).isFalse();
// EN_COURS -> TERMINE || ANNULE
assertThat(StatutEvenement.EN_COURS.peutTransitionnerVers(StatutEvenement.TERMINE)).isTrue();
assertThat(StatutEvenement.EN_COURS.peutTransitionnerVers(StatutEvenement.ANNULE)).isTrue();
assertThat(StatutEvenement.EN_COURS.peutTransitionnerVers(StatutEvenement.PLANIFIE)).isFalse();
assertThat(StatutEvenement.EN_COURS.peutTransitionnerVers(StatutEvenement.CONFIRME)).isFalse();
assertThat(StatutEvenement.EN_COURS.peutTransitionnerVers(StatutEvenement.REPORTE)).isFalse();
// REPORTE -> PLANIFIE || ANNULE (pas CONFIRME selon le code)
assertThat(StatutEvenement.REPORTE.peutTransitionnerVers(StatutEvenement.PLANIFIE)).isTrue();
assertThat(StatutEvenement.REPORTE.peutTransitionnerVers(StatutEvenement.ANNULE)).isTrue();
assertThat(StatutEvenement.REPORTE.peutTransitionnerVers(StatutEvenement.CONFIRME)).isFalse();
assertThat(StatutEvenement.REPORTE.peutTransitionnerVers(StatutEvenement.EN_COURS)).isFalse();
assertThat(StatutEvenement.REPORTE.peutTransitionnerVers(StatutEvenement.TERMINE)).isFalse();
// default -> false (pour les statuts non couverts par le switch)
// Déjà testé avec les statuts finaux ci-dessus
}
@Test
@DisplayName("Test getTransitionsPossibles - toutes les branches du switch")
void testGetTransitionsPossibles() {
// PLANIFIE -> [CONFIRME, ANNULE, REPORTE]
StatutEvenement[] transitionsPlanifie = StatutEvenement.PLANIFIE.getTransitionsPossibles();
assertThat(transitionsPlanifie).containsExactly(
StatutEvenement.CONFIRME,
StatutEvenement.ANNULE,
StatutEvenement.REPORTE);
// CONFIRME -> [EN_COURS, ANNULE, REPORTE]
StatutEvenement[] transitionsConfirme = StatutEvenement.CONFIRME.getTransitionsPossibles();
assertThat(transitionsConfirme).containsExactly(
StatutEvenement.EN_COURS,
StatutEvenement.ANNULE,
StatutEvenement.REPORTE);
// EN_COURS -> [TERMINE, ANNULE]
StatutEvenement[] transitionsEnCours = StatutEvenement.EN_COURS.getTransitionsPossibles();
assertThat(transitionsEnCours).containsExactly(
StatutEvenement.TERMINE,
StatutEvenement.ANNULE);
// REPORTE -> [PLANIFIE, CONFIRME, ANNULE] (selon getTransitionsPossibles)
StatutEvenement[] transitionsReporte = StatutEvenement.REPORTE.getTransitionsPossibles();
assertThat(transitionsReporte).containsExactly(
StatutEvenement.PLANIFIE,
StatutEvenement.CONFIRME,
StatutEvenement.ANNULE);
// TERMINE, ANNULE -> [] (aucune transition)
StatutEvenement[] transitionsTermine = StatutEvenement.TERMINE.getTransitionsPossibles();
assertThat(transitionsTermine).isEmpty();
StatutEvenement[] transitionsAnnule = StatutEvenement.ANNULE.getTransitionsPossibles();
assertThat(transitionsAnnule).isEmpty();
}
}
@Test
@DisplayName("Test cohérence globale des données")
void testCoherenceGlobale() {
for (StatutEvenement statut : StatutEvenement.values()) {
// Tous les champs obligatoires non null
assertThat(statut.getLibelle()).isNotNull().isNotEmpty();
assertThat(statut.getCode()).isNotNull().isNotEmpty();
assertThat(statut.getDescription()).isNotNull().isNotEmpty();
assertThat(statut.getCouleur()).isNotNull().matches("#[0-9A-Fa-f]{6}");
assertThat(statut.getIcone()).isNotNull().isNotEmpty();
// Cohérence logique
if (statut.isEstFinal()) {
// Les statuts finaux ne permettent pas la modification
assertThat(statut.permetModification()).isFalse();
}
if (statut.isEstEchec()) {
// Les statuts d'échec ne sont pas des succès
assertThat(statut.isSucces()).isFalse();
// Les statuts d'échec sont finaux
assertThat(statut.isEstFinal()).isTrue();
}
if (statut.isSucces()) {
// Les statuts de succès ne sont pas des échecs
assertThat(statut.isEstEchec()).isFalse();
// Les statuts de succès sont finaux
assertThat(statut.isEstFinal()).isTrue();
}
// Niveau de priorité cohérent
int niveau = statut.getNiveauPriorite();
assertThat(niveau).isBetween(1, 6);
// Transitions cohérentes
assertThat(statut.peutTransitionnerVers(statut)).isFalse(); // Pas de transition vers soi-même
// Méthodes de recherche cohérentes
assertThat(StatutEvenement.fromCode(statut.getCode())).isEqualTo(statut);
assertThat(StatutEvenement.fromLibelle(statut.getLibelle())).isEqualTo(statut);
}
}
}

437
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/enums/solidarite/PrioriteAideTest.java Normal file
View File

@@ -0,0 +1,437 @@
package dev.lions.unionflow.server.api.enums.solidarite;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.within;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.List;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires EXHAUSTIFS pour PrioriteAide - Couverture 100%
*
* @author UnionFlow Team
* @version 1.0
* @since 2025-01-16
*/
@DisplayName("Tests EXHAUSTIFS PrioriteAide")
class PrioriteAideTest {
@Nested
@DisplayName("Tests des valeurs enum et constructeur")
class TestsValeursEnum {
@Test
@DisplayName("Test toutes les valeurs enum avec propriétés exactes")
void testToutesValeursExactes() {
// CRITIQUE
assertThat(PrioriteAide.CRITIQUE.getLibelle()).isEqualTo("Critique");
assertThat(PrioriteAide.CRITIQUE.getCode()).isEqualTo("critical");
assertThat(PrioriteAide.CRITIQUE.getNiveau()).isEqualTo(1);
assertThat(PrioriteAide.CRITIQUE.getDescription()).isEqualTo("Situation critique nécessitant une intervention immédiate");
assertThat(PrioriteAide.CRITIQUE.getCouleur()).isEqualTo("#F44336");
assertThat(PrioriteAide.CRITIQUE.getIcone()).isEqualTo("emergency");
assertThat(PrioriteAide.CRITIQUE.getDelaiTraitementHeures()).isEqualTo(24);
assertThat(PrioriteAide.CRITIQUE.isNotificationImmediate()).isTrue();
assertThat(PrioriteAide.CRITIQUE.isEscaladeAutomatique()).isTrue();
// URGENTE
assertThat(PrioriteAide.URGENTE.getLibelle()).isEqualTo("Urgente");
assertThat(PrioriteAide.URGENTE.getCode()).isEqualTo("urgent");
assertThat(PrioriteAide.URGENTE.getNiveau()).isEqualTo(2);
assertThat(PrioriteAide.URGENTE.getDescription()).isEqualTo("Situation urgente nécessitant une réponse rapide");
assertThat(PrioriteAide.URGENTE.getCouleur()).isEqualTo("#FF5722");
assertThat(PrioriteAide.URGENTE.getIcone()).isEqualTo("priority_high");
assertThat(PrioriteAide.URGENTE.getDelaiTraitementHeures()).isEqualTo(72);
assertThat(PrioriteAide.URGENTE.isNotificationImmediate()).isTrue();
assertThat(PrioriteAide.URGENTE.isEscaladeAutomatique()).isFalse();
// ELEVEE
assertThat(PrioriteAide.ELEVEE.getLibelle()).isEqualTo("Élevée");
assertThat(PrioriteAide.ELEVEE.getCode()).isEqualTo("high");
assertThat(PrioriteAide.ELEVEE.getNiveau()).isEqualTo(3);
assertThat(PrioriteAide.ELEVEE.getDescription()).isEqualTo("Priorité élevée, traitement dans les meilleurs délais");
assertThat(PrioriteAide.ELEVEE.getCouleur()).isEqualTo("#FF9800");
assertThat(PrioriteAide.ELEVEE.getIcone()).isEqualTo("keyboard_arrow_up");
assertThat(PrioriteAide.ELEVEE.getDelaiTraitementHeures()).isEqualTo(168);
assertThat(PrioriteAide.ELEVEE.isNotificationImmediate()).isFalse();
assertThat(PrioriteAide.ELEVEE.isEscaladeAutomatique()).isFalse();
// NORMALE
assertThat(PrioriteAide.NORMALE.getLibelle()).isEqualTo("Normale");
assertThat(PrioriteAide.NORMALE.getCode()).isEqualTo("normal");
assertThat(PrioriteAide.NORMALE.getNiveau()).isEqualTo(4);
assertThat(PrioriteAide.NORMALE.getDescription()).isEqualTo("Priorité normale, traitement selon les délais standards");
assertThat(PrioriteAide.NORMALE.getCouleur()).isEqualTo("#2196F3");
assertThat(PrioriteAide.NORMALE.getIcone()).isEqualTo("remove");
assertThat(PrioriteAide.NORMALE.getDelaiTraitementHeures()).isEqualTo(336);
assertThat(PrioriteAide.NORMALE.isNotificationImmediate()).isFalse();
assertThat(PrioriteAide.NORMALE.isEscaladeAutomatique()).isFalse();
// FAIBLE
assertThat(PrioriteAide.FAIBLE.getLibelle()).isEqualTo("Faible");
assertThat(PrioriteAide.FAIBLE.getCode()).isEqualTo("low");
assertThat(PrioriteAide.FAIBLE.getNiveau()).isEqualTo(5);
assertThat(PrioriteAide.FAIBLE.getDescription()).isEqualTo("Priorité faible, traitement quand les ressources le permettent");
assertThat(PrioriteAide.FAIBLE.getCouleur()).isEqualTo("#4CAF50");
assertThat(PrioriteAide.FAIBLE.getIcone()).isEqualTo("keyboard_arrow_down");
assertThat(PrioriteAide.FAIBLE.getDelaiTraitementHeures()).isEqualTo(720);
assertThat(PrioriteAide.FAIBLE.isNotificationImmediate()).isFalse();
assertThat(PrioriteAide.FAIBLE.isEscaladeAutomatique()).isFalse();
}
@Test
@DisplayName("Test valueOf et values")
void testValueOfEtValues() {
PrioriteAide[] values = PrioriteAide.values();
assertThat(values).hasSize(5);
assertThat(values).containsExactly(
PrioriteAide.CRITIQUE,
PrioriteAide.URGENTE,
PrioriteAide.ELEVEE,
PrioriteAide.NORMALE,
PrioriteAide.FAIBLE);
assertThat(PrioriteAide.valueOf("CRITIQUE")).isEqualTo(PrioriteAide.CRITIQUE);
assertThat(PrioriteAide.valueOf("URGENTE")).isEqualTo(PrioriteAide.URGENTE);
assertThat(PrioriteAide.valueOf("ELEVEE")).isEqualTo(PrioriteAide.ELEVEE);
assertThat(PrioriteAide.valueOf("NORMALE")).isEqualTo(PrioriteAide.NORMALE);
assertThat(PrioriteAide.valueOf("FAIBLE")).isEqualTo(PrioriteAide.FAIBLE);
assertThatThrownBy(() -> PrioriteAide.valueOf("INEXISTANT"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("Test ordinal et name")
void testOrdinalEtName() {
assertThat(PrioriteAide.CRITIQUE.ordinal()).isEqualTo(0);
assertThat(PrioriteAide.URGENTE.ordinal()).isEqualTo(1);
assertThat(PrioriteAide.ELEVEE.ordinal()).isEqualTo(2);
assertThat(PrioriteAide.NORMALE.ordinal()).isEqualTo(3);
assertThat(PrioriteAide.FAIBLE.ordinal()).isEqualTo(4);
assertThat(PrioriteAide.CRITIQUE.name()).isEqualTo("CRITIQUE");
assertThat(PrioriteAide.URGENTE.name()).isEqualTo("URGENTE");
assertThat(PrioriteAide.ELEVEE.name()).isEqualTo("ELEVEE");
assertThat(PrioriteAide.NORMALE.name()).isEqualTo("NORMALE");
assertThat(PrioriteAide.FAIBLE.name()).isEqualTo("FAIBLE");
}
@Test
@DisplayName("Test toString")
void testToString() {
assertThat(PrioriteAide.CRITIQUE.toString()).isEqualTo("CRITIQUE");
assertThat(PrioriteAide.URGENTE.toString()).isEqualTo("URGENTE");
assertThat(PrioriteAide.ELEVEE.toString()).isEqualTo("ELEVEE");
assertThat(PrioriteAide.NORMALE.toString()).isEqualTo("NORMALE");
assertThat(PrioriteAide.FAIBLE.toString()).isEqualTo("FAIBLE");
}
}
@Nested
@DisplayName("Tests des méthodes métier")
class TestsMethodesMetier {
@Test
@DisplayName("Test isUrgente - toutes les branches")
void testIsUrgente() {
// Priorités urgentes (this == CRITIQUE || this == URGENTE)
assertThat(PrioriteAide.CRITIQUE.isUrgente()).isTrue();
assertThat(PrioriteAide.URGENTE.isUrgente()).isTrue();
// Priorités non urgentes
assertThat(PrioriteAide.ELEVEE.isUrgente()).isFalse();
assertThat(PrioriteAide.NORMALE.isUrgente()).isFalse();
assertThat(PrioriteAide.FAIBLE.isUrgente()).isFalse();
}
@Test
@DisplayName("Test necessiteTraitementImmediat - toutes les branches")
void testNecessiteTraitementImmediat() {
// Niveau <= 2
assertThat(PrioriteAide.CRITIQUE.necessiteTraitementImmediat()).isTrue(); // niveau 1
assertThat(PrioriteAide.URGENTE.necessiteTraitementImmediat()).isTrue(); // niveau 2
// Niveau > 2
assertThat(PrioriteAide.ELEVEE.necessiteTraitementImmediat()).isFalse(); // niveau 3
assertThat(PrioriteAide.NORMALE.necessiteTraitementImmediat()).isFalse(); // niveau 4
assertThat(PrioriteAide.FAIBLE.necessiteTraitementImmediat()).isFalse(); // niveau 5
}
@Test
@DisplayName("Test getDateLimiteTraitement")
void testGetDateLimiteTraitement() {
LocalDateTime avant = LocalDateTime.now();
LocalDateTime dateLimite = PrioriteAide.CRITIQUE.getDateLimiteTraitement();
LocalDateTime apres = LocalDateTime.now();
// La date limite doit être maintenant + 24 heures (±1 seconde pour l'exécution)
LocalDateTime attendu = avant.plusHours(24);
assertThat(dateLimite).isBetween(attendu.minusSeconds(1), apres.plusHours(24).plusSeconds(1));
// Test avec URGENTE (72 heures)
dateLimite = PrioriteAide.URGENTE.getDateLimiteTraitement();
attendu = LocalDateTime.now().plusHours(72);
assertThat(dateLimite).isCloseTo(attendu, within(1, ChronoUnit.SECONDS));
}
@Test
@DisplayName("Test getPrioriteEscalade - toutes les branches du switch")
void testGetPrioriteEscalade() {
// Test toutes les branches du switch
assertThat(PrioriteAide.FAIBLE.getPrioriteEscalade()).isEqualTo(PrioriteAide.NORMALE);
assertThat(PrioriteAide.NORMALE.getPrioriteEscalade()).isEqualTo(PrioriteAide.ELEVEE);
assertThat(PrioriteAide.ELEVEE.getPrioriteEscalade()).isEqualTo(PrioriteAide.URGENTE);
assertThat(PrioriteAide.URGENTE.getPrioriteEscalade()).isEqualTo(PrioriteAide.CRITIQUE);
assertThat(PrioriteAide.CRITIQUE.getPrioriteEscalade()).isEqualTo(PrioriteAide.CRITIQUE); // Déjà au maximum
}
}
@Nested
@DisplayName("Tests des méthodes statiques")
class TestsMethodesStatiques {
@Test
@DisplayName("Test getPrioritesUrgentes")
void testGetPrioritesUrgentes() {
List<PrioriteAide> urgentes = PrioriteAide.getPrioritesUrgentes();
assertThat(urgentes).hasSize(2);
assertThat(urgentes).containsExactly(PrioriteAide.CRITIQUE, PrioriteAide.URGENTE);
// Vérifier que toutes les priorités retournées sont bien urgentes
urgentes.forEach(p -> assertThat(p.isUrgente()).isTrue());
}
@Test
@DisplayName("Test getParNiveauCroissant")
void testGetParNiveauCroissant() {
List<PrioriteAide> croissant = PrioriteAide.getParNiveauCroissant();
assertThat(croissant).hasSize(5);
assertThat(croissant).containsExactly(
PrioriteAide.CRITIQUE, // niveau 1
PrioriteAide.URGENTE, // niveau 2
PrioriteAide.ELEVEE, // niveau 3
PrioriteAide.NORMALE, // niveau 4
PrioriteAide.FAIBLE); // niveau 5
// Vérifier l'ordre croissant
for (int i = 0; i < croissant.size() - 1; i++) {
assertThat(croissant.get(i).getNiveau()).isLessThan(croissant.get(i + 1).getNiveau());
}
}
@Test
@DisplayName("Test getParNiveauDecroissant")
void testGetParNiveauDecroissant() {
List<PrioriteAide> decroissant = PrioriteAide.getParNiveauDecroissant();
assertThat(decroissant).hasSize(5);
assertThat(decroissant).containsExactly(
PrioriteAide.FAIBLE, // niveau 5
PrioriteAide.NORMALE, // niveau 4
PrioriteAide.ELEVEE, // niveau 3
PrioriteAide.URGENTE, // niveau 2
PrioriteAide.CRITIQUE); // niveau 1
// Vérifier l'ordre décroissant
for (int i = 0; i < decroissant.size() - 1; i++) {
assertThat(decroissant.get(i).getNiveau()).isGreaterThan(decroissant.get(i + 1).getNiveau());
}
}
@Test
@DisplayName("Test parCode - toutes les branches")
void testParCode() {
// Codes existants
assertThat(PrioriteAide.parCode("critical")).isEqualTo(PrioriteAide.CRITIQUE);
assertThat(PrioriteAide.parCode("urgent")).isEqualTo(PrioriteAide.URGENTE);
assertThat(PrioriteAide.parCode("high")).isEqualTo(PrioriteAide.ELEVEE);
assertThat(PrioriteAide.parCode("normal")).isEqualTo(PrioriteAide.NORMALE);
assertThat(PrioriteAide.parCode("low")).isEqualTo(PrioriteAide.FAIBLE);
// Code inexistant - retourne NORMALE par défaut
assertThat(PrioriteAide.parCode("inexistant")).isEqualTo(PrioriteAide.NORMALE);
assertThat(PrioriteAide.parCode("")).isEqualTo(PrioriteAide.NORMALE);
assertThat(PrioriteAide.parCode(null)).isEqualTo(PrioriteAide.NORMALE);
}
@Test
@DisplayName("Test determinerPriorite - toutes les branches")
void testDeterminerPriorite() {
// Types urgents avec switch spécifique
assertThat(PrioriteAide.determinerPriorite(TypeAide.AIDE_FINANCIERE_URGENTE))
.isEqualTo(PrioriteAide.CRITIQUE);
assertThat(PrioriteAide.determinerPriorite(TypeAide.AIDE_FRAIS_MEDICAUX))
.isEqualTo(PrioriteAide.CRITIQUE);
assertThat(PrioriteAide.determinerPriorite(TypeAide.HEBERGEMENT_URGENCE))
.isEqualTo(PrioriteAide.URGENTE);
assertThat(PrioriteAide.determinerPriorite(TypeAide.AIDE_ALIMENTAIRE))
.isEqualTo(PrioriteAide.URGENTE);
// Type urgent avec default du switch
assertThat(PrioriteAide.determinerPriorite(TypeAide.PRET_SANS_INTERET))
.isEqualTo(PrioriteAide.ELEVEE); // urgent mais pas dans les cas spécifiques
// Type avec priorité "important" (non urgent)
assertThat(PrioriteAide.determinerPriorite(TypeAide.AIDE_FRAIS_SCOLARITE))
.isEqualTo(PrioriteAide.ELEVEE); // priorité "important"
// Type normal (ni urgent ni important)
assertThat(PrioriteAide.determinerPriorite(TypeAide.DON_MATERIEL))
.isEqualTo(PrioriteAide.NORMALE); // priorité "normal"
assertThat(PrioriteAide.determinerPriorite(TypeAide.AIDE_COTISATION))
.isEqualTo(PrioriteAide.NORMALE); // priorité "normal"
}
}
@Nested
@DisplayName("Tests des méthodes de calcul et temporelles")
class TestsCalculsTemporels {
@Test
@DisplayName("Test getScorePriorite - toutes les branches")
void testGetScorePriorite() {
// CRITIQUE: niveau=1, notificationImmediate=true, escaladeAutomatique=true, delai=24h
// Score = 1 - 0.5 - 0.3 = 0.2
assertThat(PrioriteAide.CRITIQUE.getScorePriorite()).isEqualTo(0.2);
// URGENTE: niveau=2, notificationImmediate=true, escaladeAutomatique=false, delai=72h
// Score = 2 - 0.5 = 1.5
assertThat(PrioriteAide.URGENTE.getScorePriorite()).isEqualTo(1.5);
// ELEVEE: niveau=3, notificationImmediate=false, escaladeAutomatique=false, delai=168h
// Score = 3 (pas de bonus/malus car délai = 168h exactement)
assertThat(PrioriteAide.ELEVEE.getScorePriorite()).isEqualTo(3.0);
// NORMALE: niveau=4, notificationImmediate=false, escaladeAutomatique=false, delai=336h
// Score = 4 + 0.2 = 4.2 (malus car délai > 168h)
assertThat(PrioriteAide.NORMALE.getScorePriorite()).isEqualTo(4.2);
// FAIBLE: niveau=5, notificationImmediate=false, escaladeAutomatique=false, delai=720h
// Score = 5 + 0.2 = 5.2 (malus car délai > 168h)
assertThat(PrioriteAide.FAIBLE.getScorePriorite()).isEqualTo(5.2);
}
@Test
@DisplayName("Test isDelaiDepasse - toutes les branches")
void testIsDelaiDepasse() {
LocalDateTime maintenant = LocalDateTime.now();
// Délai non dépassé
LocalDateTime dateCreationRecente = maintenant.minusHours(1);
assertThat(PrioriteAide.CRITIQUE.isDelaiDepasse(dateCreationRecente)).isFalse(); // 1h < 24h
// Délai dépassé
LocalDateTime dateCreationAncienne = maintenant.minusHours(25);
assertThat(PrioriteAide.CRITIQUE.isDelaiDepasse(dateCreationAncienne)).isTrue(); // 25h > 24h
// Test limite exacte
LocalDateTime dateCreationLimite = maintenant.minusHours(24);
assertThat(PrioriteAide.CRITIQUE.isDelaiDepasse(dateCreationLimite)).isFalse(); // 24h = 24h (pas après)
// Test avec URGENTE
dateCreationAncienne = maintenant.minusHours(73);
assertThat(PrioriteAide.URGENTE.isDelaiDepasse(dateCreationAncienne)).isTrue(); // 73h > 72h
}
@Test
@DisplayName("Test getPourcentageTempsEcoule - toutes les branches")
void testGetPourcentageTempsEcoule() {
LocalDateTime maintenant = LocalDateTime.now();
// 0% écoulé (juste créé)
LocalDateTime dateCreation = maintenant;
double pourcentage = PrioriteAide.CRITIQUE.getPourcentageTempsEcoule(dateCreation);
assertThat(pourcentage).isCloseTo(0.0, within(1.0));
// 50% écoulé (12h sur 24h)
dateCreation = maintenant.minusHours(12);
pourcentage = PrioriteAide.CRITIQUE.getPourcentageTempsEcoule(dateCreation);
assertThat(pourcentage).isCloseTo(50.0, within(1.0));
// 100% écoulé (24h sur 24h)
dateCreation = maintenant.minusHours(24);
pourcentage = PrioriteAide.CRITIQUE.getPourcentageTempsEcoule(dateCreation);
assertThat(pourcentage).isCloseTo(100.0, within(1.0));
// Plus de 100% écoulé (30h sur 24h) - plafonné à 100%
dateCreation = maintenant.minusHours(30);
pourcentage = PrioriteAide.CRITIQUE.getPourcentageTempsEcoule(dateCreation);
assertThat(pourcentage).isEqualTo(100.0);
// Test cas limite: date future (dureeEcoulee négative)
dateCreation = maintenant.plusHours(1);
pourcentage = PrioriteAide.CRITIQUE.getPourcentageTempsEcoule(dateCreation);
// dateCreation = maintenant + 1h, dateLimite = dateCreation + 24h = maintenant + 25h
// dureeTotal = 24h = 1440 min (positif), dureeEcoulee = -1h = -60 min (négatif)
// Calcul: (-60 * 100) / 1440 = -4.166..., puis Math.min(100, -4.166) = -4.166
assertThat(pourcentage).isCloseTo(-4.166666666666667, within(0.001));
}
@Test
@DisplayName("Test getMessageAlerte - toutes les branches")
void testGetMessageAlerte() {
LocalDateTime maintenant = LocalDateTime.now();
// Aucun message (< 60%)
LocalDateTime dateCreation = maintenant.minusHours(10); // ~42% pour CRITIQUE
String message = PrioriteAide.CRITIQUE.getMessageAlerte(dateCreation);
assertThat(message).isNull();
// Plus de la moitié du délai écoulé (60% <= x < 80%)
dateCreation = maintenant.minusHours(15); // ~62% pour CRITIQUE
message = PrioriteAide.CRITIQUE.getMessageAlerte(dateCreation);
assertThat(message).isEqualTo("Plus de la moitié du délai écoulé");
// Délai bientôt dépassé (80% <= x < 100%)
dateCreation = maintenant.minusHours(20); // ~83% pour CRITIQUE
message = PrioriteAide.CRITIQUE.getMessageAlerte(dateCreation);
assertThat(message).isEqualTo("Délai de traitement bientôt dépassé");
// Délai dépassé (>= 100%)
dateCreation = maintenant.minusHours(25); // > 100% pour CRITIQUE
message = PrioriteAide.CRITIQUE.getMessageAlerte(dateCreation);
assertThat(message).isEqualTo("Délai de traitement dépassé !");
}
}
@Test
@DisplayName("Test cohérence globale des données")
void testCoherenceGlobale() {
for (PrioriteAide priorite : PrioriteAide.values()) {
// Tous les champs obligatoires non null
assertThat(priorite.getLibelle()).isNotNull().isNotEmpty();
assertThat(priorite.getCode()).isNotNull().isNotEmpty();
assertThat(priorite.getDescription()).isNotNull().isNotEmpty();
assertThat(priorite.getCouleur()).isNotNull().matches("#[0-9A-Fa-f]{6}");
assertThat(priorite.getIcone()).isNotNull().isNotEmpty();
assertThat(priorite.getNiveau()).isPositive();
assertThat(priorite.getDelaiTraitementHeures()).isPositive();
// Cohérence logique
if (priorite.getNiveau() <= 2) {
assertThat(priorite.necessiteTraitementImmediat()).isTrue();
}
if (priorite == PrioriteAide.CRITIQUE || priorite == PrioriteAide.URGENTE) {
assertThat(priorite.isUrgente()).isTrue();
}
// Score de priorité cohérent (plus bas = plus prioritaire)
double score = priorite.getScorePriorite();
assertThat(score).isPositive();
// Les méthodes temporelles fonctionnent
LocalDateTime maintenant = LocalDateTime.now();
assertThat(priorite.getDateLimiteTraitement()).isAfter(maintenant);
assertThat(priorite.getPourcentageTempsEcoule(maintenant.minusHours(1))).isBetween(0.0, 100.0);
}
}
}

663
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/enums/solidarite/StatutAideTest.java Normal file
View File

@@ -0,0 +1,663 @@
package dev.lions.unionflow.server.api.enums.solidarite;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.List;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires EXHAUSTIFS pour StatutAide - Couverture 100%
*
* @author UnionFlow Team
* @version 1.0
* @since 2025-01-16
*/
@DisplayName("Tests EXHAUSTIFS StatutAide")
class StatutAideTest {
@Nested
@DisplayName("Tests des valeurs enum et constructeur")
class TestsValeursEnum {
@Test
@DisplayName("Test toutes les valeurs enum avec propriétés exactes")
void testToutesValeursExactes() {
// STATUTS INITIAUX
assertThat(StatutAide.BROUILLON.getLibelle()).isEqualTo("Brouillon");
assertThat(StatutAide.BROUILLON.getCode()).isEqualTo("draft");
assertThat(StatutAide.BROUILLON.getDescription()).isEqualTo("La demande est en cours de rédaction");
assertThat(StatutAide.BROUILLON.getCouleur()).isEqualTo("#9E9E9E");
assertThat(StatutAide.BROUILLON.getIcone()).isEqualTo("edit");
assertThat(StatutAide.BROUILLON.isEstFinal()).isFalse();
assertThat(StatutAide.BROUILLON.isEstEchec()).isFalse();
assertThat(StatutAide.SOUMISE.getLibelle()).isEqualTo("Soumise");
assertThat(StatutAide.SOUMISE.getCode()).isEqualTo("submitted");
assertThat(StatutAide.SOUMISE.getDescription()).isEqualTo("La demande a été soumise et attend validation");
assertThat(StatutAide.SOUMISE.getCouleur()).isEqualTo("#FF9800");
assertThat(StatutAide.SOUMISE.getIcone()).isEqualTo("send");
assertThat(StatutAide.SOUMISE.isEstFinal()).isFalse();
assertThat(StatutAide.SOUMISE.isEstEchec()).isFalse();
// STATUTS D'ÉVALUATION
assertThat(StatutAide.EN_ATTENTE.getLibelle()).isEqualTo("En attente");
assertThat(StatutAide.EN_ATTENTE.getCode()).isEqualTo("pending");
assertThat(StatutAide.EN_ATTENTE.getDescription()).isEqualTo("La demande est en attente d'évaluation");
assertThat(StatutAide.EN_ATTENTE.getCouleur()).isEqualTo("#2196F3");
assertThat(StatutAide.EN_ATTENTE.getIcone()).isEqualTo("hourglass_empty");
assertThat(StatutAide.EN_ATTENTE.isEstFinal()).isFalse();
assertThat(StatutAide.EN_ATTENTE.isEstEchec()).isFalse();
assertThat(StatutAide.EN_COURS_EVALUATION.getLibelle()).isEqualTo("En cours d'évaluation");
assertThat(StatutAide.EN_COURS_EVALUATION.getCode()).isEqualTo("under_review");
assertThat(StatutAide.EN_COURS_EVALUATION.getDescription()).isEqualTo("La demande est en cours d'évaluation");
assertThat(StatutAide.EN_COURS_EVALUATION.getCouleur()).isEqualTo("#FF9800");
assertThat(StatutAide.EN_COURS_EVALUATION.getIcone()).isEqualTo("rate_review");
assertThat(StatutAide.EN_COURS_EVALUATION.isEstFinal()).isFalse();
assertThat(StatutAide.EN_COURS_EVALUATION.isEstEchec()).isFalse();
assertThat(StatutAide.INFORMATIONS_REQUISES.getLibelle()).isEqualTo("Informations requises");
assertThat(StatutAide.INFORMATIONS_REQUISES.getCode()).isEqualTo("info_required");
assertThat(StatutAide.INFORMATIONS_REQUISES.getDescription()).isEqualTo("Des informations complémentaires sont requises");
assertThat(StatutAide.INFORMATIONS_REQUISES.getCouleur()).isEqualTo("#FF5722");
assertThat(StatutAide.INFORMATIONS_REQUISES.getIcone()).isEqualTo("info");
assertThat(StatutAide.INFORMATIONS_REQUISES.isEstFinal()).isFalse();
assertThat(StatutAide.INFORMATIONS_REQUISES.isEstEchec()).isFalse();
// STATUTS DE DÉCISION
assertThat(StatutAide.APPROUVEE.getLibelle()).isEqualTo("Approuvée");
assertThat(StatutAide.APPROUVEE.getCode()).isEqualTo("approved");
assertThat(StatutAide.APPROUVEE.getDescription()).isEqualTo("La demande a été approuvée");
assertThat(StatutAide.APPROUVEE.getCouleur()).isEqualTo("#4CAF50");
assertThat(StatutAide.APPROUVEE.getIcone()).isEqualTo("check_circle");
assertThat(StatutAide.APPROUVEE.isEstFinal()).isTrue();
assertThat(StatutAide.APPROUVEE.isEstEchec()).isFalse();
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.getLibelle()).isEqualTo("Approuvée partiellement");
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.getCode()).isEqualTo("partially_approved");
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.getDescription()).isEqualTo("La demande a été approuvée partiellement");
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.getCouleur()).isEqualTo("#8BC34A");
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.getIcone()).isEqualTo("check_circle_outline");
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.isEstFinal()).isTrue();
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.isEstEchec()).isFalse();
assertThat(StatutAide.REJETEE.getLibelle()).isEqualTo("Rejetée");
assertThat(StatutAide.REJETEE.getCode()).isEqualTo("rejected");
assertThat(StatutAide.REJETEE.getDescription()).isEqualTo("La demande a été rejetée");
assertThat(StatutAide.REJETEE.getCouleur()).isEqualTo("#F44336");
assertThat(StatutAide.REJETEE.getIcone()).isEqualTo("cancel");
assertThat(StatutAide.REJETEE.isEstFinal()).isTrue();
assertThat(StatutAide.REJETEE.isEstEchec()).isTrue();
// STATUTS DE TRAITEMENT
assertThat(StatutAide.EN_COURS_TRAITEMENT.getLibelle()).isEqualTo("En cours de traitement");
assertThat(StatutAide.EN_COURS_TRAITEMENT.getCode()).isEqualTo("processing");
assertThat(StatutAide.EN_COURS_TRAITEMENT.getDescription()).isEqualTo("La demande approuvée est en cours de traitement");
assertThat(StatutAide.EN_COURS_TRAITEMENT.getCouleur()).isEqualTo("#9C27B0");
assertThat(StatutAide.EN_COURS_TRAITEMENT.getIcone()).isEqualTo("settings");
assertThat(StatutAide.EN_COURS_TRAITEMENT.isEstFinal()).isFalse();
assertThat(StatutAide.EN_COURS_TRAITEMENT.isEstEchec()).isFalse();
assertThat(StatutAide.EN_COURS_VERSEMENT.getLibelle()).isEqualTo("En cours de versement");
assertThat(StatutAide.EN_COURS_VERSEMENT.getCode()).isEqualTo("payment_processing");
assertThat(StatutAide.EN_COURS_VERSEMENT.getDescription()).isEqualTo("Le versement est en cours");
assertThat(StatutAide.EN_COURS_VERSEMENT.getCouleur()).isEqualTo("#3F51B5");
assertThat(StatutAide.EN_COURS_VERSEMENT.getIcone()).isEqualTo("payment");
assertThat(StatutAide.EN_COURS_VERSEMENT.isEstFinal()).isFalse();
assertThat(StatutAide.EN_COURS_VERSEMENT.isEstEchec()).isFalse();
// STATUTS FINAUX
assertThat(StatutAide.VERSEE.getLibelle()).isEqualTo("Versée");
assertThat(StatutAide.VERSEE.getCode()).isEqualTo("paid");
assertThat(StatutAide.VERSEE.getDescription()).isEqualTo("L'aide a été versée avec succès");
assertThat(StatutAide.VERSEE.getCouleur()).isEqualTo("#4CAF50");
assertThat(StatutAide.VERSEE.getIcone()).isEqualTo("paid");
assertThat(StatutAide.VERSEE.isEstFinal()).isTrue();
assertThat(StatutAide.VERSEE.isEstEchec()).isFalse();
assertThat(StatutAide.LIVREE.getLibelle()).isEqualTo("Livrée");
assertThat(StatutAide.LIVREE.getCode()).isEqualTo("delivered");
assertThat(StatutAide.LIVREE.getDescription()).isEqualTo("L'aide matérielle a été livrée");
assertThat(StatutAide.LIVREE.getCouleur()).isEqualTo("#4CAF50");
assertThat(StatutAide.LIVREE.getIcone()).isEqualTo("local_shipping");
assertThat(StatutAide.LIVREE.isEstFinal()).isTrue();
assertThat(StatutAide.LIVREE.isEstEchec()).isFalse();
assertThat(StatutAide.TERMINEE.getLibelle()).isEqualTo("Terminée");
assertThat(StatutAide.TERMINEE.getCode()).isEqualTo("completed");
assertThat(StatutAide.TERMINEE.getDescription()).isEqualTo("L'aide a été fournie avec succès");
assertThat(StatutAide.TERMINEE.getCouleur()).isEqualTo("#4CAF50");
assertThat(StatutAide.TERMINEE.getIcone()).isEqualTo("done_all");
assertThat(StatutAide.TERMINEE.isEstFinal()).isTrue();
assertThat(StatutAide.TERMINEE.isEstEchec()).isFalse();
// STATUTS D'EXCEPTION
assertThat(StatutAide.ANNULEE.getLibelle()).isEqualTo("Annulée");
assertThat(StatutAide.ANNULEE.getCode()).isEqualTo("cancelled");
assertThat(StatutAide.ANNULEE.getDescription()).isEqualTo("La demande a été annulée");
assertThat(StatutAide.ANNULEE.getCouleur()).isEqualTo("#9E9E9E");
assertThat(StatutAide.ANNULEE.getIcone()).isEqualTo("cancel");
assertThat(StatutAide.ANNULEE.isEstFinal()).isTrue();
assertThat(StatutAide.ANNULEE.isEstEchec()).isTrue();
assertThat(StatutAide.SUSPENDUE.getLibelle()).isEqualTo("Suspendue");
assertThat(StatutAide.SUSPENDUE.getCode()).isEqualTo("suspended");
assertThat(StatutAide.SUSPENDUE.getDescription()).isEqualTo("La demande a été suspendue temporairement");
assertThat(StatutAide.SUSPENDUE.getCouleur()).isEqualTo("#FF5722");
assertThat(StatutAide.SUSPENDUE.getIcone()).isEqualTo("pause_circle");
assertThat(StatutAide.SUSPENDUE.isEstFinal()).isFalse();
assertThat(StatutAide.SUSPENDUE.isEstEchec()).isFalse();
assertThat(StatutAide.EXPIREE.getLibelle()).isEqualTo("Expirée");
assertThat(StatutAide.EXPIREE.getCode()).isEqualTo("expired");
assertThat(StatutAide.EXPIREE.getDescription()).isEqualTo("La demande a expiré");
assertThat(StatutAide.EXPIREE.getCouleur()).isEqualTo("#795548");
assertThat(StatutAide.EXPIREE.getIcone()).isEqualTo("schedule");
assertThat(StatutAide.EXPIREE.isEstFinal()).isTrue();
assertThat(StatutAide.EXPIREE.isEstEchec()).isTrue();
// STATUTS DE SUIVI
assertThat(StatutAide.EN_SUIVI.getLibelle()).isEqualTo("En suivi");
assertThat(StatutAide.EN_SUIVI.getCode()).isEqualTo("follow_up");
assertThat(StatutAide.EN_SUIVI.getDescription()).isEqualTo("L'aide fait l'objet d'un suivi");
assertThat(StatutAide.EN_SUIVI.getCouleur()).isEqualTo("#607D8B");
assertThat(StatutAide.EN_SUIVI.getIcone()).isEqualTo("track_changes");
assertThat(StatutAide.EN_SUIVI.isEstFinal()).isFalse();
assertThat(StatutAide.EN_SUIVI.isEstEchec()).isFalse();
assertThat(StatutAide.CLOTUREE.getLibelle()).isEqualTo("Clôturée");
assertThat(StatutAide.CLOTUREE.getCode()).isEqualTo("closed");
assertThat(StatutAide.CLOTUREE.getDescription()).isEqualTo("Le dossier d'aide est clôturé");
assertThat(StatutAide.CLOTUREE.getCouleur()).isEqualTo("#9E9E9E");
assertThat(StatutAide.CLOTUREE.getIcone()).isEqualTo("folder");
assertThat(StatutAide.CLOTUREE.isEstFinal()).isTrue();
assertThat(StatutAide.CLOTUREE.isEstEchec()).isFalse();
}
@Test
@DisplayName("Test valueOf et values")
void testValueOfEtValues() {
StatutAide[] values = StatutAide.values();
assertThat(values).hasSize(18);
assertThat(values).containsExactly(
StatutAide.BROUILLON,
StatutAide.SOUMISE,
StatutAide.EN_ATTENTE,
StatutAide.EN_COURS_EVALUATION,
StatutAide.INFORMATIONS_REQUISES,
StatutAide.APPROUVEE,
StatutAide.APPROUVEE_PARTIELLEMENT,
StatutAide.REJETEE,
StatutAide.EN_COURS_TRAITEMENT,
StatutAide.EN_COURS_VERSEMENT,
StatutAide.VERSEE,
StatutAide.LIVREE,
StatutAide.TERMINEE,
StatutAide.ANNULEE,
StatutAide.SUSPENDUE,
StatutAide.EXPIREE,
StatutAide.EN_SUIVI,
StatutAide.CLOTUREE);
// Test valueOf pour quelques valeurs
assertThat(StatutAide.valueOf("BROUILLON")).isEqualTo(StatutAide.BROUILLON);
assertThat(StatutAide.valueOf("EN_COURS_EVALUATION")).isEqualTo(StatutAide.EN_COURS_EVALUATION);
assertThat(StatutAide.valueOf("APPROUVEE_PARTIELLEMENT")).isEqualTo(StatutAide.APPROUVEE_PARTIELLEMENT);
assertThatThrownBy(() -> StatutAide.valueOf("INEXISTANT"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("Test ordinal, name et toString")
void testOrdinalNameToString() {
assertThat(StatutAide.BROUILLON.ordinal()).isEqualTo(0);
assertThat(StatutAide.SOUMISE.ordinal()).isEqualTo(1);
assertThat(StatutAide.CLOTUREE.ordinal()).isEqualTo(17);
assertThat(StatutAide.BROUILLON.name()).isEqualTo("BROUILLON");
assertThat(StatutAide.EN_COURS_EVALUATION.name()).isEqualTo("EN_COURS_EVALUATION");
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.name()).isEqualTo("APPROUVEE_PARTIELLEMENT");
assertThat(StatutAide.BROUILLON.toString()).isEqualTo("BROUILLON");
assertThat(StatutAide.EN_COURS_EVALUATION.toString()).isEqualTo("EN_COURS_EVALUATION");
}
}
@Nested
@DisplayName("Tests des méthodes métier")
class TestsMethodesMetier {
@Test
@DisplayName("Test isSucces - toutes les branches")
void testIsSucces() {
// Statuts de succès (this == VERSEE || this == LIVREE || this == TERMINEE)
assertThat(StatutAide.VERSEE.isSucces()).isTrue();
assertThat(StatutAide.LIVREE.isSucces()).isTrue();
assertThat(StatutAide.TERMINEE.isSucces()).isTrue();
// Tous les autres statuts ne sont pas des succès
assertThat(StatutAide.BROUILLON.isSucces()).isFalse();
assertThat(StatutAide.SOUMISE.isSucces()).isFalse();
assertThat(StatutAide.EN_ATTENTE.isSucces()).isFalse();
assertThat(StatutAide.EN_COURS_EVALUATION.isSucces()).isFalse();
assertThat(StatutAide.INFORMATIONS_REQUISES.isSucces()).isFalse();
assertThat(StatutAide.APPROUVEE.isSucces()).isFalse();
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.isSucces()).isFalse();
assertThat(StatutAide.REJETEE.isSucces()).isFalse();
assertThat(StatutAide.EN_COURS_TRAITEMENT.isSucces()).isFalse();
assertThat(StatutAide.EN_COURS_VERSEMENT.isSucces()).isFalse();
assertThat(StatutAide.ANNULEE.isSucces()).isFalse();
assertThat(StatutAide.SUSPENDUE.isSucces()).isFalse();
assertThat(StatutAide.EXPIREE.isSucces()).isFalse();
assertThat(StatutAide.EN_SUIVI.isSucces()).isFalse();
assertThat(StatutAide.CLOTUREE.isSucces()).isFalse();
}
@Test
@DisplayName("Test isEnCours - toutes les branches")
void testIsEnCours() {
// Statuts en cours (this == EN_COURS_EVALUATION || this == EN_COURS_TRAITEMENT || this == EN_COURS_VERSEMENT)
assertThat(StatutAide.EN_COURS_EVALUATION.isEnCours()).isTrue();
assertThat(StatutAide.EN_COURS_TRAITEMENT.isEnCours()).isTrue();
assertThat(StatutAide.EN_COURS_VERSEMENT.isEnCours()).isTrue();
// Tous les autres statuts ne sont pas en cours
assertThat(StatutAide.BROUILLON.isEnCours()).isFalse();
assertThat(StatutAide.SOUMISE.isEnCours()).isFalse();
assertThat(StatutAide.EN_ATTENTE.isEnCours()).isFalse();
assertThat(StatutAide.INFORMATIONS_REQUISES.isEnCours()).isFalse();
assertThat(StatutAide.APPROUVEE.isEnCours()).isFalse();
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.isEnCours()).isFalse();
assertThat(StatutAide.REJETEE.isEnCours()).isFalse();
assertThat(StatutAide.VERSEE.isEnCours()).isFalse();
assertThat(StatutAide.LIVREE.isEnCours()).isFalse();
assertThat(StatutAide.TERMINEE.isEnCours()).isFalse();
assertThat(StatutAide.ANNULEE.isEnCours()).isFalse();
assertThat(StatutAide.SUSPENDUE.isEnCours()).isFalse();
assertThat(StatutAide.EXPIREE.isEnCours()).isFalse();
assertThat(StatutAide.EN_SUIVI.isEnCours()).isFalse();
assertThat(StatutAide.CLOTUREE.isEnCours()).isFalse();
}
@Test
@DisplayName("Test permetModification - toutes les branches")
void testPermetModification() {
// Statuts qui permettent modification (this == BROUILLON || this == INFORMATIONS_REQUISES)
assertThat(StatutAide.BROUILLON.permetModification()).isTrue();
assertThat(StatutAide.INFORMATIONS_REQUISES.permetModification()).isTrue();
// Tous les autres statuts ne permettent pas la modification
assertThat(StatutAide.SOUMISE.permetModification()).isFalse();
assertThat(StatutAide.EN_ATTENTE.permetModification()).isFalse();
assertThat(StatutAide.EN_COURS_EVALUATION.permetModification()).isFalse();
assertThat(StatutAide.APPROUVEE.permetModification()).isFalse();
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.permetModification()).isFalse();
assertThat(StatutAide.REJETEE.permetModification()).isFalse();
assertThat(StatutAide.EN_COURS_TRAITEMENT.permetModification()).isFalse();
assertThat(StatutAide.EN_COURS_VERSEMENT.permetModification()).isFalse();
assertThat(StatutAide.VERSEE.permetModification()).isFalse();
assertThat(StatutAide.LIVREE.permetModification()).isFalse();
assertThat(StatutAide.TERMINEE.permetModification()).isFalse();
assertThat(StatutAide.ANNULEE.permetModification()).isFalse();
assertThat(StatutAide.SUSPENDUE.permetModification()).isFalse();
assertThat(StatutAide.EXPIREE.permetModification()).isFalse();
assertThat(StatutAide.EN_SUIVI.permetModification()).isFalse();
assertThat(StatutAide.CLOTUREE.permetModification()).isFalse();
}
@Test
@DisplayName("Test permetAnnulation - toutes les branches")
void testPermetAnnulation() {
// Permet annulation si (!estFinal && this != ANNULEE)
// Statuts non finaux et non annulés = permettent annulation
assertThat(StatutAide.BROUILLON.permetAnnulation()).isTrue();
assertThat(StatutAide.SOUMISE.permetAnnulation()).isTrue();
assertThat(StatutAide.EN_ATTENTE.permetAnnulation()).isTrue();
assertThat(StatutAide.EN_COURS_EVALUATION.permetAnnulation()).isTrue();
assertThat(StatutAide.INFORMATIONS_REQUISES.permetAnnulation()).isTrue();
assertThat(StatutAide.EN_COURS_TRAITEMENT.permetAnnulation()).isTrue();
assertThat(StatutAide.EN_COURS_VERSEMENT.permetAnnulation()).isTrue();
assertThat(StatutAide.SUSPENDUE.permetAnnulation()).isTrue();
assertThat(StatutAide.EN_SUIVI.permetAnnulation()).isTrue();
// Statuts finaux = ne permettent pas annulation
assertThat(StatutAide.APPROUVEE.permetAnnulation()).isFalse();
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.permetAnnulation()).isFalse();
assertThat(StatutAide.REJETEE.permetAnnulation()).isFalse();
assertThat(StatutAide.VERSEE.permetAnnulation()).isFalse();
assertThat(StatutAide.LIVREE.permetAnnulation()).isFalse();
assertThat(StatutAide.TERMINEE.permetAnnulation()).isFalse();
assertThat(StatutAide.EXPIREE.permetAnnulation()).isFalse();
assertThat(StatutAide.CLOTUREE.permetAnnulation()).isFalse();
// ANNULEE = ne permet pas annulation (déjà annulé)
assertThat(StatutAide.ANNULEE.permetAnnulation()).isFalse();
}
}
@Nested
@DisplayName("Tests des méthodes statiques")
class TestsMethodesStatiques {
@Test
@DisplayName("Test getStatutsFinaux")
void testGetStatutsFinaux() {
List<StatutAide> finaux = StatutAide.getStatutsFinaux();
// Vérifier que tous les statuts finaux sont inclus
assertThat(finaux).contains(
StatutAide.APPROUVEE,
StatutAide.APPROUVEE_PARTIELLEMENT,
StatutAide.REJETEE,
StatutAide.VERSEE,
StatutAide.LIVREE,
StatutAide.TERMINEE,
StatutAide.ANNULEE,
StatutAide.EXPIREE,
StatutAide.CLOTUREE);
// Vérifier qu'aucun statut non final n'est inclus
assertThat(finaux).doesNotContain(
StatutAide.BROUILLON,
StatutAide.SOUMISE,
StatutAide.EN_ATTENTE,
StatutAide.EN_COURS_EVALUATION,
StatutAide.INFORMATIONS_REQUISES,
StatutAide.EN_COURS_TRAITEMENT,
StatutAide.EN_COURS_VERSEMENT,
StatutAide.SUSPENDUE,
StatutAide.EN_SUIVI);
// Vérifier que tous les statuts retournés sont bien finaux
finaux.forEach(statut -> assertThat(statut.isEstFinal()).isTrue());
}
@Test
@DisplayName("Test getStatutsEchec")
void testGetStatutsEchec() {
List<StatutAide> echecs = StatutAide.getStatutsEchec();
// Vérifier que tous les statuts d'échec sont inclus
assertThat(echecs).contains(
StatutAide.REJETEE,
StatutAide.ANNULEE,
StatutAide.EXPIREE);
// Vérifier qu'aucun statut non échec n'est inclus
assertThat(echecs).doesNotContain(
StatutAide.BROUILLON,
StatutAide.SOUMISE,
StatutAide.EN_ATTENTE,
StatutAide.EN_COURS_EVALUATION,
StatutAide.INFORMATIONS_REQUISES,
StatutAide.APPROUVEE,
StatutAide.APPROUVEE_PARTIELLEMENT,
StatutAide.EN_COURS_TRAITEMENT,
StatutAide.EN_COURS_VERSEMENT,
StatutAide.VERSEE,
StatutAide.LIVREE,
StatutAide.TERMINEE,
StatutAide.SUSPENDUE,
StatutAide.EN_SUIVI,
StatutAide.CLOTUREE);
// Vérifier que tous les statuts retournés sont bien des échecs
echecs.forEach(statut -> assertThat(statut.isEstEchec()).isTrue());
}
@Test
@DisplayName("Test getStatutsSucces")
void testGetStatutsSucces() {
List<StatutAide> succes = StatutAide.getStatutsSucces();
// Vérifier que tous les statuts de succès sont inclus
assertThat(succes).contains(
StatutAide.VERSEE,
StatutAide.LIVREE,
StatutAide.TERMINEE);
// Vérifier qu'aucun statut non succès n'est inclus
assertThat(succes).doesNotContain(
StatutAide.BROUILLON,
StatutAide.SOUMISE,
StatutAide.EN_ATTENTE,
StatutAide.EN_COURS_EVALUATION,
StatutAide.INFORMATIONS_REQUISES,
StatutAide.APPROUVEE,
StatutAide.APPROUVEE_PARTIELLEMENT,
StatutAide.REJETEE,
StatutAide.EN_COURS_TRAITEMENT,
StatutAide.EN_COURS_VERSEMENT,
StatutAide.ANNULEE,
StatutAide.SUSPENDUE,
StatutAide.EXPIREE,
StatutAide.EN_SUIVI,
StatutAide.CLOTUREE);
// Vérifier que tous les statuts retournés sont bien des succès
succes.forEach(statut -> assertThat(statut.isSucces()).isTrue());
}
@Test
@DisplayName("Test getStatutsEnCours")
void testGetStatutsEnCours() {
List<StatutAide> enCours = StatutAide.getStatutsEnCours();
// Vérifier que tous les statuts en cours sont inclus
assertThat(enCours).contains(
StatutAide.EN_COURS_EVALUATION,
StatutAide.EN_COURS_TRAITEMENT,
StatutAide.EN_COURS_VERSEMENT);
// Vérifier qu'aucun statut non en cours n'est inclus
assertThat(enCours).doesNotContain(
StatutAide.BROUILLON,
StatutAide.SOUMISE,
StatutAide.EN_ATTENTE,
StatutAide.INFORMATIONS_REQUISES,
StatutAide.APPROUVEE,
StatutAide.APPROUVEE_PARTIELLEMENT,
StatutAide.REJETEE,
StatutAide.VERSEE,
StatutAide.LIVREE,
StatutAide.TERMINEE,
StatutAide.ANNULEE,
StatutAide.SUSPENDUE,
StatutAide.EXPIREE,
StatutAide.EN_SUIVI,
StatutAide.CLOTUREE);
// Vérifier que tous les statuts retournés sont bien en cours
enCours.forEach(statut -> assertThat(statut.isEnCours()).isTrue());
}
}
@Nested
@DisplayName("Tests des méthodes complexes")
class TestsMethodesComplexes {
@Test
@DisplayName("Test peutTransitionnerVers - toutes les branches du switch")
void testPeutTransitionnerVers() {
// Règles générales
// this == nouveauStatut -> false
assertThat(StatutAide.BROUILLON.peutTransitionnerVers(StatutAide.BROUILLON)).isFalse();
assertThat(StatutAide.EN_ATTENTE.peutTransitionnerVers(StatutAide.EN_ATTENTE)).isFalse();
// estFinal && nouveauStatut != EN_SUIVI -> false
assertThat(StatutAide.TERMINEE.peutTransitionnerVers(StatutAide.BROUILLON)).isFalse();
assertThat(StatutAide.VERSEE.peutTransitionnerVers(StatutAide.EN_ATTENTE)).isFalse();
assertThat(StatutAide.REJETEE.peutTransitionnerVers(StatutAide.APPROUVEE)).isFalse();
// estFinal && nouveauStatut == EN_SUIVI -> mais default false dans switch
// Les statuts finaux ne sont pas dans le switch, donc default -> false
assertThat(StatutAide.TERMINEE.peutTransitionnerVers(StatutAide.EN_SUIVI)).isFalse();
assertThat(StatutAide.VERSEE.peutTransitionnerVers(StatutAide.EN_SUIVI)).isFalse();
assertThat(StatutAide.REJETEE.peutTransitionnerVers(StatutAide.EN_SUIVI)).isFalse();
// BROUILLON -> SOUMISE || ANNULEE
assertThat(StatutAide.BROUILLON.peutTransitionnerVers(StatutAide.SOUMISE)).isTrue();
assertThat(StatutAide.BROUILLON.peutTransitionnerVers(StatutAide.ANNULEE)).isTrue();
assertThat(StatutAide.BROUILLON.peutTransitionnerVers(StatutAide.EN_ATTENTE)).isFalse();
assertThat(StatutAide.BROUILLON.peutTransitionnerVers(StatutAide.APPROUVEE)).isFalse();
// SOUMISE -> EN_ATTENTE || ANNULEE
assertThat(StatutAide.SOUMISE.peutTransitionnerVers(StatutAide.EN_ATTENTE)).isTrue();
assertThat(StatutAide.SOUMISE.peutTransitionnerVers(StatutAide.ANNULEE)).isTrue();
assertThat(StatutAide.SOUMISE.peutTransitionnerVers(StatutAide.BROUILLON)).isFalse();
assertThat(StatutAide.SOUMISE.peutTransitionnerVers(StatutAide.APPROUVEE)).isFalse();
// EN_ATTENTE -> EN_COURS_EVALUATION || ANNULEE
assertThat(StatutAide.EN_ATTENTE.peutTransitionnerVers(StatutAide.EN_COURS_EVALUATION)).isTrue();
assertThat(StatutAide.EN_ATTENTE.peutTransitionnerVers(StatutAide.ANNULEE)).isTrue();
assertThat(StatutAide.EN_ATTENTE.peutTransitionnerVers(StatutAide.SOUMISE)).isFalse();
assertThat(StatutAide.EN_ATTENTE.peutTransitionnerVers(StatutAide.APPROUVEE)).isFalse();
// EN_COURS_EVALUATION -> APPROUVEE || APPROUVEE_PARTIELLEMENT || REJETEE || INFORMATIONS_REQUISES || SUSPENDUE
assertThat(StatutAide.EN_COURS_EVALUATION.peutTransitionnerVers(StatutAide.APPROUVEE)).isTrue();
assertThat(StatutAide.EN_COURS_EVALUATION.peutTransitionnerVers(StatutAide.APPROUVEE_PARTIELLEMENT)).isTrue();
assertThat(StatutAide.EN_COURS_EVALUATION.peutTransitionnerVers(StatutAide.REJETEE)).isTrue();
assertThat(StatutAide.EN_COURS_EVALUATION.peutTransitionnerVers(StatutAide.INFORMATIONS_REQUISES)).isTrue();
assertThat(StatutAide.EN_COURS_EVALUATION.peutTransitionnerVers(StatutAide.SUSPENDUE)).isTrue();
assertThat(StatutAide.EN_COURS_EVALUATION.peutTransitionnerVers(StatutAide.EN_ATTENTE)).isFalse();
assertThat(StatutAide.EN_COURS_EVALUATION.peutTransitionnerVers(StatutAide.TERMINEE)).isFalse();
// INFORMATIONS_REQUISES -> EN_COURS_EVALUATION || ANNULEE
assertThat(StatutAide.INFORMATIONS_REQUISES.peutTransitionnerVers(StatutAide.EN_COURS_EVALUATION)).isTrue();
assertThat(StatutAide.INFORMATIONS_REQUISES.peutTransitionnerVers(StatutAide.ANNULEE)).isTrue();
assertThat(StatutAide.INFORMATIONS_REQUISES.peutTransitionnerVers(StatutAide.APPROUVEE)).isFalse();
assertThat(StatutAide.INFORMATIONS_REQUISES.peutTransitionnerVers(StatutAide.BROUILLON)).isFalse();
// APPROUVEE, APPROUVEE_PARTIELLEMENT sont estFinal=true, donc condition estFinal bloque
// Même si le switch permet ces transitions, la condition estFinal prend le dessus
assertThat(StatutAide.APPROUVEE.peutTransitionnerVers(StatutAide.EN_COURS_TRAITEMENT)).isFalse();
assertThat(StatutAide.APPROUVEE.peutTransitionnerVers(StatutAide.SUSPENDUE)).isFalse();
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.peutTransitionnerVers(StatutAide.EN_COURS_TRAITEMENT)).isFalse();
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.peutTransitionnerVers(StatutAide.SUSPENDUE)).isFalse();
assertThat(StatutAide.APPROUVEE.peutTransitionnerVers(StatutAide.TERMINEE)).isFalse();
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.peutTransitionnerVers(StatutAide.REJETEE)).isFalse();
// EN_COURS_TRAITEMENT -> EN_COURS_VERSEMENT || LIVREE || TERMINEE || SUSPENDUE
assertThat(StatutAide.EN_COURS_TRAITEMENT.peutTransitionnerVers(StatutAide.EN_COURS_VERSEMENT)).isTrue();
assertThat(StatutAide.EN_COURS_TRAITEMENT.peutTransitionnerVers(StatutAide.LIVREE)).isTrue();
assertThat(StatutAide.EN_COURS_TRAITEMENT.peutTransitionnerVers(StatutAide.TERMINEE)).isTrue();
assertThat(StatutAide.EN_COURS_TRAITEMENT.peutTransitionnerVers(StatutAide.SUSPENDUE)).isTrue();
assertThat(StatutAide.EN_COURS_TRAITEMENT.peutTransitionnerVers(StatutAide.APPROUVEE)).isFalse();
assertThat(StatutAide.EN_COURS_TRAITEMENT.peutTransitionnerVers(StatutAide.REJETEE)).isFalse();
// EN_COURS_VERSEMENT -> VERSEE || SUSPENDUE
assertThat(StatutAide.EN_COURS_VERSEMENT.peutTransitionnerVers(StatutAide.VERSEE)).isTrue();
assertThat(StatutAide.EN_COURS_VERSEMENT.peutTransitionnerVers(StatutAide.SUSPENDUE)).isTrue();
assertThat(StatutAide.EN_COURS_VERSEMENT.peutTransitionnerVers(StatutAide.TERMINEE)).isFalse();
assertThat(StatutAide.EN_COURS_VERSEMENT.peutTransitionnerVers(StatutAide.LIVREE)).isFalse();
// SUSPENDUE -> EN_COURS_EVALUATION || ANNULEE
assertThat(StatutAide.SUSPENDUE.peutTransitionnerVers(StatutAide.EN_COURS_EVALUATION)).isTrue();
assertThat(StatutAide.SUSPENDUE.peutTransitionnerVers(StatutAide.ANNULEE)).isTrue();
assertThat(StatutAide.SUSPENDUE.peutTransitionnerVers(StatutAide.APPROUVEE)).isFalse();
assertThat(StatutAide.SUSPENDUE.peutTransitionnerVers(StatutAide.TERMINEE)).isFalse();
// default -> false (pour les statuts non couverts par le switch)
// EN_SUIVI n'est pas dans le switch, donc default -> false
assertThat(StatutAide.EN_SUIVI.peutTransitionnerVers(StatutAide.CLOTUREE)).isFalse();
assertThat(StatutAide.EN_SUIVI.peutTransitionnerVers(StatutAide.TERMINEE)).isFalse();
// Autres statuts finaux (déjà testés avec règle estFinal)
assertThat(StatutAide.VERSEE.peutTransitionnerVers(StatutAide.TERMINEE)).isFalse(); // Statut final, sauf EN_SUIVI
assertThat(StatutAide.LIVREE.peutTransitionnerVers(StatutAide.VERSEE)).isFalse(); // Statut final, sauf EN_SUIVI
}
@Test
@DisplayName("Test getNiveauPriorite - toutes les branches du switch")
void testGetNiveauPriorite() {
// INFORMATIONS_REQUISES -> 1
assertThat(StatutAide.INFORMATIONS_REQUISES.getNiveauPriorite()).isEqualTo(1);
// EN_COURS_EVALUATION, EN_COURS_TRAITEMENT, EN_COURS_VERSEMENT -> 2
assertThat(StatutAide.EN_COURS_EVALUATION.getNiveauPriorite()).isEqualTo(2);
assertThat(StatutAide.EN_COURS_TRAITEMENT.getNiveauPriorite()).isEqualTo(2);
assertThat(StatutAide.EN_COURS_VERSEMENT.getNiveauPriorite()).isEqualTo(2);
// APPROUVEE, APPROUVEE_PARTIELLEMENT -> 3
assertThat(StatutAide.APPROUVEE.getNiveauPriorite()).isEqualTo(3);
assertThat(StatutAide.APPROUVEE_PARTIELLEMENT.getNiveauPriorite()).isEqualTo(3);
// EN_ATTENTE, SOUMISE -> 4
assertThat(StatutAide.EN_ATTENTE.getNiveauPriorite()).isEqualTo(4);
assertThat(StatutAide.SOUMISE.getNiveauPriorite()).isEqualTo(4);
// SUSPENDUE -> 5
assertThat(StatutAide.SUSPENDUE.getNiveauPriorite()).isEqualTo(5);
// BROUILLON -> 6
assertThat(StatutAide.BROUILLON.getNiveauPriorite()).isEqualTo(6);
// EN_SUIVI -> 7
assertThat(StatutAide.EN_SUIVI.getNiveauPriorite()).isEqualTo(7);
// default -> 8 (Statuts finaux)
assertThat(StatutAide.REJETEE.getNiveauPriorite()).isEqualTo(8);
assertThat(StatutAide.VERSEE.getNiveauPriorite()).isEqualTo(8);
assertThat(StatutAide.LIVREE.getNiveauPriorite()).isEqualTo(8);
assertThat(StatutAide.TERMINEE.getNiveauPriorite()).isEqualTo(8);
assertThat(StatutAide.ANNULEE.getNiveauPriorite()).isEqualTo(8);
assertThat(StatutAide.EXPIREE.getNiveauPriorite()).isEqualTo(8);
assertThat(StatutAide.CLOTUREE.getNiveauPriorite()).isEqualTo(8);
}
}
@Test
@DisplayName("Test cohérence globale des données")
void testCoherenceGlobale() {
for (StatutAide statut : StatutAide.values()) {
// Tous les champs obligatoires non null
assertThat(statut.getLibelle()).isNotNull().isNotEmpty();
assertThat(statut.getCode()).isNotNull().isNotEmpty();
assertThat(statut.getDescription()).isNotNull().isNotEmpty();
assertThat(statut.getCouleur()).isNotNull().matches("#[0-9A-Fa-f]{6}");
assertThat(statut.getIcone()).isNotNull().isNotEmpty();
// Cohérence logique
if (statut.isEstFinal()) {
// Les statuts finaux ne permettent pas la modification
assertThat(statut.permetModification()).isFalse();
// Les statuts finaux ne permettent pas l'annulation (sauf transition vers EN_SUIVI)
assertThat(statut.permetAnnulation()).isFalse();
}
if (statut.isEstEchec()) {
// Les statuts d'échec ne sont pas des succès
assertThat(statut.isSucces()).isFalse();
// Les statuts d'échec sont finaux
assertThat(statut.isEstFinal()).isTrue();
}
if (statut.isSucces()) {
// Les statuts de succès ne sont pas des échecs
assertThat(statut.isEstEchec()).isFalse();
// Les statuts de succès sont finaux
assertThat(statut.isEstFinal()).isTrue();
}
if (statut.isEnCours()) {
// Les statuts en cours ne sont pas finaux
assertThat(statut.isEstFinal()).isFalse();
// Les statuts en cours ne sont ni succès ni échec
assertThat(statut.isSucces()).isFalse();
assertThat(statut.isEstEchec()).isFalse();
}
// Niveau de priorité cohérent
int niveau = statut.getNiveauPriorite();
assertThat(niveau).isBetween(1, 8);
// Transitions cohérentes
assertThat(statut.peutTransitionnerVers(statut)).isFalse(); // Pas de transition vers soi-même
}
}
}

554
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/enums/solidarite/TypeAideTest.java Normal file
View File

@@ -0,0 +1,554 @@
package dev.lions.unionflow.server.api.enums.solidarite;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.within;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.List;
import java.util.Set;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires EXHAUSTIFS pour TypeAide - Couverture 100%
*
* @author UnionFlow Team
* @version 1.0
* @since 2025-01-16
*/
@DisplayName("Tests EXHAUSTIFS TypeAide")
class TypeAideTest {
@Nested
@DisplayName("Tests des valeurs enum et constructeur")
class TestsValeursEnum {
@Test
@DisplayName("Test valueOf et values")
void testValueOfEtValues() {
TypeAide[] values = TypeAide.values();
assertThat(values).hasSize(24);
assertThat(values).containsExactly(
TypeAide.AIDE_FINANCIERE_URGENTE,
TypeAide.PRET_SANS_INTERET,
TypeAide.AIDE_COTISATION,
TypeAide.AIDE_FRAIS_MEDICAUX,
TypeAide.AIDE_FRAIS_SCOLARITE,
TypeAide.DON_MATERIEL,
TypeAide.PRET_MATERIEL,
TypeAide.AIDE_DEMENAGEMENT,
TypeAide.AIDE_TRAVAUX,
TypeAide.AIDE_RECHERCHE_EMPLOI,
TypeAide.FORMATION_PROFESSIONNELLE,
TypeAide.CONSEIL_JURIDIQUE,
TypeAide.AIDE_CREATION_ENTREPRISE,
TypeAide.GARDE_ENFANTS,
TypeAide.AIDE_PERSONNES_AGEES,
TypeAide.TRANSPORT,
TypeAide.AIDE_ADMINISTRATIVE,
TypeAide.HEBERGEMENT_URGENCE,
TypeAide.AIDE_ALIMENTAIRE,
TypeAide.AIDE_VESTIMENTAIRE,
TypeAide.SOUTIEN_PSYCHOLOGIQUE,
TypeAide.AIDE_NUMERIQUE,
TypeAide.TRADUCTION,
TypeAide.AUTRE);
// Test valueOf pour quelques valeurs
assertThat(TypeAide.valueOf("AIDE_FINANCIERE_URGENTE")).isEqualTo(TypeAide.AIDE_FINANCIERE_URGENTE);
assertThat(TypeAide.valueOf("HEBERGEMENT_URGENCE")).isEqualTo(TypeAide.HEBERGEMENT_URGENCE);
assertThat(TypeAide.valueOf("SOUTIEN_PSYCHOLOGIQUE")).isEqualTo(TypeAide.SOUTIEN_PSYCHOLOGIQUE);
assertThatThrownBy(() -> TypeAide.valueOf("INEXISTANT"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
@DisplayName("Test ordinal, name et toString")
void testOrdinalNameToString() {
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.ordinal()).isEqualTo(0);
assertThat(TypeAide.PRET_SANS_INTERET.ordinal()).isEqualTo(1);
assertThat(TypeAide.AUTRE.ordinal()).isEqualTo(23);
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.name()).isEqualTo("AIDE_FINANCIERE_URGENTE");
assertThat(TypeAide.HEBERGEMENT_URGENCE.name()).isEqualTo("HEBERGEMENT_URGENCE");
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.toString()).isEqualTo("AIDE_FINANCIERE_URGENTE");
assertThat(TypeAide.SOUTIEN_PSYCHOLOGIQUE.toString()).isEqualTo("SOUTIEN_PSYCHOLOGIQUE");
}
@Test
@DisplayName("Test propriétés AIDE_FINANCIERE_URGENTE")
void testProprietesAideFinanciereUrgente() {
TypeAide type = TypeAide.AIDE_FINANCIERE_URGENTE;
assertThat(type.getLibelle()).isEqualTo("Aide financière urgente");
assertThat(type.getCategorie()).isEqualTo("financiere");
assertThat(type.getPriorite()).isEqualTo("urgent");
assertThat(type.getDescription()).isEqualTo("Aide financière pour situation d'urgence");
assertThat(type.getIcone()).isEqualTo("emergency_fund");
assertThat(type.getCouleur()).isEqualTo("#F44336");
assertThat(type.isNecessiteMontant()).isTrue();
assertThat(type.isNecessiteValidation()).isTrue();
assertThat(type.getMontantMin()).isEqualTo(5000.0);
assertThat(type.getMontantMax()).isEqualTo(50000.0);
assertThat(type.getDelaiReponseJours()).isEqualTo(7);
}
@Test
@DisplayName("Test propriétés PRET_SANS_INTERET")
void testProprietesPreSansInteret() {
TypeAide type = TypeAide.PRET_SANS_INTERET;
assertThat(type.getLibelle()).isEqualTo("Prêt sans intérêt");
assertThat(type.getCategorie()).isEqualTo("financiere");
assertThat(type.getPriorite()).isEqualTo("important");
assertThat(type.getDescription()).isEqualTo("Prêt sans intérêt entre membres");
assertThat(type.getIcone()).isEqualTo("account_balance");
assertThat(type.getCouleur()).isEqualTo("#FF9800");
assertThat(type.isNecessiteMontant()).isTrue();
assertThat(type.isNecessiteValidation()).isTrue();
assertThat(type.getMontantMin()).isEqualTo(10000.0);
assertThat(type.getMontantMax()).isEqualTo(100000.0);
assertThat(type.getDelaiReponseJours()).isEqualTo(30);
}
@Test
@DisplayName("Test propriétés DON_MATERIEL")
void testProprietesDoMateriel() {
TypeAide type = TypeAide.DON_MATERIEL;
assertThat(type.getLibelle()).isEqualTo("Don de matériel");
assertThat(type.getCategorie()).isEqualTo("materielle");
assertThat(type.getPriorite()).isEqualTo("normal");
assertThat(type.getDescription()).isEqualTo("Don d'objets, équipements ou matériel");
assertThat(type.getIcone()).isEqualTo("inventory");
assertThat(type.getCouleur()).isEqualTo("#4CAF50");
assertThat(type.isNecessiteMontant()).isFalse();
assertThat(type.isNecessiteValidation()).isFalse();
assertThat(type.getMontantMin()).isNull();
assertThat(type.getMontantMax()).isNull();
assertThat(type.getDelaiReponseJours()).isEqualTo(14);
}
@Test
@DisplayName("Test propriétés HEBERGEMENT_URGENCE")
void testProprietesHebergementUrgence() {
TypeAide type = TypeAide.HEBERGEMENT_URGENCE;
assertThat(type.getLibelle()).isEqualTo("Hébergement d'urgence");
assertThat(type.getCategorie()).isEqualTo("urgence");
assertThat(type.getPriorite()).isEqualTo("urgent");
assertThat(type.getDescription()).isEqualTo("Hébergement temporaire d'urgence");
assertThat(type.getIcone()).isEqualTo("home");
assertThat(type.getCouleur()).isEqualTo("#F44336");
assertThat(type.isNecessiteMontant()).isFalse();
assertThat(type.isNecessiteValidation()).isTrue();
assertThat(type.getMontantMin()).isNull();
assertThat(type.getMontantMax()).isNull();
assertThat(type.getDelaiReponseJours()).isEqualTo(7);
}
@Test
@DisplayName("Test propriétés AIDE_ALIMENTAIRE")
void testProprietesAideAlimentaire() {
TypeAide type = TypeAide.AIDE_ALIMENTAIRE;
assertThat(type.getLibelle()).isEqualTo("Aide alimentaire");
assertThat(type.getCategorie()).isEqualTo("urgence");
assertThat(type.getPriorite()).isEqualTo("urgent");
assertThat(type.getDescription()).isEqualTo("Aide alimentaire d'urgence");
assertThat(type.getIcone()).isEqualTo("restaurant");
assertThat(type.getCouleur()).isEqualTo("#FF5722");
assertThat(type.isNecessiteMontant()).isFalse();
assertThat(type.isNecessiteValidation()).isTrue();
assertThat(type.getMontantMin()).isNull();
assertThat(type.getMontantMax()).isNull();
assertThat(type.getDelaiReponseJours()).isEqualTo(3);
}
@Test
@DisplayName("Test propriétés SOUTIEN_PSYCHOLOGIQUE")
void testProprieteSoutienPsychologique() {
TypeAide type = TypeAide.SOUTIEN_PSYCHOLOGIQUE;
assertThat(type.getLibelle()).isEqualTo("Soutien psychologique");
assertThat(type.getCategorie()).isEqualTo("specialisee");
assertThat(type.getPriorite()).isEqualTo("important");
assertThat(type.getDescription()).isEqualTo("Soutien et écoute psychologique");
assertThat(type.getIcone()).isEqualTo("psychology");
assertThat(type.getCouleur()).isEqualTo("#E91E63");
assertThat(type.isNecessiteMontant()).isFalse();
assertThat(type.isNecessiteValidation()).isTrue();
assertThat(type.getMontantMin()).isNull();
assertThat(type.getMontantMax()).isNull();
assertThat(type.getDelaiReponseJours()).isEqualTo(30);
}
@Test
@DisplayName("Test propriétés AUTRE")
void testProprietesAutre() {
TypeAide type = TypeAide.AUTRE;
assertThat(type.getLibelle()).isEqualTo("Autre");
assertThat(type.getCategorie()).isEqualTo("autre");
assertThat(type.getPriorite()).isEqualTo("normal");
assertThat(type.getDescription()).isEqualTo("Autre type d'aide non catégorisé");
assertThat(type.getIcone()).isEqualTo("help");
assertThat(type.getCouleur()).isEqualTo("#9E9E9E");
assertThat(type.isNecessiteMontant()).isFalse();
assertThat(type.isNecessiteValidation()).isFalse();
assertThat(type.getMontantMin()).isNull();
assertThat(type.getMontantMax()).isNull();
assertThat(type.getDelaiReponseJours()).isEqualTo(14);
}
}
@Nested
@DisplayName("Tests des méthodes métier")
class TestsMethodesMetier {
@Test
@DisplayName("Test isUrgent - toutes les branches")
void testIsUrgent() {
// Types urgents (priorite == "urgent")
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.isUrgent()).isTrue();
assertThat(TypeAide.AIDE_FRAIS_MEDICAUX.isUrgent()).isTrue();
assertThat(TypeAide.HEBERGEMENT_URGENCE.isUrgent()).isTrue();
assertThat(TypeAide.AIDE_ALIMENTAIRE.isUrgent()).isTrue();
// Types non urgents
assertThat(TypeAide.PRET_SANS_INTERET.isUrgent()).isFalse(); // "important"
assertThat(TypeAide.DON_MATERIEL.isUrgent()).isFalse(); // "normal"
assertThat(TypeAide.AIDE_RECHERCHE_EMPLOI.isUrgent()).isFalse(); // "important"
assertThat(TypeAide.FORMATION_PROFESSIONNELLE.isUrgent()).isFalse(); // "normal"
assertThat(TypeAide.AUTRE.isUrgent()).isFalse(); // "normal"
}
@Test
@DisplayName("Test isFinancier - toutes les branches")
void testIsFinancier() {
// Types financiers (categorie == "financiere")
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.isFinancier()).isTrue();
assertThat(TypeAide.PRET_SANS_INTERET.isFinancier()).isTrue();
assertThat(TypeAide.AIDE_COTISATION.isFinancier()).isTrue();
assertThat(TypeAide.AIDE_FRAIS_MEDICAUX.isFinancier()).isTrue();
assertThat(TypeAide.AIDE_FRAIS_SCOLARITE.isFinancier()).isTrue();
// Types non financiers
assertThat(TypeAide.DON_MATERIEL.isFinancier()).isFalse(); // "materielle"
assertThat(TypeAide.AIDE_RECHERCHE_EMPLOI.isFinancier()).isFalse(); // "professionnelle"
assertThat(TypeAide.GARDE_ENFANTS.isFinancier()).isFalse(); // "sociale"
assertThat(TypeAide.HEBERGEMENT_URGENCE.isFinancier()).isFalse(); // "urgence"
assertThat(TypeAide.SOUTIEN_PSYCHOLOGIQUE.isFinancier()).isFalse(); // "specialisee"
assertThat(TypeAide.AUTRE.isFinancier()).isFalse(); // "autre"
}
@Test
@DisplayName("Test isMateriel - toutes les branches")
void testIsMateriel() {
// Types matériels (categorie == "materielle")
assertThat(TypeAide.DON_MATERIEL.isMateriel()).isTrue();
assertThat(TypeAide.PRET_MATERIEL.isMateriel()).isTrue();
assertThat(TypeAide.AIDE_DEMENAGEMENT.isMateriel()).isTrue();
assertThat(TypeAide.AIDE_TRAVAUX.isMateriel()).isTrue();
// Types non matériels
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.isMateriel()).isFalse(); // "financiere"
assertThat(TypeAide.AIDE_RECHERCHE_EMPLOI.isMateriel()).isFalse(); // "professionnelle"
assertThat(TypeAide.GARDE_ENFANTS.isMateriel()).isFalse(); // "sociale"
assertThat(TypeAide.HEBERGEMENT_URGENCE.isMateriel()).isFalse(); // "urgence"
assertThat(TypeAide.SOUTIEN_PSYCHOLOGIQUE.isMateriel()).isFalse(); // "specialisee"
assertThat(TypeAide.AUTRE.isMateriel()).isFalse(); // "autre"
}
@Test
@DisplayName("Test isMontantValide - toutes les branches")
void testIsMontantValide() {
// Type qui ne nécessite pas de montant -> toujours valide
assertThat(TypeAide.DON_MATERIEL.isMontantValide(null)).isTrue();
assertThat(TypeAide.DON_MATERIEL.isMontantValide(1000.0)).isTrue();
assertThat(TypeAide.DON_MATERIEL.isMontantValide(-1000.0)).isTrue();
// Type qui nécessite un montant mais montant null -> valide
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.isMontantValide(null)).isTrue();
// Type avec montant min/max : AIDE_FINANCIERE_URGENTE (5000-50000)
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.isMontantValide(4999.0)).isFalse(); // < min
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.isMontantValide(5000.0)).isTrue(); // = min
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.isMontantValide(25000.0)).isTrue(); // dans la fourchette
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.isMontantValide(50000.0)).isTrue(); // = max
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.isMontantValide(50001.0)).isFalse(); // > max
// Type avec montant min/max : PRET_SANS_INTERET (10000-100000)
assertThat(TypeAide.PRET_SANS_INTERET.isMontantValide(9999.0)).isFalse(); // < min
assertThat(TypeAide.PRET_SANS_INTERET.isMontantValide(10000.0)).isTrue(); // = min
assertThat(TypeAide.PRET_SANS_INTERET.isMontantValide(50000.0)).isTrue(); // dans la fourchette
assertThat(TypeAide.PRET_SANS_INTERET.isMontantValide(100000.0)).isTrue(); // = max
assertThat(TypeAide.PRET_SANS_INTERET.isMontantValide(100001.0)).isFalse(); // > max
}
@Test
@DisplayName("Test getNiveauPriorite - toutes les branches du switch")
void testGetNiveauPriorite() {
// "urgent" -> 1
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getNiveauPriorite()).isEqualTo(1);
assertThat(TypeAide.AIDE_FRAIS_MEDICAUX.getNiveauPriorite()).isEqualTo(1);
assertThat(TypeAide.HEBERGEMENT_URGENCE.getNiveauPriorite()).isEqualTo(1);
assertThat(TypeAide.AIDE_ALIMENTAIRE.getNiveauPriorite()).isEqualTo(1);
// "important" -> 2
assertThat(TypeAide.PRET_SANS_INTERET.getNiveauPriorite()).isEqualTo(2);
assertThat(TypeAide.AIDE_FRAIS_SCOLARITE.getNiveauPriorite()).isEqualTo(2);
assertThat(TypeAide.AIDE_RECHERCHE_EMPLOI.getNiveauPriorite()).isEqualTo(2);
assertThat(TypeAide.CONSEIL_JURIDIQUE.getNiveauPriorite()).isEqualTo(2);
assertThat(TypeAide.AIDE_PERSONNES_AGEES.getNiveauPriorite()).isEqualTo(2);
assertThat(TypeAide.SOUTIEN_PSYCHOLOGIQUE.getNiveauPriorite()).isEqualTo(2);
// "normal" -> 3
assertThat(TypeAide.AIDE_COTISATION.getNiveauPriorite()).isEqualTo(3);
assertThat(TypeAide.DON_MATERIEL.getNiveauPriorite()).isEqualTo(3);
assertThat(TypeAide.FORMATION_PROFESSIONNELLE.getNiveauPriorite()).isEqualTo(3);
assertThat(TypeAide.GARDE_ENFANTS.getNiveauPriorite()).isEqualTo(3);
assertThat(TypeAide.TRANSPORT.getNiveauPriorite()).isEqualTo(3);
assertThat(TypeAide.AIDE_ADMINISTRATIVE.getNiveauPriorite()).isEqualTo(3);
assertThat(TypeAide.AIDE_VESTIMENTAIRE.getNiveauPriorite()).isEqualTo(3);
assertThat(TypeAide.AIDE_NUMERIQUE.getNiveauPriorite()).isEqualTo(3);
assertThat(TypeAide.TRADUCTION.getNiveauPriorite()).isEqualTo(3);
assertThat(TypeAide.AUTRE.getNiveauPriorite()).isEqualTo(3);
// default -> 3 (pour toute autre valeur)
// Pas de test direct possible car toutes les valeurs sont couvertes
}
@Test
@DisplayName("Test getDateLimiteReponse")
void testGetDateLimiteReponse() {
LocalDateTime avant = LocalDateTime.now();
// AIDE_FINANCIERE_URGENTE : 7 jours
LocalDateTime dateLimite = TypeAide.AIDE_FINANCIERE_URGENTE.getDateLimiteReponse();
LocalDateTime attendu = avant.plusDays(7);
assertThat(dateLimite).isCloseTo(attendu, within(1, ChronoUnit.SECONDS));
// AIDE_ALIMENTAIRE : 3 jours
dateLimite = TypeAide.AIDE_ALIMENTAIRE.getDateLimiteReponse();
attendu = LocalDateTime.now().plusDays(3);
assertThat(dateLimite).isCloseTo(attendu, within(1, ChronoUnit.SECONDS));
// FORMATION_PROFESSIONNELLE : 60 jours
dateLimite = TypeAide.FORMATION_PROFESSIONNELLE.getDateLimiteReponse();
attendu = LocalDateTime.now().plusDays(60);
assertThat(dateLimite).isCloseTo(attendu, within(1, ChronoUnit.SECONDS));
}
}
@Nested
@DisplayName("Tests des méthodes statiques")
class TestsMethodesStatiques {
@Test
@DisplayName("Test getParCategorie")
void testGetParCategorie() {
// Catégorie "financiere"
List<TypeAide> financiers = TypeAide.getParCategorie("financiere");
assertThat(financiers).contains(
TypeAide.AIDE_FINANCIERE_URGENTE,
TypeAide.PRET_SANS_INTERET,
TypeAide.AIDE_COTISATION,
TypeAide.AIDE_FRAIS_MEDICAUX,
TypeAide.AIDE_FRAIS_SCOLARITE);
assertThat(financiers).doesNotContain(TypeAide.DON_MATERIEL, TypeAide.GARDE_ENFANTS);
// Catégorie "materielle"
List<TypeAide> materiels = TypeAide.getParCategorie("materielle");
assertThat(materiels).contains(
TypeAide.DON_MATERIEL,
TypeAide.PRET_MATERIEL,
TypeAide.AIDE_DEMENAGEMENT,
TypeAide.AIDE_TRAVAUX);
assertThat(materiels).doesNotContain(TypeAide.AIDE_FINANCIERE_URGENTE, TypeAide.GARDE_ENFANTS);
// Catégorie "urgence"
List<TypeAide> urgences = TypeAide.getParCategorie("urgence");
assertThat(urgences).contains(
TypeAide.HEBERGEMENT_URGENCE,
TypeAide.AIDE_ALIMENTAIRE,
TypeAide.AIDE_VESTIMENTAIRE);
assertThat(urgences).doesNotContain(TypeAide.AIDE_FINANCIERE_URGENTE, TypeAide.DON_MATERIEL);
// Catégorie inexistante
List<TypeAide> inexistante = TypeAide.getParCategorie("inexistante");
assertThat(inexistante).isEmpty();
}
@Test
@DisplayName("Test getUrgents")
void testGetUrgents() {
List<TypeAide> urgents = TypeAide.getUrgents();
// Vérifier que tous les types urgents sont inclus
assertThat(urgents).contains(
TypeAide.AIDE_FINANCIERE_URGENTE,
TypeAide.AIDE_FRAIS_MEDICAUX,
TypeAide.HEBERGEMENT_URGENCE,
TypeAide.AIDE_ALIMENTAIRE);
// Vérifier qu'aucun type non urgent n'est inclus
assertThat(urgents).doesNotContain(
TypeAide.PRET_SANS_INTERET, // "important"
TypeAide.DON_MATERIEL, // "normal"
TypeAide.AIDE_RECHERCHE_EMPLOI, // "important"
TypeAide.FORMATION_PROFESSIONNELLE); // "normal"
// Vérifier que tous les types retournés sont bien urgents
urgents.forEach(type -> assertThat(type.isUrgent()).isTrue());
}
@Test
@DisplayName("Test getFinanciers")
void testGetFinanciers() {
List<TypeAide> financiers = TypeAide.getFinanciers();
// Vérifier que tous les types financiers sont inclus
assertThat(financiers).contains(
TypeAide.AIDE_FINANCIERE_URGENTE,
TypeAide.PRET_SANS_INTERET,
TypeAide.AIDE_COTISATION,
TypeAide.AIDE_FRAIS_MEDICAUX,
TypeAide.AIDE_FRAIS_SCOLARITE);
// Vérifier qu'aucun type non financier n'est inclus
assertThat(financiers).doesNotContain(
TypeAide.DON_MATERIEL, // "materielle"
TypeAide.AIDE_RECHERCHE_EMPLOI, // "professionnelle"
TypeAide.GARDE_ENFANTS, // "sociale"
TypeAide.HEBERGEMENT_URGENCE); // "urgence"
// Vérifier que tous les types retournés sont bien financiers
financiers.forEach(type -> assertThat(type.isFinancier()).isTrue());
}
@Test
@DisplayName("Test getCategories")
void testGetCategories() {
Set<String> categories = TypeAide.getCategories();
// Vérifier que toutes les catégories sont présentes
assertThat(categories).contains(
"financiere",
"materielle",
"professionnelle",
"sociale",
"urgence",
"specialisee",
"autre");
// Vérifier qu'il n'y a pas de doublons (Set)
assertThat(categories).hasSize(7);
}
}
@Nested
@DisplayName("Tests des méthodes complexes")
class TestsMethodesComplexes {
@Test
@DisplayName("Test getLibelleCategorie - toutes les branches du switch")
void testGetLibelleCategorie() {
// Toutes les branches du switch
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getLibelleCategorie()).isEqualTo("Aide financière");
assertThat(TypeAide.DON_MATERIEL.getLibelleCategorie()).isEqualTo("Aide matérielle");
assertThat(TypeAide.AIDE_RECHERCHE_EMPLOI.getLibelleCategorie()).isEqualTo("Aide professionnelle");
assertThat(TypeAide.GARDE_ENFANTS.getLibelleCategorie()).isEqualTo("Aide sociale");
assertThat(TypeAide.HEBERGEMENT_URGENCE.getLibelleCategorie()).isEqualTo("Aide d'urgence");
assertThat(TypeAide.SOUTIEN_PSYCHOLOGIQUE.getLibelleCategorie()).isEqualTo("Aide spécialisée");
assertThat(TypeAide.AUTRE.getLibelleCategorie()).isEqualTo("Autre");
// default -> retourne la catégorie telle quelle
// Pas de test direct possible car toutes les catégories sont couvertes
}
@Test
@DisplayName("Test getUniteMontant - toutes les branches")
void testGetUniteMontant() {
// Types qui nécessitent un montant -> "FCFA"
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getUniteMontant()).isEqualTo("FCFA");
assertThat(TypeAide.PRET_SANS_INTERET.getUniteMontant()).isEqualTo("FCFA");
assertThat(TypeAide.AIDE_COTISATION.getUniteMontant()).isEqualTo("FCFA");
// Types qui ne nécessitent pas de montant -> null
assertThat(TypeAide.DON_MATERIEL.getUniteMontant()).isNull();
assertThat(TypeAide.HEBERGEMENT_URGENCE.getUniteMontant()).isNull();
assertThat(TypeAide.GARDE_ENFANTS.getUniteMontant()).isNull();
}
@Test
@DisplayName("Test getMessageValidationMontant - toutes les branches")
void testGetMessageValidationMontant() {
// Type qui ne nécessite pas de montant -> null
assertThat(TypeAide.DON_MATERIEL.getMessageValidationMontant(1000.0)).isNull();
assertThat(TypeAide.DON_MATERIEL.getMessageValidationMontant(null)).isNull();
// Type qui nécessite un montant mais montant null -> message obligatoire
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getMessageValidationMontant(null))
.isEqualTo("Le montant est obligatoire");
// Montant < min -> message minimum
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getMessageValidationMontant(4999.0))
.isEqualTo("Le montant minimum est de 5000 FCFA");
// Montant > max -> message maximum
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getMessageValidationMontant(50001.0))
.isEqualTo("Le montant maximum est de 50000 FCFA");
// Montant valide -> null
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getMessageValidationMontant(25000.0)).isNull();
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getMessageValidationMontant(5000.0)).isNull();
assertThat(TypeAide.AIDE_FINANCIERE_URGENTE.getMessageValidationMontant(50000.0)).isNull();
}
}
@Test
@DisplayName("Test cohérence globale des données")
void testCoherenceGlobale() {
for (TypeAide type : TypeAide.values()) {
// Tous les champs obligatoires non null
assertThat(type.getLibelle()).isNotNull().isNotEmpty();
assertThat(type.getCategorie()).isNotNull().isNotEmpty();
assertThat(type.getPriorite()).isNotNull().isNotEmpty();
assertThat(type.getDescription()).isNotNull().isNotEmpty();
assertThat(type.getIcone()).isNotNull().isNotEmpty();
assertThat(type.getCouleur()).isNotNull().matches("#[0-9A-Fa-f]{6}");
assertThat(type.getDelaiReponseJours()).isPositive();
// Cohérence logique
if (type.isNecessiteMontant()) {
assertThat(type.getUniteMontant()).isEqualTo("FCFA");
} else {
assertThat(type.getUniteMontant()).isNull();
assertThat(type.getMontantMin()).isNull();
assertThat(type.getMontantMax()).isNull();
}
if (type.getMontantMin() != null && type.getMontantMax() != null) {
assertThat(type.getMontantMax()).isGreaterThanOrEqualTo(type.getMontantMin());
}
// Priorité cohérente
assertThat(type.getPriorite()).isIn("urgent", "important", "normal");
assertThat(type.getNiveauPriorite()).isBetween(1, 3);
// Catégorie cohérente
assertThat(type.getCategorie()).isIn("financiere", "materielle", "professionnelle",
"sociale", "urgence", "specialisee", "autre");
assertThat(type.getLibelleCategorie()).isNotNull().isNotEmpty();
// Méthodes temporelles fonctionnent
assertThat(type.getDateLimiteReponse()).isAfter(LocalDateTime.now());
// Validation de montant cohérente
if (type.isNecessiteMontant()) {
assertThat(type.getMessageValidationMontant(null)).isEqualTo("Le montant est obligatoire");
} else {
assertThat(type.getMessageValidationMontant(null)).isNull();
}
}
}
}

207
unionflow-server-api/src/test/java/dev/lions/unionflow/server/api/validation/ValidationConstantsTest.java Normal file
View File

@@ -0,0 +1,207 @@
package dev.lions.unionflow.server.api.validation;
import static org.assertj.core.api.Assertions.assertThat;
import java.lang.reflect.Constructor;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
/**
* Tests unitaires pour ValidationConstants - Couverture 100%
*
* @author UnionFlow Team
* @version 2.0
* @since 2025-01-16
*/
@DisplayName("Tests ValidationConstants")
class ValidationConstantsTest {
@Test
@DisplayName("Test constructeur privé")
void testConstructeurPrive() throws Exception {
Constructor<ValidationConstants> constructor = ValidationConstants.class.getDeclaredConstructor();
constructor.setAccessible(true);
// Le constructeur doit être accessible et créer une instance
ValidationConstants instance = constructor.newInstance();
assertThat(instance).isNotNull();
}
@Nested
@DisplayName("Tests des constantes de taille")
class TestsConstantesTaille {
@Test
@DisplayName("Test constantes titre")
void testConstantesTitre() {
assertThat(ValidationConstants.TITRE_MIN_LENGTH).isEqualTo(5);
assertThat(ValidationConstants.TITRE_MAX_LENGTH).isEqualTo(100);
assertThat(ValidationConstants.TITRE_SIZE_MESSAGE).contains("5").contains("100").contains("titre");
}
@Test
@DisplayName("Test constantes nom organisation")
void testConstantesNomOrganisation() {
assertThat(ValidationConstants.NOM_ORGANISATION_MIN_LENGTH).isEqualTo(2);
assertThat(ValidationConstants.NOM_ORGANISATION_MAX_LENGTH).isEqualTo(200);
assertThat(ValidationConstants.NOM_ORGANISATION_SIZE_MESSAGE)
.contains("2")
.contains("200")
.contains("nom");
}
@Test
@DisplayName("Test constantes description")
void testConstantesDescription() {
assertThat(ValidationConstants.DESCRIPTION_MIN_LENGTH).isEqualTo(20);
assertThat(ValidationConstants.DESCRIPTION_MAX_LENGTH).isEqualTo(2000);
assertThat(ValidationConstants.DESCRIPTION_SIZE_MESSAGE)
.contains("20")
.contains("2000")
.contains("description");
}
@Test
@DisplayName("Test constantes description courte")
void testConstantesDescriptionCourte() {
assertThat(ValidationConstants.DESCRIPTION_COURTE_MAX_LENGTH).isEqualTo(1000);
assertThat(ValidationConstants.DESCRIPTION_COURTE_SIZE_MESSAGE)
.contains("1000")
.contains("description");
}
@Test
@DisplayName("Test constantes justification")
void testConstantesJustification() {
assertThat(ValidationConstants.JUSTIFICATION_MAX_LENGTH).isEqualTo(1000);
assertThat(ValidationConstants.JUSTIFICATION_SIZE_MESSAGE)
.contains("1000")
.contains("justification");
}
@Test
@DisplayName("Test constantes commentaires")
void testConstantesCommentaires() {
assertThat(ValidationConstants.COMMENTAIRES_MAX_LENGTH).isEqualTo(1000);
assertThat(ValidationConstants.COMMENTAIRES_SIZE_MESSAGE)
.contains("1000")
.contains("commentaires");
}
@Test
@DisplayName("Test constantes raison rejet")
void testConstantesRaisonRejet() {
assertThat(ValidationConstants.RAISON_REJET_MAX_LENGTH).isEqualTo(500);
assertThat(ValidationConstants.RAISON_REJET_SIZE_MESSAGE).contains("500").contains("rejet");
}
@Test
@DisplayName("Test constantes email")
void testConstantesEmail() {
assertThat(ValidationConstants.EMAIL_MAX_LENGTH).isEqualTo(100);
assertThat(ValidationConstants.EMAIL_SIZE_MESSAGE).contains("100").contains("email");
}
@Test
@DisplayName("Test constantes nom et prénom")
void testConstantesNomPrenom() {
assertThat(ValidationConstants.NOM_PRENOM_MIN_LENGTH).isEqualTo(2);
assertThat(ValidationConstants.NOM_PRENOM_MAX_LENGTH).isEqualTo(50);
assertThat(ValidationConstants.NOM_SIZE_MESSAGE).contains("2").contains("50").contains("nom");
assertThat(ValidationConstants.PRENOM_SIZE_MESSAGE).contains("2").contains("50").contains("prénom");
}
}
@Nested
@DisplayName("Tests des patterns de validation")
class TestsPatternsValidation {
@Test
@DisplayName("Test patterns téléphone")
void testPatternsTelephone() {
assertThat(ValidationConstants.TELEPHONE_PATTERN).isNotNull();
assertThat(ValidationConstants.TELEPHONE_MESSAGE).contains("téléphone");
}
@Test
@DisplayName("Test patterns devise")
void testPatternsDevise() {
assertThat(ValidationConstants.DEVISE_PATTERN).isNotNull();
assertThat(ValidationConstants.DEVISE_MESSAGE).contains("devise");
}
@Test
@DisplayName("Test patterns référence aide")
void testPatternsReferenceAide() {
assertThat(ValidationConstants.REFERENCE_AIDE_PATTERN).isNotNull();
assertThat(ValidationConstants.REFERENCE_AIDE_MESSAGE).contains("référence");
}
@Test
@DisplayName("Test patterns numéro membre")
void testPatternsNumeroMembre() {
assertThat(ValidationConstants.NUMERO_MEMBRE_PATTERN).isNotNull();
assertThat(ValidationConstants.NUMERO_MEMBRE_MESSAGE).contains("numéro");
}
@Test
@DisplayName("Test patterns couleur hexadécimale")
void testPatternsCouleurHex() {
assertThat(ValidationConstants.COULEUR_HEX_PATTERN).isNotNull();
assertThat(ValidationConstants.COULEUR_HEX_MESSAGE).contains("couleur");
}
}
@Nested
@DisplayName("Tests des messages obligatoires")
class TestsMessagesObligatoires {
@Test
@DisplayName("Test message obligatoire")
void testMessageObligatoire() {
assertThat(ValidationConstants.OBLIGATOIRE_MESSAGE).contains("obligatoire");
}
@Test
@DisplayName("Test message email format")
void testMessageEmailFormat() {
assertThat(ValidationConstants.EMAIL_FORMAT_MESSAGE).contains("email");
}
@Test
@DisplayName("Test messages de date")
void testMessagesDate() {
assertThat(ValidationConstants.DATE_PASSEE_MESSAGE).contains("passé");
assertThat(ValidationConstants.DATE_FUTURE_MESSAGE).contains("futur");
}
}
@Nested
@DisplayName("Tests des constantes numériques")
class TestsConstantesNumeriques {
@Test
@DisplayName("Test constantes montant")
void testConstantesMontant() {
assertThat(ValidationConstants.MONTANT_MIN_VALUE).isEqualTo("0.0");
assertThat(ValidationConstants.MONTANT_INTEGER_DIGITS).isEqualTo(10);
assertThat(ValidationConstants.MONTANT_FRACTION_DIGITS).isEqualTo(2);
assertThat(ValidationConstants.MONTANT_DIGITS_MESSAGE).contains("10").contains("2");
assertThat(ValidationConstants.MONTANT_POSITIF_MESSAGE).contains("positif");
}
}
@Test
@DisplayName("Test toutes les constantes sont non nulles")
void testToutesConstantesNonNulles() {
// Vérification que toutes les constantes String sont non nulles
assertThat(ValidationConstants.TITRE_SIZE_MESSAGE).isNotNull();
assertThat(ValidationConstants.NOM_ORGANISATION_SIZE_MESSAGE).isNotNull();
assertThat(ValidationConstants.DESCRIPTION_SIZE_MESSAGE).isNotNull();
assertThat(ValidationConstants.TELEPHONE_PATTERN).isNotNull();
assertThat(ValidationConstants.DEVISE_PATTERN).isNotNull();
assertThat(ValidationConstants.OBLIGATOIRE_MESSAGE).isNotNull();
assertThat(ValidationConstants.EMAIL_FORMAT_MESSAGE).isNotNull();
}
}