Refactoring
This commit is contained in:
dahoud
163
src/test/java/com/lions/dev/resource/BookingResourceTest.java
Normal file
163
src/test/java/com/lions/dev/resource/BookingResourceTest.java
Normal file
@@ -0,0 +1,163 @@
|
||||
package com.lions.dev.resource;
|
||||
|
||||
import io.quarkus.test.junit.QuarkusTest;
|
||||
import io.quarkus.test.security.TestSecurity;
|
||||
import io.restassured.http.ContentType;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
import static io.restassured.RestAssured.given;
|
||||
import static org.hamcrest.Matchers.*;
|
||||
|
||||
/**
|
||||
* Tests d'intégration pour BookingResource.
|
||||
*
|
||||
* @since 2.0 - Tests production-ready
|
||||
*/
|
||||
@QuarkusTest
|
||||
class BookingResourceTest {
|
||||
|
||||
// =========================================================================
|
||||
// Tests d'accès sans authentification
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("GET /bookings - Sans authentification devrait retourner 401")
|
||||
void testGetAllBookingsWithoutAuth() {
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/bookings")
|
||||
.then()
|
||||
.statusCode(401);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("POST /bookings - Sans authentification devrait retourner 401")
|
||||
void testCreateBookingWithoutAuth() {
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"eventId": "00000000-0000-0000-0000-000000000001",
|
||||
"userId": "00000000-0000-0000-0000-000000000002",
|
||||
"seats": 2
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.post("/afterwork/bookings")
|
||||
.then()
|
||||
.statusCode(401);
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests avec authentification USER
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "user@test.com", roles = {"USER"})
|
||||
@DisplayName("GET /bookings/user/{userId} - Accès aux propres réservations")
|
||||
void testGetOwnBookings() {
|
||||
UUID userId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/bookings/user/" + userId)
|
||||
.then()
|
||||
.statusCode(anyOf(is(200), is(403))); // 403 si userId ne correspond pas
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "user@test.com", roles = {"USER"})
|
||||
@DisplayName("GET /bookings/{id} - Réservation inexistante devrait retourner 404")
|
||||
void testGetNonExistentBooking() {
|
||||
UUID randomId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/bookings/" + randomId)
|
||||
.then()
|
||||
.statusCode(404);
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "user@test.com", roles = {"USER"})
|
||||
@DisplayName("DELETE /bookings/{id} - Réservation inexistante devrait retourner 404")
|
||||
void testCancelNonExistentBooking() {
|
||||
UUID randomId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.when()
|
||||
.delete("/afterwork/bookings/" + randomId)
|
||||
.then()
|
||||
.statusCode(404);
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests avec authentification ADMIN
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "admin@test.com", roles = {"ADMIN"})
|
||||
@DisplayName("GET /bookings - ADMIN peut voir toutes les réservations")
|
||||
void testAdminCanViewAllBookings() {
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/bookings")
|
||||
.then()
|
||||
.statusCode(200)
|
||||
.body("$", instanceOf(java.util.List.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "admin@test.com", roles = {"ADMIN"})
|
||||
@DisplayName("GET /bookings/event/{eventId} - ADMIN peut voir les réservations d'un événement")
|
||||
void testAdminCanViewEventBookings() {
|
||||
UUID eventId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/bookings/event/" + eventId)
|
||||
.then()
|
||||
.statusCode(anyOf(is(200), is(404)));
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests avec authentification OWNER/MANAGER
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "owner@test.com", roles = {"OWNER"})
|
||||
@DisplayName("GET /bookings/establishment/{id} - OWNER peut voir les réservations de son établissement")
|
||||
void testOwnerCanViewEstablishmentBookings() {
|
||||
UUID establishmentId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/bookings/establishment/" + establishmentId)
|
||||
.then()
|
||||
.statusCode(anyOf(is(200), is(404), is(403)));
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests de validation
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "user@test.com", roles = {"USER"})
|
||||
@DisplayName("POST /bookings - Données invalides devrait retourner 400")
|
||||
void testCreateBookingWithInvalidData() {
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"seats": -1
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.post("/afterwork/bookings")
|
||||
.then()
|
||||
.statusCode(400);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,223 @@
|
||||
package com.lions.dev.resource;
|
||||
|
||||
import io.quarkus.test.junit.QuarkusTest;
|
||||
import io.quarkus.test.security.TestSecurity;
|
||||
import io.restassured.http.ContentType;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
import static io.restassured.RestAssured.given;
|
||||
import static org.hamcrest.Matchers.*;
|
||||
|
||||
/**
|
||||
* Tests d'intégration pour EstablishmentResource.
|
||||
*
|
||||
* @since 2.0 - Tests production-ready
|
||||
*/
|
||||
@QuarkusTest
|
||||
class EstablishmentResourceTest {
|
||||
|
||||
// =========================================================================
|
||||
// Tests endpoints publics (lecture)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("GET /establishments - Liste des établissements (public)")
|
||||
void testGetAllEstablishments() {
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/establishments")
|
||||
.then()
|
||||
.statusCode(200)
|
||||
.body("$", instanceOf(java.util.List.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("GET /establishments/{id} - Établissement inexistant devrait retourner 404")
|
||||
void testGetNonExistentEstablishment() {
|
||||
UUID randomId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/establishments/" + randomId)
|
||||
.then()
|
||||
.statusCode(404);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("GET /establishments/search - Recherche d'établissements")
|
||||
void testSearchEstablishments() {
|
||||
given()
|
||||
.queryParam("q", "bar")
|
||||
.when()
|
||||
.get("/afterwork/establishments/search")
|
||||
.then()
|
||||
.statusCode(200)
|
||||
.body("$", instanceOf(java.util.List.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("GET /establishments/nearby - Recherche par proximité")
|
||||
void testGetNearbyEstablishments() {
|
||||
given()
|
||||
.queryParam("lat", 5.3600)
|
||||
.queryParam("lng", -3.9400)
|
||||
.queryParam("radius", 10)
|
||||
.when()
|
||||
.get("/afterwork/establishments/nearby")
|
||||
.then()
|
||||
.statusCode(200)
|
||||
.body("$", instanceOf(java.util.List.class));
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests endpoints protégés (création, modification)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("POST /establishments - Sans authentification devrait retourner 401")
|
||||
void testCreateEstablishmentWithoutAuth() {
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"name": "Test Bar",
|
||||
"description": "Un bar de test",
|
||||
"address": "123 Rue Test",
|
||||
"city": "Abidjan"
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.post("/afterwork/establishments")
|
||||
.then()
|
||||
.statusCode(401);
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "user@test.com", roles = {"USER"})
|
||||
@DisplayName("POST /establishments - USER ne peut pas créer d'établissement")
|
||||
void testCreateEstablishmentWithUserRole() {
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"name": "Test Bar",
|
||||
"description": "Un bar de test",
|
||||
"address": "123 Rue Test",
|
||||
"city": "Abidjan"
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.post("/afterwork/establishments")
|
||||
.then()
|
||||
.statusCode(403);
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "owner@test.com", roles = {"OWNER"})
|
||||
@DisplayName("POST /establishments - OWNER peut créer un établissement")
|
||||
void testCreateEstablishmentWithOwnerRole() {
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"name": "Test Bar",
|
||||
"description": "Un bar de test",
|
||||
"address": "123 Rue Test",
|
||||
"city": "Abidjan",
|
||||
"phone": "+22501234567",
|
||||
"email": "testbar@test.com",
|
||||
"latitude": 5.3600,
|
||||
"longitude": -3.9400
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.post("/afterwork/establishments")
|
||||
.then()
|
||||
.statusCode(anyOf(is(201), is(200), is(400))); // 400 si validation échoue
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "owner@test.com", roles = {"OWNER"})
|
||||
@DisplayName("PUT /establishments/{id} - OWNER peut modifier un établissement")
|
||||
void testUpdateEstablishmentWithOwnerRole() {
|
||||
UUID randomId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"name": "Updated Bar Name",
|
||||
"description": "Description mise à jour"
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.put("/afterwork/establishments/" + randomId)
|
||||
.then()
|
||||
.statusCode(anyOf(is(200), is(404), is(403))); // 404 si n'existe pas, 403 si pas propriétaire
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "owner@test.com", roles = {"OWNER"})
|
||||
@DisplayName("DELETE /establishments/{id} - Établissement inexistant devrait retourner 404")
|
||||
void testDeleteNonExistentEstablishment() {
|
||||
UUID randomId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.when()
|
||||
.delete("/afterwork/establishments/" + randomId)
|
||||
.then()
|
||||
.statusCode(404);
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests endpoints admin
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "admin@test.com", roles = {"ADMIN"})
|
||||
@DisplayName("GET /establishments/pending - ADMIN peut voir les établissements en attente")
|
||||
void testGetPendingEstablishments() {
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/establishments/pending")
|
||||
.then()
|
||||
.statusCode(anyOf(is(200), is(404)));
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "admin@test.com", roles = {"ADMIN"})
|
||||
@DisplayName("PATCH /establishments/{id}/approve - ADMIN peut approuver un établissement")
|
||||
void testApproveEstablishment() {
|
||||
UUID randomId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.when()
|
||||
.patch("/afterwork/establishments/" + randomId + "/approve")
|
||||
.then()
|
||||
.statusCode(anyOf(is(200), is(404)));
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests de validation
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "owner@test.com", roles = {"OWNER"})
|
||||
@DisplayName("POST /establishments - Données invalides devrait retourner 400")
|
||||
void testCreateEstablishmentWithInvalidData() {
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"name": ""
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.post("/afterwork/establishments")
|
||||
.then()
|
||||
.statusCode(400);
|
||||
}
|
||||
}
|
||||
215
src/test/java/com/lions/dev/resource/UsersResourceTest.java
Normal file
215
src/test/java/com/lions/dev/resource/UsersResourceTest.java
Normal file
@@ -0,0 +1,215 @@
|
||||
package com.lions.dev.resource;
|
||||
|
||||
import io.quarkus.test.junit.QuarkusTest;
|
||||
import io.quarkus.test.security.TestSecurity;
|
||||
import io.restassured.http.ContentType;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
import static io.restassured.RestAssured.given;
|
||||
import static org.hamcrest.Matchers.*;
|
||||
|
||||
/**
|
||||
* Tests d'intégration pour UsersResource.
|
||||
*
|
||||
* @since 2.0 - Tests production-ready
|
||||
*/
|
||||
@QuarkusTest
|
||||
class UsersResourceTest {
|
||||
|
||||
// =========================================================================
|
||||
// Tests endpoints publics (authentification, inscription)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("POST /users/authenticate - Identifiants invalides devrait retourner 401")
|
||||
void testAuthenticateWithInvalidCredentials() {
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"email": "invalid@test.com",
|
||||
"password": "wrongpassword"
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.post("/afterwork/users/authenticate")
|
||||
.then()
|
||||
.statusCode(anyOf(is(401), is(404)));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("POST /users/authenticate - Email manquant devrait retourner 400")
|
||||
void testAuthenticateWithMissingEmail() {
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"password": "somepassword"
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.post("/afterwork/users/authenticate")
|
||||
.then()
|
||||
.statusCode(400);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("POST /users/register - Email invalide devrait retourner 400")
|
||||
void testRegisterWithInvalidEmail() {
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"email": "invalidemail",
|
||||
"password": "ValidPassword123!",
|
||||
"firstName": "Test",
|
||||
"lastName": "User"
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.post("/afterwork/users/register")
|
||||
.then()
|
||||
.statusCode(400);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("POST /users/forgot-password - Email inexistant devrait retourner 404 ou 200 (sécurité)")
|
||||
void testForgotPasswordWithNonExistentEmail() {
|
||||
// Pour des raisons de sécurité, certaines implémentations retournent 200
|
||||
// même si l'email n'existe pas (pour ne pas divulguer d'informations)
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"email": "nonexistent@test.com"
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.post("/afterwork/users/forgot-password")
|
||||
.then()
|
||||
.statusCode(anyOf(is(200), is(404)));
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests endpoints protégés (profil utilisateur)
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("GET /users/me - Sans authentification devrait retourner 401")
|
||||
void testGetProfileWithoutAuth() {
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/users/me")
|
||||
.then()
|
||||
.statusCode(401);
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "testuser@test.com", roles = {"USER"})
|
||||
@DisplayName("GET /users/me - Avec authentification devrait retourner le profil")
|
||||
void testGetProfileWithAuth() {
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/users/me")
|
||||
.then()
|
||||
.statusCode(anyOf(is(200), is(404))); // 404 si l'utilisateur de test n'existe pas en BDD
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("PUT /users/{id} - Sans authentification devrait retourner 401")
|
||||
void testUpdateProfileWithoutAuth() {
|
||||
UUID randomId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body("""
|
||||
{
|
||||
"firstName": "Updated",
|
||||
"lastName": "User"
|
||||
}
|
||||
""")
|
||||
.when()
|
||||
.put("/afterwork/users/" + randomId)
|
||||
.then()
|
||||
.statusCode(401);
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests endpoints admin
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("GET /users - Sans authentification devrait retourner 401")
|
||||
void testGetAllUsersWithoutAuth() {
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/users")
|
||||
.then()
|
||||
.statusCode(401);
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "user@test.com", roles = {"USER"})
|
||||
@DisplayName("GET /users - Avec rôle USER devrait retourner 403")
|
||||
void testGetAllUsersWithUserRole() {
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/users")
|
||||
.then()
|
||||
.statusCode(403);
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "admin@test.com", roles = {"ADMIN"})
|
||||
@DisplayName("GET /users - Avec rôle ADMIN devrait retourner 200")
|
||||
void testGetAllUsersWithAdminRole() {
|
||||
given()
|
||||
.when()
|
||||
.get("/afterwork/users")
|
||||
.then()
|
||||
.statusCode(200)
|
||||
.body("$", instanceOf(java.util.List.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "admin@test.com", roles = {"ADMIN"})
|
||||
@DisplayName("DELETE /users/{id} - Suppression d'un utilisateur inexistant devrait retourner 404")
|
||||
void testDeleteNonExistentUser() {
|
||||
UUID randomId = UUID.randomUUID();
|
||||
|
||||
given()
|
||||
.when()
|
||||
.delete("/afterwork/users/" + randomId)
|
||||
.then()
|
||||
.statusCode(404);
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests de validation
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("POST /users/register - Données complètes valides")
|
||||
void testRegisterValidation() {
|
||||
String uniqueEmail = "test_" + System.currentTimeMillis() + "@test.com";
|
||||
|
||||
given()
|
||||
.contentType(ContentType.JSON)
|
||||
.body(String.format("""
|
||||
{
|
||||
"email": "%s",
|
||||
"password": "ValidPassword123!",
|
||||
"firstName": "Test",
|
||||
"lastName": "User",
|
||||
"phone": "+33612345678"
|
||||
}
|
||||
""", uniqueEmail))
|
||||
.when()
|
||||
.post("/afterwork/users/register")
|
||||
.then()
|
||||
.statusCode(anyOf(is(201), is(200), is(409))); // 409 si l'email existe déjà
|
||||
}
|
||||
}
|
||||
113
src/test/java/com/lions/dev/service/MessageServiceTest.java
Normal file
113
src/test/java/com/lions/dev/service/MessageServiceTest.java
Normal file
@@ -0,0 +1,113 @@
|
||||
package com.lions.dev.service;
|
||||
|
||||
import io.quarkus.test.junit.QuarkusTest;
|
||||
import io.quarkus.test.security.TestSecurity;
|
||||
import jakarta.inject.Inject;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Tests unitaires pour MessageService.
|
||||
*
|
||||
* @since 2.0 - Tests production-ready
|
||||
*/
|
||||
@QuarkusTest
|
||||
class MessageServiceTest {
|
||||
|
||||
@Inject
|
||||
MessageService messageService;
|
||||
|
||||
// =========================================================================
|
||||
// Tests de base
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("Service devrait être injecté")
|
||||
void testServiceInjection() {
|
||||
assertNotNull(messageService, "MessageService devrait être injecté");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("getUserConversations devrait retourner une liste vide pour un utilisateur sans conversations")
|
||||
void testGetUserConversationsEmpty() {
|
||||
UUID randomUserId = UUID.randomUUID();
|
||||
|
||||
var conversations = messageService.getUserConversations(randomUserId);
|
||||
|
||||
assertNotNull(conversations, "La liste ne devrait pas être null");
|
||||
assertTrue(conversations.isEmpty(), "La liste devrait être vide pour un nouvel utilisateur");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("getConversation devrait retourner null pour une conversation inexistante")
|
||||
void testGetNonExistentConversation() {
|
||||
UUID randomConvId = UUID.randomUUID();
|
||||
|
||||
var conversation = messageService.getConversation(randomConvId);
|
||||
|
||||
assertNull(conversation, "Devrait retourner null pour une conversation inexistante");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("getConversationMessages devrait retourner une liste vide pour une conversation inexistante")
|
||||
void testGetMessagesForNonExistentConversation() {
|
||||
UUID randomConvId = UUID.randomUUID();
|
||||
|
||||
var messages = messageService.getConversationMessages(randomConvId, 0, 50);
|
||||
|
||||
assertNotNull(messages, "La liste ne devrait pas être null");
|
||||
assertTrue(messages.isEmpty(), "La liste devrait être vide");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("getTotalUnreadCount devrait retourner 0 pour un utilisateur sans messages")
|
||||
void testGetUnreadCountForNewUser() {
|
||||
UUID randomUserId = UUID.randomUUID();
|
||||
|
||||
long count = messageService.getTotalUnreadCount(randomUserId);
|
||||
|
||||
assertEquals(0, count, "Le compte de messages non lus devrait être 0");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("deleteMessage devrait retourner false pour un message inexistant")
|
||||
void testDeleteNonExistentMessage() {
|
||||
UUID randomMessageId = UUID.randomUUID();
|
||||
|
||||
boolean deleted = messageService.deleteMessage(randomMessageId);
|
||||
|
||||
assertFalse(deleted, "Devrait retourner false pour un message inexistant");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("deleteConversation devrait retourner false pour une conversation inexistante")
|
||||
void testDeleteNonExistentConversation() {
|
||||
UUID randomConvId = UUID.randomUUID();
|
||||
|
||||
boolean deleted = messageService.deleteConversation(randomConvId);
|
||||
|
||||
assertFalse(deleted, "Devrait retourner false pour une conversation inexistante");
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests de pagination
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("getConversationMessages devrait respecter les paramètres de pagination")
|
||||
void testMessagesPagination() {
|
||||
UUID randomConvId = UUID.randomUUID();
|
||||
|
||||
// Page 0, size 10
|
||||
var page1 = messageService.getConversationMessages(randomConvId, 0, 10);
|
||||
assertNotNull(page1);
|
||||
|
||||
// Page 1, size 10
|
||||
var page2 = messageService.getConversationMessages(randomConvId, 1, 10);
|
||||
assertNotNull(page2);
|
||||
}
|
||||
}
|
||||
164
src/test/java/com/lions/dev/service/SecurityServiceTest.java
Normal file
164
src/test/java/com/lions/dev/service/SecurityServiceTest.java
Normal file
@@ -0,0 +1,164 @@
|
||||
package com.lions.dev.service;
|
||||
|
||||
import com.lions.dev.security.Permission;
|
||||
import com.lions.dev.security.Role;
|
||||
import com.lions.dev.security.RolePermissionConfig;
|
||||
import io.quarkus.test.junit.QuarkusTest;
|
||||
import io.quarkus.test.security.TestSecurity;
|
||||
import jakarta.inject.Inject;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Tests unitaires pour le SecurityService.
|
||||
* Utilise @TestSecurity pour simuler différents contextes de sécurité.
|
||||
*
|
||||
* @since 2.0 - Tests production-ready
|
||||
*/
|
||||
@QuarkusTest
|
||||
class SecurityServiceTest {
|
||||
|
||||
@Inject
|
||||
SecurityService securityService;
|
||||
|
||||
// =========================================================================
|
||||
// Tests des permissions par rôle
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("Role USER devrait avoir les permissions de base")
|
||||
void testUserRoleHasBasicPermissions() {
|
||||
Set<Permission> userPermissions = RolePermissionConfig.getPermissions(Role.USER);
|
||||
|
||||
// Vérifier les permissions de profil
|
||||
assertTrue(userPermissions.contains(Permission.PROFILE_READ), "USER devrait pouvoir lire son profil");
|
||||
assertTrue(userPermissions.contains(Permission.PROFILE_UPDATE), "USER devrait pouvoir modifier son profil");
|
||||
|
||||
// Vérifier les permissions de lecture
|
||||
assertTrue(userPermissions.contains(Permission.EVENTS_READ), "USER devrait pouvoir lire les événements");
|
||||
assertTrue(userPermissions.contains(Permission.ESTABLISHMENTS_READ), "USER devrait pouvoir lire les établissements");
|
||||
|
||||
// Vérifier les permissions de participation
|
||||
assertTrue(userPermissions.contains(Permission.EVENTS_PARTICIPATE), "USER devrait pouvoir participer aux événements");
|
||||
assertTrue(userPermissions.contains(Permission.RESERVATIONS_CREATE), "USER devrait pouvoir créer des réservations");
|
||||
|
||||
// Vérifier l'absence de permissions admin
|
||||
assertFalse(userPermissions.contains(Permission.SUPER_ADMIN_ACCESS), "USER ne devrait pas avoir accès super admin");
|
||||
assertFalse(userPermissions.contains(Permission.USERS_DELETE_ANY), "USER ne devrait pas pouvoir supprimer d'autres utilisateurs");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Role OWNER devrait avoir les permissions d'établissement")
|
||||
void testOwnerRoleHasEstablishmentPermissions() {
|
||||
Set<Permission> ownerPermissions = RolePermissionConfig.getPermissions(Role.OWNER);
|
||||
|
||||
// Permissions de gestion d'établissement
|
||||
assertTrue(ownerPermissions.contains(Permission.ESTABLISHMENTS_CREATE), "OWNER devrait pouvoir créer un établissement");
|
||||
assertTrue(ownerPermissions.contains(Permission.ESTABLISHMENTS_UPDATE_OWN), "OWNER devrait pouvoir modifier son établissement");
|
||||
assertTrue(ownerPermissions.contains(Permission.ESTABLISHMENTS_DELETE_OWN), "OWNER devrait pouvoir supprimer son établissement");
|
||||
assertTrue(ownerPermissions.contains(Permission.ESTABLISHMENTS_MANAGE_STAFF), "OWNER devrait pouvoir gérer le personnel");
|
||||
assertTrue(ownerPermissions.contains(Permission.ESTABLISHMENTS_VIEW_ANALYTICS), "OWNER devrait voir les analytics");
|
||||
|
||||
// Permissions de promotions
|
||||
assertTrue(ownerPermissions.contains(Permission.PROMOTIONS_CREATE), "OWNER devrait pouvoir créer des promotions");
|
||||
assertTrue(ownerPermissions.contains(Permission.PROMOTIONS_UPDATE_OWN), "OWNER devrait pouvoir modifier ses promotions");
|
||||
assertTrue(ownerPermissions.contains(Permission.PROMOTIONS_DELETE_OWN), "OWNER devrait pouvoir supprimer ses promotions");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Role SUPER_ADMIN devrait avoir toutes les permissions")
|
||||
void testSuperAdminHasAllPermissions() {
|
||||
Set<Permission> superAdminPermissions = RolePermissionConfig.getPermissions(Role.SUPER_ADMIN);
|
||||
|
||||
// SUPER_ADMIN devrait avoir accès à tout
|
||||
assertTrue(superAdminPermissions.contains(Permission.SUPER_ADMIN_ACCESS), "SUPER_ADMIN devrait avoir accès super admin");
|
||||
assertTrue(superAdminPermissions.contains(Permission.USERS_DELETE_ANY), "SUPER_ADMIN devrait pouvoir supprimer tout utilisateur");
|
||||
assertTrue(superAdminPermissions.contains(Permission.EVENTS_DELETE_ANY), "SUPER_ADMIN devrait pouvoir supprimer tout événement");
|
||||
assertTrue(superAdminPermissions.contains(Permission.ESTABLISHMENTS_DELETE_ANY), "SUPER_ADMIN devrait pouvoir supprimer tout établissement");
|
||||
assertTrue(superAdminPermissions.contains(Permission.ADMIN_SETTINGS), "SUPER_ADMIN devrait pouvoir modifier les paramètres système");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Role MODERATOR devrait avoir les permissions de modération")
|
||||
void testModeratorRoleHasModerationPermissions() {
|
||||
Set<Permission> modPermissions = RolePermissionConfig.getPermissions(Role.MODERATOR);
|
||||
|
||||
assertTrue(modPermissions.contains(Permission.MODERATION_VIEW_REPORTS), "MODERATOR devrait voir les signalements");
|
||||
assertTrue(modPermissions.contains(Permission.MODERATION_HANDLE_REPORTS), "MODERATOR devrait traiter les signalements");
|
||||
assertTrue(modPermissions.contains(Permission.MODERATION_HIDE_CONTENT), "MODERATOR devrait pouvoir masquer du contenu");
|
||||
assertTrue(modPermissions.contains(Permission.POSTS_MODERATE), "MODERATOR devrait pouvoir modérer les posts");
|
||||
assertTrue(modPermissions.contains(Permission.REVIEWS_MODERATE), "MODERATOR devrait pouvoir modérer les avis");
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests du contexte de sécurité avec @TestSecurity
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "testuser@test.com", roles = {"USER"})
|
||||
@DisplayName("Utilisateur authentifié avec rôle USER")
|
||||
void testAuthenticatedUserRole() {
|
||||
assertTrue(securityService.hasAnyRole("USER"), "Devrait avoir le rôle USER");
|
||||
assertFalse(securityService.hasAnyRole("ADMIN"), "Ne devrait pas avoir le rôle ADMIN");
|
||||
assertFalse(securityService.hasAnyRole("SUPER_ADMIN"), "Ne devrait pas avoir le rôle SUPER_ADMIN");
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "admin@test.com", roles = {"ADMIN"})
|
||||
@DisplayName("Utilisateur authentifié avec rôle ADMIN")
|
||||
void testAuthenticatedAdminRole() {
|
||||
assertTrue(securityService.hasAnyRole("ADMIN"), "Devrait avoir le rôle ADMIN");
|
||||
assertTrue(securityService.hasAnyRole("USER", "ADMIN"), "Devrait avoir USER ou ADMIN");
|
||||
}
|
||||
|
||||
@Test
|
||||
@TestSecurity(user = "superadmin@test.com", roles = {"SUPER_ADMIN"})
|
||||
@DisplayName("Utilisateur authentifié avec rôle SUPER_ADMIN")
|
||||
void testAuthenticatedSuperAdminRole() {
|
||||
assertTrue(securityService.hasAnyRole("SUPER_ADMIN"), "Devrait avoir le rôle SUPER_ADMIN");
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests des utilitaires de rôle
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("Test conversion String vers Role")
|
||||
void testRoleFromString() {
|
||||
assertEquals(Role.USER, Role.valueOf("USER"));
|
||||
assertEquals(Role.OWNER, Role.valueOf("OWNER"));
|
||||
assertEquals(Role.MANAGER, Role.valueOf("MANAGER"));
|
||||
assertEquals(Role.ADMIN, Role.valueOf("ADMIN"));
|
||||
assertEquals(Role.SUPER_ADMIN, Role.valueOf("SUPER_ADMIN"));
|
||||
assertEquals(Role.MODERATOR, Role.valueOf("MODERATOR"));
|
||||
assertEquals(Role.SUPPORT, Role.valueOf("SUPPORT"));
|
||||
assertEquals(Role.FINANCE, Role.valueOf("FINANCE"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test que chaque rôle a au moins une permission")
|
||||
void testAllRolesHavePermissions() {
|
||||
for (Role role : Role.values()) {
|
||||
Set<Permission> permissions = RolePermissionConfig.getPermissions(role);
|
||||
assertFalse(permissions.isEmpty(), "Le rôle " + role + " devrait avoir au moins une permission");
|
||||
}
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
// Tests des permissions
|
||||
// =========================================================================
|
||||
|
||||
@Test
|
||||
@DisplayName("Test que toutes les permissions ont une description")
|
||||
void testAllPermissionsHaveDescription() {
|
||||
for (Permission permission : Permission.values()) {
|
||||
assertNotNull(permission.getDescription(), "La permission " + permission + " devrait avoir une description");
|
||||
assertFalse(permission.getDescription().isBlank(), "La description de " + permission + " ne devrait pas être vide");
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user