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

Tests à un bon niveau - A completer plus tard.

Browse Source
This commit is contained in:
DahoudG
2025-09-11 11:53:54 +00:00
parent b8c7949f41
commit 8184bc77bb
22 changed files with 2964 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
unionflow-server-impl-quarkus/src/test/java/dev/lions/unionflow/server/UnionFlowServerApplicationTest.java Normal file
View File

@@ -0,0 +1,150 @@
package dev.lions.unionflow.server;
import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests pour UnionFlowServerApplication
*
* @author Lions Dev Team
* @since 2025-01-10
*/
@QuarkusTest
@DisplayName("Tests UnionFlowServerApplication")
class UnionFlowServerApplicationTest {
@Test
@DisplayName("Test de l'application - Contexte Quarkus")
void testApplicationContext() {
// Given & When & Then
// Le simple fait que ce test s'exécute sans erreur
// prouve que l'application Quarkus démarre correctement
assertThat(true).isTrue();
}
@Test
@DisplayName("Test de l'application - Classe principale existe")
void testMainClassExists() {
// Given & When & Then
assertThat(UnionFlowServerApplication.class).isNotNull();
assertThat(UnionFlowServerApplication.class.getAnnotation(io.quarkus.runtime.annotations.QuarkusMain.class))
.isNotNull();
}
@Test
@DisplayName("Test de l'application - Implémente QuarkusApplication")
void testImplementsQuarkusApplication() {
// Given & When & Then
assertThat(io.quarkus.runtime.QuarkusApplication.class)
.isAssignableFrom(UnionFlowServerApplication.class);
}
@Test
@DisplayName("Test de l'application - Méthode main existe")
void testMainMethodExists() throws NoSuchMethodException {
// Given & When & Then
assertThat(UnionFlowServerApplication.class.getMethod("main", String[].class))
.isNotNull();
}
@Test
@DisplayName("Test de l'application - Méthode run existe")
void testRunMethodExists() throws NoSuchMethodException {
// Given & When & Then
assertThat(UnionFlowServerApplication.class.getMethod("run", String[].class))
.isNotNull();
}
@Test
@DisplayName("Test de l'application - Annotation ApplicationScoped")
void testApplicationScopedAnnotation() {
// Given & When & Then
assertThat(UnionFlowServerApplication.class.getAnnotation(jakarta.enterprise.context.ApplicationScoped.class))
.isNotNull();
}
@Test
@DisplayName("Test de l'application - Logger statique")
void testStaticLogger() throws NoSuchFieldException {
// Given & When & Then
assertThat(UnionFlowServerApplication.class.getDeclaredField("LOG"))
.isNotNull();
}
@Test
@DisplayName("Test de l'application - Instance créable")
void testInstanceCreation() {
// Given & When
UnionFlowServerApplication app = new UnionFlowServerApplication();
// Then
assertThat(app).isNotNull();
assertThat(app).isInstanceOf(io.quarkus.runtime.QuarkusApplication.class);
}
@Test
@DisplayName("Test de la méthode main - Signature correcte")
void testMainMethodSignature() throws NoSuchMethodException {
// Given & When
var mainMethod = UnionFlowServerApplication.class.getMethod("main", String[].class);
// Then
assertThat(mainMethod.getReturnType()).isEqualTo(void.class);
assertThat(java.lang.reflect.Modifier.isStatic(mainMethod.getModifiers())).isTrue();
assertThat(java.lang.reflect.Modifier.isPublic(mainMethod.getModifiers())).isTrue();
}
@Test
@DisplayName("Test de la méthode run - Signature correcte")
void testRunMethodSignature() throws NoSuchMethodException {
// Given & When
var runMethod = UnionFlowServerApplication.class.getMethod("run", String[].class);
// Then
assertThat(runMethod.getReturnType()).isEqualTo(int.class);
assertThat(java.lang.reflect.Modifier.isPublic(runMethod.getModifiers())).isTrue();
assertThat(runMethod.getExceptionTypes()).contains(Exception.class);
}
@Test
@DisplayName("Test de l'implémentation QuarkusApplication")
void testQuarkusApplicationImplementation() {
// Given & When & Then
assertThat(io.quarkus.runtime.QuarkusApplication.class.isAssignableFrom(UnionFlowServerApplication.class))
.isTrue();
}
@Test
@DisplayName("Test du package de la classe")
void testPackageName() {
// Given & When & Then
assertThat(UnionFlowServerApplication.class.getPackage().getName())
.isEqualTo("dev.lions.unionflow.server");
}
@Test
@DisplayName("Test de la classe - Modificateurs")
void testClassModifiers() {
// Given & When & Then
assertThat(java.lang.reflect.Modifier.isPublic(UnionFlowServerApplication.class.getModifiers())).isTrue();
assertThat(java.lang.reflect.Modifier.isFinal(UnionFlowServerApplication.class.getModifiers())).isFalse();
assertThat(java.lang.reflect.Modifier.isAbstract(UnionFlowServerApplication.class.getModifiers())).isFalse();
}
@Test
@DisplayName("Test des constructeurs")
void testConstructors() {
// Given & When
var constructors = UnionFlowServerApplication.class.getConstructors();
// Then
assertThat(constructors).hasSize(1);
assertThat(constructors[0].getParameterCount()).isEqualTo(0);
assertThat(java.lang.reflect.Modifier.isPublic(constructors[0].getModifiers())).isTrue();
}
}

223
unionflow-server-impl-quarkus/src/test/java/dev/lions/unionflow/server/entity/MembreLombokTest.java
View File

@@ -1,223 +0,0 @@
package dev.lions.unionflow.server.entity;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.time.LocalDate;
import java.time.LocalDateTime;
import static org.junit.jupiter.api.Assertions.*;
/**
* Tests unitaires pour valider les fonctionnalités Lombok de l'entité Membre
*/
@DisplayName("Tests Lombok - Entité Membre")
class MembreLombokTest {
private String numeroMembre;
private String prenom;
private String nom;
private String email;
private String telephone;
private LocalDate dateNaissance;
private LocalDate dateAdhesion;
@BeforeEach
void setUp() {
numeroMembre = "UF2025-ABC123";
prenom = "Jean";
nom = "Dupont";
email = "jean.dupont@example.com";
telephone = "+33123456789";
dateNaissance = LocalDate.of(1990, 5, 15);
dateAdhesion = LocalDate.of(2025, 1, 1);
}
@Test
@DisplayName("Test des annotations Lombok - Builder pattern")
void testLombokBuilder() {
// Given & When
Membre membre = Membre.builder()
.numeroMembre(numeroMembre)
.prenom(prenom)
.nom(nom)
.email(email)
.telephone(telephone)
.dateNaissance(dateNaissance)
.dateAdhesion(dateAdhesion)
.actif(true)
.build();
// Then
assertNotNull(membre);
assertEquals(numeroMembre, membre.getNumeroMembre());
assertEquals(prenom, membre.getPrenom());
assertEquals(nom, membre.getNom());
assertEquals(email, membre.getEmail());
assertEquals(telephone, membre.getTelephone());
assertEquals(dateNaissance, membre.getDateNaissance());
assertEquals(dateAdhesion, membre.getDateAdhesion());
assertTrue(membre.getActif());
assertNotNull(membre.getDateCreation());
}
@Test
@DisplayName("Test des annotations Lombok - Constructeur sans arguments")
void testLombokNoArgsConstructor() {
// Given & When
Membre membre = new Membre();
// Then
assertNotNull(membre);
assertNull(membre.getNumeroMembre());
assertNull(membre.getPrenom());
assertNull(membre.getNom());
assertNull(membre.getEmail());
assertNull(membre.getTelephone());
assertNull(membre.getDateNaissance());
assertNull(membre.getDateAdhesion());
assertTrue(membre.getActif()); // Valeur par défaut
assertNotNull(membre.getDateCreation()); // Valeur par défaut
}
@Test
@DisplayName("Test des annotations Lombok - Constructeur avec tous les arguments")
void testLombokAllArgsConstructor() {
// Given
LocalDateTime dateCreation = LocalDateTime.now();
LocalDateTime dateModification = LocalDateTime.now();
// When
Membre membre = new Membre(numeroMembre, prenom, nom, email, telephone,
dateNaissance, dateAdhesion, true, dateCreation, dateModification);
// Then
assertNotNull(membre);
assertEquals(numeroMembre, membre.getNumeroMembre());
assertEquals(prenom, membre.getPrenom());
assertEquals(nom, membre.getNom());
assertEquals(email, membre.getEmail());
assertEquals(telephone, membre.getTelephone());
assertEquals(dateNaissance, membre.getDateNaissance());
assertEquals(dateAdhesion, membre.getDateAdhesion());
assertTrue(membre.getActif());
assertEquals(dateCreation, membre.getDateCreation());
assertEquals(dateModification, membre.getDateModification());
}
@Test
@DisplayName("Test des annotations Lombok - Getters et Setters")
void testLombokGettersSetters() {
// Given
Membre membre = new Membre();
// When & Then - Test des setters
membre.setNumeroMembre(numeroMembre);
membre.setPrenom(prenom);
membre.setNom(nom);
membre.setEmail(email);
membre.setTelephone(telephone);
membre.setDateNaissance(dateNaissance);
membre.setDateAdhesion(dateAdhesion);
membre.setActif(false);
// Test des getters
assertEquals(numeroMembre, membre.getNumeroMembre());
assertEquals(prenom, membre.getPrenom());
assertEquals(nom, membre.getNom());
assertEquals(email, membre.getEmail());
assertEquals(telephone, membre.getTelephone());
assertEquals(dateNaissance, membre.getDateNaissance());
assertEquals(dateAdhesion, membre.getDateAdhesion());
assertFalse(membre.getActif());
}
@Test
@DisplayName("Test des annotations Lombok - equals et hashCode")
void testLombokEqualsHashCode() {
// Given
Membre membre1 = Membre.builder()
.numeroMembre(numeroMembre)
.prenom(prenom)
.nom(nom)
.email(email)
.build();
Membre membre2 = Membre.builder()
.numeroMembre(numeroMembre)
.prenom(prenom)
.nom(nom)
.email(email)
.build();
Membre membre3 = Membre.builder()
.numeroMembre("DIFFERENT")
.prenom(prenom)
.nom(nom)
.email(email)
.build();
// Then
assertEquals(membre1, membre2);
assertEquals(membre1.hashCode(), membre2.hashCode());
assertNotEquals(membre1, membre3);
assertNotEquals(membre1.hashCode(), membre3.hashCode());
}
@Test
@DisplayName("Test des annotations Lombok - toString")
void testLombokToString() {
// Given
Membre membre = Membre.builder()
.numeroMembre(numeroMembre)
.prenom(prenom)
.nom(nom)
.email(email)
.build();
// When
String toStringResult = membre.toString();
// Then
assertNotNull(toStringResult);
assertTrue(toStringResult.contains("Membre"));
assertTrue(toStringResult.contains(numeroMembre));
assertTrue(toStringResult.contains(prenom));
assertTrue(toStringResult.contains(nom));
assertTrue(toStringResult.contains(email));
}
@Test
@DisplayName("Test des méthodes métier personnalisées")
void testMethodesMetier() {
// Given
Membre membre = Membre.builder()
.prenom(prenom)
.nom(nom)
.dateNaissance(LocalDate.of(1990, 5, 15)) // 34 ans
.build();
// When & Then
assertEquals("Jean Dupont", membre.getNomComplet());
assertTrue(membre.isMajeur());
assertEquals(34, membre.getAge());
}
@Test
@DisplayName("Test des valeurs par défaut avec @Builder.Default")
void testBuilderDefaults() {
// Given & When
Membre membre = Membre.builder()
.numeroMembre(numeroMembre)
.prenom(prenom)
.nom(nom)
.email(email)
.build();
// Then
assertTrue(membre.getActif()); // Valeur par défaut
assertNotNull(membre.getDateCreation()); // Valeur par défaut
assertTrue(membre.getDateCreation().isBefore(LocalDateTime.now().plusSeconds(1)));
}
}

243
unionflow-server-impl-quarkus/src/test/java/dev/lions/unionflow/server/entity/MembreSimpleTest.java Normal file
View File

@@ -0,0 +1,243 @@
package dev.lions.unionflow.server.entity;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.time.LocalDate;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests simples pour l'entité Membre
*
* @author Lions Dev Team
* @since 2025-01-10
*/
@DisplayName("Tests simples Membre")
class MembreSimpleTest {
@Test
@DisplayName("Test de création d'un membre avec builder")
void testCreationMembreAvecBuilder() {
// Given & When
Membre membre = Membre.builder()
.numeroMembre("UF2025-TEST01")
.prenom("Jean")
.nom("Dupont")
.email("jean.dupont@test.com")
.telephone("221701234567")
.dateNaissance(LocalDate.of(1990, 5, 15))
.dateAdhesion(LocalDate.now())
.actif(true)
.build();
// Then
assertThat(membre).isNotNull();
assertThat(membre.getNumeroMembre()).isEqualTo("UF2025-TEST01");
assertThat(membre.getPrenom()).isEqualTo("Jean");
assertThat(membre.getNom()).isEqualTo("Dupont");
assertThat(membre.getEmail()).isEqualTo("jean.dupont@test.com");
assertThat(membre.getTelephone()).isEqualTo("221701234567");
assertThat(membre.getDateNaissance()).isEqualTo(LocalDate.of(1990, 5, 15));
assertThat(membre.getActif()).isTrue();
}
@Test
@DisplayName("Test de la méthode getNomComplet")
void testGetNomComplet() {
// Given
Membre membre = Membre.builder()
.prenom("Jean")
.nom("Dupont")
.build();
// When
String nomComplet = membre.getNomComplet();
// Then
assertThat(nomComplet).isEqualTo("Jean Dupont");
}
@Test
@DisplayName("Test de la méthode isMajeur - Majeur")
void testIsMajeurMajeur() {
// Given
Membre membre = Membre.builder()
.dateNaissance(LocalDate.of(1990, 5, 15))
.build();
// When
boolean majeur = membre.isMajeur();
// Then
assertThat(majeur).isTrue();
}
@Test
@DisplayName("Test de la méthode isMajeur - Mineur")
void testIsMajeurMineur() {
// Given
Membre membre = Membre.builder()
.dateNaissance(LocalDate.now().minusYears(17))
.build();
// When
boolean majeur = membre.isMajeur();
// Then
assertThat(majeur).isFalse();
}
@Test
@DisplayName("Test de la méthode getAge")
void testGetAge() {
// Given
Membre membre = Membre.builder()
.dateNaissance(LocalDate.now().minusYears(25))
.build();
// When
int age = membre.getAge();
// Then
assertThat(age).isEqualTo(25);
}
@Test
@DisplayName("Test de création d'un membre sans builder")
void testCreationMembreSansBuilder() {
// Given & When
Membre membre = new Membre();
membre.setNumeroMembre("UF2025-TEST02");
membre.setPrenom("Marie");
membre.setNom("Martin");
membre.setEmail("marie.martin@test.com");
membre.setActif(true);
// Then
assertThat(membre).isNotNull();
assertThat(membre.getNumeroMembre()).isEqualTo("UF2025-TEST02");
assertThat(membre.getPrenom()).isEqualTo("Marie");
assertThat(membre.getNom()).isEqualTo("Martin");
assertThat(membre.getEmail()).isEqualTo("marie.martin@test.com");
assertThat(membre.getActif()).isTrue();
}
@Test
@DisplayName("Test des annotations JPA")
void testAnnotationsJPA() {
// Given & When & Then
assertThat(Membre.class.getAnnotation(jakarta.persistence.Entity.class)).isNotNull();
assertThat(Membre.class.getAnnotation(jakarta.persistence.Table.class)).isNotNull();
assertThat(Membre.class.getAnnotation(jakarta.persistence.Table.class).name()).isEqualTo("membres");
}
@Test
@DisplayName("Test des annotations Lombok")
void testAnnotationsLombok() {
// Given & When & Then
// Vérifier que les annotations Lombok sont présentes (peuvent être null selon la compilation)
// Nous testons plutôt que les méthodes générées existent
assertThat(Membre.builder()).isNotNull();
Membre membre = new Membre();
assertThat(membre.toString()).isNotNull();
assertThat(membre.hashCode()).isNotZero();
}
@Test
@DisplayName("Test de l'héritage PanacheEntity")
void testHeritageePanacheEntity() {
// Given & When & Then
assertThat(io.quarkus.hibernate.orm.panache.PanacheEntity.class)
.isAssignableFrom(Membre.class);
}
@Test
@DisplayName("Test des méthodes héritées de PanacheEntity")
void testMethodesHeriteesPanacheEntity() throws NoSuchMethodException {
// Given & When & Then
// Vérifier que les méthodes de PanacheEntity sont disponibles
assertThat(Membre.class.getMethod("persist")).isNotNull();
assertThat(Membre.class.getMethod("delete")).isNotNull();
assertThat(Membre.class.getMethod("isPersistent")).isNotNull();
}
@Test
@DisplayName("Test de toString")
void testToString() {
// Given
Membre membre = Membre.builder()
.numeroMembre("UF2025-TEST01")
.prenom("Jean")
.nom("Dupont")
.email("jean.dupont@test.com")
.actif(true)
.build();
// When
String toString = membre.toString();
// Then
assertThat(toString).isNotNull();
assertThat(toString).contains("Jean");
assertThat(toString).contains("Dupont");
assertThat(toString).contains("UF2025-TEST01");
assertThat(toString).contains("jean.dupont@test.com");
}
@Test
@DisplayName("Test de hashCode")
void testHashCode() {
// Given
Membre membre1 = Membre.builder()
.numeroMembre("UF2025-TEST01")
.prenom("Jean")
.nom("Dupont")
.email("jean.dupont@test.com")
.build();
Membre membre2 = Membre.builder()
.numeroMembre("UF2025-TEST01")
.prenom("Jean")
.nom("Dupont")
.email("jean.dupont@test.com")
.build();
// When & Then
assertThat(membre1.hashCode()).isNotZero();
assertThat(membre2.hashCode()).isNotZero();
}
@Test
@DisplayName("Test des propriétés nulles")
void testProprietesNulles() {
// Given
Membre membre = new Membre();
// When & Then
assertThat(membre.getNumeroMembre()).isNull();
assertThat(membre.getPrenom()).isNull();
assertThat(membre.getNom()).isNull();
assertThat(membre.getEmail()).isNull();
assertThat(membre.getTelephone()).isNull();
assertThat(membre.getDateNaissance()).isNull();
assertThat(membre.getDateAdhesion()).isNull();
// Le champ actif a une valeur par défaut à true dans l'entité
// assertThat(membre.getActif()).isNull();
}
@Test
@DisplayName("Test de la méthode preUpdate")
void testPreUpdate() {
// Given
Membre membre = new Membre();
assertThat(membre.getDateModification()).isNull();
// When
membre.preUpdate();
// Then
assertThat(membre.getDateModification()).isNotNull();
}
}

184
unionflow-server-impl-quarkus/src/test/java/dev/lions/unionflow/server/repository/MembreRepositoryIntegrationTest.java Normal file
View File

@@ -0,0 +1,184 @@
package dev.lions.unionflow.server.repository;
import dev.lions.unionflow.server.entity.Membre;
import io.quarkus.test.junit.QuarkusTest;
import jakarta.inject.Inject;
import jakarta.transaction.Transactional;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.time.LocalDate;
import java.util.List;
import java.util.Optional;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests d'intégration pour MembreRepository
*
* @author Lions Dev Team
* @since 2025-01-10
*/
@QuarkusTest
@DisplayName("Tests d'intégration MembreRepository")
class MembreRepositoryIntegrationTest {
@Inject
MembreRepository membreRepository;
private Membre membreTest;
@BeforeEach
@Transactional
void setUp() {
// Nettoyer la base de données
membreRepository.deleteAll();
// Créer un membre de test
membreTest = Membre.builder()
.numeroMembre("UF2025-TEST01")
.prenom("Jean")
.nom("Dupont")
.email("jean.dupont@test.com")
.telephone("221701234567")
.dateNaissance(LocalDate.of(1990, 5, 15))
.dateAdhesion(LocalDate.now())
.actif(true)
.build();
membreRepository.persist(membreTest);
}
@Test
@DisplayName("Test findByEmail - Membre existant")
@Transactional
void testFindByEmailExistant() {
// When
Optional<Membre> result = membreRepository.findByEmail("jean.dupont@test.com");
// Then
assertThat(result).isPresent();
assertThat(result.get().getPrenom()).isEqualTo("Jean");
assertThat(result.get().getNom()).isEqualTo("Dupont");
}
@Test
@DisplayName("Test findByEmail - Membre inexistant")
@Transactional
void testFindByEmailInexistant() {
// When
Optional<Membre> result = membreRepository.findByEmail("inexistant@test.com");
// Then
assertThat(result).isEmpty();
}
@Test
@DisplayName("Test findByNumeroMembre - Membre existant")
@Transactional
void testFindByNumeroMembreExistant() {
// When
Optional<Membre> result = membreRepository.findByNumeroMembre("UF2025-TEST01");
// Then
assertThat(result).isPresent();
assertThat(result.get().getPrenom()).isEqualTo("Jean");
assertThat(result.get().getNom()).isEqualTo("Dupont");
}
@Test
@DisplayName("Test findByNumeroMembre - Membre inexistant")
@Transactional
void testFindByNumeroMembreInexistant() {
// When
Optional<Membre> result = membreRepository.findByNumeroMembre("UF2025-INEXISTANT");
// Then
assertThat(result).isEmpty();
}
@Test
@DisplayName("Test findAllActifs - Seuls les membres actifs")
@Transactional
void testFindAllActifs() {
// Given - Ajouter un membre inactif
Membre membreInactif = Membre.builder()
.numeroMembre("UF2025-TEST02")
.prenom("Marie")
.nom("Martin")
.email("marie.martin@test.com")
.telephone("221701234568")
.dateNaissance(LocalDate.of(1985, 8, 20))
.dateAdhesion(LocalDate.now())
.actif(false)
.build();
membreRepository.persist(membreInactif);
// When
List<Membre> result = membreRepository.findAllActifs();
// Then
assertThat(result).hasSize(1);
assertThat(result.get(0).getActif()).isTrue();
assertThat(result.get(0).getPrenom()).isEqualTo("Jean");
}
@Test
@DisplayName("Test countActifs - Nombre de membres actifs")
@Transactional
void testCountActifs() {
// When
long count = membreRepository.countActifs();
// Then
assertThat(count).isEqualTo(1);
}
@Test
@DisplayName("Test findByNomOrPrenom - Recherche par nom")
@Transactional
void testFindByNomOrPrenomParNom() {
// When
List<Membre> result = membreRepository.findByNomOrPrenom("dupont");
// Then
assertThat(result).hasSize(1);
assertThat(result.get(0).getNom()).isEqualTo("Dupont");
}
@Test
@DisplayName("Test findByNomOrPrenom - Recherche par prénom")
@Transactional
void testFindByNomOrPrenomParPrenom() {
// When
List<Membre> result = membreRepository.findByNomOrPrenom("jean");
// Then
assertThat(result).hasSize(1);
assertThat(result.get(0).getPrenom()).isEqualTo("Jean");
}
@Test
@DisplayName("Test findByNomOrPrenom - Aucun résultat")
@Transactional
void testFindByNomOrPrenomAucunResultat() {
// When
List<Membre> result = membreRepository.findByNomOrPrenom("inexistant");
// Then
assertThat(result).isEmpty();
}
@Test
@DisplayName("Test findByNomOrPrenom - Recherche insensible à la casse")
@Transactional
void testFindByNomOrPrenomCaseInsensitive() {
// When
List<Membre> result = membreRepository.findByNomOrPrenom("DUPONT");
// Then
assertThat(result).hasSize(1);
assertThat(result.get(0).getNom()).isEqualTo("Dupont");
}
}

107
unionflow-server-impl-quarkus/src/test/java/dev/lions/unionflow/server/repository/MembreRepositoryTest.java Normal file
View File

@@ -0,0 +1,107 @@
package dev.lions.unionflow.server.repository;
import dev.lions.unionflow.server.entity.Membre;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
/**
* Tests pour MembreRepository
*
* @author Lions Dev Team
* @since 2025-01-10
*/
@ExtendWith(MockitoExtension.class)
@DisplayName("Tests MembreRepository")
class MembreRepositoryTest {
@Mock
MembreRepository membreRepository;
private Membre membreTest;
private Membre membreInactif;
@BeforeEach
void setUp() {
// Créer des membres de test
membreTest = Membre.builder()
.numeroMembre("UF2025-TEST01")
.prenom("Jean")
.nom("Dupont")
.email("jean.dupont@test.com")
.telephone("221701234567")
.dateNaissance(LocalDate.of(1990, 5, 15))
.dateAdhesion(LocalDate.now())
.actif(true)
.build();
membreInactif = Membre.builder()
.numeroMembre("UF2025-TEST02")
.prenom("Marie")
.nom("Martin")
.email("marie.martin@test.com")
.telephone("221701234568")
.dateNaissance(LocalDate.of(1985, 8, 20))
.dateAdhesion(LocalDate.now())
.actif(false)
.build();
}
@Test
@DisplayName("Test de l'existence de la classe MembreRepository")
void testMembreRepositoryExists() {
// Given & When & Then
assertThat(MembreRepository.class).isNotNull();
assertThat(membreRepository).isNotNull();
}
@Test
@DisplayName("Test des méthodes du repository")
void testRepositoryMethods() throws NoSuchMethodException {
// Given & When & Then
assertThat(MembreRepository.class.getMethod("findByEmail", String.class)).isNotNull();
assertThat(MembreRepository.class.getMethod("findByNumeroMembre", String.class)).isNotNull();
assertThat(MembreRepository.class.getMethod("findAllActifs")).isNotNull();
assertThat(MembreRepository.class.getMethod("countActifs")).isNotNull();
assertThat(MembreRepository.class.getMethod("findByNomOrPrenom", String.class)).isNotNull();
}
@Test
@DisplayName("Test de l'annotation ApplicationScoped")
void testApplicationScopedAnnotation() {
// Given & When & Then
assertThat(MembreRepository.class.getAnnotation(jakarta.enterprise.context.ApplicationScoped.class))
.isNotNull();
}
@Test
@DisplayName("Test de l'implémentation PanacheRepository")
void testPanacheRepositoryImplementation() {
// Given & When & Then
assertThat(io.quarkus.hibernate.orm.panache.PanacheRepository.class)
.isAssignableFrom(MembreRepository.class);
}
@Test
@DisplayName("Test de la création d'instance")
void testInstanceCreation() {
// Given & When
MembreRepository repository = new MembreRepository();
// Then
assertThat(repository).isNotNull();
assertThat(repository).isInstanceOf(io.quarkus.hibernate.orm.panache.PanacheRepository.class);
}
}

74
unionflow-server-impl-quarkus/src/test/java/dev/lions/unionflow/server/resource/HealthResourceTest.java Normal file
View File

@@ -0,0 +1,74 @@
package dev.lions.unionflow.server.resource;
import io.quarkus.test.junit.QuarkusTest;
import io.restassured.http.ContentType;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.*;
/**
* Tests pour HealthResource
*
* @author Lions Dev Team
* @since 2025-01-10
*/
@QuarkusTest
@DisplayName("Tests HealthResource")
class HealthResourceTest {
@Test
@DisplayName("Test GET /api/status - Statut du serveur")
void testGetStatus() {
given()
.when()
.get("/api/status")
.then()
.statusCode(200)
.contentType(ContentType.JSON)
.body("status", equalTo("UP"))
.body("service", equalTo("UnionFlow Server"))
.body("version", equalTo("1.0.0"))
.body("message", equalTo("Serveur opérationnel"))
.body("timestamp", notNullValue());
}
@Test
@DisplayName("Test GET /api/status - Vérification de la structure de la réponse")
void testGetStatusStructure() {
given()
.when()
.get("/api/status")
.then()
.statusCode(200)
.contentType(ContentType.JSON)
.body("$", hasKey("status"))
.body("$", hasKey("service"))
.body("$", hasKey("version"))
.body("$", hasKey("timestamp"))
.body("$", hasKey("message"));
}
@Test
@DisplayName("Test GET /api/status - Vérification du Content-Type")
void testGetStatusContentType() {
given()
.when()
.get("/api/status")
.then()
.statusCode(200)
.contentType("application/json");
}
@Test
@DisplayName("Test GET /api/status - Réponse rapide")
void testGetStatusPerformance() {
given()
.when()
.get("/api/status")
.then()
.statusCode(200)
.time(lessThan(1000L)); // Moins d'1 seconde
}
}

322
unionflow-server-impl-quarkus/src/test/java/dev/lions/unionflow/server/resource/MembreResourceCompleteIntegrationTest.java Normal file
View File

@@ -0,0 +1,322 @@
package dev.lions.unionflow.server.resource;
import io.quarkus.test.junit.QuarkusTest;
import io.restassured.http.ContentType;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.*;
/**
* Tests d'intégration complets pour MembreResource
* Couvre tous les endpoints et cas d'erreur
*/
@QuarkusTest
@DisplayName("Tests d'intégration complets MembreResource")
class MembreResourceCompleteIntegrationTest {
@Test
@DisplayName("POST /api/membres - Création avec email existant")
void testCreerMembreEmailExistant() {
// Créer un premier membre
String membreJson1 = """
{
"numeroMembre": "UF2025-EXIST01",
"prenom": "Premier",
"nom": "Membre",
"email": "existe@test.com",
"telephone": "221701234567",
"dateNaissance": "1990-05-15",
"dateAdhesion": "2025-01-10",
"actif": true
}
""";
given()
.contentType(ContentType.JSON)
.body(membreJson1)
.when()
.post("/api/membres")
.then()
.statusCode(anyOf(is(201), is(400))); // 201 si nouveau, 400 si existe déjà
// Essayer de créer un deuxième membre avec le même email
String membreJson2 = """
{
"numeroMembre": "UF2025-EXIST02",
"prenom": "Deuxieme",
"nom": "Membre",
"email": "existe@test.com",
"telephone": "221701234568",
"dateNaissance": "1985-08-20",
"dateAdhesion": "2025-01-10",
"actif": true
}
""";
given()
.contentType(ContentType.JSON)
.body(membreJson2)
.when()
.post("/api/membres")
.then()
.statusCode(400)
.body("message", notNullValue());
}
@Test
@DisplayName("POST /api/membres - Validation des champs obligatoires")
void testCreerMembreValidationChamps() {
// Test avec prénom manquant
String membreSansPrenom = """
{
"nom": "Test",
"email": "test.sans.prenom@test.com",
"telephone": "221701234567"
}
""";
given()
.contentType(ContentType.JSON)
.body(membreSansPrenom)
.when()
.post("/api/membres")
.then()
.statusCode(400);
// Test avec email invalide
String membreEmailInvalide = """
{
"prenom": "Test",
"nom": "Test",
"email": "email-invalide",
"telephone": "221701234567"
}
""";
given()
.contentType(ContentType.JSON)
.body(membreEmailInvalide)
.when()
.post("/api/membres")
.then()
.statusCode(400);
}
@Test
@DisplayName("PUT /api/membres/{id} - Mise à jour membre existant")
void testMettreAJourMembreExistant() {
// D'abord créer un membre
String membreOriginal = """
{
"numeroMembre": "UF2025-UPDATE01",
"prenom": "Original",
"nom": "Membre",
"email": "original.update@test.com",
"telephone": "221701234567",
"dateNaissance": "1990-05-15",
"dateAdhesion": "2025-01-10",
"actif": true
}
""";
// Créer le membre (peut réussir ou échouer si existe déjà)
given()
.contentType(ContentType.JSON)
.body(membreOriginal)
.when()
.post("/api/membres")
.then()
.statusCode(anyOf(is(201), is(400)));
// Essayer de mettre à jour avec ID 1 (peut exister ou non)
String membreMisAJour = """
{
"numeroMembre": "UF2025-UPDATE01",
"prenom": "Modifie",
"nom": "Membre",
"email": "modifie.update@test.com",
"telephone": "221701234567",
"dateNaissance": "1990-05-15",
"dateAdhesion": "2025-01-10",
"actif": true
}
""";
given()
.contentType(ContentType.JSON)
.body(membreMisAJour)
.when()
.put("/api/membres/1")
.then()
.statusCode(anyOf(is(200), is(400))); // 200 si trouvé, 400 si non trouvé
}
@Test
@DisplayName("PUT /api/membres/{id} - Membre inexistant")
void testMettreAJourMembreInexistant() {
String membreJson = """
{
"numeroMembre": "UF2025-INEXIST01",
"prenom": "Inexistant",
"nom": "Membre",
"email": "inexistant@test.com",
"telephone": "221701234567",
"dateNaissance": "1990-05-15",
"dateAdhesion": "2025-01-10",
"actif": true
}
""";
given()
.contentType(ContentType.JSON)
.body(membreJson)
.when()
.put("/api/membres/99999")
.then()
.statusCode(400)
.body("message", notNullValue());
}
@Test
@DisplayName("DELETE /api/membres/{id} - Désactiver membre existant")
void testDesactiverMembreExistant() {
// Essayer de désactiver le membre ID 1 (peut exister ou non)
given()
.when()
.delete("/api/membres/1")
.then()
.statusCode(anyOf(is(204), is(404))); // 204 si trouvé, 404 si non trouvé
}
@Test
@DisplayName("DELETE /api/membres/{id} - Membre inexistant")
void testDesactiverMembreInexistant() {
given()
.when()
.delete("/api/membres/99999")
.then()
.statusCode(404)
.body("message", notNullValue());
}
@Test
@DisplayName("GET /api/membres/{id} - Membre existant")
void testObtenirMembreExistant() {
// Essayer d'obtenir le membre ID 1 (peut exister ou non)
given()
.when()
.get("/api/membres/1")
.then()
.statusCode(anyOf(is(200), is(404))); // 200 si trouvé, 404 si non trouvé
}
@Test
@DisplayName("GET /api/membres/{id} - Membre inexistant")
void testObtenirMembreInexistant() {
given()
.when()
.get("/api/membres/99999")
.then()
.statusCode(404)
.body("message", equalTo("Membre non trouvé"));
}
@Test
@DisplayName("GET /api/membres/recherche - Recherche avec terme null")
void testRechercherMembresTermeNull() {
given()
.when()
.get("/api/membres/recherche")
.then()
.statusCode(400)
.body("message", equalTo("Le terme de recherche est requis"));
}
@Test
@DisplayName("GET /api/membres/recherche - Recherche avec terme valide")
void testRechercherMembresTermeValide() {
given()
.queryParam("q", "test")
.when()
.get("/api/membres/recherche")
.then()
.statusCode(200)
.contentType(ContentType.JSON);
}
@Test
@DisplayName("Test des headers HTTP")
void testHeadersHTTP() {
// Test avec différents Accept headers
given()
.accept(ContentType.JSON)
.when()
.get("/api/membres")
.then()
.statusCode(200)
.contentType(ContentType.JSON);
given()
.accept(ContentType.XML)
.when()
.get("/api/membres")
.then()
.statusCode(anyOf(is(200), is(406))); // 200 si supporté, 406 si non supporté
}
@Test
@DisplayName("Test des méthodes HTTP non supportées")
void testMethodesHTTPNonSupportees() {
// OPTIONS peut être supporté ou non
given()
.when()
.options("/api/membres")
.then()
.statusCode(anyOf(is(200), is(405)));
// HEAD peut être supporté ou non
given()
.when()
.head("/api/membres")
.then()
.statusCode(anyOf(is(200), is(405)));
}
@Test
@DisplayName("Test de performance et robustesse")
void testPerformanceEtRobustesse() {
// Test avec une grande quantité de données
StringBuilder largeJson = new StringBuilder();
largeJson.append("{");
largeJson.append("\"prenom\": \"").append("A".repeat(100)).append("\",");
largeJson.append("\"nom\": \"").append("B".repeat(100)).append("\",");
largeJson.append("\"email\": \"large.test@test.com\",");
largeJson.append("\"telephone\": \"221701234567\"");
largeJson.append("}");
given()
.contentType(ContentType.JSON)
.body(largeJson.toString())
.when()
.post("/api/membres")
.then()
.statusCode(anyOf(is(201), is(400))); // Peut réussir ou échouer selon la validation
}
@Test
@DisplayName("Test de gestion des erreurs serveur")
void testGestionErreursServeur() {
// Test avec des données qui peuvent causer des erreurs internes
String jsonMalformed = "{ invalid json }";
given()
.contentType(ContentType.JSON)
.body(jsonMalformed)
.when()
.post("/api/membres")
.then()
.statusCode(400); // Bad Request pour JSON malformé
}
}

258
unionflow-server-impl-quarkus/src/test/java/dev/lions/unionflow/server/resource/MembreResourceSimpleIntegrationTest.java Normal file
View File

@@ -0,0 +1,258 @@
package dev.lions.unionflow.server.resource;
import io.quarkus.test.junit.QuarkusTest;
import io.restassured.http.ContentType;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.*;
/**
* Tests d'intégration simples pour MembreResource
*
* @author Lions Dev Team
* @since 2025-01-10
*/
@QuarkusTest
@DisplayName("Tests d'intégration simples MembreResource")
class MembreResourceSimpleIntegrationTest {
@Test
@DisplayName("GET /api/membres - Lister tous les membres actifs")
void testListerMembres() {
given()
.when()
.get("/api/membres")
.then()
.statusCode(200)
.contentType(ContentType.JSON)
.body("$", notNullValue());
}
@Test
@DisplayName("GET /api/membres/999 - Membre non trouvé")
void testObtenirMembreNonTrouve() {
given()
.when()
.get("/api/membres/999")
.then()
.statusCode(404)
.contentType(ContentType.JSON)
.body("message", equalTo("Membre non trouvé"));
}
@Test
@DisplayName("POST /api/membres - Données invalides")
void testCreerMembreDonneesInvalides() {
String membreJson = """
{
"prenom": "",
"nom": "",
"email": "email-invalide",
"telephone": "123",
"dateNaissance": "2030-01-01"
}
""";
given()
.contentType(ContentType.JSON)
.body(membreJson)
.when()
.post("/api/membres")
.then()
.statusCode(400);
}
@Test
@DisplayName("PUT /api/membres/999 - Membre non trouvé")
void testMettreAJourMembreNonTrouve() {
String membreJson = """
{
"prenom": "Pierre",
"nom": "Martin",
"email": "pierre.martin@test.com"
}
""";
given()
.contentType(ContentType.JSON)
.body(membreJson)
.when()
.put("/api/membres/999")
.then()
.statusCode(400); // Simplement vérifier le code de statut
}
@Test
@DisplayName("DELETE /api/membres/999 - Membre non trouvé")
void testDesactiverMembreNonTrouve() {
given()
.when()
.delete("/api/membres/999")
.then()
.statusCode(404)
.contentType(ContentType.JSON)
.body("message", containsString("Membre non trouvé"));
}
@Test
@DisplayName("GET /api/membres/recherche - Terme manquant")
void testRechercherMembresTermeManquant() {
given()
.when()
.get("/api/membres/recherche")
.then()
.statusCode(400)
.contentType(ContentType.JSON)
.body("message", equalTo("Le terme de recherche est requis"));
}
@Test
@DisplayName("GET /api/membres/recherche - Terme vide")
void testRechercherMembresTermeVide() {
given()
.queryParam("q", " ")
.when()
.get("/api/membres/recherche")
.then()
.statusCode(400)
.contentType(ContentType.JSON)
.body("message", equalTo("Le terme de recherche est requis"));
}
@Test
@DisplayName("GET /api/membres/recherche - Recherche valide")
void testRechercherMembresValide() {
given()
.queryParam("q", "test")
.when()
.get("/api/membres/recherche")
.then()
.statusCode(200)
.contentType(ContentType.JSON)
.body("$", notNullValue());
}
@Test
@DisplayName("GET /api/membres/stats - Statistiques")
void testObtenirStatistiques() {
given()
.when()
.get("/api/membres/stats")
.then()
.statusCode(200)
.contentType(ContentType.JSON)
.body("nombreMembresActifs", notNullValue())
.body("timestamp", notNullValue());
}
@Test
@DisplayName("POST /api/membres - Membre valide")
void testCreerMembreValide() {
String membreJson = """
{
"prenom": "Jean",
"nom": "Dupont",
"email": "jean.dupont.test@example.com",
"telephone": "221701234567",
"dateNaissance": "1990-05-15",
"dateAdhesion": "2025-01-10"
}
""";
given()
.contentType(ContentType.JSON)
.body(membreJson)
.when()
.post("/api/membres")
.then()
.statusCode(anyOf(is(201), is(400))); // 201 si succès, 400 si email existe déjà
}
@Test
@DisplayName("Test des endpoints avec différents content types")
void testContentTypes() {
// Test avec Accept header
given()
.accept(ContentType.JSON)
.when()
.get("/api/membres")
.then()
.statusCode(200)
.contentType(ContentType.JSON);
// Test avec Accept header pour les stats
given()
.accept(ContentType.JSON)
.when()
.get("/api/membres/stats")
.then()
.statusCode(200)
.contentType(ContentType.JSON);
}
@Test
@DisplayName("Test des méthodes HTTP non supportées")
void testMethodesNonSupportees() {
// PATCH n'est pas supporté
given()
.when()
.patch("/api/membres/1")
.then()
.statusCode(405); // Method Not Allowed
}
@Test
@DisplayName("PUT /api/membres/{id} - Mise à jour avec données invalides")
void testMettreAJourMembreAvecDonneesInvalides() {
String membreInvalideJson = """
{
"prenom": "",
"nom": "",
"email": "email-invalide"
}
""";
given()
.contentType(ContentType.JSON)
.body(membreInvalideJson)
.when()
.put("/api/membres/1")
.then()
.statusCode(400);
}
@Test
@DisplayName("POST /api/membres - Données invalides")
void testCreerMembreAvecDonneesInvalides() {
String membreInvalideJson = """
{
"prenom": "",
"nom": "",
"email": "email-invalide"
}
""";
given()
.contentType(ContentType.JSON)
.body(membreInvalideJson)
.when()
.post("/api/membres")
.then()
.statusCode(400);
}
@Test
@DisplayName("GET /api/membres/recherche - Terme avec espaces seulement")
void testRechercherMembresTermeAvecEspacesUniquement() {
given()
.queryParam("q", " ")
.when()
.get("/api/membres/recherche")
.then()
.statusCode(400)
.contentType(ContentType.JSON)
.body("message", equalTo("Le terme de recherche est requis"));
}
}

248
unionflow-server-impl-quarkus/src/test/java/dev/lions/unionflow/server/resource/MembreResourceTest.java Normal file
View File

@@ -0,0 +1,248 @@
package dev.lions.unionflow.server.resource;
import dev.lions.unionflow.server.entity.Membre;
import dev.lions.unionflow.server.service.MembreService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import jakarta.ws.rs.core.Response;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.when;
/**
* Tests pour MembreResource
*
* @author Lions Dev Team
* @since 2025-01-10
*/
@ExtendWith(MockitoExtension.class)
@DisplayName("Tests MembreResource")
class MembreResourceTest {
@InjectMocks
MembreResource membreResource;
@Mock
MembreService membreService;
@Test
@DisplayName("Test de l'existence de la classe MembreResource")
void testMembreResourceExists() {
// Given & When & Then
assertThat(MembreResource.class).isNotNull();
assertThat(membreResource).isNotNull();
}
@Test
@DisplayName("Test de l'annotation Path")
void testPathAnnotation() {
// Given & When & Then
assertThat(MembreResource.class.getAnnotation(jakarta.ws.rs.Path.class))
.isNotNull();
assertThat(MembreResource.class.getAnnotation(jakarta.ws.rs.Path.class).value())
.isEqualTo("/api/membres");
}
@Test
@DisplayName("Test de l'annotation ApplicationScoped")
void testApplicationScopedAnnotation() {
// Given & When & Then
assertThat(MembreResource.class.getAnnotation(jakarta.enterprise.context.ApplicationScoped.class))
.isNotNull();
}
@Test
@DisplayName("Test de l'annotation Produces")
void testProducesAnnotation() {
// Given & When & Then
assertThat(MembreResource.class.getAnnotation(jakarta.ws.rs.Produces.class))
.isNotNull();
assertThat(MembreResource.class.getAnnotation(jakarta.ws.rs.Produces.class).value())
.contains("application/json");
}
@Test
@DisplayName("Test de l'annotation Consumes")
void testConsumesAnnotation() {
// Given & When & Then
assertThat(MembreResource.class.getAnnotation(jakarta.ws.rs.Consumes.class))
.isNotNull();
assertThat(MembreResource.class.getAnnotation(jakarta.ws.rs.Consumes.class).value())
.contains("application/json");
}
@Test
@DisplayName("Test des méthodes du resource")
void testResourceMethods() throws NoSuchMethodException {
// Given & When & Then
assertThat(MembreResource.class.getMethod("listerMembres")).isNotNull();
assertThat(MembreResource.class.getMethod("obtenirMembre", Long.class)).isNotNull();
assertThat(MembreResource.class.getMethod("creerMembre", Membre.class)).isNotNull();
assertThat(MembreResource.class.getMethod("mettreAJourMembre", Long.class, Membre.class)).isNotNull();
assertThat(MembreResource.class.getMethod("desactiverMembre", Long.class)).isNotNull();
assertThat(MembreResource.class.getMethod("rechercherMembres", String.class)).isNotNull();
assertThat(MembreResource.class.getMethod("obtenirStatistiques")).isNotNull();
}
@Test
@DisplayName("Test de la création d'instance")
void testInstanceCreation() {
// Given & When
MembreResource resource = new MembreResource();
// Then
assertThat(resource).isNotNull();
}
@Test
@DisplayName("Test listerMembres")
void testListerMembres() {
// Given
List<Membre> membres = Arrays.asList(
createTestMembre("Jean", "Dupont"),
createTestMembre("Marie", "Martin")
);
when(membreService.listerMembresActifs()).thenReturn(membres);
// When
Response response = membreResource.listerMembres();
// Then
assertThat(response.getStatus()).isEqualTo(200);
assertThat(response.getEntity()).isEqualTo(membres);
}
@Test
@DisplayName("Test obtenirMembre")
void testObtenirMembre() {
// Given
Long id = 1L;
Membre membre = createTestMembre("Jean", "Dupont");
when(membreService.trouverParId(id)).thenReturn(Optional.of(membre));
// When
Response response = membreResource.obtenirMembre(id);
// Then
assertThat(response.getStatus()).isEqualTo(200);
assertThat(response.getEntity()).isEqualTo(membre);
}
@Test
@DisplayName("Test obtenirMembre - membre non trouvé")
void testObtenirMembreNonTrouve() {
// Given
Long id = 999L;
when(membreService.trouverParId(id)).thenReturn(Optional.empty());
// When
Response response = membreResource.obtenirMembre(id);
// Then
assertThat(response.getStatus()).isEqualTo(404);
}
@Test
@DisplayName("Test creerMembre")
void testCreerMembre() {
// Given
Membre membre = createTestMembre("Jean", "Dupont");
Membre membreCreated = createTestMembre("Jean", "Dupont");
membreCreated.id = 1L;
when(membreService.creerMembre(any(Membre.class))).thenReturn(membreCreated);
// When
Response response = membreResource.creerMembre(membre);
// Then
assertThat(response.getStatus()).isEqualTo(201);
assertThat(response.getEntity()).isEqualTo(membreCreated);
}
@Test
@DisplayName("Test mettreAJourMembre")
void testMettreAJourMembre() {
// Given
Long id = 1L;
Membre membre = createTestMembre("Jean", "Dupont");
Membre membreUpdated = createTestMembre("Jean", "Martin");
membreUpdated.id = id;
when(membreService.mettreAJourMembre(anyLong(), any(Membre.class))).thenReturn(membreUpdated);
// When
Response response = membreResource.mettreAJourMembre(id, membre);
// Then
assertThat(response.getStatus()).isEqualTo(200);
assertThat(response.getEntity()).isEqualTo(membreUpdated);
}
@Test
@DisplayName("Test desactiverMembre")
void testDesactiverMembre() {
// Given
Long id = 1L;
// When
Response response = membreResource.desactiverMembre(id);
// Then
assertThat(response.getStatus()).isEqualTo(204);
}
@Test
@DisplayName("Test rechercherMembres")
void testRechercherMembres() {
// Given
String recherche = "Jean";
List<Membre> membres = Arrays.asList(createTestMembre("Jean", "Dupont"));
when(membreService.rechercherMembres(anyString())).thenReturn(membres);
// When
Response response = membreResource.rechercherMembres(recherche);
// Then
assertThat(response.getStatus()).isEqualTo(200);
assertThat(response.getEntity()).isEqualTo(membres);
}
@Test
@DisplayName("Test obtenirStatistiques")
void testObtenirStatistiques() {
// Given
long count = 42L;
when(membreService.compterMembresActifs()).thenReturn(count);
// When
Response response = membreResource.obtenirStatistiques();
// Then
assertThat(response.getStatus()).isEqualTo(200);
assertThat(response.getEntity()).isInstanceOf(java.util.Map.class);
}
private Membre createTestMembre(String prenom, String nom) {
return Membre.builder()
.prenom(prenom)
.nom(nom)
.email(prenom.toLowerCase() + "." + nom.toLowerCase() + "@test.com")
.telephone("221701234567")
.dateNaissance(LocalDate.of(1990, 1, 1))
.dateAdhesion(LocalDate.now())
.actif(true)
.build();
}
}

350
unionflow-server-impl-quarkus/src/test/java/dev/lions/unionflow/server/service/MembreServiceTest.java Normal file
View File

@@ -0,0 +1,350 @@
package dev.lions.unionflow.server.service;
import dev.lions.unionflow.server.entity.Membre;
import dev.lions.unionflow.server.repository.MembreRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.*;
/**
* Tests pour MembreService
*
* @author Lions Dev Team
* @since 2025-01-10
*/
@ExtendWith(MockitoExtension.class)
@DisplayName("Tests MembreService")
class MembreServiceTest {
@InjectMocks
MembreService membreService;
@Mock
MembreRepository membreRepository;
private Membre membreTest;
@BeforeEach
void setUp() {
membreTest = Membre.builder()
.prenom("Jean")
.nom("Dupont")
.email("jean.dupont@test.com")
.telephone("221701234567")
.dateNaissance(LocalDate.of(1990, 5, 15))
.dateAdhesion(LocalDate.now())
.actif(true)
.build();
}
@Nested
@DisplayName("Tests creerMembre")
class CreerMembreTests {
@Test
@DisplayName("Création réussie d'un membre")
void testCreerMembreReussi() {
// Given
when(membreRepository.findByEmail(anyString())).thenReturn(Optional.empty());
when(membreRepository.findByNumeroMembre(anyString())).thenReturn(Optional.empty());
// When
Membre result = membreService.creerMembre(membreTest);
// Then
assertThat(result).isNotNull();
assertThat(result.getNumeroMembre()).isNotNull();
assertThat(result.getNumeroMembre()).startsWith("UF2025-");
verify(membreRepository).persist(membreTest);
}
@Test
@DisplayName("Erreur si email déjà existant")
void testCreerMembreEmailExistant() {
// Given
when(membreRepository.findByEmail(membreTest.getEmail()))
.thenReturn(Optional.of(membreTest));
// When & Then
assertThatThrownBy(() -> membreService.creerMembre(membreTest))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Un membre avec cet email existe déjà");
}
@Test
@DisplayName("Erreur si numéro de membre déjà existant")
void testCreerMembreNumeroExistant() {
// Given
membreTest.setNumeroMembre("UF2025-EXIST");
when(membreRepository.findByEmail(anyString())).thenReturn(Optional.empty());
when(membreRepository.findByNumeroMembre("UF2025-EXIST"))
.thenReturn(Optional.of(membreTest));
// When & Then
assertThatThrownBy(() -> membreService.creerMembre(membreTest))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Un membre avec ce numéro existe déjà");
}
@Test
@DisplayName("Génération automatique du numéro de membre")
void testGenerationNumeroMembre() {
// Given
membreTest.setNumeroMembre(null);
when(membreRepository.findByEmail(anyString())).thenReturn(Optional.empty());
when(membreRepository.findByNumeroMembre(anyString())).thenReturn(Optional.empty());
// When
membreService.creerMembre(membreTest);
// Then
ArgumentCaptor<Membre> captor = ArgumentCaptor.forClass(Membre.class);
verify(membreRepository).persist(captor.capture());
assertThat(captor.getValue().getNumeroMembre()).isNotNull();
assertThat(captor.getValue().getNumeroMembre()).startsWith("UF2025-");
}
@Test
@DisplayName("Génération automatique du numéro de membre avec chaîne vide")
void testGenerationNumeroMembreChainVide() {
// Given
membreTest.setNumeroMembre(""); // Chaîne vide
when(membreRepository.findByEmail(anyString())).thenReturn(Optional.empty());
when(membreRepository.findByNumeroMembre(anyString())).thenReturn(Optional.empty());
// When
membreService.creerMembre(membreTest);
// Then
ArgumentCaptor<Membre> captor = ArgumentCaptor.forClass(Membre.class);
verify(membreRepository).persist(captor.capture());
assertThat(captor.getValue().getNumeroMembre()).isNotNull();
assertThat(captor.getValue().getNumeroMembre()).isNotEmpty();
assertThat(captor.getValue().getNumeroMembre()).startsWith("UF2025-");
}
}
@Nested
@DisplayName("Tests mettreAJourMembre")
class MettreAJourMembreTests {
@Test
@DisplayName("Mise à jour réussie d'un membre")
void testMettreAJourMembreReussi() {
// Given
Long id = 1L;
membreTest.id = id; // Utiliser le champ directement
Membre membreModifie = Membre.builder()
.prenom("Pierre")
.nom("Martin")
.email("pierre.martin@test.com")
.telephone("221701234568")
.dateNaissance(LocalDate.of(1985, 8, 20))
.actif(false)
.build();
when(membreRepository.findById(id)).thenReturn(membreTest);
when(membreRepository.findByEmail("pierre.martin@test.com")).thenReturn(Optional.empty());
// When
Membre result = membreService.mettreAJourMembre(id, membreModifie);
// Then
assertThat(result.getPrenom()).isEqualTo("Pierre");
assertThat(result.getNom()).isEqualTo("Martin");
assertThat(result.getEmail()).isEqualTo("pierre.martin@test.com");
assertThat(result.getTelephone()).isEqualTo("221701234568");
assertThat(result.getDateNaissance()).isEqualTo(LocalDate.of(1985, 8, 20));
assertThat(result.getActif()).isFalse();
}
@Test
@DisplayName("Erreur si membre non trouvé")
void testMettreAJourMembreNonTrouve() {
// Given
Long id = 999L;
when(membreRepository.findById(id)).thenReturn(null);
// When & Then
assertThatThrownBy(() -> membreService.mettreAJourMembre(id, membreTest))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Membre non trouvé avec l'ID: " + id);
}
@Test
@DisplayName("Erreur si nouvel email déjà existant")
void testMettreAJourMembreEmailExistant() {
// Given
Long id = 1L;
membreTest.id = id; // Utiliser le champ directement
membreTest.setEmail("ancien@test.com");
Membre membreModifie = Membre.builder()
.email("nouveau@test.com")
.build();
Membre autreMembreAvecEmail = Membre.builder()
.email("nouveau@test.com")
.build();
autreMembreAvecEmail.id = 2L; // Utiliser le champ directement
when(membreRepository.findById(id)).thenReturn(membreTest);
when(membreRepository.findByEmail("nouveau@test.com"))
.thenReturn(Optional.of(autreMembreAvecEmail));
// When & Then
assertThatThrownBy(() -> membreService.mettreAJourMembre(id, membreModifie))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Un membre avec cet email existe déjà");
}
@Test
@DisplayName("Mise à jour sans changement d'email")
void testMettreAJourMembreSansChangementEmail() {
// Given
Long id = 1L;
membreTest.id = id; // Utiliser le champ directement
membreTest.setEmail("meme@test.com");
Membre membreModifie = Membre.builder()
.prenom("Pierre")
.nom("Martin")
.email("meme@test.com") // Même email
.telephone("221701234568")
.dateNaissance(LocalDate.of(1985, 8, 20))
.actif(false)
.build();
when(membreRepository.findById(id)).thenReturn(membreTest);
// Pas besoin de mocker findByEmail car l'email n'a pas changé
// When
Membre result = membreService.mettreAJourMembre(id, membreModifie);
// Then
assertThat(result.getPrenom()).isEqualTo("Pierre");
assertThat(result.getNom()).isEqualTo("Martin");
assertThat(result.getEmail()).isEqualTo("meme@test.com");
// Vérifier que findByEmail n'a pas été appelé
verify(membreRepository, never()).findByEmail("meme@test.com");
}
}
@Test
@DisplayName("Test trouverParId")
void testTrouverParId() {
// Given
Long id = 1L;
when(membreRepository.findById(id)).thenReturn(membreTest);
// When
Optional<Membre> result = membreService.trouverParId(id);
// Then
assertThat(result).isPresent();
assertThat(result.get()).isEqualTo(membreTest);
}
@Test
@DisplayName("Test trouverParEmail")
void testTrouverParEmail() {
// Given
String email = "jean.dupont@test.com";
when(membreRepository.findByEmail(email)).thenReturn(Optional.of(membreTest));
// When
Optional<Membre> result = membreService.trouverParEmail(email);
// Then
assertThat(result).isPresent();
assertThat(result.get()).isEqualTo(membreTest);
}
@Test
@DisplayName("Test listerMembresActifs")
void testListerMembresActifs() {
// Given
List<Membre> membresActifs = Arrays.asList(membreTest);
when(membreRepository.findAllActifs()).thenReturn(membresActifs);
// When
List<Membre> result = membreService.listerMembresActifs();
// Then
assertThat(result).hasSize(1);
assertThat(result.get(0)).isEqualTo(membreTest);
}
@Test
@DisplayName("Test rechercherMembres")
void testRechercherMembres() {
// Given
String recherche = "Jean";
List<Membre> resultatsRecherche = Arrays.asList(membreTest);
when(membreRepository.findByNomOrPrenom(recherche)).thenReturn(resultatsRecherche);
// When
List<Membre> result = membreService.rechercherMembres(recherche);
// Then
assertThat(result).hasSize(1);
assertThat(result.get(0)).isEqualTo(membreTest);
}
@Test
@DisplayName("Test desactiverMembre - Succès")
void testDesactiverMembreReussi() {
// Given
Long id = 1L;
membreTest.id = id; // Utiliser le champ directement
when(membreRepository.findById(id)).thenReturn(membreTest);
// When
membreService.desactiverMembre(id);
// Then
assertThat(membreTest.getActif()).isFalse();
}
@Test
@DisplayName("Test desactiverMembre - Membre non trouvé")
void testDesactiverMembreNonTrouve() {
// Given
Long id = 999L;
when(membreRepository.findById(id)).thenReturn(null);
// When & Then
assertThatThrownBy(() -> membreService.desactiverMembre(id))
.isInstanceOf(IllegalArgumentException.class)
.hasMessage("Membre non trouvé avec l'ID: " + id);
}
@Test
@DisplayName("Test compterMembresActifs")
void testCompterMembresActifs() {
// Given
when(membreRepository.countActifs()).thenReturn(5L);
// When
long result = membreService.compterMembresActifs();
// Then
assertThat(result).isEqualTo(5L);
}
}