feat(lum): KeycloakRealmSetupService + rôles RBAC UnionFlow + Jacoco 100%
- Ajoute KeycloakRealmSetupService : auto-initialisation des rôles realm (admin, user_manager, user_viewer, role_manager...) et assignation du rôle user_manager au service account unionflow-server au démarrage (idempotent, retries, thread séparé pour ne pas bloquer le démarrage) → Corrige le 403 sur resetPassword / changement de mot de passe premier login - UserResource : étend les @RolesAllowed avec ADMIN/SUPER_ADMIN/USER pour permettre aux appels inter-services unionflow-server d'accéder aux endpoints sans être bloqués par le RBAC LUM ; corrige sendVerificationEmail (retourne Response) - application-dev.properties : service-accounts.user-manager-clients=unionflow-server - application-prod.properties : client-id, credentials.secret, token.audience, auto-setup - application-test.properties : H2 in-memory (plus besoin de Docker pour les tests) - pom.xml : H2 scope test, Jacoco 100% enforcement (exclusions MapStruct/repos/setup), annotation processors MapStruct+Lombok explicites - .gitignore + .env ajouté (.env exclu du commit) - script/docker/.env.example : variables KEYCLOAK_ADMIN_USERNAME/PASSWORD documentées
This commit is contained in:
dahoud
@@ -1,5 +1,7 @@
|
||||
package dev.lions.user.manager.client;
|
||||
|
||||
import com.sun.net.httpserver.HttpServer;
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
@@ -16,6 +18,9 @@ import org.mockito.junit.jupiter.MockitoExtension;
|
||||
|
||||
import jakarta.ws.rs.NotFoundException;
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Method;
|
||||
import java.net.InetSocketAddress;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
@@ -36,6 +41,9 @@ class KeycloakAdminClientImplCompleteTest {
|
||||
@InjectMocks
|
||||
KeycloakAdminClientImpl client;
|
||||
|
||||
private HttpServer localServer;
|
||||
private int localPort;
|
||||
|
||||
private void setField(String fieldName, Object value) throws Exception {
|
||||
Field field = KeycloakAdminClientImpl.class.getDeclaredField(fieldName);
|
||||
field.setAccessible(true);
|
||||
@@ -50,6 +58,26 @@ class KeycloakAdminClientImplCompleteTest {
|
||||
setField("adminUsername", "admin");
|
||||
}
|
||||
|
||||
@AfterEach
|
||||
void tearDown() {
|
||||
if (localServer != null) {
|
||||
localServer.stop(0);
|
||||
localServer = null;
|
||||
}
|
||||
}
|
||||
|
||||
private int startLocalServer(String path, String responseBody, int statusCode) throws Exception {
|
||||
localServer = HttpServer.create(new InetSocketAddress(0), 0);
|
||||
localServer.createContext(path, exchange -> {
|
||||
byte[] bytes = responseBody.getBytes(StandardCharsets.UTF_8);
|
||||
exchange.sendResponseHeaders(statusCode, bytes.length);
|
||||
exchange.getResponseBody().write(bytes);
|
||||
exchange.getResponseBody().close();
|
||||
});
|
||||
localServer.start();
|
||||
return localServer.getAddress().getPort();
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetInstance() {
|
||||
Keycloak result = client.getInstance();
|
||||
@@ -162,4 +190,76 @@ class KeycloakAdminClientImplCompleteTest {
|
||||
void testReconnect() {
|
||||
assertDoesNotThrow(() -> client.reconnect());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testInit() throws Exception {
|
||||
// init() est appelé @PostConstruct — l'appeler via réflexion pour couvrir la méthode
|
||||
Method initMethod = KeycloakAdminClientImpl.class.getDeclaredMethod("init");
|
||||
initMethod.setAccessible(true);
|
||||
assertDoesNotThrow(() -> initMethod.invoke(client));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetAllRealms_Success() throws Exception {
|
||||
// Démarrer un serveur HTTP local qui retourne une liste de realms JSON
|
||||
String realmsJson = "[{\"realm\":\"master\",\"id\":\"1\"},{\"realm\":\"lions\",\"id\":\"2\"}]";
|
||||
localPort = startLocalServer("/admin/realms", realmsJson, 200);
|
||||
setField("serverUrl", "http://localhost:" + localPort);
|
||||
|
||||
when(mockKeycloak.tokenManager()).thenReturn(mockTokenManager);
|
||||
when(mockTokenManager.getAccessTokenString()).thenReturn("fake-token");
|
||||
|
||||
List<String> realms = client.getAllRealms();
|
||||
|
||||
assertNotNull(realms);
|
||||
assertEquals(2, realms.size());
|
||||
assertTrue(realms.contains("master"));
|
||||
assertTrue(realms.contains("lions"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetAllRealms_NonOkResponse() throws Exception {
|
||||
localPort = startLocalServer("/admin/realms", "Forbidden", 403);
|
||||
setField("serverUrl", "http://localhost:" + localPort);
|
||||
|
||||
when(mockKeycloak.tokenManager()).thenReturn(mockTokenManager);
|
||||
when(mockTokenManager.getAccessTokenString()).thenReturn("fake-token");
|
||||
|
||||
assertThrows(RuntimeException.class, () -> client.getAllRealms());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetRealmClients_Success() throws Exception {
|
||||
String clientsJson = "[{\"clientId\":\"admin-cli\",\"id\":\"1\"},{\"clientId\":\"account\",\"id\":\"2\"}]";
|
||||
localPort = startLocalServer("/admin/realms/master/clients", clientsJson, 200);
|
||||
setField("serverUrl", "http://localhost:" + localPort);
|
||||
|
||||
when(mockKeycloak.tokenManager()).thenReturn(mockTokenManager);
|
||||
when(mockTokenManager.getAccessTokenString()).thenReturn("fake-token");
|
||||
|
||||
List<String> clients = client.getRealmClients("master");
|
||||
|
||||
assertNotNull(clients);
|
||||
assertEquals(2, clients.size());
|
||||
assertTrue(clients.contains("admin-cli"));
|
||||
assertTrue(clients.contains("account"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetRealmClients_NonOkResponse() throws Exception {
|
||||
localPort = startLocalServer("/admin/realms/bad/clients", "Not Found", 404);
|
||||
setField("serverUrl", "http://localhost:" + localPort);
|
||||
|
||||
when(mockKeycloak.tokenManager()).thenReturn(mockTokenManager);
|
||||
when(mockTokenManager.getAccessTokenString()).thenReturn("fake-token");
|
||||
|
||||
assertThrows(RuntimeException.class, () -> client.getRealmClients("bad"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetRealmClients_TokenError() {
|
||||
when(mockKeycloak.tokenManager()).thenThrow(new RuntimeException("Token error"));
|
||||
|
||||
assertThrows(RuntimeException.class, () -> client.getRealmClients("master"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
package dev.lions.user.manager.config;
|
||||
|
||||
import com.fasterxml.jackson.databind.DeserializationFeature;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Tests pour JacksonConfig et KeycloakJacksonCustomizer.
|
||||
*/
|
||||
class JacksonConfigTest {
|
||||
|
||||
@Test
|
||||
void testJacksonConfig_DisablesFailOnUnknownProperties() {
|
||||
JacksonConfig config = new JacksonConfig();
|
||||
ObjectMapper mapper = new ObjectMapper();
|
||||
|
||||
// Avant : comportement par défaut (fail = true)
|
||||
assertTrue(mapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
|
||||
|
||||
config.customize(mapper);
|
||||
|
||||
// Après : doit être désactivé
|
||||
assertFalse(mapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testJacksonConfig_CustomizeCalledMultipleTimes() {
|
||||
JacksonConfig config = new JacksonConfig();
|
||||
ObjectMapper mapper = new ObjectMapper();
|
||||
|
||||
config.customize(mapper);
|
||||
config.customize(mapper); // idempotent
|
||||
|
||||
assertFalse(mapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testKeycloakJacksonCustomizer_AddsMixins() {
|
||||
KeycloakJacksonCustomizer customizer = new KeycloakJacksonCustomizer();
|
||||
ObjectMapper mapper = new ObjectMapper();
|
||||
|
||||
customizer.customize(mapper);
|
||||
|
||||
// Vérifie que des mix-ins ont été ajoutés pour les classes Keycloak
|
||||
assertNotNull(mapper.findMixInClassFor(org.keycloak.representations.idm.RealmRepresentation.class));
|
||||
assertNotNull(mapper.findMixInClassFor(org.keycloak.representations.idm.UserRepresentation.class));
|
||||
assertNotNull(mapper.findMixInClassFor(org.keycloak.representations.idm.RoleRepresentation.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testKeycloakJacksonCustomizer_MixinIgnoresUnknownProperties() throws Exception {
|
||||
KeycloakJacksonCustomizer customizer = new KeycloakJacksonCustomizer();
|
||||
ObjectMapper mapper = new ObjectMapper();
|
||||
customizer.customize(mapper);
|
||||
|
||||
// Le mix-in doit permettre la désérialisation avec des champs inconnus
|
||||
String jsonWithUnknownField = "{\"id\":\"test\",\"unknownField\":\"value\",\"realm\":\"test\"}";
|
||||
// Ne doit pas lancer d'exception
|
||||
assertDoesNotThrow(() ->
|
||||
mapper.readValue(jsonWithUnknownField, org.keycloak.representations.idm.RealmRepresentation.class)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testKeycloakJacksonCustomizer_UserRepresentation_WithUnknownField() throws Exception {
|
||||
KeycloakJacksonCustomizer customizer = new KeycloakJacksonCustomizer();
|
||||
ObjectMapper mapper = new ObjectMapper();
|
||||
customizer.customize(mapper);
|
||||
|
||||
String json = "{\"id\":\"user-1\",\"username\":\"test\",\"bruteForceStatus\":\"someValue\"}";
|
||||
assertDoesNotThrow(() ->
|
||||
mapper.readValue(json, org.keycloak.representations.idm.UserRepresentation.class)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Couvre KeycloakJacksonCustomizer.java L31 :
|
||||
* le constructeur par défaut de la classe abstraite imbriquée IgnoreUnknownMixin.
|
||||
* JaCoCo instrumente le constructeur par défaut implicite des classes abstraites ;
|
||||
* instancier une sous-classe concrète anonyme déclenche l'appel à ce constructeur.
|
||||
*/
|
||||
@Test
|
||||
void testIgnoreUnknownMixin_ConstructorIsCovered() throws Exception {
|
||||
// Récupérer la classe interne via reflection
|
||||
Class<?> mixinClass = Class.forName(
|
||||
"dev.lions.user.manager.config.KeycloakJacksonCustomizer$IgnoreUnknownMixin");
|
||||
|
||||
// Créer une sous-classe concrète via un proxy ByteBuddy n'est pas disponible ici ;
|
||||
// on utilise javassist/objenesis ou simplement ProxyFactory de Mockito.
|
||||
// La façon la plus simple : utiliser Mockito pour créer un mock de la classe abstraite.
|
||||
Object instance = org.mockito.Mockito.mock(mixinClass);
|
||||
assertNotNull(instance);
|
||||
}
|
||||
|
||||
/**
|
||||
* Couvre L31 via instanciation directe d'une sous-classe anonyme (même package).
|
||||
* La sous-classe anonyme appelle super() → constructeur implicite de IgnoreUnknownMixin.
|
||||
*/
|
||||
@Test
|
||||
void testIgnoreUnknownMixin_AnonymousSubclass_CoversL31() {
|
||||
KeycloakJacksonCustomizer.IgnoreUnknownMixin mixin = new KeycloakJacksonCustomizer.IgnoreUnknownMixin() {};
|
||||
assertNotNull(mixin);
|
||||
}
|
||||
}
|
||||
@@ -347,10 +347,76 @@ class KeycloakTestUserConfigCompleteTest {
|
||||
|
||||
Method method = KeycloakTestUserConfig.class.getDeclaredMethod("getCreatedId", Response.class);
|
||||
method.setAccessible(true);
|
||||
|
||||
|
||||
Exception exception = assertThrows(Exception.class, () -> method.invoke(config, response));
|
||||
assertTrue(exception.getCause() instanceof RuntimeException);
|
||||
assertTrue(exception.getCause().getMessage().contains("Erreur lors de la création"));
|
||||
}
|
||||
|
||||
/**
|
||||
* Couvre L250-252 : le scope "roles" n'est pas encore dans les scopes du client,
|
||||
* donc addDefaultClientScope est appelé.
|
||||
*/
|
||||
@Test
|
||||
void testEnsureClientAndMapper_ClientExists_RolesScopeNotYetPresent() throws Exception {
|
||||
when(adminClient.realms()).thenReturn(realmsResource);
|
||||
when(realmsResource.realm("lions-user-manager")).thenReturn(realmResource);
|
||||
when(realmResource.clients()).thenReturn(clientsResource);
|
||||
|
||||
ClientRepresentation existingClient = new ClientRepresentation();
|
||||
existingClient.setId("client-id-456");
|
||||
when(clientsResource.findByClientId("lions-user-manager-client")).thenReturn(List.of(existingClient));
|
||||
|
||||
// Le scope "roles" existe dans le realm
|
||||
when(realmResource.clientScopes()).thenReturn(clientScopesResource);
|
||||
ClientScopeRepresentation rolesScope = new ClientScopeRepresentation();
|
||||
rolesScope.setId("scope-roles-id");
|
||||
rolesScope.setName("roles");
|
||||
when(clientScopesResource.findAll()).thenReturn(List.of(rolesScope));
|
||||
|
||||
// Mais il N'EST PAS encore dans les scopes par défaut du client (liste vide)
|
||||
when(clientsResource.get("client-id-456")).thenReturn(clientResource);
|
||||
when(clientResource.getDefaultClientScopes()).thenReturn(Collections.emptyList());
|
||||
doNothing().when(clientResource).addDefaultClientScope(anyString());
|
||||
|
||||
Method method = KeycloakTestUserConfig.class.getDeclaredMethod("ensureClientAndMapper", Keycloak.class);
|
||||
method.setAccessible(true);
|
||||
|
||||
assertDoesNotThrow(() -> method.invoke(config, adminClient));
|
||||
// Vérifie que addDefaultClientScope a été appelé avec l'ID du scope
|
||||
verify(clientResource).addDefaultClientScope("scope-roles-id");
|
||||
}
|
||||
|
||||
/**
|
||||
* Couvre L259-260 : addDefaultClientScope lève une exception → catch warn.
|
||||
*/
|
||||
@Test
|
||||
void testEnsureClientAndMapper_ClientExists_AddScopeThrowsException() throws Exception {
|
||||
when(adminClient.realms()).thenReturn(realmsResource);
|
||||
when(realmsResource.realm("lions-user-manager")).thenReturn(realmResource);
|
||||
when(realmResource.clients()).thenReturn(clientsResource);
|
||||
|
||||
ClientRepresentation existingClient = new ClientRepresentation();
|
||||
existingClient.setId("client-id-789");
|
||||
when(clientsResource.findByClientId("lions-user-manager-client")).thenReturn(List.of(existingClient));
|
||||
|
||||
when(realmResource.clientScopes()).thenReturn(clientScopesResource);
|
||||
ClientScopeRepresentation rolesScope = new ClientScopeRepresentation();
|
||||
rolesScope.setId("scope-roles-id-2");
|
||||
rolesScope.setName("roles");
|
||||
when(clientScopesResource.findAll()).thenReturn(List.of(rolesScope));
|
||||
|
||||
// Scope pas encore présent
|
||||
when(clientsResource.get("client-id-789")).thenReturn(clientResource);
|
||||
when(clientResource.getDefaultClientScopes()).thenReturn(Collections.emptyList());
|
||||
// addDefaultClientScope lève une exception → couvre le catch L259-260
|
||||
doThrow(new RuntimeException("Forbidden")).when(clientResource).addDefaultClientScope(anyString());
|
||||
|
||||
Method method = KeycloakTestUserConfig.class.getDeclaredMethod("ensureClientAndMapper", Keycloak.class);
|
||||
method.setAccessible(true);
|
||||
|
||||
// La méthode ne doit pas propager l'exception (catch + warn)
|
||||
assertDoesNotThrow(() -> method.invoke(config, adminClient));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -75,5 +75,17 @@ class RoleMapperAdditionalTest {
|
||||
|
||||
// La méthode toKeycloak() n'existe pas dans RoleMapper
|
||||
// Ces tests sont supprimés car la méthode n'est pas disponible
|
||||
|
||||
/**
|
||||
* Couvre RoleMapper.java L13 : le constructeur par défaut implicite de la classe utilitaire.
|
||||
* JaCoCo (counter=LINE) marque la déclaration de classe comme non couverte si aucune instance
|
||||
* n'est jamais créée.
|
||||
*/
|
||||
@Test
|
||||
void testRoleMapperInstantiation() {
|
||||
// Instantie la classe pour couvrir le constructeur par défaut (L13)
|
||||
RoleMapper mapper = new RoleMapper();
|
||||
assertNotNull(mapper);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -135,4 +135,99 @@ class AuditResourceTest {
|
||||
|
||||
verify(auditService).purgeOldLogs(any());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSearchLogs_NullActeur_UsesRealm() {
|
||||
List<AuditLogDTO> logs = Collections.singletonList(
|
||||
AuditLogDTO.builder().acteurUsername("admin").typeAction(TypeActionAudit.USER_CREATE).build());
|
||||
when(auditService.findByRealm(eq("master"), any(), any(), eq(0), eq(50))).thenReturn(logs);
|
||||
|
||||
List<AuditLogDTO> result = auditResource.searchLogs(null, null, null, null, null, null, 0, 50);
|
||||
|
||||
assertEquals(logs, result);
|
||||
verify(auditService).findByRealm(eq("master"), any(), any(), eq(0), eq(50));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSearchLogs_BlankActeur_UsesRealm() {
|
||||
List<AuditLogDTO> logs = Collections.emptyList();
|
||||
when(auditService.findByRealm(eq("master"), any(), any(), eq(0), eq(20))).thenReturn(logs);
|
||||
|
||||
List<AuditLogDTO> result = auditResource.searchLogs(" ", null, null, null, null, null, 0, 20);
|
||||
|
||||
assertEquals(logs, result);
|
||||
verify(auditService).findByRealm(eq("master"), any(), any(), eq(0), eq(20));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSearchLogs_WithPostFilter_TypeAction() {
|
||||
AuditLogDTO matchLog = AuditLogDTO.builder()
|
||||
.acteurUsername("admin")
|
||||
.typeAction(TypeActionAudit.USER_CREATE)
|
||||
.build();
|
||||
AuditLogDTO otherLog = AuditLogDTO.builder()
|
||||
.acteurUsername("admin")
|
||||
.typeAction(TypeActionAudit.USER_DELETE)
|
||||
.build();
|
||||
when(auditService.findByActeur(eq("admin"), any(), any(), eq(0), eq(50)))
|
||||
.thenReturn(List.of(matchLog, otherLog));
|
||||
|
||||
List<AuditLogDTO> result = auditResource.searchLogs("admin", null, null,
|
||||
TypeActionAudit.USER_CREATE, null, null, 0, 50);
|
||||
|
||||
assertEquals(1, result.size());
|
||||
assertEquals(TypeActionAudit.USER_CREATE, result.get(0).getTypeAction());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSearchLogs_WithPostFilter_RessourceType() {
|
||||
AuditLogDTO matchLog = AuditLogDTO.builder()
|
||||
.acteurUsername("admin")
|
||||
.typeAction(TypeActionAudit.USER_CREATE)
|
||||
.ressourceType("USER")
|
||||
.build();
|
||||
AuditLogDTO otherLog = AuditLogDTO.builder()
|
||||
.acteurUsername("admin")
|
||||
.typeAction(TypeActionAudit.USER_CREATE)
|
||||
.ressourceType("ROLE")
|
||||
.build();
|
||||
when(auditService.findByActeur(eq("admin"), any(), any(), eq(0), eq(50)))
|
||||
.thenReturn(List.of(matchLog, otherLog));
|
||||
|
||||
List<AuditLogDTO> result = auditResource.searchLogs("admin", null, null,
|
||||
null, "USER", null, 0, 50);
|
||||
|
||||
assertEquals(1, result.size());
|
||||
assertEquals("USER", result.get(0).getRessourceType());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSearchLogs_WithPostFilter_Succes() {
|
||||
AuditLogDTO successLog = AuditLogDTO.builder()
|
||||
.acteurUsername("admin")
|
||||
.typeAction(TypeActionAudit.USER_CREATE)
|
||||
.success(true)
|
||||
.build();
|
||||
AuditLogDTO failLog = AuditLogDTO.builder()
|
||||
.acteurUsername("admin")
|
||||
.typeAction(TypeActionAudit.USER_CREATE)
|
||||
.success(false)
|
||||
.build();
|
||||
when(auditService.findByActeur(eq("admin"), any(), any(), eq(0), eq(50)))
|
||||
.thenReturn(List.of(successLog, failLog));
|
||||
|
||||
List<AuditLogDTO> result = auditResource.searchLogs("admin", null, null,
|
||||
null, null, Boolean.TRUE, 0, 50);
|
||||
|
||||
assertEquals(1, result.size());
|
||||
assertTrue(result.get(0).isSuccessful());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testExportLogsToCSV_Exception() {
|
||||
when(auditService.exportToCSV(eq("master"), any(), any()))
|
||||
.thenThrow(new RuntimeException("Export failed"));
|
||||
|
||||
assertThrows(RuntimeException.class, () -> auditResource.exportLogsToCSV(null, null));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
package dev.lions.user.manager.resource;
|
||||
|
||||
import dev.lions.user.manager.client.KeycloakAdminClient;
|
||||
import org.eclipse.microprofile.health.HealthCheckResponse;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
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 static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
class KeycloakHealthCheckTest {
|
||||
|
||||
@Mock
|
||||
KeycloakAdminClient keycloakAdminClient;
|
||||
|
||||
@InjectMocks
|
||||
KeycloakHealthCheck healthCheck;
|
||||
|
||||
@Test
|
||||
void testCall_Connected() {
|
||||
when(keycloakAdminClient.isConnected()).thenReturn(true);
|
||||
|
||||
HealthCheckResponse response = healthCheck.call();
|
||||
|
||||
assertNotNull(response);
|
||||
assertEquals(HealthCheckResponse.Status.UP, response.getStatus());
|
||||
assertEquals("keycloak-connection", response.getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCall_NotConnected() {
|
||||
when(keycloakAdminClient.isConnected()).thenReturn(false);
|
||||
|
||||
HealthCheckResponse response = healthCheck.call();
|
||||
|
||||
assertNotNull(response);
|
||||
assertEquals(HealthCheckResponse.Status.DOWN, response.getStatus());
|
||||
assertEquals("keycloak-connection", response.getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCall_Exception() {
|
||||
when(keycloakAdminClient.isConnected()).thenThrow(new RuntimeException("Connection refused"));
|
||||
|
||||
HealthCheckResponse response = healthCheck.call();
|
||||
|
||||
assertNotNull(response);
|
||||
assertEquals(HealthCheckResponse.Status.DOWN, response.getStatus());
|
||||
assertEquals("keycloak-connection", response.getName());
|
||||
}
|
||||
}
|
||||
@@ -186,4 +186,37 @@ class RealmAssignmentResourceTest {
|
||||
|
||||
verify(realmAuthorizationService).setSuperAdmin("user-1", true);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAssignRealmToUser_NullPrincipal() {
|
||||
when(securityContext.getUserPrincipal()).thenReturn(null);
|
||||
when(realmAuthorizationService.assignRealmToUser(any(RealmAssignmentDTO.class))).thenReturn(assignment);
|
||||
|
||||
Response response = realmAssignmentResource.assignRealmToUser(assignment);
|
||||
|
||||
assertEquals(201, response.getStatus());
|
||||
// assignedBy n'est pas modifié car le principal est null
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAssignRealmToUser_IllegalArgumentException() {
|
||||
when(securityContext.getUserPrincipal()).thenReturn(principal);
|
||||
when(principal.getName()).thenReturn("admin");
|
||||
when(realmAuthorizationService.assignRealmToUser(any(RealmAssignmentDTO.class)))
|
||||
.thenThrow(new IllegalArgumentException("Affectation déjà existante"));
|
||||
|
||||
Response response = realmAssignmentResource.assignRealmToUser(assignment);
|
||||
|
||||
assertEquals(409, response.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAssignRealmToUser_GenericException() {
|
||||
when(securityContext.getUserPrincipal()).thenReturn(principal);
|
||||
when(principal.getName()).thenReturn("admin");
|
||||
when(realmAuthorizationService.assignRealmToUser(any(RealmAssignmentDTO.class)))
|
||||
.thenThrow(new RuntimeException("Erreur inattendue"));
|
||||
|
||||
assertThrows(RuntimeException.class, () -> realmAssignmentResource.assignRealmToUser(assignment));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -56,4 +56,33 @@ class RealmResourceAdditionalTest {
|
||||
|
||||
assertThrows(RuntimeException.class, () -> realmResource.getAllRealms());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetRealmClients_Success() {
|
||||
List<String> clients = Arrays.asList("admin-cli", "account", "lions-app");
|
||||
when(keycloakAdminClient.getRealmClients("test-realm")).thenReturn(clients);
|
||||
|
||||
List<String> result = realmResource.getRealmClients("test-realm");
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(3, result.size());
|
||||
assertTrue(result.contains("admin-cli"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetRealmClients_Empty() {
|
||||
when(keycloakAdminClient.getRealmClients("test-realm")).thenReturn(List.of());
|
||||
|
||||
List<String> result = realmResource.getRealmClients("test-realm");
|
||||
|
||||
assertNotNull(result);
|
||||
assertTrue(result.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetRealmClients_Exception() {
|
||||
when(keycloakAdminClient.getRealmClients("bad-realm")).thenThrow(new RuntimeException("Not found"));
|
||||
|
||||
assertThrows(RuntimeException.class, () -> realmResource.getRealmClients("bad-realm"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -263,4 +263,108 @@ class RoleResourceTest {
|
||||
|
||||
assertEquals(composites, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCreateRealmRole_GenericException() {
|
||||
RoleDTO input = RoleDTO.builder().name("role").build();
|
||||
when(roleService.createRealmRole(any(), eq(REALM)))
|
||||
.thenThrow(new RuntimeException("Internal error"));
|
||||
|
||||
assertThrows(RuntimeException.class, () -> roleResource.createRealmRole(input, REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testUpdateRealmRole_NotFound() {
|
||||
when(roleService.getRoleByName("role", REALM, TypeRole.REALM_ROLE, null))
|
||||
.thenReturn(Optional.empty());
|
||||
|
||||
RoleDTO input = RoleDTO.builder().description("updated").build();
|
||||
assertThrows(RuntimeException.class, () -> roleResource.updateRealmRole("role", input, REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDeleteRealmRole_NotFound() {
|
||||
when(roleService.getRoleByName("role", REALM, TypeRole.REALM_ROLE, null))
|
||||
.thenReturn(Optional.empty());
|
||||
|
||||
assertThrows(RuntimeException.class, () -> roleResource.deleteRealmRole("role", REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCreateClientRole_IllegalArgumentException() {
|
||||
RoleDTO input = RoleDTO.builder().name("role").build();
|
||||
when(roleService.createClientRole(any(RoleDTO.class), eq(CLIENT_ID), eq(REALM)))
|
||||
.thenThrow(new IllegalArgumentException("Conflict"));
|
||||
|
||||
Response response = roleResource.createClientRole(CLIENT_ID, input, REALM);
|
||||
|
||||
assertEquals(409, response.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCreateClientRole_GenericException() {
|
||||
RoleDTO input = RoleDTO.builder().name("role").build();
|
||||
when(roleService.createClientRole(any(RoleDTO.class), eq(CLIENT_ID), eq(REALM)))
|
||||
.thenThrow(new RuntimeException("Internal error"));
|
||||
|
||||
assertThrows(RuntimeException.class, () -> roleResource.createClientRole(CLIENT_ID, input, REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetClientRole_NotFound() {
|
||||
when(roleService.getRoleByName("role", REALM, TypeRole.CLIENT_ROLE, CLIENT_ID))
|
||||
.thenReturn(Optional.empty());
|
||||
|
||||
assertThrows(RuntimeException.class, () -> roleResource.getClientRole(CLIENT_ID, "role", REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDeleteClientRole_NotFound() {
|
||||
when(roleService.getRoleByName("role", REALM, TypeRole.CLIENT_ROLE, CLIENT_ID))
|
||||
.thenReturn(Optional.empty());
|
||||
|
||||
assertThrows(RuntimeException.class, () -> roleResource.deleteClientRole(CLIENT_ID, "role", REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAddComposites_ParentNotFound() {
|
||||
when(roleService.getRoleByName("role", REALM, TypeRole.REALM_ROLE, null))
|
||||
.thenReturn(Optional.empty());
|
||||
|
||||
RoleAssignmentRequestDTO request = RoleAssignmentRequestDTO.builder()
|
||||
.roleNames(Collections.singletonList("composite"))
|
||||
.build();
|
||||
|
||||
assertThrows(RuntimeException.class, () -> roleResource.addComposites("role", REALM, request));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAddComposites_ChildNotFound_FilteredOut() {
|
||||
RoleDTO parentRole = RoleDTO.builder().id("parent-1").name("role").build();
|
||||
|
||||
when(roleService.getRoleByName("role", REALM, TypeRole.REALM_ROLE, null))
|
||||
.thenReturn(Optional.of(parentRole));
|
||||
when(roleService.getRoleByName("nonexistent", REALM, TypeRole.REALM_ROLE, null))
|
||||
.thenReturn(Optional.empty()); // will be filtered out (null id)
|
||||
doNothing().when(roleService).addCompositeRoles(eq("parent-1"), anyList(), eq(REALM),
|
||||
eq(TypeRole.REALM_ROLE), isNull());
|
||||
|
||||
RoleAssignmentRequestDTO request = RoleAssignmentRequestDTO.builder()
|
||||
.roleNames(Collections.singletonList("nonexistent"))
|
||||
.build();
|
||||
|
||||
roleResource.addComposites("role", REALM, request);
|
||||
|
||||
// addCompositeRoles called with empty list (filtered out)
|
||||
verify(roleService).addCompositeRoles(eq("parent-1"), eq(Collections.emptyList()), eq(REALM),
|
||||
eq(TypeRole.REALM_ROLE), isNull());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetComposites_RoleNotFound() {
|
||||
when(roleService.getRoleByName("role", REALM, TypeRole.REALM_ROLE, null))
|
||||
.thenReturn(Optional.empty());
|
||||
|
||||
assertThrows(RuntimeException.class, () -> roleResource.getComposites("role", REALM));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,6 +2,8 @@ package dev.lions.user.manager.resource;
|
||||
|
||||
import dev.lions.user.manager.api.SyncResourceApi;
|
||||
import dev.lions.user.manager.dto.sync.HealthStatusDTO;
|
||||
import dev.lions.user.manager.dto.sync.SyncConsistencyDTO;
|
||||
import dev.lions.user.manager.dto.sync.SyncHistoryDTO;
|
||||
import dev.lions.user.manager.dto.sync.SyncResultDTO;
|
||||
import dev.lions.user.manager.service.SyncService;
|
||||
import org.junit.jupiter.api.Test;
|
||||
@@ -79,4 +81,83 @@ class SyncResourceTest {
|
||||
assertTrue(result.isSuccess());
|
||||
assertEquals(5, result.getRealmRolesCount());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSyncRolesError() {
|
||||
when(syncService.syncRolesFromRealm(REALM)).thenThrow(new RuntimeException("Roles sync failed"));
|
||||
|
||||
SyncResultDTO result = syncResource.syncRoles(REALM, null);
|
||||
|
||||
assertFalse(result.isSuccess());
|
||||
assertEquals("Roles sync failed", result.getErrorMessage());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testPing() {
|
||||
String response = syncResource.ping();
|
||||
|
||||
assertNotNull(response);
|
||||
assertTrue(response.contains("pong"));
|
||||
assertTrue(response.contains("SyncResource"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCheckDataConsistency_Success() {
|
||||
when(syncService.checkDataConsistency(REALM)).thenReturn(Map.of(
|
||||
"realmName", REALM,
|
||||
"status", "OK",
|
||||
"usersKeycloakCount", 10,
|
||||
"usersLocalCount", 10
|
||||
));
|
||||
|
||||
var result = syncResource.checkDataConsistency(REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(REALM, result.getRealmName());
|
||||
assertEquals("OK", result.getStatus());
|
||||
assertEquals(10, result.getUsersKeycloakCount());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCheckDataConsistency_Exception() {
|
||||
when(syncService.checkDataConsistency(REALM)).thenThrow(new RuntimeException("DB error"));
|
||||
|
||||
var result = syncResource.checkDataConsistency(REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals("ERROR", result.getStatus());
|
||||
assertEquals(REALM, result.getRealmName());
|
||||
assertEquals("DB error", result.getError());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetLastSyncStatus() {
|
||||
var result = syncResource.getLastSyncStatus(REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(REALM, result.getRealmName());
|
||||
assertEquals("NEVER_SYNCED", result.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testForceSyncRealm_Success() {
|
||||
when(syncService.forceSyncRealm(REALM)).thenReturn(Map.of());
|
||||
|
||||
var result = syncResource.forceSyncRealm(REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals("SUCCESS", result.getStatus());
|
||||
assertEquals(REALM, result.getRealmName());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testForceSyncRealm_Exception() {
|
||||
doThrow(new RuntimeException("Force sync failed")).when(syncService).forceSyncRealm(REALM);
|
||||
|
||||
var result = syncResource.forceSyncRealm(REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals("FAILED", result.getStatus());
|
||||
assertEquals(REALM, result.getRealmName());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package dev.lions.user.manager.resource;
|
||||
|
||||
import dev.lions.user.manager.dto.importexport.ImportResultDTO;
|
||||
import dev.lions.user.manager.dto.user.*;
|
||||
import dev.lions.user.manager.service.UserService;
|
||||
import jakarta.ws.rs.core.Response;
|
||||
@@ -15,6 +16,7 @@ import java.util.Optional;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.ArgumentMatchers.eq;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
@@ -164,9 +166,11 @@ class UserResourceTest {
|
||||
void testSendVerificationEmail() {
|
||||
doNothing().when(userService).sendVerificationEmail("1", REALM);
|
||||
|
||||
userResource.sendVerificationEmail("1", REALM);
|
||||
Response response = userResource.sendVerificationEmail("1", REALM);
|
||||
|
||||
verify(userService).sendVerificationEmail("1", REALM);
|
||||
assertNotNull(response);
|
||||
assertEquals(202, response.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -189,4 +193,51 @@ class UserResourceTest {
|
||||
assertEquals(1, result.size());
|
||||
assertEquals("session-1", result.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCreateUser_IllegalArgumentException() {
|
||||
UserDTO newUser = UserDTO.builder().username("existinguser").email("existing@test.com").build();
|
||||
when(userService.createUser(any(), eq(REALM))).thenThrow(new IllegalArgumentException("Username exists"));
|
||||
|
||||
Response response = userResource.createUser(newUser, REALM);
|
||||
|
||||
assertEquals(409, response.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCreateUser_RuntimeException() {
|
||||
UserDTO newUser = UserDTO.builder().username("user").email("user@test.com").build();
|
||||
when(userService.createUser(any(), eq(REALM))).thenThrow(new RuntimeException("Connection error"));
|
||||
|
||||
assertThrows(RuntimeException.class, () -> userResource.createUser(newUser, REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testExportUsersToCSV() {
|
||||
String csvContent = "username,email,prenom,nom\ntest,test@test.com,Test,User";
|
||||
when(userService.exportUsersToCSV(any())).thenReturn(csvContent);
|
||||
|
||||
Response response = userResource.exportUsersToCSV(REALM);
|
||||
|
||||
assertEquals(200, response.getStatus());
|
||||
assertEquals(csvContent, response.getEntity());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV() {
|
||||
String csvContent = "username,email,prenom,nom\ntest,test@test.com,Test,User";
|
||||
ImportResultDTO importResult = ImportResultDTO.builder()
|
||||
.successCount(1)
|
||||
.errorCount(0)
|
||||
.totalLines(2)
|
||||
.errors(Collections.emptyList())
|
||||
.build();
|
||||
when(userService.importUsersFromCSV(csvContent, REALM)).thenReturn(importResult);
|
||||
|
||||
ImportResultDTO result = userResource.importUsersFromCSV(REALM, csvContent);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(1, result.getSuccessCount());
|
||||
assertEquals(0, result.getErrorCount());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,86 @@
|
||||
package dev.lions.user.manager.security;
|
||||
|
||||
import io.quarkus.security.identity.AuthenticationRequestContext;
|
||||
import io.quarkus.security.identity.SecurityIdentity;
|
||||
import io.smallrye.mutiny.Uni;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.jupiter.MockitoExtension;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
/**
|
||||
* Tests unitaires pour DevModeSecurityAugmentor.
|
||||
*/
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
class DevModeSecurityAugmentorTest {
|
||||
|
||||
@Mock
|
||||
SecurityIdentity identity;
|
||||
|
||||
@Mock
|
||||
AuthenticationRequestContext context;
|
||||
|
||||
DevModeSecurityAugmentor augmentor;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() throws Exception {
|
||||
augmentor = new DevModeSecurityAugmentor();
|
||||
}
|
||||
|
||||
private void setField(String name, Object value) throws Exception {
|
||||
Field field = DevModeSecurityAugmentor.class.getDeclaredField(name);
|
||||
field.setAccessible(true);
|
||||
field.set(augmentor, value);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAugment_OidcDisabled_AnonymousIdentity() throws Exception {
|
||||
setField("oidcEnabled", false);
|
||||
when(identity.isAnonymous()).thenReturn(true);
|
||||
// Mock credentials/roles/attributes to avoid NPE in QuarkusSecurityIdentity.builder
|
||||
when(identity.getCredentials()).thenReturn(java.util.Set.of());
|
||||
when(identity.getRoles()).thenReturn(java.util.Set.of());
|
||||
when(identity.getAttributes()).thenReturn(java.util.Map.of());
|
||||
|
||||
Uni<SecurityIdentity> result = augmentor.augment(identity, context);
|
||||
|
||||
assertNotNull(result);
|
||||
SecurityIdentity augmented = result.await().indefinitely();
|
||||
assertNotNull(augmented);
|
||||
// The augmented identity should have the dev roles
|
||||
assertTrue(augmented.getRoles().contains("admin"));
|
||||
assertTrue(augmented.getRoles().contains("user_manager"));
|
||||
assertEquals("dev-user", augmented.getPrincipal().getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAugment_OidcDisabled_AuthenticatedIdentity() throws Exception {
|
||||
setField("oidcEnabled", false);
|
||||
when(identity.isAnonymous()).thenReturn(false);
|
||||
|
||||
Uni<SecurityIdentity> result = augmentor.augment(identity, context);
|
||||
|
||||
assertNotNull(result);
|
||||
SecurityIdentity returned = result.await().indefinitely();
|
||||
// Should return the original identity without modification
|
||||
assertSame(identity, returned);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAugment_OidcEnabled() throws Exception {
|
||||
setField("oidcEnabled", true);
|
||||
|
||||
Uni<SecurityIdentity> result = augmentor.augment(identity, context);
|
||||
|
||||
assertNotNull(result);
|
||||
SecurityIdentity returned = result.await().indefinitely();
|
||||
// Should return the original identity without checking isAnonymous
|
||||
assertSame(identity, returned);
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@ import jakarta.ws.rs.core.UriInfo;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.jupiter.MockitoExtension;
|
||||
|
||||
@@ -84,5 +85,94 @@ class DevSecurityContextProducerTest {
|
||||
|
||||
verify(requestContext, times(1)).setSecurityContext(any(SecurityContext.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDevSecurityContext_GetUserPrincipal() throws Exception {
|
||||
setField("profile", "dev");
|
||||
setField("oidcEnabled", false);
|
||||
|
||||
when(requestContext.getUriInfo()).thenReturn(uriInfo);
|
||||
when(uriInfo.getPath()).thenReturn("/api/test");
|
||||
when(requestContext.getSecurityContext()).thenReturn(originalSecurityContext);
|
||||
|
||||
ArgumentCaptor<SecurityContext> captor = ArgumentCaptor.forClass(SecurityContext.class);
|
||||
producer.filter(requestContext);
|
||||
verify(requestContext).setSecurityContext(captor.capture());
|
||||
|
||||
SecurityContext devCtx = captor.getValue();
|
||||
assertNotNull(devCtx.getUserPrincipal());
|
||||
assertEquals("dev-user", devCtx.getUserPrincipal().getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDevSecurityContext_IsUserInRole() throws Exception {
|
||||
setField("profile", "dev");
|
||||
setField("oidcEnabled", false);
|
||||
|
||||
when(requestContext.getUriInfo()).thenReturn(uriInfo);
|
||||
when(uriInfo.getPath()).thenReturn("/api/test");
|
||||
when(requestContext.getSecurityContext()).thenReturn(originalSecurityContext);
|
||||
|
||||
ArgumentCaptor<SecurityContext> captor = ArgumentCaptor.forClass(SecurityContext.class);
|
||||
producer.filter(requestContext);
|
||||
verify(requestContext).setSecurityContext(captor.capture());
|
||||
|
||||
SecurityContext devCtx = captor.getValue();
|
||||
assertTrue(devCtx.isUserInRole("admin"));
|
||||
assertTrue(devCtx.isUserInRole("user_manager"));
|
||||
assertTrue(devCtx.isUserInRole("any_role"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDevSecurityContext_IsSecure_WithOriginal() throws Exception {
|
||||
setField("profile", "dev");
|
||||
setField("oidcEnabled", false);
|
||||
|
||||
when(requestContext.getUriInfo()).thenReturn(uriInfo);
|
||||
when(uriInfo.getPath()).thenReturn("/api/test");
|
||||
when(requestContext.getSecurityContext()).thenReturn(originalSecurityContext);
|
||||
when(originalSecurityContext.isSecure()).thenReturn(true);
|
||||
|
||||
ArgumentCaptor<SecurityContext> captor = ArgumentCaptor.forClass(SecurityContext.class);
|
||||
producer.filter(requestContext);
|
||||
verify(requestContext).setSecurityContext(captor.capture());
|
||||
|
||||
SecurityContext devCtx = captor.getValue();
|
||||
assertTrue(devCtx.isSecure()); // delegates to original which returns true
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDevSecurityContext_IsSecure_WithNullOriginal() throws Exception {
|
||||
setField("profile", "dev");
|
||||
setField("oidcEnabled", false);
|
||||
|
||||
when(requestContext.getUriInfo()).thenReturn(uriInfo);
|
||||
when(uriInfo.getPath()).thenReturn("/api/test");
|
||||
when(requestContext.getSecurityContext()).thenReturn(null); // null original
|
||||
|
||||
ArgumentCaptor<SecurityContext> captor = ArgumentCaptor.forClass(SecurityContext.class);
|
||||
producer.filter(requestContext);
|
||||
verify(requestContext).setSecurityContext(captor.capture());
|
||||
|
||||
SecurityContext devCtx = captor.getValue();
|
||||
assertFalse(devCtx.isSecure()); // original is null → returns false
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDevSecurityContext_GetAuthenticationScheme() throws Exception {
|
||||
setField("profile", "dev");
|
||||
setField("oidcEnabled", false);
|
||||
|
||||
when(requestContext.getUriInfo()).thenReturn(uriInfo);
|
||||
when(uriInfo.getPath()).thenReturn("/api/test");
|
||||
when(requestContext.getSecurityContext()).thenReturn(originalSecurityContext);
|
||||
|
||||
ArgumentCaptor<SecurityContext> captor = ArgumentCaptor.forClass(SecurityContext.class);
|
||||
producer.filter(requestContext);
|
||||
verify(requestContext).setSecurityContext(captor.capture());
|
||||
|
||||
SecurityContext devCtx = captor.getValue();
|
||||
assertEquals("DEV", devCtx.getAuthenticationScheme());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,174 @@
|
||||
package dev.lions.user.manager.server.impl.entity;
|
||||
|
||||
import dev.lions.user.manager.enums.audit.TypeActionAudit;
|
||||
import io.quarkus.test.junit.QuarkusTest;
|
||||
import io.quarkus.test.junit.QuarkusTestProfile;
|
||||
import io.quarkus.test.junit.TestProfile;
|
||||
import jakarta.transaction.Transactional;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Tests @QuarkusTest pour les méthodes statiques Panache de AuditLogEntity.
|
||||
* Utilise H2 en mémoire (pas besoin de Docker).
|
||||
* Couvre : L134, L144, L154, L165, L175, L186, L196, L207.
|
||||
*/
|
||||
@QuarkusTest
|
||||
@TestProfile(AuditLogEntityQuarkusTest.H2Profile.class)
|
||||
class AuditLogEntityQuarkusTest {
|
||||
|
||||
public static class H2Profile implements QuarkusTestProfile {
|
||||
@Override
|
||||
public Map<String, String> getConfigOverrides() {
|
||||
return Map.ofEntries(
|
||||
// DevServices désactivé (pas de Docker)
|
||||
Map.entry("quarkus.devservices.enabled", "false"),
|
||||
Map.entry("quarkus.oidc.devservices.enabled", "false"),
|
||||
// Base de données H2 en mémoire
|
||||
Map.entry("quarkus.datasource.db-kind", "h2"),
|
||||
Map.entry("quarkus.datasource.jdbc.url", "jdbc:h2:mem:auditlogtest;DB_CLOSE_DELAY=-1;MODE=PostgreSQL"),
|
||||
Map.entry("quarkus.hibernate-orm.database.generation", "drop-and-create"),
|
||||
Map.entry("quarkus.flyway.enabled", "false"),
|
||||
// OIDC désactivé
|
||||
Map.entry("quarkus.oidc.tenant-enabled", "false"),
|
||||
Map.entry("quarkus.keycloak.policy-enforcer.enable", "false"),
|
||||
// Keycloak admin client activé (pour le bean CDI) mais pas de connexion réelle
|
||||
Map.entry("quarkus.keycloak.admin-client.enabled", "true"),
|
||||
Map.entry("quarkus.keycloak.admin-client.server-url", "http://localhost:8080"),
|
||||
Map.entry("quarkus.keycloak.admin-client.realm", "master"),
|
||||
Map.entry("quarkus.keycloak.admin-client.client-id", "admin-cli"),
|
||||
Map.entry("quarkus.keycloak.admin-client.username", "admin"),
|
||||
Map.entry("quarkus.keycloak.admin-client.password", "admin"),
|
||||
Map.entry("quarkus.keycloak.admin-client.grant-type", "PASSWORD"),
|
||||
// Propriétés applicatives requises
|
||||
Map.entry("lions.keycloak.server-url", "http://localhost:8080"),
|
||||
Map.entry("lions.keycloak.admin-realm", "master"),
|
||||
Map.entry("lions.keycloak.admin-client-id", "admin-cli"),
|
||||
Map.entry("lions.keycloak.admin-username", "admin"),
|
||||
Map.entry("lions.keycloak.admin-password", "admin"),
|
||||
Map.entry("lions.keycloak.connection-pool-size", "10"),
|
||||
Map.entry("lions.keycloak.timeout-seconds", "30"),
|
||||
Map.entry("lions.keycloak.authorized-realms", "master,lions-user-manager")
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
private AuditLogEntity buildEntity(String userId, String auteur, String realm,
|
||||
TypeActionAudit action, boolean success) {
|
||||
AuditLogEntity entity = new AuditLogEntity();
|
||||
entity.setUserId(userId);
|
||||
entity.setAuteurAction(auteur);
|
||||
entity.setRealmName(realm);
|
||||
entity.setAction(action);
|
||||
entity.setSuccess(success);
|
||||
entity.setDetails("test details");
|
||||
entity.setTimestamp(LocalDateTime.now());
|
||||
return entity;
|
||||
}
|
||||
|
||||
@Test
|
||||
@Transactional
|
||||
void testFindByUserId_CoversL134() {
|
||||
AuditLogEntity entity = buildEntity("user-qt-1", "admin", "realm1",
|
||||
TypeActionAudit.USER_CREATE, true);
|
||||
entity.persist();
|
||||
|
||||
List<AuditLogEntity> results = AuditLogEntity.findByUserId("user-qt-1");
|
||||
assertNotNull(results);
|
||||
assertFalse(results.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
@Transactional
|
||||
void testFindByAction_CoversL144() {
|
||||
AuditLogEntity entity = buildEntity("user-qt-2", "admin", "realm1",
|
||||
TypeActionAudit.USER_UPDATE, true);
|
||||
entity.persist();
|
||||
|
||||
List<AuditLogEntity> results = AuditLogEntity.findByAction(TypeActionAudit.USER_UPDATE);
|
||||
assertNotNull(results);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Transactional
|
||||
void testFindByAuteur_CoversL154() {
|
||||
AuditLogEntity entity = buildEntity("user-qt-3", "auteur-qt", "realm1",
|
||||
TypeActionAudit.USER_DELETE, true);
|
||||
entity.persist();
|
||||
|
||||
List<AuditLogEntity> results = AuditLogEntity.findByAuteur("auteur-qt");
|
||||
assertNotNull(results);
|
||||
assertFalse(results.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
@Transactional
|
||||
void testFindByPeriod_CoversL165() {
|
||||
LocalDateTime now = LocalDateTime.now();
|
||||
AuditLogEntity entity = buildEntity("user-qt-4", "admin", "realm1",
|
||||
TypeActionAudit.USER_CREATE, true);
|
||||
entity.setTimestamp(now);
|
||||
entity.persist();
|
||||
|
||||
List<AuditLogEntity> results = AuditLogEntity.findByPeriod(now.minusSeconds(5), now.plusSeconds(5));
|
||||
assertNotNull(results);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Transactional
|
||||
void testFindByRealm_CoversL175() {
|
||||
AuditLogEntity entity = buildEntity("user-qt-5", "admin", "realm-qt-test",
|
||||
TypeActionAudit.REALM_ASSIGN, true);
|
||||
entity.persist();
|
||||
|
||||
List<AuditLogEntity> results = AuditLogEntity.findByRealm("realm-qt-test");
|
||||
assertNotNull(results);
|
||||
assertFalse(results.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
@Transactional
|
||||
void testDeleteOlderThan_CoversL186() {
|
||||
AuditLogEntity entity = buildEntity("user-qt-6", "admin", "realm1",
|
||||
TypeActionAudit.USER_CREATE, true);
|
||||
entity.setTimestamp(LocalDateTime.now().minusDays(365));
|
||||
entity.persist();
|
||||
|
||||
long deleted = AuditLogEntity.deleteOlderThan(LocalDateTime.now().minusDays(1));
|
||||
assertTrue(deleted >= 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Transactional
|
||||
void testCountByAuteur_CoversL196() {
|
||||
AuditLogEntity entity = buildEntity("user-qt-7", "count-auteur-qt", "realm1",
|
||||
TypeActionAudit.USER_CREATE, true);
|
||||
entity.persist();
|
||||
|
||||
long count = AuditLogEntity.countByAuteur("count-auteur-qt");
|
||||
assertTrue(count >= 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Transactional
|
||||
void testCountFailuresByUserId_CoversL207() {
|
||||
AuditLogEntity failEntity = buildEntity("user-qt-fail", "admin", "realm1",
|
||||
TypeActionAudit.USER_CREATE, false);
|
||||
failEntity.persist();
|
||||
|
||||
long failures = AuditLogEntity.countFailuresByUserId("user-qt-fail");
|
||||
assertTrue(failures >= 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Transactional
|
||||
void testCountFailuresByUserId_NoFailures() {
|
||||
long failures = AuditLogEntity.countFailuresByUserId("user-qt-nonexistent-9999");
|
||||
assertEquals(0, failures);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,246 @@
|
||||
package dev.lions.user.manager.server.impl.entity;
|
||||
|
||||
import dev.lions.user.manager.enums.audit.TypeActionAudit;
|
||||
import io.quarkus.hibernate.orm.panache.PanacheEntityBase;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.mockito.MockedStatic;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.ArrayList;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.ArgumentMatchers.anyString;
|
||||
import static org.mockito.Mockito.mockStatic;
|
||||
|
||||
/**
|
||||
* Tests pour les entités JPA (getters/setters Lombok @Data).
|
||||
* Les entités étendent PanacheEntity mais peuvent être instanciées sans contexte CDI.
|
||||
*/
|
||||
class EntitiesTest {
|
||||
|
||||
// ===================== AuditLogEntity =====================
|
||||
|
||||
@Test
|
||||
void testAuditLogEntity_GettersSetters() {
|
||||
AuditLogEntity entity = new AuditLogEntity();
|
||||
|
||||
entity.setRealmName("test-realm");
|
||||
entity.setAction(TypeActionAudit.USER_CREATE);
|
||||
entity.setUserId("user-1");
|
||||
entity.setAuteurAction("admin");
|
||||
entity.setDetails("Test action");
|
||||
entity.setSuccess(true);
|
||||
entity.setErrorMessage(null);
|
||||
entity.setIpAddress("127.0.0.1");
|
||||
entity.setUserAgent("Mozilla/5.0");
|
||||
LocalDateTime now = LocalDateTime.now();
|
||||
entity.setTimestamp(now);
|
||||
|
||||
assertEquals("test-realm", entity.getRealmName());
|
||||
assertEquals(TypeActionAudit.USER_CREATE, entity.getAction());
|
||||
assertEquals("user-1", entity.getUserId());
|
||||
assertEquals("admin", entity.getAuteurAction());
|
||||
assertEquals("Test action", entity.getDetails());
|
||||
assertTrue(entity.getSuccess());
|
||||
assertNull(entity.getErrorMessage());
|
||||
assertEquals("127.0.0.1", entity.getIpAddress());
|
||||
assertEquals("Mozilla/5.0", entity.getUserAgent());
|
||||
assertEquals(now, entity.getTimestamp());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAuditLogEntity_Equals_HashCode() {
|
||||
AuditLogEntity e1 = new AuditLogEntity();
|
||||
e1.setRealmName("realm");
|
||||
AuditLogEntity e2 = new AuditLogEntity();
|
||||
e2.setRealmName("realm");
|
||||
|
||||
// @Data génère equals/hashCode basés sur les champs
|
||||
assertNotNull(e1.toString());
|
||||
assertNotNull(e1.hashCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAuditLogEntity_ErrorMessage() {
|
||||
AuditLogEntity entity = new AuditLogEntity();
|
||||
entity.setErrorMessage("Connection failed");
|
||||
entity.setSuccess(false);
|
||||
|
||||
assertEquals("Connection failed", entity.getErrorMessage());
|
||||
assertFalse(entity.getSuccess());
|
||||
}
|
||||
|
||||
// ===================== SyncHistoryEntity =====================
|
||||
|
||||
@Test
|
||||
void testSyncHistoryEntity_Constructor_SetsSyncDate() {
|
||||
SyncHistoryEntity entity = new SyncHistoryEntity();
|
||||
// Le constructeur initialise syncDate à now()
|
||||
assertNotNull(entity.getSyncDate());
|
||||
assertTrue(entity.getSyncDate().isBefore(LocalDateTime.now().plusSeconds(1)));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSyncHistoryEntity_GettersSetters() {
|
||||
SyncHistoryEntity entity = new SyncHistoryEntity();
|
||||
LocalDateTime syncDate = LocalDateTime.now().minusMinutes(5);
|
||||
|
||||
entity.setRealmName("my-realm");
|
||||
entity.setSyncDate(syncDate);
|
||||
entity.setSyncType("USER");
|
||||
entity.setStatus("SUCCESS");
|
||||
entity.setItemsProcessed(42);
|
||||
entity.setDurationMs(1500L);
|
||||
entity.setErrorMessage(null);
|
||||
|
||||
assertEquals("my-realm", entity.getRealmName());
|
||||
assertEquals(syncDate, entity.getSyncDate());
|
||||
assertEquals("USER", entity.getSyncType());
|
||||
assertEquals("SUCCESS", entity.getStatus());
|
||||
assertEquals(42, entity.getItemsProcessed());
|
||||
assertEquals(1500L, entity.getDurationMs());
|
||||
assertNull(entity.getErrorMessage());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSyncHistoryEntity_WithError() {
|
||||
SyncHistoryEntity entity = new SyncHistoryEntity();
|
||||
entity.setStatus("FAILURE");
|
||||
entity.setErrorMessage("Connection refused");
|
||||
|
||||
assertEquals("FAILURE", entity.getStatus());
|
||||
assertEquals("Connection refused", entity.getErrorMessage());
|
||||
assertNotNull(entity.toString());
|
||||
}
|
||||
|
||||
// ===================== SyncedRoleEntity =====================
|
||||
|
||||
@Test
|
||||
void testSyncedRoleEntity_GettersSetters() {
|
||||
SyncedRoleEntity entity = new SyncedRoleEntity();
|
||||
|
||||
entity.setRealmName("lions");
|
||||
entity.setRoleName("admin");
|
||||
entity.setDescription("Administrator role");
|
||||
|
||||
assertEquals("lions", entity.getRealmName());
|
||||
assertEquals("admin", entity.getRoleName());
|
||||
assertEquals("Administrator role", entity.getDescription());
|
||||
assertNotNull(entity.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSyncedRoleEntity_NullDescription() {
|
||||
SyncedRoleEntity entity = new SyncedRoleEntity();
|
||||
entity.setRealmName("realm");
|
||||
entity.setRoleName("viewer");
|
||||
entity.setDescription(null);
|
||||
|
||||
assertNull(entity.getDescription());
|
||||
assertEquals("viewer", entity.getRoleName());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSyncedRoleEntity_Equals() {
|
||||
SyncedRoleEntity e1 = new SyncedRoleEntity();
|
||||
e1.setRealmName("realm");
|
||||
e1.setRoleName("admin");
|
||||
|
||||
// @EqualsAndHashCode(callSuper = true) → délègue à PanacheEntityBase (identité objet)
|
||||
assertEquals(e1, e1);
|
||||
assertNotEquals(e1, new SyncedRoleEntity());
|
||||
assertNotNull(e1.hashCode());
|
||||
}
|
||||
|
||||
// ===================== SyncedUserEntity =====================
|
||||
|
||||
@Test
|
||||
void testSyncedUserEntity_GettersSetters() {
|
||||
SyncedUserEntity entity = new SyncedUserEntity();
|
||||
LocalDateTime createdAt = LocalDateTime.now();
|
||||
|
||||
entity.setRealmName("lions");
|
||||
entity.setKeycloakId("kc-123");
|
||||
entity.setUsername("john.doe");
|
||||
entity.setEmail("john@lions.dev");
|
||||
entity.setEnabled(true);
|
||||
entity.setEmailVerified(false);
|
||||
entity.setCreatedAt(createdAt);
|
||||
|
||||
assertEquals("lions", entity.getRealmName());
|
||||
assertEquals("kc-123", entity.getKeycloakId());
|
||||
assertEquals("john.doe", entity.getUsername());
|
||||
assertEquals("john@lions.dev", entity.getEmail());
|
||||
assertTrue(entity.getEnabled());
|
||||
assertFalse(entity.getEmailVerified());
|
||||
assertEquals(createdAt, entity.getCreatedAt());
|
||||
assertNotNull(entity.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSyncedUserEntity_NullFields() {
|
||||
SyncedUserEntity entity = new SyncedUserEntity();
|
||||
entity.setRealmName("realm");
|
||||
entity.setKeycloakId("kc-456");
|
||||
entity.setUsername("user");
|
||||
entity.setEmail(null);
|
||||
entity.setEnabled(null);
|
||||
entity.setEmailVerified(null);
|
||||
entity.setCreatedAt(null);
|
||||
|
||||
assertNull(entity.getEmail());
|
||||
assertNull(entity.getEnabled());
|
||||
assertNull(entity.getEmailVerified());
|
||||
assertNull(entity.getCreatedAt());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSyncedUserEntity_Equals() {
|
||||
SyncedUserEntity e1 = new SyncedUserEntity();
|
||||
e1.setKeycloakId("kc-1");
|
||||
e1.setRealmName("realm");
|
||||
e1.setUsername("user");
|
||||
|
||||
// @EqualsAndHashCode(callSuper = true) → délègue à PanacheEntityBase (identité objet)
|
||||
assertEquals(e1, e1);
|
||||
assertNotEquals(e1, new SyncedUserEntity());
|
||||
assertNotNull(e1.hashCode());
|
||||
}
|
||||
|
||||
// ===================== AuditLogEntity — méthodes Panache statiques =====================
|
||||
|
||||
/**
|
||||
* Couvre AuditLogEntity L134, L144, L154, L165, L175, L186, L196, L207.
|
||||
*
|
||||
* Stratégie : mockStatic(PanacheEntityBase.class) — PAS AuditLogEntity.
|
||||
* - mockStatic(PanacheEntityBase) retire les sondes JaCoCo de PanacheEntityBase (lib tierce, pas de souci).
|
||||
* - Les sondes JaCoCo de AuditLogEntity restent INTACTES.
|
||||
* - list/count/delete retournent une valeur au lieu de lancer RuntimeException.
|
||||
* - L'exécution atteint l'areturn à offset 13 → sonde JaCoCo fire → ligne couverte.
|
||||
* - Le cast (Object[]) any() désambiguïse le surclassement varargs de list/count/delete.
|
||||
*/
|
||||
@Test
|
||||
@SuppressWarnings({"unchecked", "rawtypes"})
|
||||
void testAuditLogEntity_PanacheStaticMethods_CoverLines() {
|
||||
try (MockedStatic<PanacheEntityBase> panacheMocked = mockStatic(PanacheEntityBase.class)) {
|
||||
panacheMocked.when(() -> PanacheEntityBase.list(anyString(), (Object[]) any()))
|
||||
.thenReturn(new ArrayList<>());
|
||||
panacheMocked.when(() -> PanacheEntityBase.delete(anyString(), (Object[]) any()))
|
||||
.thenReturn(0L);
|
||||
panacheMocked.when(() -> PanacheEntityBase.count(anyString(), (Object[]) any()))
|
||||
.thenReturn(0L);
|
||||
|
||||
LocalDateTime now = LocalDateTime.now();
|
||||
|
||||
assertNotNull(AuditLogEntity.findByUserId("u1")); // L134
|
||||
assertNotNull(AuditLogEntity.findByAction(TypeActionAudit.USER_CREATE)); // L144
|
||||
assertNotNull(AuditLogEntity.findByAuteur("admin")); // L154
|
||||
assertNotNull(AuditLogEntity.findByPeriod(now.minusDays(1), now)); // L165
|
||||
assertNotNull(AuditLogEntity.findByRealm("realm")); // L175
|
||||
AuditLogEntity.deleteOlderThan(now.minusDays(30)); // L186
|
||||
AuditLogEntity.countByAuteur("admin"); // L196
|
||||
AuditLogEntity.countFailuresByUserId("u1"); // L207
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,206 @@
|
||||
package dev.lions.user.manager.server.impl.interceptor;
|
||||
|
||||
import dev.lions.user.manager.enums.audit.TypeActionAudit;
|
||||
import dev.lions.user.manager.service.AuditService;
|
||||
import io.quarkus.security.identity.SecurityIdentity;
|
||||
import jakarta.interceptor.InvocationContext;
|
||||
import org.eclipse.microprofile.jwt.JsonWebToken;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.jupiter.MockitoExtension;
|
||||
import org.mockito.junit.jupiter.MockitoSettings;
|
||||
import org.mockito.quality.Strictness;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Method;
|
||||
import java.security.Principal;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
@MockitoSettings(strictness = Strictness.LENIENT)
|
||||
class AuditInterceptorTest {
|
||||
|
||||
@Mock
|
||||
AuditService auditService;
|
||||
|
||||
@Mock
|
||||
SecurityIdentity securityIdentity;
|
||||
|
||||
@Mock
|
||||
InvocationContext invocationContext;
|
||||
|
||||
AuditInterceptor auditInterceptor;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() throws Exception {
|
||||
auditInterceptor = new AuditInterceptor();
|
||||
setField("auditService", auditService);
|
||||
setField("securityIdentity", securityIdentity);
|
||||
}
|
||||
|
||||
private void setField(String name, Object value) throws Exception {
|
||||
Field field = AuditInterceptor.class.getDeclaredField(name);
|
||||
field.setAccessible(true);
|
||||
field.set(auditInterceptor, value);
|
||||
}
|
||||
|
||||
@Logged(action = "USER_CREATE", resource = "USER")
|
||||
public void annotatedMethod() {}
|
||||
|
||||
public void nonAnnotatedMethod() {}
|
||||
|
||||
@Test
|
||||
void testAuditMethod_Success_AnonymousUser() throws Exception {
|
||||
Method method = getClass().getDeclaredMethod("annotatedMethod");
|
||||
when(invocationContext.getMethod()).thenReturn(method);
|
||||
when(invocationContext.getTarget()).thenReturn(this);
|
||||
when(invocationContext.getParameters()).thenReturn(new Object[0]);
|
||||
when(invocationContext.proceed()).thenReturn("result");
|
||||
when(securityIdentity.isAnonymous()).thenReturn(true);
|
||||
|
||||
Object result = auditInterceptor.auditMethod(invocationContext);
|
||||
|
||||
assertEquals("result", result);
|
||||
verify(auditService).logSuccess(eq(TypeActionAudit.USER_CREATE), eq("USER"),
|
||||
any(), any(), any(), eq("anonymous"), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAuditMethod_Success_AuthenticatedUser_WithStringParam() throws Exception {
|
||||
Method method = getClass().getDeclaredMethod("annotatedMethod");
|
||||
when(invocationContext.getMethod()).thenReturn(method);
|
||||
when(invocationContext.getTarget()).thenReturn(this);
|
||||
when(invocationContext.getParameters()).thenReturn(new Object[]{"user-123"});
|
||||
when(invocationContext.proceed()).thenReturn(null);
|
||||
Principal principal = () -> "admin-user";
|
||||
when(securityIdentity.isAnonymous()).thenReturn(false);
|
||||
when(securityIdentity.getPrincipal()).thenReturn(principal);
|
||||
|
||||
auditInterceptor.auditMethod(invocationContext);
|
||||
|
||||
verify(auditService).logSuccess(any(), any(), eq("user-123"), any(), any(), eq("admin-user"), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAuditMethod_Success_JwtUser_RealmExtracted() throws Exception {
|
||||
Method method = getClass().getDeclaredMethod("annotatedMethod");
|
||||
when(invocationContext.getMethod()).thenReturn(method);
|
||||
when(invocationContext.getTarget()).thenReturn(this);
|
||||
when(invocationContext.getParameters()).thenReturn(new Object[0]);
|
||||
when(invocationContext.proceed()).thenReturn(null);
|
||||
|
||||
JsonWebToken jwt = mock(JsonWebToken.class);
|
||||
when(jwt.getName()).thenReturn("jwt-user");
|
||||
when(jwt.getIssuer()).thenReturn("http://keycloak:8080/realms/test-realm");
|
||||
when(securityIdentity.isAnonymous()).thenReturn(false);
|
||||
when(securityIdentity.getPrincipal()).thenReturn(jwt);
|
||||
|
||||
auditInterceptor.auditMethod(invocationContext);
|
||||
|
||||
verify(auditService).logSuccess(any(), any(), any(), any(), eq("test-realm"), eq("jwt-user"), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAuditMethod_Success_JwtUser_NoRealmsInIssuer() throws Exception {
|
||||
Method method = getClass().getDeclaredMethod("annotatedMethod");
|
||||
when(invocationContext.getMethod()).thenReturn(method);
|
||||
when(invocationContext.getTarget()).thenReturn(this);
|
||||
when(invocationContext.getParameters()).thenReturn(new Object[0]);
|
||||
when(invocationContext.proceed()).thenReturn(null);
|
||||
|
||||
JsonWebToken jwt = mock(JsonWebToken.class);
|
||||
when(jwt.getName()).thenReturn("jwt-user");
|
||||
when(jwt.getIssuer()).thenReturn("http://other-issuer.com");
|
||||
when(securityIdentity.isAnonymous()).thenReturn(false);
|
||||
when(securityIdentity.getPrincipal()).thenReturn(jwt);
|
||||
|
||||
auditInterceptor.auditMethod(invocationContext);
|
||||
|
||||
verify(auditService).logSuccess(any(), any(), any(), any(), eq("unknown"), any(), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAuditMethod_Success_JwtUser_NullIssuer() throws Exception {
|
||||
Method method = getClass().getDeclaredMethod("annotatedMethod");
|
||||
when(invocationContext.getMethod()).thenReturn(method);
|
||||
when(invocationContext.getTarget()).thenReturn(this);
|
||||
when(invocationContext.getParameters()).thenReturn(new Object[0]);
|
||||
when(invocationContext.proceed()).thenReturn(null);
|
||||
|
||||
JsonWebToken jwt = mock(JsonWebToken.class);
|
||||
when(jwt.getName()).thenReturn("jwt-user");
|
||||
when(jwt.getIssuer()).thenReturn(null);
|
||||
when(securityIdentity.isAnonymous()).thenReturn(false);
|
||||
when(securityIdentity.getPrincipal()).thenReturn(jwt);
|
||||
|
||||
auditInterceptor.auditMethod(invocationContext);
|
||||
|
||||
verify(auditService).logSuccess(any(), any(), any(), any(), eq("unknown"), any(), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAuditMethod_Failure_Exception() throws Exception {
|
||||
Method method = getClass().getDeclaredMethod("annotatedMethod");
|
||||
when(invocationContext.getMethod()).thenReturn(method);
|
||||
when(invocationContext.getTarget()).thenReturn(this);
|
||||
when(invocationContext.getParameters()).thenReturn(new Object[0]);
|
||||
when(securityIdentity.isAnonymous()).thenReturn(true);
|
||||
when(invocationContext.proceed()).thenThrow(new RuntimeException("Service unavailable"));
|
||||
|
||||
assertThrows(RuntimeException.class, () -> auditInterceptor.auditMethod(invocationContext));
|
||||
|
||||
verify(auditService).logFailure(eq(TypeActionAudit.USER_CREATE), eq("USER"),
|
||||
any(), any(), any(), eq("anonymous"), any(), eq("Service unavailable"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAuditMethod_Success_UnknownAction_NoAnnotation() throws Exception {
|
||||
// When method has no @Logged and class has no @Logged → action = "UNKNOWN"
|
||||
// TypeActionAudit.valueOf("UNKNOWN") throws IllegalArgumentException → caught, logged as warning
|
||||
Method method = getClass().getDeclaredMethod("nonAnnotatedMethod");
|
||||
when(invocationContext.getMethod()).thenReturn(method);
|
||||
when(invocationContext.getTarget()).thenReturn(this);
|
||||
when(invocationContext.getParameters()).thenReturn(new Object[0]);
|
||||
when(securityIdentity.isAnonymous()).thenReturn(true);
|
||||
when(invocationContext.proceed()).thenReturn("ok");
|
||||
|
||||
Object result = auditInterceptor.auditMethod(invocationContext);
|
||||
|
||||
assertEquals("ok", result);
|
||||
verify(auditService, never()).logSuccess(any(), any(), any(), any(), any(), any(), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAuditMethod_Failure_UnknownAction() throws Exception {
|
||||
Method method = getClass().getDeclaredMethod("nonAnnotatedMethod");
|
||||
when(invocationContext.getMethod()).thenReturn(method);
|
||||
when(invocationContext.getTarget()).thenReturn(this);
|
||||
when(invocationContext.getParameters()).thenReturn(new Object[0]);
|
||||
when(securityIdentity.isAnonymous()).thenReturn(true);
|
||||
when(invocationContext.proceed()).thenThrow(new RuntimeException("error"));
|
||||
|
||||
assertThrows(RuntimeException.class, () -> auditInterceptor.auditMethod(invocationContext));
|
||||
|
||||
verify(auditService, never()).logFailure(any(), any(), any(), any(), any(), any(), any(), any());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAuditMethod_Success_NonStringFirstParam() throws Exception {
|
||||
Method method = getClass().getDeclaredMethod("annotatedMethod");
|
||||
when(invocationContext.getMethod()).thenReturn(method);
|
||||
when(invocationContext.getTarget()).thenReturn(this);
|
||||
// First param is Integer, not String → resourceId should be ""
|
||||
when(invocationContext.getParameters()).thenReturn(new Object[]{42});
|
||||
when(invocationContext.proceed()).thenReturn(null);
|
||||
when(securityIdentity.isAnonymous()).thenReturn(true);
|
||||
|
||||
auditInterceptor.auditMethod(invocationContext);
|
||||
|
||||
verify(auditService).logSuccess(any(), any(), eq(""), any(), any(), any(), any());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
package dev.lions.user.manager.server.impl.mapper;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Tests for default methods in AuditLogMapper and SyncHistoryMapper interfaces.
|
||||
* These default methods are NOT generated by MapStruct and must be tested via anonymous implementations.
|
||||
*/
|
||||
class AuditLogMapperDefaultMethodsTest {
|
||||
|
||||
// Create anonymous implementation of AuditLogMapper to test default methods
|
||||
private final AuditLogMapper auditLogMapper = new AuditLogMapper() {
|
||||
@Override
|
||||
public dev.lions.user.manager.dto.audit.AuditLogDTO toDTO(dev.lions.user.manager.server.impl.entity.AuditLogEntity entity) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public dev.lions.user.manager.server.impl.entity.AuditLogEntity toEntity(dev.lions.user.manager.dto.audit.AuditLogDTO dto) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public java.util.List<dev.lions.user.manager.dto.audit.AuditLogDTO> toDTOList(java.util.List<dev.lions.user.manager.server.impl.entity.AuditLogEntity> entities) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public java.util.List<dev.lions.user.manager.server.impl.entity.AuditLogEntity> toEntityList(java.util.List<dev.lions.user.manager.dto.audit.AuditLogDTO> dtos) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateEntityFromDTO(dev.lions.user.manager.dto.audit.AuditLogDTO dto, dev.lions.user.manager.server.impl.entity.AuditLogEntity entity) {
|
||||
}
|
||||
};
|
||||
|
||||
// Create anonymous implementation of SyncHistoryMapper to test default methods
|
||||
private final SyncHistoryMapper syncHistoryMapper = new SyncHistoryMapper() {
|
||||
@Override
|
||||
public dev.lions.user.manager.dto.sync.SyncHistoryDTO toDTO(dev.lions.user.manager.server.impl.entity.SyncHistoryEntity entity) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public java.util.List<dev.lions.user.manager.dto.sync.SyncHistoryDTO> toDTOList(java.util.List<dev.lions.user.manager.server.impl.entity.SyncHistoryEntity> entities) {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
// AuditLogMapper.longToString() tests
|
||||
|
||||
@Test
|
||||
void testLongToString_Null() {
|
||||
assertNull(auditLogMapper.longToString(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testLongToString_Value() {
|
||||
assertEquals("123", auditLogMapper.longToString(123L));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testLongToString_Zero() {
|
||||
assertEquals("0", auditLogMapper.longToString(0L));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testLongToString_LargeValue() {
|
||||
assertEquals("9999999999", auditLogMapper.longToString(9999999999L));
|
||||
}
|
||||
|
||||
// AuditLogMapper.stringToLong() tests
|
||||
|
||||
@Test
|
||||
void testStringToLong_Null() {
|
||||
assertNull(auditLogMapper.stringToLong(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testStringToLong_Blank() {
|
||||
assertNull(auditLogMapper.stringToLong(" "));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testStringToLong_Empty() {
|
||||
assertNull(auditLogMapper.stringToLong(""));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testStringToLong_ValidNumber() {
|
||||
assertEquals(456L, auditLogMapper.stringToLong("456"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testStringToLong_InvalidFormat() {
|
||||
// Should return null and print warning instead of throwing
|
||||
assertNull(auditLogMapper.stringToLong("not-a-number"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testStringToLong_WithLetters() {
|
||||
assertNull(auditLogMapper.stringToLong("123abc"));
|
||||
}
|
||||
|
||||
// SyncHistoryMapper.longToString() tests
|
||||
|
||||
@Test
|
||||
void testSyncHistoryMapper_LongToString_Null() {
|
||||
assertNull(syncHistoryMapper.longToString(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSyncHistoryMapper_LongToString_Value() {
|
||||
assertEquals("1", syncHistoryMapper.longToString(1L));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSyncHistoryMapper_LongToString_LargeValue() {
|
||||
assertEquals("100000", syncHistoryMapper.longToString(100000L));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
package dev.lions.user.manager.service.exception;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class KeycloakServiceExceptionTest {
|
||||
|
||||
@Test
|
||||
void testConstructor_MessageOnly() {
|
||||
KeycloakServiceException ex = new KeycloakServiceException("Test error");
|
||||
assertEquals("Test error", ex.getMessage());
|
||||
assertEquals(0, ex.getHttpStatus());
|
||||
assertEquals("Keycloak", ex.getServiceName());
|
||||
assertNull(ex.getCause());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testConstructor_MessageAndCause() {
|
||||
Throwable cause = new RuntimeException("Root cause");
|
||||
KeycloakServiceException ex = new KeycloakServiceException("Test error", cause);
|
||||
assertEquals("Test error", ex.getMessage());
|
||||
assertEquals(0, ex.getHttpStatus());
|
||||
assertEquals("Keycloak", ex.getServiceName());
|
||||
assertSame(cause, ex.getCause());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testConstructor_MessageAndStatus() {
|
||||
KeycloakServiceException ex = new KeycloakServiceException("Not found", 404);
|
||||
assertEquals("Not found", ex.getMessage());
|
||||
assertEquals(404, ex.getHttpStatus());
|
||||
assertEquals("Keycloak", ex.getServiceName());
|
||||
assertNull(ex.getCause());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testConstructor_MessageStatusAndCause() {
|
||||
Throwable cause = new RuntimeException("Root cause");
|
||||
KeycloakServiceException ex = new KeycloakServiceException("Server error", 500, cause);
|
||||
assertEquals("Server error", ex.getMessage());
|
||||
assertEquals(500, ex.getHttpStatus());
|
||||
assertEquals("Keycloak", ex.getServiceName());
|
||||
assertSame(cause, ex.getCause());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testIsRuntimeException() {
|
||||
KeycloakServiceException ex = new KeycloakServiceException("test");
|
||||
assertInstanceOf(RuntimeException.class, ex);
|
||||
}
|
||||
|
||||
// ServiceUnavailableException tests
|
||||
|
||||
@Test
|
||||
void testServiceUnavailableException_MessageOnly() {
|
||||
KeycloakServiceException.ServiceUnavailableException ex =
|
||||
new KeycloakServiceException.ServiceUnavailableException("connection refused");
|
||||
assertTrue(ex.getMessage().contains("Service Keycloak indisponible"));
|
||||
assertTrue(ex.getMessage().contains("connection refused"));
|
||||
assertEquals("Keycloak", ex.getServiceName());
|
||||
assertEquals(0, ex.getHttpStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testServiceUnavailableException_MessageAndCause() {
|
||||
Throwable cause = new RuntimeException("network error");
|
||||
KeycloakServiceException.ServiceUnavailableException ex =
|
||||
new KeycloakServiceException.ServiceUnavailableException("timeout", cause);
|
||||
assertTrue(ex.getMessage().contains("Service Keycloak indisponible"));
|
||||
assertTrue(ex.getMessage().contains("timeout"));
|
||||
assertSame(cause, ex.getCause());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testServiceUnavailableException_IsKeycloakServiceException() {
|
||||
KeycloakServiceException.ServiceUnavailableException ex =
|
||||
new KeycloakServiceException.ServiceUnavailableException("error");
|
||||
assertInstanceOf(KeycloakServiceException.class, ex);
|
||||
}
|
||||
|
||||
// TimeoutException tests
|
||||
|
||||
@Test
|
||||
void testTimeoutException_MessageOnly() {
|
||||
KeycloakServiceException.TimeoutException ex =
|
||||
new KeycloakServiceException.TimeoutException("30s elapsed");
|
||||
assertTrue(ex.getMessage().contains("Timeout"));
|
||||
assertTrue(ex.getMessage().contains("30s elapsed"));
|
||||
assertEquals("Keycloak", ex.getServiceName());
|
||||
assertEquals(0, ex.getHttpStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTimeoutException_MessageAndCause() {
|
||||
Throwable cause = new java.net.SocketTimeoutException("read timed out");
|
||||
KeycloakServiceException.TimeoutException ex =
|
||||
new KeycloakServiceException.TimeoutException("connection timeout", cause);
|
||||
assertTrue(ex.getMessage().contains("Timeout"));
|
||||
assertTrue(ex.getMessage().contains("connection timeout"));
|
||||
assertSame(cause, ex.getCause());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTimeoutException_IsKeycloakServiceException() {
|
||||
KeycloakServiceException.TimeoutException ex =
|
||||
new KeycloakServiceException.TimeoutException("error");
|
||||
assertInstanceOf(KeycloakServiceException.class, ex);
|
||||
}
|
||||
}
|
||||
@@ -192,4 +192,129 @@ class AuditServiceImplAdditionalTest {
|
||||
|
||||
assertEquals(2, total);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testLogSuccess() {
|
||||
auditService.logSuccess(
|
||||
TypeActionAudit.USER_CREATE,
|
||||
"USER",
|
||||
"user-1",
|
||||
"John Doe",
|
||||
"realm1",
|
||||
"admin",
|
||||
"Utilisateur créé"
|
||||
);
|
||||
// logSuccess calls logAction() which logs (no exception)
|
||||
}
|
||||
|
||||
@Test
|
||||
void testLogFailure() {
|
||||
auditService.logFailure(
|
||||
TypeActionAudit.USER_CREATE,
|
||||
"USER",
|
||||
"user-1",
|
||||
"John Doe",
|
||||
"realm1",
|
||||
"admin",
|
||||
"USER_ALREADY_EXISTS",
|
||||
"L'utilisateur existe déjà"
|
||||
);
|
||||
// logFailure calls logAction() which logs (no exception)
|
||||
}
|
||||
|
||||
@Test
|
||||
void testLogAction_WithDatabase() {
|
||||
auditService.logToDatabase = true;
|
||||
|
||||
AuditLogEntity entity = new AuditLogEntity();
|
||||
entity.id = 1L;
|
||||
when(auditLogMapper.toEntity(any())).thenReturn(entity);
|
||||
doAnswer(invocation -> {
|
||||
AuditLogEntity e = invocation.getArgument(0);
|
||||
e.id = 42L;
|
||||
return null;
|
||||
}).when(auditLogRepository).persist(any(AuditLogEntity.class));
|
||||
|
||||
AuditLogDTO auditLog = AuditLogDTO.builder()
|
||||
.typeAction(TypeActionAudit.USER_CREATE)
|
||||
.acteurUsername("admin")
|
||||
.realmName("realm1")
|
||||
.ressourceType("USER")
|
||||
.ressourceId("1")
|
||||
.build();
|
||||
|
||||
AuditLogDTO result = auditService.logAction(auditLog);
|
||||
|
||||
assertNotNull(result);
|
||||
verify(auditLogRepository).persist(any(AuditLogEntity.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testLogAction_WithDatabase_PersistException() {
|
||||
auditService.logToDatabase = true;
|
||||
|
||||
when(auditLogMapper.toEntity(any())).thenReturn(new AuditLogEntity());
|
||||
doThrow(new RuntimeException("DB error")).when(auditLogRepository).persist(any(AuditLogEntity.class));
|
||||
|
||||
AuditLogDTO auditLog = AuditLogDTO.builder()
|
||||
.typeAction(TypeActionAudit.USER_CREATE)
|
||||
.acteurUsername("admin")
|
||||
.realmName("realm1")
|
||||
.ressourceType("USER")
|
||||
.ressourceId("1")
|
||||
.dateAction(java.time.LocalDateTime.now())
|
||||
.build();
|
||||
|
||||
// Should not throw — exception is caught and logged
|
||||
AuditLogDTO result = auditService.logAction(auditLog);
|
||||
assertNotNull(result);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCountByActionType_UnknownAction() {
|
||||
LocalDateTime past = LocalDateTime.now().minusDays(1);
|
||||
LocalDateTime future = LocalDateTime.now().plusDays(1);
|
||||
|
||||
when(entityManager.createNativeQuery(anyString())).thenReturn(nativeQuery);
|
||||
when(nativeQuery.setParameter(anyString(), any())).thenReturn(nativeQuery);
|
||||
java.util.List<Object> rows = new java.util.ArrayList<>();
|
||||
rows.add(new Object[]{"UNKNOWN_ACTION", 1L});
|
||||
when(nativeQuery.getResultList()).thenReturn(rows);
|
||||
|
||||
var counts = auditService.countByActionType("realm1", past, future);
|
||||
assertNotNull(counts);
|
||||
assertTrue(counts.isEmpty()); // unknown action is ignored
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCountByActionType_NullDates() {
|
||||
when(entityManager.createNativeQuery(anyString())).thenReturn(nativeQuery);
|
||||
when(nativeQuery.setParameter(anyString(), any())).thenReturn(nativeQuery);
|
||||
when(nativeQuery.getResultList()).thenReturn(java.util.Collections.emptyList());
|
||||
|
||||
var counts = auditService.countByActionType("realm1", null, null);
|
||||
assertNotNull(counts);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCountByActeur_NullDates() {
|
||||
when(entityManager.createNativeQuery(anyString())).thenReturn(nativeQuery);
|
||||
when(nativeQuery.setParameter(anyString(), any())).thenReturn(nativeQuery);
|
||||
when(nativeQuery.getResultList()).thenReturn(java.util.Collections.emptyList());
|
||||
|
||||
var counts = auditService.countByActeur("realm1", null, null);
|
||||
assertNotNull(counts);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCountSuccessVsFailure_NullDates() {
|
||||
when(entityManager.createNativeQuery(anyString())).thenReturn(nativeQuery);
|
||||
when(nativeQuery.setParameter(anyString(), any())).thenReturn(nativeQuery);
|
||||
when(nativeQuery.getResultList()).thenReturn(java.util.Collections.emptyList());
|
||||
|
||||
var result = auditService.countSuccessVsFailure("realm1", null, null);
|
||||
assertNotNull(result);
|
||||
assertEquals(0L, result.get("success"));
|
||||
assertEquals(0L, result.get("failure"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,252 @@
|
||||
package dev.lions.user.manager.service.impl;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class CsvValidationHelperTest {
|
||||
|
||||
// isValidEmail tests
|
||||
|
||||
@Test
|
||||
void testIsValidEmail_Null() {
|
||||
assertFalse(CsvValidationHelper.isValidEmail(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testIsValidEmail_Blank() {
|
||||
assertFalse(CsvValidationHelper.isValidEmail(" "));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testIsValidEmail_Valid() {
|
||||
assertTrue(CsvValidationHelper.isValidEmail("user@example.com"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testIsValidEmail_ValidWithSubdomain() {
|
||||
assertTrue(CsvValidationHelper.isValidEmail("user@mail.example.com"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testIsValidEmail_Invalid_NoAt() {
|
||||
assertFalse(CsvValidationHelper.isValidEmail("userexample.com"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testIsValidEmail_Invalid_NoDomain() {
|
||||
assertFalse(CsvValidationHelper.isValidEmail("user@"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testIsValidEmail_WithPlusSign() {
|
||||
assertTrue(CsvValidationHelper.isValidEmail("user+tag@example.com"));
|
||||
}
|
||||
|
||||
// validateUsername tests
|
||||
|
||||
@Test
|
||||
void testValidateUsername_Null() {
|
||||
assertEquals("Username obligatoire", CsvValidationHelper.validateUsername(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateUsername_Blank() {
|
||||
assertEquals("Username obligatoire", CsvValidationHelper.validateUsername(" "));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateUsername_TooShort() {
|
||||
String result = CsvValidationHelper.validateUsername("a");
|
||||
assertNotNull(result);
|
||||
assertTrue(result.contains("trop court"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateUsername_TooLong() {
|
||||
String longName = "a".repeat(256);
|
||||
String result = CsvValidationHelper.validateUsername(longName);
|
||||
assertNotNull(result);
|
||||
assertTrue(result.contains("trop long"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateUsername_InvalidChars() {
|
||||
String result = CsvValidationHelper.validateUsername("user@name!");
|
||||
assertNotNull(result);
|
||||
assertTrue(result.contains("invalide"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateUsername_Valid() {
|
||||
assertNull(CsvValidationHelper.validateUsername("valid.user-name_123"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateUsername_Valid_Minimal() {
|
||||
assertNull(CsvValidationHelper.validateUsername("ab"));
|
||||
}
|
||||
|
||||
// validateEmail tests
|
||||
|
||||
@Test
|
||||
void testValidateEmail_Null() {
|
||||
assertNull(CsvValidationHelper.validateEmail(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateEmail_Blank() {
|
||||
assertNull(CsvValidationHelper.validateEmail(" "));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateEmail_Invalid() {
|
||||
String result = CsvValidationHelper.validateEmail("not-an-email");
|
||||
assertNotNull(result);
|
||||
assertTrue(result.contains("invalide"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateEmail_Valid() {
|
||||
assertNull(CsvValidationHelper.validateEmail("valid@example.com"));
|
||||
}
|
||||
|
||||
// validateName tests
|
||||
|
||||
@Test
|
||||
void testValidateName_Null() {
|
||||
assertNull(CsvValidationHelper.validateName(null, "lastName"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateName_Blank() {
|
||||
assertNull(CsvValidationHelper.validateName(" ", "firstName"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateName_TooLong() {
|
||||
String longName = "a".repeat(256);
|
||||
String result = CsvValidationHelper.validateName(longName, "firstName");
|
||||
assertNotNull(result);
|
||||
assertTrue(result.contains("trop long"));
|
||||
assertTrue(result.contains("firstName"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateName_Valid() {
|
||||
assertNull(CsvValidationHelper.validateName("Jean-Pierre", "firstName"));
|
||||
}
|
||||
|
||||
// validateBoolean tests
|
||||
|
||||
@Test
|
||||
void testValidateBoolean_Null() {
|
||||
assertNull(CsvValidationHelper.validateBoolean(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateBoolean_Blank() {
|
||||
assertNull(CsvValidationHelper.validateBoolean(" "));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateBoolean_True() {
|
||||
assertNull(CsvValidationHelper.validateBoolean("true"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateBoolean_False() {
|
||||
assertNull(CsvValidationHelper.validateBoolean("false"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateBoolean_One() {
|
||||
assertNull(CsvValidationHelper.validateBoolean("1"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateBoolean_Zero() {
|
||||
assertNull(CsvValidationHelper.validateBoolean("0"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateBoolean_Yes() {
|
||||
assertNull(CsvValidationHelper.validateBoolean("yes"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateBoolean_No() {
|
||||
assertNull(CsvValidationHelper.validateBoolean("no"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateBoolean_Invalid() {
|
||||
String result = CsvValidationHelper.validateBoolean("maybe");
|
||||
assertNotNull(result);
|
||||
assertTrue(result.contains("invalide"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValidateBoolean_UpperCase() {
|
||||
assertNull(CsvValidationHelper.validateBoolean("TRUE"));
|
||||
}
|
||||
|
||||
// parseBoolean tests
|
||||
|
||||
@Test
|
||||
void testParseBoolean_Null() {
|
||||
assertFalse(CsvValidationHelper.parseBoolean(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testParseBoolean_Blank() {
|
||||
assertFalse(CsvValidationHelper.parseBoolean(" "));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testParseBoolean_True() {
|
||||
assertTrue(CsvValidationHelper.parseBoolean("true"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testParseBoolean_One() {
|
||||
assertTrue(CsvValidationHelper.parseBoolean("1"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testParseBoolean_Yes() {
|
||||
assertTrue(CsvValidationHelper.parseBoolean("yes"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testParseBoolean_False() {
|
||||
assertFalse(CsvValidationHelper.parseBoolean("false"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testParseBoolean_UpperCaseTrue() {
|
||||
assertTrue(CsvValidationHelper.parseBoolean("TRUE"));
|
||||
}
|
||||
|
||||
// clean tests
|
||||
|
||||
@Test
|
||||
void testClean_Null() {
|
||||
assertNull(CsvValidationHelper.clean(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testClean_Blank() {
|
||||
assertNull(CsvValidationHelper.clean(" "));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testClean_WithSpaces() {
|
||||
assertEquals("hello", CsvValidationHelper.clean(" hello "));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testClean_Normal() {
|
||||
assertEquals("value", CsvValidationHelper.clean("value"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
package dev.lions.user.manager.service.impl;
|
||||
|
||||
import dev.lions.user.manager.dto.realm.RealmAssignmentDTO;
|
||||
import dev.lions.user.manager.enums.audit.TypeActionAudit;
|
||||
import dev.lions.user.manager.service.AuditService;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
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 org.mockito.junit.jupiter.MockitoSettings;
|
||||
import org.mockito.quality.Strictness;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
/**
|
||||
* Tests supplémentaires pour RealmAuthorizationServiceImpl.
|
||||
* Couvre les lignes non couvertes :
|
||||
* L138 (génération d'ID quand null), L232-240 (revokeAllUsersFromRealm), L300 (activateAssignment non trouvée).
|
||||
*/
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
@MockitoSettings(strictness = Strictness.LENIENT)
|
||||
class RealmAuthorizationServiceImplAdditionalTest {
|
||||
|
||||
@Mock
|
||||
private AuditService auditService;
|
||||
|
||||
@InjectMocks
|
||||
private RealmAuthorizationServiceImpl realmAuthorizationService;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
doNothing().when(auditService).logSuccess(
|
||||
any(TypeActionAudit.class),
|
||||
anyString(), anyString(), anyString(), anyString(), anyString(), anyString()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Couvre L138 : quand assignment.getId() == null, un UUID est généré.
|
||||
*/
|
||||
@Test
|
||||
void testAssignRealmToUser_NullId_GeneratesUUID() {
|
||||
RealmAssignmentDTO assignment = RealmAssignmentDTO.builder()
|
||||
.id(null) // ID null → L138 sera couvert
|
||||
.userId("user-null-id")
|
||||
.username("nulluser")
|
||||
.email("null@example.com")
|
||||
.realmName("realm-null")
|
||||
.isSuperAdmin(false)
|
||||
.active(true)
|
||||
.assignedAt(LocalDateTime.now())
|
||||
.assignedBy("admin")
|
||||
.build();
|
||||
|
||||
RealmAssignmentDTO result = realmAuthorizationService.assignRealmToUser(assignment);
|
||||
|
||||
assertNotNull(result);
|
||||
assertNotNull(result.getId()); // L138 : UUID généré
|
||||
assertTrue(result.isActive());
|
||||
}
|
||||
|
||||
/**
|
||||
* Couvre L232-240 : revokeAllUsersFromRealm — révoque tous les utilisateurs d'un realm.
|
||||
*/
|
||||
@Test
|
||||
void testRevokeAllUsersFromRealm_WithUsers() {
|
||||
// Créer des assignations
|
||||
RealmAssignmentDTO assignment1 = RealmAssignmentDTO.builder()
|
||||
.id("ra-a1")
|
||||
.userId("user-a")
|
||||
.username("usera")
|
||||
.email("a@example.com")
|
||||
.realmName("realm-multi")
|
||||
.isSuperAdmin(false)
|
||||
.active(true)
|
||||
.assignedAt(LocalDateTime.now())
|
||||
.assignedBy("admin")
|
||||
.build();
|
||||
|
||||
RealmAssignmentDTO assignment2 = RealmAssignmentDTO.builder()
|
||||
.id("ra-b1")
|
||||
.userId("user-b")
|
||||
.username("userb")
|
||||
.email("b@example.com")
|
||||
.realmName("realm-multi")
|
||||
.isSuperAdmin(false)
|
||||
.active(true)
|
||||
.assignedAt(LocalDateTime.now())
|
||||
.assignedBy("admin")
|
||||
.build();
|
||||
|
||||
realmAuthorizationService.assignRealmToUser(assignment1);
|
||||
realmAuthorizationService.assignRealmToUser(assignment2);
|
||||
|
||||
// Vérifie que les utilisateurs sont bien assignés
|
||||
assertEquals(2, realmAuthorizationService.getAssignmentsByRealm("realm-multi").size());
|
||||
|
||||
// Couvre L232-240
|
||||
realmAuthorizationService.revokeAllUsersFromRealm("realm-multi");
|
||||
|
||||
// Après révocation, plus d'assignations pour ce realm
|
||||
assertTrue(realmAuthorizationService.getAssignmentsByRealm("realm-multi").isEmpty());
|
||||
}
|
||||
|
||||
/**
|
||||
* Couvre L300 : activateAssignment quand l'assignation n'existe pas.
|
||||
*/
|
||||
@Test
|
||||
void testActivateAssignment_NotFound_ThrowsIllegalArgumentException() {
|
||||
assertThrows(IllegalArgumentException.class, () ->
|
||||
realmAuthorizationService.activateAssignment("non-existent-assignment-id")
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Couvre revokeAllUsersFromRealm quand le realm n'a pas d'utilisateurs.
|
||||
*/
|
||||
@Test
|
||||
void testRevokeAllUsersFromRealm_Empty() {
|
||||
// Ne doit pas lancer d'exception
|
||||
assertDoesNotThrow(() ->
|
||||
realmAuthorizationService.revokeAllUsersFromRealm("realm-vide")
|
||||
);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,265 @@
|
||||
package dev.lions.user.manager.service.impl;
|
||||
|
||||
import com.sun.net.httpserver.HttpServer;
|
||||
import dev.lions.user.manager.client.KeycloakAdminClient;
|
||||
import dev.lions.user.manager.server.impl.entity.SyncHistoryEntity;
|
||||
import dev.lions.user.manager.server.impl.repository.SyncHistoryRepository;
|
||||
import dev.lions.user.manager.server.impl.repository.SyncedRoleRepository;
|
||||
import dev.lions.user.manager.server.impl.repository.SyncedUserRepository;
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.keycloak.admin.client.Keycloak;
|
||||
import org.keycloak.admin.client.resource.*;
|
||||
import org.keycloak.admin.client.token.TokenManager;
|
||||
import org.keycloak.representations.idm.RoleRepresentation;
|
||||
import org.keycloak.representations.idm.UserRepresentation;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.jupiter.MockitoExtension;
|
||||
import org.mockito.junit.jupiter.MockitoSettings;
|
||||
import org.mockito.quality.Strictness;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.net.InetSocketAddress;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
/**
|
||||
* Tests supplémentaires pour SyncServiceImpl — branches non couvertes.
|
||||
*/
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
@MockitoSettings(strictness = Strictness.LENIENT)
|
||||
class SyncServiceImplAdditionalTest {
|
||||
|
||||
@Mock
|
||||
KeycloakAdminClient keycloakAdminClient;
|
||||
|
||||
@Mock
|
||||
Keycloak keycloakInstance;
|
||||
|
||||
@Mock
|
||||
TokenManager mockTokenManager;
|
||||
|
||||
@Mock
|
||||
RealmResource realmResource;
|
||||
|
||||
@Mock
|
||||
UsersResource usersResource;
|
||||
|
||||
@Mock
|
||||
RolesResource rolesResource;
|
||||
|
||||
@Mock
|
||||
SyncHistoryRepository syncHistoryRepository;
|
||||
|
||||
@Mock
|
||||
SyncedUserRepository syncedUserRepository;
|
||||
|
||||
@Mock
|
||||
SyncedRoleRepository syncedRoleRepository;
|
||||
|
||||
@InjectMocks
|
||||
SyncServiceImpl syncService;
|
||||
|
||||
private HttpServer localServer;
|
||||
|
||||
@AfterEach
|
||||
void tearDown() {
|
||||
if (localServer != null) {
|
||||
localServer.stop(0);
|
||||
localServer = null;
|
||||
}
|
||||
}
|
||||
|
||||
private void setField(String name, Object value) throws Exception {
|
||||
Field field = SyncServiceImpl.class.getDeclaredField(name);
|
||||
field.setAccessible(true);
|
||||
field.set(syncService, value);
|
||||
}
|
||||
|
||||
private int startLocalServer(String path, String body, int status) throws Exception {
|
||||
localServer = HttpServer.create(new InetSocketAddress(0), 0);
|
||||
localServer.createContext(path, exchange -> {
|
||||
byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
|
||||
exchange.sendResponseHeaders(status, bytes.length);
|
||||
exchange.getResponseBody().write(bytes);
|
||||
exchange.getResponseBody().close();
|
||||
});
|
||||
localServer.start();
|
||||
return localServer.getAddress().getPort();
|
||||
}
|
||||
|
||||
// ==================== syncUsersFromRealm with createdTimestamp ====================
|
||||
|
||||
@Test
|
||||
void testSyncUsersFromRealm_WithCreatedTimestamp() {
|
||||
when(keycloakInstance.realm("realm")).thenReturn(realmResource);
|
||||
when(realmResource.users()).thenReturn(usersResource);
|
||||
|
||||
UserRepresentation user = new UserRepresentation();
|
||||
user.setId("user-1");
|
||||
user.setUsername("john");
|
||||
user.setCreatedTimestamp(System.currentTimeMillis()); // NOT null → covers the if-branch
|
||||
|
||||
when(usersResource.list()).thenReturn(List.of(user));
|
||||
|
||||
int count = syncService.syncUsersFromRealm("realm");
|
||||
assertEquals(1, count);
|
||||
verify(syncedUserRepository).replaceForRealm(eq("realm"), anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSyncRolesFromRealm_WithSnapshots() {
|
||||
when(keycloakInstance.realm("realm")).thenReturn(realmResource);
|
||||
when(realmResource.roles()).thenReturn(rolesResource);
|
||||
|
||||
RoleRepresentation role = new RoleRepresentation();
|
||||
role.setName("admin");
|
||||
role.setDescription("Admin role");
|
||||
|
||||
when(rolesResource.list()).thenReturn(List.of(role));
|
||||
|
||||
int count = syncService.syncRolesFromRealm("realm");
|
||||
assertEquals(1, count);
|
||||
verify(syncedRoleRepository).replaceForRealm(eq("realm"), anyList());
|
||||
}
|
||||
|
||||
// ==================== syncAllRealms with null/blank realm ====================
|
||||
|
||||
@Test
|
||||
void testSyncAllRealms_WithBlankRealmName() {
|
||||
when(keycloakAdminClient.getAllRealms()).thenReturn(List.of("", " ", "valid-realm"));
|
||||
when(keycloakInstance.realm("valid-realm")).thenReturn(realmResource);
|
||||
when(realmResource.users()).thenReturn(usersResource);
|
||||
when(usersResource.list()).thenReturn(Collections.emptyList());
|
||||
when(realmResource.roles()).thenReturn(rolesResource);
|
||||
when(rolesResource.list()).thenReturn(Collections.emptyList());
|
||||
|
||||
Map<String, Integer> result = syncService.syncAllRealms();
|
||||
|
||||
// Only valid-realm should be in the result
|
||||
assertFalse(result.containsKey(""));
|
||||
assertFalse(result.containsKey(" "));
|
||||
assertTrue(result.containsKey("valid-realm"));
|
||||
}
|
||||
|
||||
// ==================== recordSyncHistory exception path ====================
|
||||
|
||||
@Test
|
||||
void testRecordSyncHistory_PersistException() {
|
||||
when(keycloakInstance.realm("realm")).thenReturn(realmResource);
|
||||
when(realmResource.users()).thenReturn(usersResource);
|
||||
when(usersResource.list()).thenReturn(Collections.emptyList());
|
||||
doThrow(new RuntimeException("DB error")).when(syncHistoryRepository).persist(any(SyncHistoryEntity.class));
|
||||
|
||||
// Should not throw — the exception in recordSyncHistory is caught
|
||||
assertDoesNotThrow(() -> syncService.syncUsersFromRealm("realm"));
|
||||
}
|
||||
|
||||
// ==================== getLastSyncStatus - no history ====================
|
||||
|
||||
@Test
|
||||
void testGetLastSyncStatus_NeverSynced() {
|
||||
when(syncHistoryRepository.findLatestByRealm("realm", 1)).thenReturn(Collections.emptyList());
|
||||
|
||||
Map<String, Object> status = syncService.getLastSyncStatus("realm");
|
||||
|
||||
assertEquals("NEVER_SYNCED", status.get("status"));
|
||||
}
|
||||
|
||||
// ==================== fetchVersionViaHttp via local HTTP server ====================
|
||||
|
||||
@Test
|
||||
void testGetKeycloakHealthInfo_HttpFallback_Success_WithVersion() throws Exception {
|
||||
// getInfo() throws → fetchVersionViaHttp() is called
|
||||
when(keycloakInstance.serverInfo()).thenThrow(new RuntimeException("serverInfo failed"));
|
||||
when(keycloakInstance.tokenManager()).thenReturn(mockTokenManager);
|
||||
when(mockTokenManager.getAccessTokenString()).thenReturn("fake-token");
|
||||
|
||||
// Start local server that returns a JSON body with systemInfo and version
|
||||
String json = "{\"systemInfo\":{\"version\":\"26.0.0\",\"serverTime\":\"2026-03-28T12:00:00Z\"}}";
|
||||
int port = startLocalServer("/admin/serverinfo", json, 200);
|
||||
setField("keycloakServerUrl", "http://localhost:" + port);
|
||||
|
||||
Map<String, Object> health = syncService.getKeycloakHealthInfo();
|
||||
|
||||
assertNotNull(health);
|
||||
assertEquals("UP", health.get("status"));
|
||||
assertEquals("26.0.0", health.get("version"));
|
||||
assertEquals("2026-03-28T12:00:00Z", health.get("serverTime"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetKeycloakHealthInfo_HttpFallback_Success_NoVersion() throws Exception {
|
||||
when(keycloakInstance.serverInfo()).thenThrow(new RuntimeException("serverInfo failed"));
|
||||
when(keycloakInstance.tokenManager()).thenReturn(mockTokenManager);
|
||||
when(mockTokenManager.getAccessTokenString()).thenReturn("fake-token");
|
||||
|
||||
// Return JSON without systemInfo
|
||||
String json = "{\"other\":\"data\"}";
|
||||
int port = startLocalServer("/admin/serverinfo", json, 200);
|
||||
setField("keycloakServerUrl", "http://localhost:" + port);
|
||||
|
||||
Map<String, Object> health = syncService.getKeycloakHealthInfo();
|
||||
|
||||
assertNotNull(health);
|
||||
assertEquals("UP", health.get("status"));
|
||||
assertTrue(health.get("version").toString().contains("UP"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetKeycloakHealthInfo_HttpFallback_NonOkStatus() throws Exception {
|
||||
when(keycloakInstance.serverInfo()).thenThrow(new RuntimeException("serverInfo failed"));
|
||||
when(keycloakInstance.tokenManager()).thenReturn(mockTokenManager);
|
||||
when(mockTokenManager.getAccessTokenString()).thenReturn("fake-token");
|
||||
|
||||
int port = startLocalServer("/admin/serverinfo", "Forbidden", 403);
|
||||
setField("keycloakServerUrl", "http://localhost:" + port);
|
||||
|
||||
Map<String, Object> health = syncService.getKeycloakHealthInfo();
|
||||
|
||||
assertNotNull(health);
|
||||
assertEquals("UP", health.get("status")); // non-200 still returns UP per implementation
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetKeycloakHealthInfo_HttpFallback_Exception() throws Exception {
|
||||
when(keycloakInstance.serverInfo()).thenThrow(new RuntimeException("serverInfo failed"));
|
||||
when(keycloakInstance.tokenManager()).thenReturn(mockTokenManager);
|
||||
when(mockTokenManager.getAccessTokenString()).thenReturn("fake-token");
|
||||
|
||||
// Point to a port where nothing is listening → connection refused
|
||||
setField("keycloakServerUrl", "http://localhost:1"); // port 1 should fail
|
||||
|
||||
Map<String, Object> health = syncService.getKeycloakHealthInfo();
|
||||
|
||||
assertNotNull(health);
|
||||
assertEquals("DOWN", health.get("status"));
|
||||
}
|
||||
|
||||
// ==================== getLastSyncStatus - itemsProcessed null ====================
|
||||
|
||||
@Test
|
||||
void testGetLastSyncStatus_WithHistory() {
|
||||
SyncHistoryEntity entity = new SyncHistoryEntity();
|
||||
entity.setStatus("SUCCESS");
|
||||
entity.setSyncType("USER");
|
||||
entity.setItemsProcessed(5);
|
||||
entity.setSyncDate(java.time.LocalDateTime.now());
|
||||
|
||||
when(syncHistoryRepository.findLatestByRealm("realm", 1)).thenReturn(List.of(entity));
|
||||
|
||||
Map<String, Object> status = syncService.getLastSyncStatus("realm");
|
||||
|
||||
assertEquals("SUCCESS", status.get("status"));
|
||||
assertEquals("USER", status.get("type"));
|
||||
assertEquals(5, status.get("itemsProcessed"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,136 @@
|
||||
package dev.lions.user.manager.service.impl;
|
||||
|
||||
import dev.lions.user.manager.client.KeycloakAdminClient;
|
||||
import dev.lions.user.manager.server.impl.entity.SyncHistoryEntity;
|
||||
import dev.lions.user.manager.server.impl.repository.SyncHistoryRepository;
|
||||
import dev.lions.user.manager.server.impl.repository.SyncedRoleRepository;
|
||||
import dev.lions.user.manager.server.impl.repository.SyncedUserRepository;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.keycloak.admin.client.Keycloak;
|
||||
import org.keycloak.admin.client.resource.RealmResource;
|
||||
import org.keycloak.admin.client.resource.RolesResource;
|
||||
import org.keycloak.admin.client.resource.UsersResource;
|
||||
import org.keycloak.representations.idm.RoleRepresentation;
|
||||
import org.keycloak.representations.idm.UserRepresentation;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.jupiter.MockitoExtension;
|
||||
import org.mockito.junit.jupiter.MockitoSettings;
|
||||
import org.mockito.quality.Strictness;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
/**
|
||||
* Tests pour les lignes SyncServiceImpl non couvertes.
|
||||
*
|
||||
* L183-184 : syncAllRealms — catch externe quand getAllRealms() throw
|
||||
* L253-256 : checkDataConsistency — catch quand keycloak.realm().users().list() throw
|
||||
* L267-275 : forceSyncRealm — les deux branches (succès et erreur)
|
||||
*/
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
@MockitoSettings(strictness = Strictness.LENIENT)
|
||||
class SyncServiceImplMissingCoverageTest {
|
||||
|
||||
@Mock
|
||||
KeycloakAdminClient keycloakAdminClient;
|
||||
|
||||
@Mock
|
||||
Keycloak keycloak;
|
||||
|
||||
@Mock
|
||||
RealmResource realmResource;
|
||||
|
||||
@Mock
|
||||
UsersResource usersResource;
|
||||
|
||||
@Mock
|
||||
RolesResource rolesResource;
|
||||
|
||||
@Mock
|
||||
SyncHistoryRepository syncHistoryRepository;
|
||||
|
||||
@Mock
|
||||
SyncedUserRepository syncedUserRepository;
|
||||
|
||||
@Mock
|
||||
SyncedRoleRepository syncedRoleRepository;
|
||||
|
||||
@InjectMocks
|
||||
SyncServiceImpl syncService;
|
||||
|
||||
// =========================================================================
|
||||
// L183-184 : syncAllRealms — catch externe quand getAllRealms() throw
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testSyncAllRealms_GetAllRealmThrows_ReturnsEmptyMap() {
|
||||
when(keycloakAdminClient.getAllRealms()).thenThrow(new RuntimeException("Keycloak unavailable"));
|
||||
|
||||
Map<String, Integer> result = syncService.syncAllRealms();
|
||||
|
||||
assertNotNull(result);
|
||||
// En cas d'erreur globale, retourne map vide
|
||||
assertTrue(result.isEmpty());
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L253-256 : checkDataConsistency — catch quand keycloak.realm().users().list() throw
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testCheckDataConsistency_Exception_ReturnsErrorReport() {
|
||||
when(keycloak.realm("my-realm")).thenReturn(realmResource);
|
||||
when(realmResource.users()).thenReturn(usersResource);
|
||||
when(usersResource.list()).thenThrow(new RuntimeException("DB error"));
|
||||
|
||||
Map<String, Object> report = syncService.checkDataConsistency("my-realm");
|
||||
|
||||
assertNotNull(report);
|
||||
assertEquals("ERROR", report.get("status"));
|
||||
assertNotNull(report.get("error"));
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L267-275 : forceSyncRealm — branche succès
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testForceSyncRealm_Success() {
|
||||
when(keycloak.realm("sync-realm")).thenReturn(realmResource);
|
||||
when(realmResource.users()).thenReturn(usersResource);
|
||||
when(realmResource.roles()).thenReturn(rolesResource);
|
||||
when(usersResource.list()).thenReturn(Collections.emptyList());
|
||||
when(rolesResource.list()).thenReturn(Collections.emptyList());
|
||||
|
||||
Map<String, Object> result = syncService.forceSyncRealm("sync-realm");
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals("SUCCESS", result.get("status"));
|
||||
assertEquals(0, result.get("usersSynced"));
|
||||
assertEquals(0, result.get("rolesSynced"));
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L267-275 : forceSyncRealm — branche erreur (FAILURE)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testForceSyncRealm_Failure() {
|
||||
when(keycloak.realm("error-realm")).thenReturn(realmResource);
|
||||
when(realmResource.users()).thenReturn(usersResource);
|
||||
when(usersResource.list()).thenThrow(new RuntimeException("Sync error"));
|
||||
|
||||
Map<String, Object> result = syncService.forceSyncRealm("error-realm");
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals("FAILURE", result.get("status"));
|
||||
assertNotNull(result.get("error"));
|
||||
}
|
||||
}
|
||||
@@ -1,20 +1,31 @@
|
||||
package dev.lions.user.manager.service.impl;
|
||||
|
||||
import dev.lions.user.manager.client.KeycloakAdminClient;
|
||||
import dev.lions.user.manager.dto.importexport.ImportResultDTO;
|
||||
import dev.lions.user.manager.dto.user.UserDTO;
|
||||
import dev.lions.user.manager.dto.user.UserSearchCriteriaDTO;
|
||||
import dev.lions.user.manager.enums.user.StatutUser;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.keycloak.admin.client.resource.RoleMappingResource;
|
||||
import org.keycloak.admin.client.resource.RoleScopeResource;
|
||||
import org.keycloak.admin.client.resource.UserResource;
|
||||
import org.keycloak.admin.client.resource.UsersResource;
|
||||
import org.keycloak.representations.idm.RoleRepresentation;
|
||||
import org.keycloak.representations.idm.UserRepresentation;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.jupiter.MockitoExtension;
|
||||
import org.mockito.junit.jupiter.MockitoSettings;
|
||||
import org.mockito.quality.Strictness;
|
||||
|
||||
import java.util.Optional;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.*;
|
||||
@@ -25,6 +36,7 @@ import static org.mockito.Mockito.*;
|
||||
* Couvre les branches manquantes : filterUsers, searchUsers avec différents critères, etc.
|
||||
*/
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
@MockitoSettings(strictness = Strictness.LENIENT)
|
||||
class UserServiceImplCompleteTest {
|
||||
|
||||
private static final String REALM = "test-realm";
|
||||
@@ -311,8 +323,816 @@ class UserServiceImplCompleteTest {
|
||||
.pageSize(10)
|
||||
.build();
|
||||
|
||||
assertThrows(RuntimeException.class, () ->
|
||||
assertThrows(RuntimeException.class, () ->
|
||||
userService.searchUsers(criteria));
|
||||
}
|
||||
|
||||
// ==================== filterUsers() branches ====================
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByPrenom_UserHasNoFirstName() {
|
||||
UserRepresentation userWithName = new UserRepresentation();
|
||||
userWithName.setUsername("user1");
|
||||
userWithName.setEnabled(true);
|
||||
userWithName.setFirstName("Jean");
|
||||
|
||||
UserRepresentation userNoName = new UserRepresentation();
|
||||
userNoName.setUsername("user2");
|
||||
userNoName.setEnabled(true);
|
||||
// firstName is null
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(userWithName, userNoName));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.prenom("Jean")
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("user1", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByNom_UserHasNoLastName() {
|
||||
UserRepresentation userWithName = new UserRepresentation();
|
||||
userWithName.setUsername("user1");
|
||||
userWithName.setEnabled(true);
|
||||
userWithName.setLastName("Dupont");
|
||||
|
||||
UserRepresentation userNoName = new UserRepresentation();
|
||||
userNoName.setUsername("user2");
|
||||
userNoName.setEnabled(true);
|
||||
// lastName is null
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(userWithName, userNoName));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.nom("Dupont")
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("user1", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByTelephone_WithAttributes() {
|
||||
UserRepresentation userWithPhone = new UserRepresentation();
|
||||
userWithPhone.setUsername("user1");
|
||||
userWithPhone.setEnabled(true);
|
||||
userWithPhone.setAttributes(Map.of("phone_number", List.of("+33612345678")));
|
||||
|
||||
UserRepresentation userNoPhone = new UserRepresentation();
|
||||
userNoPhone.setUsername("user2");
|
||||
userNoPhone.setEnabled(true);
|
||||
// No attributes
|
||||
|
||||
UserRepresentation userWrongPhone = new UserRepresentation();
|
||||
userWrongPhone.setUsername("user3");
|
||||
userWrongPhone.setEnabled(true);
|
||||
userWrongPhone.setAttributes(Map.of("phone_number", List.of("+33699999999")));
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(userWithPhone, userNoPhone, userWrongPhone));
|
||||
when(usersResource.count()).thenReturn(3);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.telephone("+3361234")
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("user1", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByTelephone_AttributesWithoutPhoneKey() {
|
||||
UserRepresentation user = new UserRepresentation();
|
||||
user.setUsername("user1");
|
||||
user.setEnabled(true);
|
||||
user.setAttributes(Map.of("other_key", List.of("value"))); // no phone_number key
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(user));
|
||||
when(usersResource.count()).thenReturn(1);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.telephone("123")
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(0, result.getUsers().size()); // excluded because no phone match
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByStatut_Actif() {
|
||||
UserRepresentation activeUser = new UserRepresentation();
|
||||
activeUser.setUsername("active");
|
||||
activeUser.setEnabled(true);
|
||||
|
||||
UserRepresentation inactiveUser = new UserRepresentation();
|
||||
inactiveUser.setUsername("inactive");
|
||||
inactiveUser.setEnabled(false);
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(activeUser, inactiveUser));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.statut(StatutUser.ACTIF)
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("active", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByStatut_Inactif() {
|
||||
UserRepresentation activeUser = new UserRepresentation();
|
||||
activeUser.setUsername("active");
|
||||
activeUser.setEnabled(true);
|
||||
|
||||
UserRepresentation inactiveUser = new UserRepresentation();
|
||||
inactiveUser.setUsername("inactive");
|
||||
inactiveUser.setEnabled(false);
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(activeUser, inactiveUser));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.statut(StatutUser.INACTIF)
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("inactive", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByOrganisation() {
|
||||
UserRepresentation userWithOrg = new UserRepresentation();
|
||||
userWithOrg.setUsername("user1");
|
||||
userWithOrg.setEnabled(true);
|
||||
userWithOrg.setAttributes(Map.of("organization", List.of("Lions Corp")));
|
||||
|
||||
UserRepresentation userNoOrg = new UserRepresentation();
|
||||
userNoOrg.setUsername("user2");
|
||||
userNoOrg.setEnabled(true); // no attributes
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(userWithOrg, userNoOrg));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.organisation("Lions")
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("user1", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByDepartement() {
|
||||
UserRepresentation userWithDept = new UserRepresentation();
|
||||
userWithDept.setUsername("user1");
|
||||
userWithDept.setEnabled(true);
|
||||
userWithDept.setAttributes(Map.of("department", List.of("IT")));
|
||||
|
||||
UserRepresentation userNoDept = new UserRepresentation();
|
||||
userNoDept.setUsername("user2");
|
||||
userNoDept.setEnabled(true);
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(userWithDept, userNoDept));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.departement("IT")
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("user1", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByFonction() {
|
||||
UserRepresentation userWithJob = new UserRepresentation();
|
||||
userWithJob.setUsername("user1");
|
||||
userWithJob.setEnabled(true);
|
||||
userWithJob.setAttributes(Map.of("job_title", List.of("Developer")));
|
||||
|
||||
UserRepresentation userNoJob = new UserRepresentation();
|
||||
userNoJob.setUsername("user2");
|
||||
userNoJob.setEnabled(true);
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(userWithJob, userNoJob));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.fonction("Dev")
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("user1", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByPays() {
|
||||
UserRepresentation userWithPays = new UserRepresentation();
|
||||
userWithPays.setUsername("user1");
|
||||
userWithPays.setEnabled(true);
|
||||
userWithPays.setAttributes(Map.of("country", List.of("France")));
|
||||
|
||||
UserRepresentation userNoPays = new UserRepresentation();
|
||||
userNoPays.setUsername("user2");
|
||||
userNoPays.setEnabled(true);
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(userWithPays, userNoPays));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.pays("France")
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("user1", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByVille() {
|
||||
UserRepresentation userWithVille = new UserRepresentation();
|
||||
userWithVille.setUsername("user1");
|
||||
userWithVille.setEnabled(true);
|
||||
userWithVille.setAttributes(Map.of("city", List.of("Paris")));
|
||||
|
||||
UserRepresentation userNoVille = new UserRepresentation();
|
||||
userNoVille.setUsername("user2");
|
||||
userNoVille.setEnabled(true);
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(userWithVille, userNoVille));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.ville("Paris")
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("user1", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByDateCreationMin_WithTimestamp() {
|
||||
// User created at epoch = 1000000000000ms (Sept 2001)
|
||||
UserRepresentation oldUser = new UserRepresentation();
|
||||
oldUser.setUsername("old");
|
||||
oldUser.setEnabled(true);
|
||||
oldUser.setCreatedTimestamp(1000000000000L); // Sept 2001
|
||||
|
||||
UserRepresentation newUser = new UserRepresentation();
|
||||
newUser.setUsername("new");
|
||||
newUser.setEnabled(true);
|
||||
newUser.setCreatedTimestamp(System.currentTimeMillis()); // now
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(oldUser, newUser));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
// Filter: must be created after 2020
|
||||
LocalDateTime minDate = LocalDateTime.of(2020, 1, 1, 0, 0);
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.dateCreationMin(minDate)
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("new", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_ByDateCreationMax_WithTimestamp() {
|
||||
// User created at epoch = 1000000000000ms (Sept 2001)
|
||||
UserRepresentation oldUser = new UserRepresentation();
|
||||
oldUser.setUsername("old");
|
||||
oldUser.setEnabled(true);
|
||||
oldUser.setCreatedTimestamp(1000000000000L); // Sept 2001
|
||||
|
||||
UserRepresentation newUser = new UserRepresentation();
|
||||
newUser.setUsername("new");
|
||||
newUser.setEnabled(true);
|
||||
newUser.setCreatedTimestamp(System.currentTimeMillis()); // now
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(oldUser, newUser));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
// Filter: must be created before 2010
|
||||
LocalDateTime maxDate = LocalDateTime.of(2010, 1, 1, 0, 0);
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.dateCreationMax(maxDate)
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("old", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_DateCreation_NullTimestamp_WithMin() {
|
||||
UserRepresentation userNoTimestamp = new UserRepresentation();
|
||||
userNoTimestamp.setUsername("user1");
|
||||
userNoTimestamp.setEnabled(true);
|
||||
// createdTimestamp is null
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(userNoTimestamp));
|
||||
when(usersResource.count()).thenReturn(1);
|
||||
|
||||
LocalDateTime minDate = LocalDateTime.of(2020, 1, 1, 0, 0);
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.dateCreationMin(minDate)
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
assertEquals(0, result.getUsers().size()); // excluded because no timestamp
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFilterUsers_DateCreation_NullTimestamp_OnlyMax() {
|
||||
UserRepresentation userNoTimestamp = new UserRepresentation();
|
||||
userNoTimestamp.setUsername("user1");
|
||||
userNoTimestamp.setEnabled(true);
|
||||
// createdTimestamp is null
|
||||
|
||||
when(usersResource.list(0, 100)).thenReturn(List.of(userNoTimestamp));
|
||||
when(usersResource.count()).thenReturn(1);
|
||||
|
||||
LocalDateTime maxDate = LocalDateTime.of(2030, 1, 1, 0, 0);
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.dateCreationMax(maxDate)
|
||||
.page(0)
|
||||
.pageSize(100)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
// user with null timestamp and only max filter: not excluded (dateCreationMin is null)
|
||||
assertEquals(1, result.getUsers().size());
|
||||
}
|
||||
|
||||
// ==================== countUsers() ====================
|
||||
|
||||
@Test
|
||||
void testCountUsers() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.count()).thenReturn(42);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.build();
|
||||
|
||||
long count = userService.countUsers(criteria);
|
||||
assertEquals(42, count);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCountUsers_Exception() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.count()).thenThrow(new RuntimeException("DB error"));
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.build();
|
||||
|
||||
long count = userService.countUsers(criteria);
|
||||
assertEquals(0, count); // returns 0 on exception
|
||||
}
|
||||
|
||||
// ==================== usernameExists() / emailExists() ====================
|
||||
|
||||
@Test
|
||||
void testUsernameExists_True() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
UserRepresentation existing = new UserRepresentation();
|
||||
existing.setUsername("existinguser");
|
||||
when(usersResource.search("existinguser", 0, 1, true)).thenReturn(List.of(existing));
|
||||
|
||||
assertTrue(userService.usernameExists("existinguser", REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testUsernameExists_False() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.search("newuser", 0, 1, true)).thenReturn(Collections.emptyList());
|
||||
|
||||
assertFalse(userService.usernameExists("newuser", REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testUsernameExists_Exception() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.search("user", 0, 1, true)).thenThrow(new RuntimeException("error"));
|
||||
|
||||
assertFalse(userService.usernameExists("user", REALM)); // returns false on exception
|
||||
}
|
||||
|
||||
@Test
|
||||
void testEmailExists_True() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
UserRepresentation existing = new UserRepresentation();
|
||||
existing.setEmail("existing@test.com");
|
||||
when(usersResource.searchByEmail("existing@test.com", true)).thenReturn(List.of(existing));
|
||||
|
||||
assertTrue(userService.emailExists("existing@test.com", REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testEmailExists_False() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.searchByEmail("new@test.com", true)).thenReturn(Collections.emptyList());
|
||||
|
||||
assertFalse(userService.emailExists("new@test.com", REALM));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testEmailExists_Exception() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.searchByEmail("test@test.com", true)).thenThrow(new RuntimeException("error"));
|
||||
|
||||
assertFalse(userService.emailExists("test@test.com", REALM)); // returns false on exception
|
||||
}
|
||||
|
||||
// ==================== exportUsersToCSV() ====================
|
||||
|
||||
@Test
|
||||
void testExportUsersToCSV_Empty() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.list(anyInt(), anyInt())).thenReturn(Collections.emptyList());
|
||||
when(usersResource.count()).thenReturn(0);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.page(0)
|
||||
.pageSize(10_000)
|
||||
.build();
|
||||
|
||||
String csv = userService.exportUsersToCSV(criteria);
|
||||
assertNotNull(csv);
|
||||
assertTrue(csv.contains("username")); // header only
|
||||
}
|
||||
|
||||
@Test
|
||||
void testExportUsersToCSV_WithUsers() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
UserRepresentation user = new UserRepresentation();
|
||||
user.setUsername("john");
|
||||
user.setEmail("john@test.com");
|
||||
user.setFirstName("John");
|
||||
user.setLastName("Doe");
|
||||
user.setEnabled(true);
|
||||
user.setEmailVerified(true);
|
||||
user.setCreatedTimestamp(System.currentTimeMillis());
|
||||
when(usersResource.list(anyInt(), anyInt())).thenReturn(List.of(user));
|
||||
when(usersResource.count()).thenReturn(1);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.page(0)
|
||||
.pageSize(10_000)
|
||||
.build();
|
||||
|
||||
String csv = userService.exportUsersToCSV(criteria);
|
||||
assertNotNull(csv);
|
||||
assertTrue(csv.contains("john"));
|
||||
assertTrue(csv.contains("john@test.com"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testExportUsersToCSV_WithSpecialCharsInFields() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
UserRepresentation user = new UserRepresentation();
|
||||
user.setUsername("john,doe"); // comma in username → should be quoted
|
||||
user.setEmail("john@test.com");
|
||||
user.setFirstName("John \"The\" Best"); // quotes → should be escaped
|
||||
user.setEnabled(true);
|
||||
user.setEmailVerified(false);
|
||||
user.setCreatedTimestamp(System.currentTimeMillis());
|
||||
when(usersResource.list(anyInt(), anyInt())).thenReturn(List.of(user));
|
||||
when(usersResource.count()).thenReturn(1);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.page(0)
|
||||
.pageSize(10_000)
|
||||
.build();
|
||||
|
||||
String csv = userService.exportUsersToCSV(criteria);
|
||||
assertNotNull(csv);
|
||||
assertTrue(csv.contains("\"john,doe\"")); // quoted because comma
|
||||
assertTrue(csv.contains("\"\"")); // escaped quote
|
||||
}
|
||||
|
||||
@Test
|
||||
void testExportUsersToCSV_WithNullFields() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
UserRepresentation user = new UserRepresentation();
|
||||
user.setUsername("john");
|
||||
// email, prenom, nom, telephone, statut all null
|
||||
user.setEnabled(false);
|
||||
user.setEmailVerified(false);
|
||||
user.setCreatedTimestamp(null);
|
||||
when(usersResource.list(anyInt(), anyInt())).thenReturn(List.of(user));
|
||||
when(usersResource.count()).thenReturn(1);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.page(0)
|
||||
.pageSize(10_000)
|
||||
.build();
|
||||
|
||||
String csv = userService.exportUsersToCSV(criteria);
|
||||
assertNotNull(csv);
|
||||
assertTrue(csv.contains("john"));
|
||||
}
|
||||
|
||||
// ==================== importUsersFromCSV() ====================
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_HeaderOnly() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
|
||||
String csv = "username,email,prenom,nom";
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(0, result.getSuccessCount());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_EmptyLine() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
|
||||
String csv = "username,email,prenom,nom\n\n";
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(0, result.getSuccessCount());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_InvalidFormat_TooFewColumns() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
|
||||
String csv = "username,email,prenom,nom\njohn,john@test.com";
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(0, result.getSuccessCount());
|
||||
assertEquals(1, result.getErrorCount());
|
||||
assertEquals(ImportResultDTO.ErrorType.INVALID_FORMAT, result.getErrors().get(0).getErrorType());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_BlankUsername() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
|
||||
String csv = "username,email,prenom,nom\n ,john@test.com,John,Doe";
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(0, result.getSuccessCount());
|
||||
assertEquals(1, result.getErrorCount());
|
||||
assertEquals(ImportResultDTO.ErrorType.VALIDATION_ERROR, result.getErrors().get(0).getErrorType());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_DuplicateEmail() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
UserRepresentation existingUser = new UserRepresentation();
|
||||
existingUser.setEmail("existing@test.com");
|
||||
when(usersResource.searchByEmail("existing@test.com", true)).thenReturn(List.of(existingUser));
|
||||
|
||||
String csv = "username,email,prenom,nom\njohn,existing@test.com,John,Doe";
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(0, result.getSuccessCount());
|
||||
assertEquals(1, result.getErrorCount());
|
||||
assertEquals(ImportResultDTO.ErrorType.DUPLICATE_USER, result.getErrors().get(0).getErrorType());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_WithQuotedFields() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
// Email doesn't exist
|
||||
when(usersResource.searchByEmail("john@test.com", true)).thenReturn(Collections.emptyList());
|
||||
// Username doesn't exist
|
||||
when(usersResource.search("\"john\"", 0, 1, true)).thenReturn(Collections.emptyList());
|
||||
when(usersResource.search("john", 0, 1, true)).thenReturn(Collections.emptyList());
|
||||
|
||||
// Mock create response
|
||||
jakarta.ws.rs.core.Response response = mock(jakarta.ws.rs.core.Response.class);
|
||||
when(response.getStatus()).thenReturn(201);
|
||||
java.net.URI location = java.net.URI.create("http://localhost/users/new-id");
|
||||
when(response.getLocation()).thenReturn(location);
|
||||
when(usersResource.create(any())).thenReturn(response);
|
||||
|
||||
UserResource createdUserResource = mock(UserResource.class);
|
||||
UserRepresentation createdUser = new UserRepresentation();
|
||||
createdUser.setId("new-id");
|
||||
createdUser.setUsername("john");
|
||||
createdUser.setEnabled(true);
|
||||
when(usersResource.get("new-id")).thenReturn(createdUserResource);
|
||||
when(createdUserResource.toRepresentation()).thenReturn(createdUser);
|
||||
|
||||
// CSV with quoted field
|
||||
String csv = "username,email,prenom,nom\njohn,john@test.com,\"John\",Doe";
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_NoHeader() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
// Email doesn't exist
|
||||
when(usersResource.searchByEmail("john@test.com", true)).thenReturn(Collections.emptyList());
|
||||
when(usersResource.search("john", 0, 1, true)).thenReturn(Collections.emptyList());
|
||||
|
||||
jakarta.ws.rs.core.Response response = mock(jakarta.ws.rs.core.Response.class);
|
||||
when(response.getStatus()).thenReturn(201);
|
||||
java.net.URI location = java.net.URI.create("http://localhost/users/new-id");
|
||||
when(response.getLocation()).thenReturn(location);
|
||||
when(usersResource.create(any())).thenReturn(response);
|
||||
|
||||
UserResource createdUserResource = mock(UserResource.class);
|
||||
UserRepresentation createdUser = new UserRepresentation();
|
||||
createdUser.setId("new-id");
|
||||
createdUser.setUsername("john");
|
||||
createdUser.setEnabled(true);
|
||||
when(usersResource.get("new-id")).thenReturn(createdUserResource);
|
||||
when(createdUserResource.toRepresentation()).thenReturn(createdUser);
|
||||
|
||||
// CSV without header line
|
||||
String csv = "john,john@test.com,John,Doe";
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(1, result.getSuccessCount());
|
||||
}
|
||||
|
||||
// ==================== searchUsers avec includeRoles ====================
|
||||
|
||||
@Test
|
||||
void testSearchUsers_WithIncludeRoles_Success() {
|
||||
UserRepresentation userRep = new UserRepresentation();
|
||||
userRep.setId("user-1");
|
||||
userRep.setUsername("john");
|
||||
userRep.setEnabled(true);
|
||||
when(usersResource.list(0, 10)).thenReturn(List.of(userRep));
|
||||
when(usersResource.count()).thenReturn(1);
|
||||
|
||||
UserResource userResource = mock(UserResource.class);
|
||||
RoleMappingResource roleMappingResource = mock(RoleMappingResource.class);
|
||||
RoleScopeResource roleScopeResource = mock(RoleScopeResource.class);
|
||||
when(usersResource.get("user-1")).thenReturn(userResource);
|
||||
when(userResource.roles()).thenReturn(roleMappingResource);
|
||||
when(roleMappingResource.realmLevel()).thenReturn(roleScopeResource);
|
||||
|
||||
RoleRepresentation adminRole = new RoleRepresentation();
|
||||
adminRole.setName("admin");
|
||||
when(roleScopeResource.listAll()).thenReturn(List.of(adminRole));
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.includeRoles(true)
|
||||
.page(0)
|
||||
.pageSize(10)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertNotNull(result.getUsers().get(0).getRealmRoles());
|
||||
assertTrue(result.getUsers().get(0).getRealmRoles().contains("admin"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSearchUsers_WithIncludeRoles_RoleLoadingException() {
|
||||
UserRepresentation userRep = new UserRepresentation();
|
||||
userRep.setId("user-2");
|
||||
userRep.setUsername("jane");
|
||||
userRep.setEnabled(true);
|
||||
when(usersResource.list(0, 10)).thenReturn(List.of(userRep));
|
||||
when(usersResource.count()).thenReturn(1);
|
||||
|
||||
UserResource userResource = mock(UserResource.class);
|
||||
when(usersResource.get("user-2")).thenReturn(userResource);
|
||||
when(userResource.roles()).thenThrow(new RuntimeException("Roles unavailable"));
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.includeRoles(true)
|
||||
.page(0)
|
||||
.pageSize(10)
|
||||
.build();
|
||||
|
||||
// Should not throw — exception is caught and logged
|
||||
var result = userService.searchUsers(criteria);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
}
|
||||
|
||||
// ==================== getUserById avec rôles non vides ====================
|
||||
|
||||
@Test
|
||||
void testGetUserById_WithNonEmptyRoles() {
|
||||
UserResource userResource = mock(UserResource.class);
|
||||
RoleMappingResource roleMappingResource = mock(RoleMappingResource.class);
|
||||
RoleScopeResource roleScopeResource = mock(RoleScopeResource.class);
|
||||
|
||||
when(usersResource.get("user-1")).thenReturn(userResource);
|
||||
|
||||
UserRepresentation userRep = new UserRepresentation();
|
||||
userRep.setId("user-1");
|
||||
userRep.setUsername("john");
|
||||
userRep.setEnabled(true);
|
||||
when(userResource.toRepresentation()).thenReturn(userRep);
|
||||
when(userResource.roles()).thenReturn(roleMappingResource);
|
||||
when(roleMappingResource.realmLevel()).thenReturn(roleScopeResource);
|
||||
|
||||
RoleRepresentation adminRole = new RoleRepresentation();
|
||||
adminRole.setName("admin");
|
||||
when(roleScopeResource.listAll()).thenReturn(List.of(adminRole));
|
||||
|
||||
Optional<UserDTO> result = userService.getUserById("user-1", REALM);
|
||||
|
||||
assertTrue(result.isPresent());
|
||||
assertNotNull(result.get().getRealmRoles());
|
||||
assertTrue(result.get().getRealmRoles().contains("admin"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGetUserById_RoleLoadingException() {
|
||||
UserResource userResource = mock(UserResource.class);
|
||||
|
||||
when(usersResource.get("user-1")).thenReturn(userResource);
|
||||
|
||||
UserRepresentation userRep = new UserRepresentation();
|
||||
userRep.setId("user-1");
|
||||
userRep.setUsername("john");
|
||||
userRep.setEnabled(true);
|
||||
when(userResource.toRepresentation()).thenReturn(userRep);
|
||||
when(userResource.roles()).thenThrow(new RuntimeException("Cannot load roles"));
|
||||
|
||||
// Should not throw — role loading exception is caught
|
||||
Optional<UserDTO> result = userService.getUserById("user-1", REALM);
|
||||
|
||||
assertTrue(result.isPresent());
|
||||
assertEquals("john", result.get().getUsername());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,435 @@
|
||||
package dev.lions.user.manager.service.impl;
|
||||
|
||||
import dev.lions.user.manager.client.KeycloakAdminClient;
|
||||
import dev.lions.user.manager.dto.importexport.ImportResultDTO;
|
||||
import dev.lions.user.manager.dto.user.UserDTO;
|
||||
import dev.lions.user.manager.dto.user.UserSearchCriteriaDTO;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.keycloak.admin.client.resource.UserResource;
|
||||
import org.keycloak.admin.client.resource.UsersResource;
|
||||
import org.keycloak.representations.idm.UserRepresentation;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.jupiter.MockitoExtension;
|
||||
import org.mockito.junit.jupiter.MockitoSettings;
|
||||
import org.mockito.quality.Strictness;
|
||||
|
||||
import jakarta.ws.rs.core.Response;
|
||||
|
||||
import java.net.URI;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
/**
|
||||
* Tests pour les lignes UserServiceImpl non couvertes.
|
||||
*
|
||||
* L153-154 : getUserById — catch Exception générique (non-404)
|
||||
* L284-289 : updateUser — catch NotFoundException + catch Exception générique
|
||||
* L313-318 : deleteUser — catch NotFoundException + catch Exception générique
|
||||
* L391-393 : sendVerificationEmail — catch Exception
|
||||
* L542 : escapeCSVField — null → return ""
|
||||
* L577 : importUsersFromCSV — ligne parsée avec succès (>= 4 champs)
|
||||
* L641-649 : importUsersFromCSV — catch lors de createUser
|
||||
* L675-676 : parseCSVLine — guillemet échappé ("")
|
||||
* L710-712 : setPassword (via resetPassword) — catch Exception
|
||||
* L733, L738 : filterUsers — filtres username et email non null avec non-correspondance
|
||||
*/
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
@MockitoSettings(strictness = Strictness.LENIENT)
|
||||
class UserServiceImplMissingCoverageTest {
|
||||
|
||||
@Mock
|
||||
private KeycloakAdminClient keycloakAdminClient;
|
||||
|
||||
@Mock
|
||||
private UsersResource usersResource;
|
||||
|
||||
@Mock
|
||||
private UserResource userResource;
|
||||
|
||||
@InjectMocks
|
||||
private UserServiceImpl userService;
|
||||
|
||||
private static final String REALM = "test-realm";
|
||||
private static final String USER_ID = "user-123";
|
||||
|
||||
// =========================================================================
|
||||
// L153-154 : getUserById — catch Exception générique (non-404)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testGetUserById_GenericException_NotRelatedTo404_ThrowsRuntimeException() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.get(USER_ID)).thenReturn(userResource);
|
||||
when(userResource.toRepresentation()).thenThrow(new RuntimeException("Connection timeout"));
|
||||
|
||||
assertThrows(RuntimeException.class, () ->
|
||||
userService.getUserById(USER_ID, REALM)
|
||||
);
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L284-289 : updateUser — catch NotFoundException
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testUpdateUser_NotFoundException_ThrowsRuntimeException() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.get(USER_ID)).thenReturn(userResource);
|
||||
when(userResource.toRepresentation()).thenThrow(new jakarta.ws.rs.NotFoundException("User not found"));
|
||||
|
||||
UserDTO userDTO = UserDTO.builder().id(USER_ID).email("new@example.com").build();
|
||||
|
||||
RuntimeException ex = assertThrows(RuntimeException.class, () ->
|
||||
userService.updateUser(USER_ID, userDTO, REALM)
|
||||
);
|
||||
assertTrue(ex.getMessage().contains("non trouvé"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testUpdateUser_GenericException_ThrowsRuntimeException() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.get(USER_ID)).thenReturn(userResource);
|
||||
when(userResource.toRepresentation()).thenThrow(new RuntimeException("DB error"));
|
||||
|
||||
UserDTO userDTO = UserDTO.builder().id(USER_ID).email("new@example.com").build();
|
||||
|
||||
RuntimeException ex = assertThrows(RuntimeException.class, () ->
|
||||
userService.updateUser(USER_ID, userDTO, REALM)
|
||||
);
|
||||
assertTrue(ex.getMessage().contains("mettre à jour"));
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L313-318 : deleteUser — catch NotFoundException + catch Exception générique
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testDeleteUser_NotFoundException_ThrowsRuntimeException() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.get(USER_ID)).thenReturn(userResource);
|
||||
doThrow(new jakarta.ws.rs.NotFoundException("Not found")).when(userResource).remove();
|
||||
|
||||
RuntimeException ex = assertThrows(RuntimeException.class, () ->
|
||||
userService.deleteUser(USER_ID, REALM, true)
|
||||
);
|
||||
assertTrue(ex.getMessage().contains("non trouvé"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDeleteUser_GenericException_ThrowsRuntimeException() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.get(USER_ID)).thenReturn(userResource);
|
||||
doThrow(new RuntimeException("DB error")).when(userResource).remove();
|
||||
|
||||
RuntimeException ex = assertThrows(RuntimeException.class, () ->
|
||||
userService.deleteUser(USER_ID, REALM, true)
|
||||
);
|
||||
assertTrue(ex.getMessage().contains("supprimer"));
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// sendVerificationEmail — catch Exception → graceful WARN (best-effort)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testSendVerificationEmail_Exception_LogsWarnAndReturnsNormally() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.get(USER_ID)).thenReturn(userResource);
|
||||
doThrow(new RuntimeException("SMTP not configured")).when(userResource).sendVerifyEmail();
|
||||
|
||||
// No exception should be thrown — email sending is best-effort
|
||||
assertDoesNotThrow(() -> userService.sendVerificationEmail(USER_ID, REALM));
|
||||
|
||||
// Verify the Keycloak call was attempted
|
||||
verify(userResource).sendVerifyEmail();
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L542 : escapeCSVField — null → return ""
|
||||
// La méthode est privée, on l'appelle via reflection pour couvrir le cas null
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testEscapeCSVField_NullInput_ReturnsEmpty() throws Exception {
|
||||
java.lang.reflect.Method method =
|
||||
UserServiceImpl.class.getDeclaredMethod("escapeCSVField", String.class);
|
||||
method.setAccessible(true);
|
||||
|
||||
String result = (String) method.invoke(userService, (Object) null);
|
||||
assertEquals("", result);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testEscapeCSVField_FieldWithComma() throws Exception {
|
||||
java.lang.reflect.Method method =
|
||||
UserServiceImpl.class.getDeclaredMethod("escapeCSVField", String.class);
|
||||
method.setAccessible(true);
|
||||
|
||||
String result = (String) method.invoke(userService, "hello,world");
|
||||
assertEquals("\"hello,world\"", result);
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L577 : importUsersFromCSV — ligne avec 4+ champs (succès)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_Success_SingleLine() {
|
||||
// Mock createUser (via getUsers + create)
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
|
||||
// usernameExists → search() → vide (username n'existe pas)
|
||||
when(usersResource.search(anyString(), anyInt(), anyInt(), eq(true)))
|
||||
.thenReturn(List.of());
|
||||
// emailExists → searchByEmail() → vide (email n'existe pas)
|
||||
when(usersResource.searchByEmail(anyString(), eq(true)))
|
||||
.thenReturn(List.of());
|
||||
|
||||
Response response = mock(Response.class);
|
||||
when(response.getStatus()).thenReturn(201);
|
||||
when(response.getStatusInfo()).thenReturn(Response.Status.CREATED);
|
||||
when(response.getLocation()).thenReturn(URI.create("http://localhost/users/new-user-id"));
|
||||
when(usersResource.create(any(UserRepresentation.class))).thenReturn(response);
|
||||
when(usersResource.get("new-user-id")).thenReturn(userResource);
|
||||
when(userResource.toRepresentation()).thenReturn(new UserRepresentation());
|
||||
|
||||
// CSV avec 4 colonnes minimales (header + 1 ligne de données)
|
||||
String csv = "username,email,prenom,nom\njohn,john@example.com,John,Doe";
|
||||
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
// Au moins une ligne traitée
|
||||
assertTrue(result.getTotalLines() >= 2);
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L641-649 : importUsersFromCSV — catch lors de createUser (erreur)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_CreateUserThrows_RecordsError() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.create(any(UserRepresentation.class)))
|
||||
.thenThrow(new RuntimeException("Keycloak error"));
|
||||
|
||||
// CSV valide avec 4 colonnes
|
||||
String csv = "john,john@example.com,John,Doe";
|
||||
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(0, result.getSuccessCount());
|
||||
assertFalse(result.getErrors().isEmpty());
|
||||
assertEquals(ImportResultDTO.ErrorType.CREATION_ERROR, result.getErrors().get(0).getErrorType());
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L577 : importUsersFromCSV — ligne vide → continue
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_WithEmptyLine_SkipsIt() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.create(any())).thenThrow(new RuntimeException("fail"));
|
||||
|
||||
// CSV avec une ligne vide intercalée → déclenche le 'continue' à L577
|
||||
String csv = "john,john@example.com,John,Doe\n\nbob,bob@example.com,Bob,Smith";
|
||||
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
// Les 2 lignes non-vides tentent une création mais échouent
|
||||
assertEquals(0, result.getSuccessCount());
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L675-676 : parseCSVLine — guillemet échappé ("")
|
||||
// (via importUsersFromCSV avec un champ contenant "")
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testImportUsersFromCSV_WithEscapedQuoteInField() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
|
||||
// usernameExists + emailExists
|
||||
when(usersResource.search(anyString(), anyInt(), anyInt(), eq(true))).thenReturn(List.of());
|
||||
when(usersResource.searchByEmail(anyString(), eq(true))).thenReturn(List.of());
|
||||
|
||||
Response responseQ = mock(Response.class);
|
||||
when(responseQ.getStatus()).thenReturn(201);
|
||||
when(responseQ.getStatusInfo()).thenReturn(Response.Status.CREATED);
|
||||
when(responseQ.getLocation()).thenReturn(URI.create("http://localhost/users/q-user-id"));
|
||||
when(usersResource.create(any(UserRepresentation.class))).thenReturn(responseQ);
|
||||
when(usersResource.get("q-user-id")).thenReturn(userResource);
|
||||
when(userResource.toRepresentation()).thenReturn(new UserRepresentation());
|
||||
|
||||
// Ligne CSV avec guillemet échappé ("") → couvre L675-676
|
||||
String csv = "john,\"john\"\"s@example.com\",John,Doe";
|
||||
|
||||
ImportResultDTO result = userService.importUsersFromCSV(csv, REALM);
|
||||
|
||||
assertNotNull(result);
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L710-712 : setPassword — catch Exception (via resetPassword)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testResetPassword_SetPasswordThrows_PropagatesRuntimeException() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
when(usersResource.get(USER_ID)).thenReturn(userResource);
|
||||
doThrow(new RuntimeException("Password policy violation")).when(userResource).resetPassword(any());
|
||||
|
||||
RuntimeException ex = assertThrows(RuntimeException.class, () ->
|
||||
userService.resetPassword(USER_ID, REALM, "newPass123", false)
|
||||
);
|
||||
assertTrue(ex.getMessage().contains("mot de passe"));
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L733 : filterUsers — username criteria non null mais user.getUsername() ne correspond pas
|
||||
// L738 : filterUsers — email criteria non null mais user.getEmail() ne correspond pas
|
||||
// (via searchUsers avec filtres username/email)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testSearchUsers_FilterByUsername_NotMatching() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
|
||||
UserRepresentation user1 = new UserRepresentation();
|
||||
user1.setId("u1");
|
||||
user1.setUsername("alice");
|
||||
user1.setEnabled(true);
|
||||
|
||||
UserRepresentation user2 = new UserRepresentation();
|
||||
user2.setId("u2");
|
||||
user2.setUsername("bob");
|
||||
user2.setEnabled(true);
|
||||
|
||||
when(usersResource.list(anyInt(), anyInt())).thenReturn(List.of(user1, user2));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
// Filtre username=alice → seul alice passe
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.username("alice")
|
||||
.page(0)
|
||||
.pageSize(20)
|
||||
.build();
|
||||
|
||||
// search() avec exactMatch sur username retourne directement depuis Keycloak
|
||||
// Mais si le critère username est présent, c'est un search exact
|
||||
// On utilise searchTerm pour déclencher list() puis filterUsers()
|
||||
// En fait, searchUsers appelle usersResource.search(username, ..., true) quand username is set
|
||||
// Pour tester filterUsers L733, on doit passer par le path list() + filterUsers
|
||||
// Cela arrive via: searchTerm=null, username=null, email=null → list() → filterUsers
|
||||
// Pour L733, criteria.getUsername() != null mais dans filterUsers
|
||||
// Cela se produit quand on utilise list() + criteria.username filter
|
||||
|
||||
// On va utiliser le path avec searchTerm vide + filtres post-liste (filtres appliqués manuellement)
|
||||
// En regardant le code: si username est présent, on appelle search(username, exact) directement
|
||||
// Donc filterUsers n'est PAS appelée pour username dans ce cas
|
||||
// filterUsers est appelée quand on utilise list() (sans searchTerm/username/email)
|
||||
// mais qu'on a d'autres filtres comme prenom/nom ou statut
|
||||
|
||||
// Recréer un test qui passe par filterUsers avec username filter (criteria.username != null)
|
||||
// En regardant code UserServiceImpl.searchUsers():
|
||||
// username → search exact → pas de filterUsers
|
||||
// Pour atteindre filterUsers avec username set → il faut un autre path
|
||||
|
||||
// CORRECTION : filterUsers L733 est atteint si searchTerm is non-blank (search() returns users)
|
||||
// mais criteria.username is also set → filterUsers applique le filtre username
|
||||
// Vérifions: quand searchTerm non-blank → search(searchTerm, page, size) → filterUsers(users, criteria)
|
||||
// Si criteria.username is set → L733 est couvert
|
||||
|
||||
UserRepresentation searchResult1 = new UserRepresentation();
|
||||
searchResult1.setId("u1");
|
||||
searchResult1.setUsername("alice");
|
||||
searchResult1.setEnabled(true);
|
||||
|
||||
UserRepresentation searchResult2 = new UserRepresentation();
|
||||
searchResult2.setId("u2");
|
||||
searchResult2.setUsername("bob");
|
||||
searchResult2.setEnabled(true);
|
||||
|
||||
when(usersResource.search(eq("ali"), anyInt(), anyInt())).thenReturn(List.of(searchResult1, searchResult2));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteriaWithUsername = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.searchTerm("ali")
|
||||
.username("alice") // filtre post-search → L733
|
||||
.page(0)
|
||||
.pageSize(20)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteriaWithUsername);
|
||||
|
||||
assertNotNull(result);
|
||||
// alice correspond au filtre username
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("alice", result.getUsers().get(0).getUsername());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSearchUsers_FilterByEmail_NotMatching() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenReturn(usersResource);
|
||||
|
||||
UserRepresentation u1 = new UserRepresentation();
|
||||
u1.setId("u1");
|
||||
u1.setUsername("alice");
|
||||
u1.setEmail("alice@example.com");
|
||||
u1.setEnabled(true);
|
||||
|
||||
UserRepresentation u2 = new UserRepresentation();
|
||||
u2.setId("u2");
|
||||
u2.setUsername("bob");
|
||||
u2.setEmail("bob@example.com");
|
||||
u2.setEnabled(true);
|
||||
|
||||
when(usersResource.search(eq("example"), anyInt(), anyInt())).thenReturn(List.of(u1, u2));
|
||||
when(usersResource.count()).thenReturn(2);
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.searchTerm("example")
|
||||
.email("alice@example.com") // filtre post-search → L738
|
||||
.page(0)
|
||||
.pageSize(20)
|
||||
.build();
|
||||
|
||||
var result = userService.searchUsers(criteria);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(1, result.getUsers().size());
|
||||
assertEquals("alice@example.com", result.getUsers().get(0).getEmail());
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// L530-532 : exportUsersToCSV — catch Exception (searchUsers lève une exception)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
void testExportUsersToCSV_SearchUsersThrows_CatchBlock_CoversL530To532() {
|
||||
when(keycloakAdminClient.getUsers(REALM)).thenThrow(new RuntimeException("Keycloak unavailable"));
|
||||
|
||||
UserSearchCriteriaDTO criteria = UserSearchCriteriaDTO.builder()
|
||||
.realmName(REALM)
|
||||
.page(0)
|
||||
.pageSize(20)
|
||||
.build();
|
||||
|
||||
RuntimeException ex = assertThrows(RuntimeException.class, () ->
|
||||
userService.exportUsersToCSV(criteria)
|
||||
);
|
||||
assertTrue(ex.getMessage().contains("exporter"));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user