274 lines
10 KiB
Java
274 lines
10 KiB
Java
package dev.lions.unionflow.server.service;
|
||
|
||
import dev.lions.unionflow.server.client.RoleServiceClient;
|
||
import dev.lions.unionflow.server.client.UserServiceClient;
|
||
import dev.lions.user.manager.dto.role.RoleDTO;
|
||
import dev.lions.user.manager.dto.user.UserDTO;
|
||
import dev.lions.user.manager.dto.user.UserSearchResultDTO;
|
||
import io.quarkus.test.InjectMock;
|
||
import io.quarkus.test.junit.QuarkusTest;
|
||
import jakarta.inject.Inject;
|
||
import org.eclipse.microprofile.rest.client.inject.RestClient;
|
||
import org.junit.jupiter.api.DisplayName;
|
||
import org.junit.jupiter.api.Test;
|
||
import org.mockito.Mockito;
|
||
|
||
import java.util.List;
|
||
import java.util.UUID;
|
||
|
||
import static org.assertj.core.api.Assertions.assertThat;
|
||
import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
||
import static org.mockito.ArgumentMatchers.any;
|
||
import static org.mockito.ArgumentMatchers.eq;
|
||
|
||
@QuarkusTest
|
||
class AdminUserServiceTest {
|
||
|
||
@Inject
|
||
AdminUserService adminUserService;
|
||
|
||
@InjectMock
|
||
@RestClient
|
||
UserServiceClient userServiceClient;
|
||
|
||
@InjectMock
|
||
@RestClient
|
||
RoleServiceClient roleServiceClient;
|
||
|
||
@Test
|
||
@DisplayName("searchUsers appelle le client rest UserService")
|
||
void searchUsers_callsClient() {
|
||
UserSearchResultDTO mockResult = new UserSearchResultDTO();
|
||
Mockito.when(userServiceClient.searchUsers(any())).thenReturn(mockResult);
|
||
|
||
UserSearchResultDTO result = adminUserService.searchUsers(0, 10, "test");
|
||
|
||
assertThat(result).isNotNull();
|
||
Mockito.verify(userServiceClient).searchUsers(any());
|
||
}
|
||
|
||
@Test
|
||
@DisplayName("getUserById retourne l'utilisateur via le client")
|
||
void getUserById_returnsUser() {
|
||
String userId = UUID.randomUUID().toString();
|
||
UserDTO mockUser = new UserDTO();
|
||
mockUser.setId(userId);
|
||
mockUser.setUsername("testuser");
|
||
|
||
Mockito.when(userServiceClient.getUserById(eq(userId), any())).thenReturn(mockUser);
|
||
|
||
UserDTO result = adminUserService.getUserById(userId);
|
||
|
||
assertThat(result).isNotNull();
|
||
assertThat(result.getUsername()).isEqualTo("testuser");
|
||
}
|
||
|
||
@Test
|
||
@DisplayName("createUser appelle le client pour la création")
|
||
void createUser_callsClient() {
|
||
UserDTO user = new UserDTO();
|
||
user.setUsername("newuser");
|
||
|
||
Mockito.when(userServiceClient.createUser(any(), any())).thenReturn(user);
|
||
|
||
UserDTO result = adminUserService.createUser(user);
|
||
|
||
assertThat(result).isNotNull();
|
||
assertThat(result.getUsername()).isEqualTo("newuser");
|
||
}
|
||
|
||
// =========================================================================
|
||
// getRealmRoles
|
||
// =========================================================================
|
||
|
||
@Test
|
||
@DisplayName("getRealmRoles retourne la liste des rôles")
|
||
void getRealmRoles_returnsRoles() {
|
||
RoleDTO role = new RoleDTO();
|
||
role.setName("admin");
|
||
|
||
Mockito.when(roleServiceClient.getRealmRoles("unionflow")).thenReturn(List.of(role));
|
||
|
||
List<RoleDTO> result = adminUserService.getRealmRoles();
|
||
|
||
assertThat(result).hasSize(1);
|
||
assertThat(result.get(0).getName()).isEqualTo("admin");
|
||
}
|
||
|
||
@Test
|
||
@DisplayName("getRealmRoles retourne liste vide si le client lève une exception")
|
||
void getRealmRoles_exceptionRetourneListeVide() {
|
||
Mockito.when(roleServiceClient.getRealmRoles(any()))
|
||
.thenThrow(new RuntimeException("Service unavailable"));
|
||
|
||
List<RoleDTO> result = adminUserService.getRealmRoles();
|
||
|
||
assertThat(result).isEmpty();
|
||
}
|
||
|
||
// =========================================================================
|
||
// getUserRoles
|
||
// =========================================================================
|
||
|
||
@Test
|
||
@DisplayName("getUserRoles retourne les rôles de l'utilisateur")
|
||
void getUserRoles_returnsUserRoles() {
|
||
String userId = UUID.randomUUID().toString();
|
||
RoleDTO role = new RoleDTO();
|
||
role.setName("membre");
|
||
|
||
Mockito.when(roleServiceClient.getUserRealmRoles(eq(userId), any())).thenReturn(List.of(role));
|
||
|
||
List<RoleDTO> result = adminUserService.getUserRoles(userId);
|
||
|
||
assertThat(result).hasSize(1);
|
||
assertThat(result.get(0).getName()).isEqualTo("membre");
|
||
}
|
||
|
||
@Test
|
||
@DisplayName("getUserRoles retourne liste vide si le client lève une exception")
|
||
void getUserRoles_exceptionRetourneListeVide() {
|
||
String userId = UUID.randomUUID().toString();
|
||
Mockito.when(roleServiceClient.getUserRealmRoles(eq(userId), any()))
|
||
.thenThrow(new RuntimeException("Keycloak down"));
|
||
|
||
List<RoleDTO> result = adminUserService.getUserRoles(userId);
|
||
|
||
assertThat(result).isEmpty();
|
||
}
|
||
|
||
// =========================================================================
|
||
// updateUser
|
||
// =========================================================================
|
||
|
||
@Test
|
||
@DisplayName("updateUser appelle le client REST avec userId et realm")
|
||
void updateUser_callsClient() {
|
||
String userId = UUID.randomUUID().toString();
|
||
UserDTO user = new UserDTO();
|
||
user.setUsername("updated-user");
|
||
|
||
Mockito.when(userServiceClient.updateUser(eq(userId), any(), any())).thenReturn(user);
|
||
|
||
UserDTO result = adminUserService.updateUser(userId, user);
|
||
|
||
assertThat(result).isNotNull();
|
||
assertThat(result.getUsername()).isEqualTo("updated-user");
|
||
Mockito.verify(userServiceClient).updateUser(eq(userId), any(), eq("unionflow"));
|
||
}
|
||
|
||
// =========================================================================
|
||
// updateUserEnabled
|
||
// =========================================================================
|
||
|
||
@Test
|
||
@DisplayName("updateUserEnabled active l'utilisateur et appelle updateUser")
|
||
void updateUserEnabled_activerUtilisateur() {
|
||
String userId = UUID.randomUUID().toString();
|
||
UserDTO existing = new UserDTO();
|
||
existing.setId(userId);
|
||
existing.setUsername("testuser");
|
||
existing.setEnabled(false);
|
||
|
||
UserDTO updated = new UserDTO();
|
||
updated.setId(userId);
|
||
updated.setEnabled(true);
|
||
|
||
Mockito.when(userServiceClient.getUserById(eq(userId), any())).thenReturn(existing);
|
||
Mockito.when(userServiceClient.updateUser(eq(userId), any(), any())).thenReturn(updated);
|
||
|
||
UserDTO result = adminUserService.updateUserEnabled(userId, true);
|
||
|
||
assertThat(result).isNotNull();
|
||
Mockito.verify(userServiceClient).updateUser(eq(userId), any(), eq("unionflow"));
|
||
}
|
||
|
||
@Test
|
||
@DisplayName("updateUserEnabled lance IllegalArgumentException si l'utilisateur est null")
|
||
void updateUserEnabled_utilisateurNonTrouve_lancerException() {
|
||
String userId = UUID.randomUUID().toString();
|
||
Mockito.when(userServiceClient.getUserById(eq(userId), any())).thenReturn(null);
|
||
|
||
assertThatThrownBy(() -> adminUserService.updateUserEnabled(userId, true))
|
||
.isInstanceOf(IllegalArgumentException.class)
|
||
.hasMessageContaining("Utilisateur non trouvé");
|
||
}
|
||
|
||
// =========================================================================
|
||
// setUserRoles
|
||
// =========================================================================
|
||
|
||
@Test
|
||
@DisplayName("setUserRoles assigne les nouveaux rôles et révoque les retirés")
|
||
void setUserRoles_assigneEtRevoque() {
|
||
String userId = UUID.randomUUID().toString();
|
||
|
||
RoleDTO existingRole = new RoleDTO();
|
||
existingRole.setName("membre");
|
||
|
||
// L'utilisateur a actuellement "membre", on veut lui assigner "admin"
|
||
Mockito.when(roleServiceClient.getUserRealmRoles(eq(userId), any()))
|
||
.thenReturn(List.of(existingRole));
|
||
|
||
// assign "admin", revoke "membre"
|
||
adminUserService.setUserRoles(userId, List.of("admin"));
|
||
|
||
Mockito.verify(roleServiceClient).assignRealmRoles(eq(userId), eq("unionflow"), any());
|
||
Mockito.verify(roleServiceClient).revokeRealmRoles(eq(userId), eq("unionflow"), any());
|
||
}
|
||
|
||
@Test
|
||
@DisplayName("setUserRoles sans changement — ni assign ni revoke appelé")
|
||
void setUserRoles_sansChangement_aucunAppel() {
|
||
String userId = UUID.randomUUID().toString();
|
||
|
||
RoleDTO existingRole = new RoleDTO();
|
||
existingRole.setName("admin");
|
||
|
||
// L'utilisateur a déjà "admin", on veut "admin" → rien à faire
|
||
Mockito.when(roleServiceClient.getUserRealmRoles(eq(userId), any()))
|
||
.thenReturn(List.of(existingRole));
|
||
|
||
adminUserService.setUserRoles(userId, List.of("admin"));
|
||
|
||
Mockito.verify(roleServiceClient, Mockito.never()).assignRealmRoles(any(), any(), any());
|
||
Mockito.verify(roleServiceClient, Mockito.never()).revokeRealmRoles(any(), any(), any());
|
||
}
|
||
|
||
@Test
|
||
@DisplayName("setUserRoles avec liste cible vide — tous les rôles existants révoqués")
|
||
void setUserRoles_listeCibleNull_tousRevoque() {
|
||
String userId = UUID.randomUUID().toString();
|
||
|
||
RoleDTO existingRole = new RoleDTO();
|
||
existingRole.setName("membre");
|
||
|
||
Mockito.when(roleServiceClient.getUserRealmRoles(eq(userId), any()))
|
||
.thenReturn(List.of(existingRole));
|
||
|
||
adminUserService.setUserRoles(userId, new java.util.ArrayList<>());
|
||
|
||
// rien à assigner, "membre" à révoquer
|
||
Mockito.verify(roleServiceClient, Mockito.never()).assignRealmRoles(any(), any(), any());
|
||
Mockito.verify(roleServiceClient).revokeRealmRoles(eq(userId), eq("unionflow"), any());
|
||
}
|
||
|
||
@Test
|
||
@DisplayName("setUserRoles null targetRoleNames — couvre branche null L107")
|
||
void setUserRoles_targetRolesNull_revoqueTous() {
|
||
String userId = UUID.randomUUID().toString();
|
||
|
||
RoleDTO existingRole = new RoleDTO();
|
||
existingRole.setName("admin");
|
||
|
||
Mockito.when(roleServiceClient.getUserRealmRoles(eq(userId), any()))
|
||
.thenReturn(List.of(existingRole));
|
||
|
||
// null → toAssign = List.of(), toRevoke = currentNames − List.of() = currentNames
|
||
adminUserService.setUserRoles(userId, null);
|
||
|
||
Mockito.verify(roleServiceClient, Mockito.never()).assignRealmRoles(any(), any(), any());
|
||
Mockito.verify(roleServiceClient).revokeRealmRoles(eq(userId), eq("unionflow"), any());
|
||
}
|
||
}
|