Skip to content

Rubén Ramírez / MangAffinity

Go to a project
Commit 746f958e by Rubén Ramírez
Options

feat: [Test*]: Actualizados test del servicio por contraseñas débiles

parent b003523a
Inline Side-by-side
Showing with 394 additions and 287 deletions
src/test/java/com/ujaen/tfg/mangaffinity/rest/TestBibliotecaPersonalController.java
......@@ -20,8 +20,7 @@ import java.util.HashSet;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.util.MultiValueMap;import java.util.UUID;
@SpringBootTest(classes = {MangAffinityApplication.class, JpaTestConfig.class}, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ActiveProfiles("test")
......@@ -35,31 +34,25 @@ public class TestBibliotecaPersonalController {
@Test
@DirtiesContext
void testAnadirRecursoBiblioteca() {
// Registro de un administrador
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "admin@example.com",
"nombreUsuario", "admin",
"contrasenia", "adminpassword"
), Void.class);
// Inicio sesión con el administrador
// Login con el administrador ya inicializado automáticamente
var authAdmin = restTemplate.postForEntity("/usuarios/admin@example.com", Map.of(
"clave", "adminpassword"
), DTOLoginRespuesta.class);
assertThat(authAdmin.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(authAdmin.getBody()).isNotNull();
String tokenAdmin = "Bearer " + authAdmin.getBody().getToken();
// Registro de un usuario normal
ResponseEntity<Void> respuestaUsuario = restTemplate.postForEntity("/usuarios/", Map.of(
"email", "nuevo.usuario@example.com",
"nombreUsuario", "nuevoUsuario",
"contrasenia", "nuevaPassword"
"contrasenia", "Password123!"
), Void.class);
assertThat(respuestaUsuario.getStatusCode()).isEqualTo(HttpStatus.CREATED);
// Inicio sesión con el usuario
var authUser = restTemplate.postForEntity("/usuarios/nuevo.usuario@example.com", Map.of(
"clave", "nuevaPassword"
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(authUser.getStatusCode()).isEqualTo(HttpStatus.OK);
String tokenUser = "Bearer " + authUser.getBody().getToken();
......@@ -127,29 +120,25 @@ public class TestBibliotecaPersonalController {
@Test
@DirtiesContext
void testListarRecursosPorCategoria() {
// Registro del administrador
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "admin@example.com",
"nombreUsuario", "admin",
"contrasenia", "adminpassword"
), Void.class);
// Login del administrador
// Login con el administrador ya inicializado automáticamente
var authAdmin = restTemplate.postForEntity("/usuarios/admin@example.com", Map.of(
"clave", "adminpassword"
), DTOLoginRespuesta.class);
assertThat(authAdmin.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(authAdmin.getBody()).isNotNull();
String tokenAdmin = "Bearer " + authAdmin.getBody().getToken();
// Registro de usuario
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "usuario@example.com",
"nombreUsuario", "usuario",
"contrasenia", "password"
"contrasenia", "Password123!"
), Void.class);
// Login del usuario
var authUser = restTemplate.postForEntity("/usuarios/usuario@example.com", Map.of(
"clave", "password"
"clave", "Password123!"
), DTOLoginRespuesta.class);
String tokenUser = "Bearer " + authUser.getBody().getToken();
......@@ -204,29 +193,24 @@ public class TestBibliotecaPersonalController {
@Test
@DirtiesContext
void testModificarCategoriaDeRecurso() {
// Registro un administrador
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "admin@example.com",
"nombreUsuario", "admin",
"contrasenia", "adminpassword"
), Void.class);
// Login admin
// Login con el administrador ya inicializado automáticamente
var authAdmin = restTemplate.postForEntity("/usuarios/admin@example.com", Map.of(
"clave", "adminpassword"
), DTOLoginRespuesta.class);
assertThat(authAdmin.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(authAdmin.getBody()).isNotNull();
String tokenAdmin = "Bearer " + authAdmin.getBody().getToken();
// Registro usuario
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "usuario@example.com",
"nombreUsuario", "usuario",
"contrasenia", "password"
"contrasenia", "Password123!"
), Void.class);
// Login usuario
var authUser = restTemplate.postForEntity("/usuarios/usuario@example.com", Map.of(
"clave", "password"
"clave", "Password123!"
), DTOLoginRespuesta.class);
String tokenUser = "Bearer " + authUser.getBody().getToken();
......@@ -291,29 +275,24 @@ public class TestBibliotecaPersonalController {
@Test
@DirtiesContext
void testEliminarRecursoDeBiblioteca() {
// Registro un administrador
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "admin@example.com",
"nombreUsuario", "admin",
"contrasenia", "adminpassword"
), Void.class);
// Inicio sesión con el administrador
// Login con el administrador ya inicializado automáticamente
var authAdmin = restTemplate.postForEntity("/usuarios/admin@example.com", Map.of(
"clave", "adminpassword"
), DTOLoginRespuesta.class);
assertThat(authAdmin.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(authAdmin.getBody()).isNotNull();
String tokenAdmin = "Bearer " + authAdmin.getBody().getToken();
// Registro a un usuario normal
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "usuario@example.com",
"nombreUsuario", "usuario",
"contrasenia", "password"
"contrasenia", "Password123!"
), Void.class);
// Inicio sesión con el usuario
var authUser = restTemplate.postForEntity("/usuarios/usuario@example.com", Map.of(
"clave", "password"
"clave", "Password123!"
), DTOLoginRespuesta.class);
String tokenUser = "Bearer " + authUser.getBody().getToken();
Long usuarioId = restTemplate.getForObject("/usuarios/email/usuario@example.com", Long.class);
......@@ -376,43 +355,73 @@ public class TestBibliotecaPersonalController {
@Test
@DirtiesContext
void testAnadirRecursoAFavoritos() {
// Registro y login
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "usuario@example.com",
"nombreUsuario", "usuario",
"contrasenia", "password"
// Registro de usuario normal
ResponseEntity<Void> registro = restTemplate.postForEntity("/usuarios/", Map.of(
"email", "usuario1@example.com",
"nombreUsuario", "usuario1",
"contrasenia", "Password123!"
), Void.class);
assertThat(registro.getStatusCode()).isEqualTo(HttpStatus.CREATED);
var auth = restTemplate.postForEntity("/usuarios/usuario@example.com", Map.of(
"clave", "password"
// Login del usuario
var auth = restTemplate.postForEntity("/usuarios/usuario1@example.com", Map.of(
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(auth.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(auth.getBody()).isNotNull();
String token = "Bearer " + auth.getBody().getToken();
Long usuarioId = restTemplate.getForObject("/usuarios/email/usuario@example.com", Long.class);
// Crear recurso como admin
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "admin@example.com", "nombreUsuario", "admin", "contrasenia", "adminpassword"
), Void.class);
var authAdmin = restTemplate.postForEntity("/usuarios/admin@example.com", Map.of("clave", "adminpassword"), DTOLoginRespuesta.class);
Long usuarioId = restTemplate.getForObject("/usuarios/email/usuario1@example.com", Long.class);
assertThat(usuarioId).isNotNull();
// Login del administrador (ya creado por el backend con contraseña "adminpassword")
var authAdmin = restTemplate.postForEntity("/usuarios/admin@example.com", Map.of(
"clave", "adminpassword"
), DTOLoginRespuesta.class);
assertThat(authAdmin.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(authAdmin.getBody()).isNotNull();
String tokenAdmin = "Bearer " + authAdmin.getBody().getToken();
DTORecurso dto = new DTORecurso(null, "Favorito Test", "Desc", LocalDate.now(), "Autor", "", new HashSet<>(), 0.0);
// Crear recurso como administrador con título único
String tituloUnico = "Favorito Test " + UUID.randomUUID();
DTORecurso dto = new DTORecurso(
null,
tituloUnico,
"Desc",
LocalDate.now(),
"Autor",
"",
new HashSet<>(),
0.0
);
MultiValueMap<String, Object> formData = new LinkedMultiValueMap<>();
formData.add("recurso", dto);
formData.add("foto", new ByteArrayResource(new byte[0]) {
@Override public String getFilename() { return "foto.jpg"; }
@Override
public String getFilename() {
return "foto.jpg";
}
});
HttpHeaders adminHeaders = new HttpHeaders();
adminHeaders.set("Authorization", tokenAdmin);
adminHeaders.setContentType(MediaType.MULTIPART_FORM_DATA);
restTemplate.exchange("/recursos/", HttpMethod.POST, new HttpEntity<>(formData, adminHeaders), Void.class);
Long recursoId = restTemplate.getForObject("/recursos/titulo/Favorito Test", DTORecurso[].class)[0].getId();
var crearRecurso = restTemplate.exchange("/recursos/", HttpMethod.POST, new HttpEntity<>(formData, adminHeaders), Void.class);
assertThat(crearRecurso.getStatusCode()).isEqualTo(HttpStatus.CREATED);
// Obtener ID del recurso recién creado
DTORecurso[] recursos = restTemplate.getForObject("/recursos/titulo/" + tituloUnico, DTORecurso[].class);
assertThat(recursos).isNotEmpty();
Long recursoId = recursos[0].getId();
assertThat(recursoId).isNotNull();
// Añadir a favoritos
HttpHeaders headers = new HttpHeaders();
headers.set("Authorization", token);
ResponseEntity<Void> respuesta = restTemplate.exchange(
"/biblioteca/{usuarioId}/favoritos/{recursoId}",
HttpMethod.PUT,
......@@ -427,16 +436,78 @@ public class TestBibliotecaPersonalController {
@Test
@DirtiesContext
void testObtenerFavoritos() {
// Configuración previa igual que el anterior
testAnadirRecursoAFavoritos(); // Reutiliza el flujo anterior
// Registro de usuario
ResponseEntity<Void> registro = restTemplate.postForEntity("/usuarios/", Map.of(
"email", "usuario2@example.com",
"nombreUsuario", "usuario2",
"contrasenia", "Password123!"
), Void.class);
assertThat(registro.getStatusCode()).isEqualTo(HttpStatus.CREATED);
var auth = restTemplate.postForEntity("/usuarios/usuario@example.com", Map.of("clave", "password"), DTOLoginRespuesta.class);
// Login del usuario
var auth = restTemplate.postForEntity("/usuarios/usuario2@example.com", Map.of(
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(auth.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(auth.getBody()).isNotNull();
String token = "Bearer " + auth.getBody().getToken();
Long usuarioId = restTemplate.getForObject("/usuarios/email/usuario@example.com", Long.class);
Long usuarioId = restTemplate.getForObject("/usuarios/email/usuario2@example.com", Long.class);
assertThat(usuarioId).isNotNull();
// Login del administrador
var authAdmin = restTemplate.postForEntity("/usuarios/admin@example.com", Map.of(
"clave", "adminpassword"
), DTOLoginRespuesta.class);
assertThat(authAdmin.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(authAdmin.getBody()).isNotNull();
String tokenAdmin = "Bearer " + authAdmin.getBody().getToken();
// Crear recurso con título único
String tituloUnico = "Favorito Test " + UUID.randomUUID();
DTORecurso dto = new DTORecurso(
null,
tituloUnico,
"Descripción de prueba",
LocalDate.now(),
"Autor",
"",
new HashSet<>(),
0.0
);
MultiValueMap<String, Object> formData = new LinkedMultiValueMap<>();
formData.add("recurso", dto);
formData.add("foto", new ByteArrayResource(new byte[0]) {
@Override public String getFilename() { return "foto.jpg"; }
});
HttpHeaders adminHeaders = new HttpHeaders();
adminHeaders.set("Authorization", tokenAdmin);
adminHeaders.setContentType(MediaType.MULTIPART_FORM_DATA);
var crearRecurso = restTemplate.exchange("/recursos/", HttpMethod.POST, new HttpEntity<>(formData, adminHeaders), Void.class);
assertThat(crearRecurso.getStatusCode()).isEqualTo(HttpStatus.CREATED);
// Obtener ID del recurso
DTORecurso[] recursos = restTemplate.getForObject("/recursos/titulo/" + tituloUnico, DTORecurso[].class);
assertThat(recursos).isNotEmpty();
Long recursoId = recursos[0].getId();
// Añadir a favoritos
HttpHeaders headers = new HttpHeaders();
headers.set("Authorization", token);
var respuestaFavorito = restTemplate.exchange(
"/biblioteca/{usuarioId}/favoritos/{recursoId}",
HttpMethod.PUT,
new HttpEntity<>(headers),
Void.class,
usuarioId, recursoId
);
assertThat(respuestaFavorito.getStatusCode()).isEqualTo(HttpStatus.OK);
// Obtener favoritos
ResponseEntity<DTORecurso[]> favoritos = restTemplate.exchange(
"/biblioteca/{usuarioId}/favoritos",
HttpMethod.GET,
......@@ -448,23 +519,83 @@ public class TestBibliotecaPersonalController {
assertThat(favoritos.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(favoritos.getBody()).isNotNull();
assertThat(favoritos.getBody()).hasSize(1);
assertThat(favoritos.getBody()[0].getTitulo()).isEqualTo("Favorito Test");
assertThat(favoritos.getBody()[0].getTitulo()).isEqualTo(tituloUnico);
}
@Test
@DirtiesContext
void testEliminarFavorito() {
// Configuración previa
testAnadirRecursoAFavoritos();
// Registro de usuario
ResponseEntity<Void> registro = restTemplate.postForEntity("/usuarios/", Map.of(
"email", "usuario3@example.com",
"nombreUsuario", "usuario3",
"contrasenia", "Password123!"
), Void.class);
assertThat(registro.getStatusCode()).isEqualTo(HttpStatus.CREATED);
var auth = restTemplate.postForEntity("/usuarios/usuario@example.com", Map.of("clave", "password"), DTOLoginRespuesta.class);
// Login del usuario
var auth = restTemplate.postForEntity("/usuarios/usuario3@example.com", Map.of(
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(auth.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(auth.getBody()).isNotNull();
String token = "Bearer " + auth.getBody().getToken();
Long usuarioId = restTemplate.getForObject("/usuarios/email/usuario@example.com", Long.class);
Long recursoId = restTemplate.getForObject("/recursos/titulo/Favorito Test", DTORecurso[].class)[0].getId();
Long usuarioId = restTemplate.getForObject("/usuarios/email/usuario3@example.com", Long.class);
assertThat(usuarioId).isNotNull();
// Login del administrador
var authAdmin = restTemplate.postForEntity("/usuarios/admin@example.com", Map.of(
"clave", "adminpassword"
), DTOLoginRespuesta.class);
assertThat(authAdmin.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(authAdmin.getBody()).isNotNull();
String tokenAdmin = "Bearer " + authAdmin.getBody().getToken();
// Crear recurso como admin
DTORecurso dto = new DTORecurso(
null,
"Favorito Test",
"Descripción de prueba",
LocalDate.now(),
"Autor",
"",
new HashSet<>(),
0.0
);
MultiValueMap<String, Object> formData = new LinkedMultiValueMap<>();
formData.add("recurso", dto);
formData.add("foto", new ByteArrayResource(new byte[0]) {
@Override public String getFilename() { return "foto.jpg"; }
});
HttpHeaders adminHeaders = new HttpHeaders();
adminHeaders.set("Authorization", tokenAdmin);
adminHeaders.setContentType(MediaType.MULTIPART_FORM_DATA);
var crearRecurso = restTemplate.exchange("/recursos/", HttpMethod.POST, new HttpEntity<>(formData, adminHeaders), Void.class);
assertThat(crearRecurso.getStatusCode()).isEqualTo(HttpStatus.CREATED);
// Obtener ID del recurso
DTORecurso[] recursos = restTemplate.getForObject("/recursos/titulo/Favorito Test", DTORecurso[].class);
assertThat(recursos).isNotEmpty();
Long recursoId = recursos[0].getId();
assertThat(recursoId).isNotNull();
// Añadir a favoritos
HttpHeaders headers = new HttpHeaders();
headers.set("Authorization", token);
var añadirFavorito = restTemplate.exchange(
"/biblioteca/{usuarioId}/favoritos/{recursoId}",
HttpMethod.PUT,
new HttpEntity<>(headers),
Void.class,
usuarioId, recursoId
);
assertThat(añadirFavorito.getStatusCode()).isEqualTo(HttpStatus.OK);
// Eliminar de favoritos
ResponseEntity<Void> respuesta = restTemplate.exchange(
"/biblioteca/{usuarioId}/favoritos/{recursoId}",
HttpMethod.DELETE,
......@@ -472,10 +603,9 @@ public class TestBibliotecaPersonalController {
Void.class,
usuarioId, recursoId
);
assertThat(respuesta.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
// Verifico que ya no está
// Verificar que la lista está vacía
ResponseEntity<DTORecurso[]> favoritos = restTemplate.exchange(
"/biblioteca/{usuarioId}/favoritos",
HttpMethod.GET,
......@@ -483,8 +613,8 @@ public class TestBibliotecaPersonalController {
DTORecurso[].class,
usuarioId
);
assertThat(favoritos.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(favoritos.getBody()).isEmpty();
}
}
src/test/java/com/ujaen/tfg/mangaffinity/rest/TestRecursosController.java
......@@ -1056,7 +1056,7 @@ public class TestRecursosController {
assertThat(rankingResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(rankingResponse.getBody()).isNotEmpty();
assertThat(rankingResponse.getBody().length).isEqualTo(8); // Ahora deberían devolver 8 recursos
assertThat(rankingResponse.getBody().length).isEqualTo(8);
for (DTORecurso recurso : rankingResponse.getBody()) {
assertThat(recurso).isNotNull();
......@@ -1155,6 +1155,4 @@ public class TestRecursosController {
assertThat(respuesta404Recurso.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
}
}
src/test/java/com/ujaen/tfg/mangaffinity/rest/TestSeguimientoController.java
......@@ -32,18 +32,18 @@ public class TestSeguimientoController {
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "seguidor@example.com",
"nombreUsuario", "seguidor",
"contrasenia", "clave123"
"contrasenia", "Password123!"
), Void.class);
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "seguido@example.com",
"nombreUsuario", "seguido",
"contrasenia", "clave456"
"contrasenia", "Password123!"
), Void.class);
// Inicio de sesión con el seguidor
var authResponse = restTemplate.postForEntity("/usuarios/seguidor@example.com", Map.of(
"clave", "clave123"
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(authResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
String token = authResponse.getBody().getToken();
......@@ -72,7 +72,7 @@ public class TestSeguimientoController {
);
assertThat(noExiste.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
// Cabecera con nombre vacío → NOT_FOUND (por IllegalArgumentException)
// Cabecera con nombre vacío
headers.set("nombreUsuario", " ");
var vacioRequest = new HttpEntity<>(headers);
var vacioResponse = restTemplate.exchange(
......@@ -86,20 +86,20 @@ public class TestSeguimientoController {
void testDejarDeSeguirUsuario() {
// Registro de los usuarios: seguidor y seguido
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "seguidor@example.com",
"nombreUsuario", "seguidor",
"contrasenia", "clave123"
"email", "seguidor1@example.com",
"nombreUsuario", "seguidor1",
"contrasenia", "Password123!"
), Void.class);
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "seguido@example.com",
"nombreUsuario", "seguido",
"contrasenia", "clave456"
"email", "seguido1@example.com",
"nombreUsuario", "seguido1",
"contrasenia", "Password123!"
), Void.class);
// Inicio de sesión con el seguidor
var authResponse = restTemplate.postForEntity("/usuarios/seguidor@example.com", Map.of(
"clave", "clave123"
var authResponse = restTemplate.postForEntity("/usuarios/seguidor1@example.com", Map.of(
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(authResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
String token = authResponse.getBody().getToken();
......@@ -107,29 +107,29 @@ public class TestSeguimientoController {
// Cabeceras con el nombre del seguidor
HttpHeaders headers = new HttpHeaders();
headers.setBearerAuth(token);
headers.set("nombreUsuario", "seguidor");
headers.set("nombreUsuario", "seguidor1");
HttpEntity<Void> request = new HttpEntity<>(headers);
// Primero seguir al usuario para luego poder dejar de seguirlo
var seguirResponse = restTemplate.exchange(
"/seguimientos/seguido", HttpMethod.POST, request, Void.class
"/seguimientos/seguido1", HttpMethod.POST, request, Void.class
);
assertThat(seguirResponse.getStatusCode()).isEqualTo(HttpStatus.CREATED);
// Dejar de seguir correctamente
var dejarResponse = restTemplate.exchange(
"/seguimientos/seguido", HttpMethod.DELETE, request, Void.class
"/seguimientos/seguido1", HttpMethod.DELETE, request, Void.class
);
assertThat(dejarResponse.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
// Intentar dejar de seguir otra vez → ya no hay seguimiento → NOT_FOUND
// Intentar dejar de seguir otra vez
var yaNoSigueResponse = restTemplate.exchange(
"/seguimientos/seguido", HttpMethod.DELETE, request, Void.class
"/seguimientos/seguido1", HttpMethod.DELETE, request, Void.class
);
assertThat(yaNoSigueResponse.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
// Intentar dejar de seguir a un usuario que no existe → NOT_FOUND
// Intentar dejar de seguir a un usuario que no existe
var inexistenteResponse = restTemplate.exchange(
"/seguimientos/noexiste", HttpMethod.DELETE, request, Void.class
);
......@@ -141,20 +141,20 @@ public class TestSeguimientoController {
void testObtenerSeguidos() {
// Registro de dos usuarios: seguidor y seguido
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "seguidor@example.com",
"nombreUsuario", "seguidor",
"contrasenia", "clave123"
"email", "seguidor2@example.com",
"nombreUsuario", "seguidor2",
"contrasenia", "Password123!"
), Void.class);
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "seguido@example.com",
"nombreUsuario", "seguido",
"contrasenia", "clave456"
"email", "seguido2@example.com",
"nombreUsuario", "seguido2",
"contrasenia", "Password123!"
), Void.class);
// Inicio de sesión del seguidor
var authResponse = restTemplate.postForEntity("/usuarios/seguidor@example.com", Map.of(
"clave", "clave123"
var authResponse = restTemplate.postForEntity("/usuarios/seguidor2@example.com", Map.of(
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(authResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
String token = authResponse.getBody().getToken();
......@@ -162,34 +162,34 @@ public class TestSeguimientoController {
// Cabeceras con token y nombreUsuario
HttpHeaders headers = new HttpHeaders();
headers.setBearerAuth(token);
headers.set("nombreUsuario", "seguidor");
headers.set("nombreUsuario", "seguidor2");
HttpEntity<Void> request = new HttpEntity<>(headers);
// Seguir al usuario
var seguirResponse = restTemplate.exchange(
"/seguimientos/seguido", HttpMethod.POST, request, Void.class
"/seguimientos/seguido2", HttpMethod.POST, request, Void.class
);
assertThat(seguirResponse.getStatusCode()).isEqualTo(HttpStatus.CREATED);
// Obtener seguidos del usuario seguidor
ResponseEntity<DTOUsuario[]> seguidosResponse = restTemplate.exchange(
"/seguimientos/seguidos/seguidor", HttpMethod.GET, request, DTOUsuario[].class
"/seguimientos/seguidos/seguidor2", HttpMethod.GET, request, DTOUsuario[].class
);
assertThat(seguidosResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(seguidosResponse.getBody()).isNotNull();
assertThat(seguidosResponse.getBody().length).isEqualTo(1);
assertThat(seguidosResponse.getBody()[0].getNombreUsuario()).isEqualTo("seguido");
assertThat(seguidosResponse.getBody()[0].getNombreUsuario()).isEqualTo("seguido2");
// Registro de un usuario que no sigue a nadie
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "nuevo@example.com",
"nombreUsuario", "nuevo",
"contrasenia", "clave789"
"contrasenia", "Password123!"
), Void.class);
// Inicio de sesión para "nuevo"
// Inicio de sesión para nuevo
var nuevoLogin = restTemplate.postForEntity("/usuarios/nuevo@example.com", Map.of(
"clave", "clave789"
"clave", "Password123!"
), DTOLoginRespuesta.class);
String nuevoToken = nuevoLogin.getBody().getToken();
......@@ -197,7 +197,7 @@ public class TestSeguimientoController {
nuevoHeaders.setBearerAuth(nuevoToken);
HttpEntity<Void> nuevoRequest = new HttpEntity<>(nuevoHeaders);
// El usuario "nuevo" no sigue a nadie
// El usuario nuevo no sigue a nadie
var vacioResponse = restTemplate.exchange(
"/seguimientos/seguidos/nuevo", HttpMethod.GET, nuevoRequest, DTOUsuario[].class
);
......@@ -216,20 +216,20 @@ public class TestSeguimientoController {
void testObtenerSeguidores() {
// Registro de dos usuarios: seguidor y seguido
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "seguidor@example.com",
"nombreUsuario", "seguidor",
"contrasenia", "clave123"
"email", "seguidor3@example.com",
"nombreUsuario", "seguidor3",
"contrasenia", "Password123!"
), Void.class);
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "seguido@example.com",
"nombreUsuario", "seguido",
"contrasenia", "clave456"
"email", "seguido3@example.com",
"nombreUsuario", "seguido3",
"contrasenia", "Password123!"
), Void.class);
// Inicio de sesión con el seguidor
var authResponse = restTemplate.postForEntity("/usuarios/seguidor@example.com", Map.of(
"clave", "clave123"
var authResponse = restTemplate.postForEntity("/usuarios/seguidor3@example.com", Map.of(
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(authResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
String token = authResponse.getBody().getToken();
......@@ -237,34 +237,34 @@ public class TestSeguimientoController {
// Cabeceras con token y nombreUsuario
HttpHeaders headers = new HttpHeaders();
headers.setBearerAuth(token);
headers.set("nombreUsuario", "seguidor");
headers.set("nombreUsuario", "seguidor3");
HttpEntity<Void> request = new HttpEntity<>(headers);
// El seguidor sigue al seguido
var seguirResponse = restTemplate.exchange(
"/seguimientos/seguido", HttpMethod.POST, request, Void.class
"/seguimientos/seguido3", HttpMethod.POST, request, Void.class
);
assertThat(seguirResponse.getStatusCode()).isEqualTo(HttpStatus.CREATED);
// Obtener los seguidores de "seguido"
// Obtener los seguidores de seguido
var seguidoresResponse = restTemplate.exchange(
"/seguimientos/seguidores/seguido", HttpMethod.GET, request, DTOUsuario[].class
"/seguimientos/seguidores/seguido3", HttpMethod.GET, request, DTOUsuario[].class
);
assertThat(seguidoresResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(seguidoresResponse.getBody()).isNotNull();
assertThat(seguidoresResponse.getBody().length).isEqualTo(1);
assertThat(seguidoresResponse.getBody()[0].getNombreUsuario()).isEqualTo("seguidor");
assertThat(seguidoresResponse.getBody()[0].getNombreUsuario()).isEqualTo("seguidor3");
// Usuario que no tiene seguidores
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "nuevo@example.com",
"nombreUsuario", "nuevo",
"contrasenia", "clave789"
"email", "nuevo3@example.com",
"nombreUsuario", "nuevo3",
"contrasenia", "Password123!"
), Void.class);
// Inicio de sesión de "nuevo"
var nuevoLogin = restTemplate.postForEntity("/usuarios/nuevo@example.com", Map.of(
"clave", "clave789"
// Inicio de sesión de nuevo
var nuevoLogin = restTemplate.postForEntity("/usuarios/nuevo3@example.com", Map.of(
"clave", "Password123!"
), DTOLoginRespuesta.class);
String nuevoToken = nuevoLogin.getBody().getToken();
......@@ -272,9 +272,9 @@ public class TestSeguimientoController {
nuevoHeaders.setBearerAuth(nuevoToken);
HttpEntity<Void> nuevoRequest = new HttpEntity<>(nuevoHeaders);
// Obtener seguidores del usuario "nuevo"
// Obtener seguidores del usuario nuevo
var vacioResponse = restTemplate.exchange(
"/seguimientos/seguidores/nuevo", HttpMethod.GET, nuevoRequest, DTOUsuario[].class
"/seguimientos/seguidores/nuevo3", HttpMethod.GET, nuevoRequest, DTOUsuario[].class
);
assertThat(vacioResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(vacioResponse.getBody()).isEmpty();
......@@ -291,20 +291,20 @@ public class TestSeguimientoController {
void testEstaSiguiendo() {
// Registro de dos usuarios: seguidor y seguido
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "seguidor@example.com",
"nombreUsuario", "seguidor",
"contrasenia", "clave123"
"email", "seguidor4@example.com",
"nombreUsuario", "seguidor4",
"contrasenia", "Password123!"
), Void.class);
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "seguido@example.com",
"nombreUsuario", "seguido",
"contrasenia", "clave456"
"email", "seguido4@example.com",
"nombreUsuario", "seguido4",
"contrasenia", "Password123!"
), Void.class);
// Inicio de sesión con el seguidor
var authResponse = restTemplate.postForEntity("/usuarios/seguidor@example.com", Map.of(
"clave", "clave123"
var authResponse = restTemplate.postForEntity("/usuarios/seguidor4@example.com", Map.of(
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(authResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
String token = authResponse.getBody().getToken();
......@@ -312,19 +312,20 @@ public class TestSeguimientoController {
// Cabeceras con token y nombreUsuario
HttpHeaders headers = new HttpHeaders();
headers.setBearerAuth(token);
headers.set("nombreUsuario", "seguidor");
headers.set("nombreUsuario", "seguidor4");
HttpEntity<Void> request = new HttpEntity<>(headers);
// Seguidor sigue a seguido
var seguirResponse = restTemplate.exchange(
"/seguimientos/seguido", HttpMethod.POST, request, Void.class
"/seguimientos/seguido4", HttpMethod.POST, request, Void.class
);
assertThat(seguirResponse.getStatusCode()).isEqualTo(HttpStatus.CREATED);
// Verifico que seguidor sigue a seguido → true
// Verifico que seguidor sigue a seguido
var seguirSi = restTemplate.exchange(
"/seguimientos/existe?seguidor=seguidor&seguido=seguido", HttpMethod.GET, request, Boolean.class
"/seguimientos/existe?seguidor=seguidor4&seguido=seguido4", HttpMethod.GET, request, Boolean.class
);
assertThat(seguirSi.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(seguirSi.getBody()).isTrue();
......@@ -332,12 +333,12 @@ public class TestSeguimientoController {
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "otro@example.com",
"nombreUsuario", "otro",
"contrasenia", "clave789"
"contrasenia", "Password123!"
), Void.class);
// Inicio de sesión de "otro"
// Inicio de sesión de otro
var otroLogin = restTemplate.postForEntity("/usuarios/otro@example.com", Map.of(
"clave", "clave789"
"clave", "Password123!"
), DTOLoginRespuesta.class);
String otroToken = otroLogin.getBody().getToken();
......@@ -345,19 +346,18 @@ public class TestSeguimientoController {
otroHeaders.setBearerAuth(otroToken);
HttpEntity<Void> otroRequest = new HttpEntity<>(otroHeaders);
// "otro" no sigue a nadie → false
// "otro" no sigue a nadie
var seguirNo = restTemplate.exchange(
"/seguimientos/existe?seguidor=otro&seguido=seguido", HttpMethod.GET, otroRequest, Boolean.class
"/seguimientos/existe?seguidor=otro&seguido=seguido4", HttpMethod.GET, otroRequest, Boolean.class
);
assertThat(seguirNo.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(seguirNo.getBody()).isFalse();
// Usuario inexistente → NOT_FOUND
// Usuario inexistente
var inexistente = restTemplate.exchange(
"/seguimientos/existe?seguidor=inexistente&seguido=seguido", HttpMethod.GET, request, Void.class
"/seguimientos/existe?seguidor=inexistente&seguido=seguido4", HttpMethod.GET, request, Void.class
);
assertThat(inexistente.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
}
}
src/test/java/com/ujaen/tfg/mangaffinity/rest/TestUsuariosController.java
......@@ -18,6 +18,7 @@ import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.http.*;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ActiveProfiles;
......@@ -44,6 +45,8 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
@SpringBootTest(classes = {MangAffinityApplication.class, JpaTestConfig.class}, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
......@@ -80,7 +83,7 @@ public class TestUsuariosController {
usuarioInvalido,
String.class
);
Assertions.assertThat(respuestaInvalida.getStatusCode()).isEqualTo(HttpStatus.UNPROCESSABLE_ENTITY);
Assertions.assertThat(respuestaInvalida.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
// Usuario con contraseña débil (menos de 8 caracteres, sin mayúsculas, números ni símbolos)
var usuarioContraseniaDebil = new DTOUsuario(null, "roberto@gmail.com", "Roberto", "debile");
......@@ -115,21 +118,25 @@ public class TestUsuariosController {
@Test
@DirtiesContext
void testIniciarSesion() {
// Registro de un usuario válido
var usuarioValido = new DTOUsuario(null, "pedra@gmail.com", "Pedra", "pedrita");
ResponseEntity<DTOUsuario> respuestaRegistro = restTemplateUsuarios.postForEntity(
// Registro de un usuario válido con contraseña fuerte
var usuarioValido = new DTOUsuario(null, "pedra@gmail.com", "Pedra", "Pedrita123!");
ResponseEntity<DTOLoginRespuesta> respuestaRegistro = restTemplateUsuarios.postForEntity(
"/",
usuarioValido,
DTOUsuario.class
DTOLoginRespuesta.class
);
Assertions.assertThat(respuestaRegistro.getStatusCode()).isEqualTo(HttpStatus.CREATED);
Assertions.assertThat(respuestaRegistro.getBody()).isNotNull();
// Intento iniciar sesión con un usuario que no existe
var emailInexistente = "noexiste@example.com";
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
var requestInexistente = new HttpEntity<>(Map.of("clave", "password123"), headers);
// Intento de login con email inexistente
String emailInexistente = "noexiste@example.com";
HttpEntity<Map<String, String>> requestInexistente = new HttpEntity<>(
Map.of("clave", "password123"),
headers
);
ResponseEntity<Void> respuestaInexistente = restTemplateUsuarios.postForEntity(
"/{email}",
requestInexistente,
......@@ -138,28 +145,33 @@ public class TestUsuariosController {
);
Assertions.assertThat(respuestaInexistente.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
// Intento iniciar sesión con una contraseña incorrecta
var requestIncorrecto = new HttpEntity<>(Map.of("clave", "incorrecta"), headers);
// Intento de login con contraseña incorrecta
HttpEntity<Map<String, String>> requestIncorrecta = new HttpEntity<>(
Map.of("clave", "contraseñaIncorrecta"),
headers
);
ResponseEntity<Void> respuestaIncorrecta = restTemplateUsuarios.postForEntity(
"/{email}",
requestIncorrecto,
requestIncorrecta,
Void.class,
usuarioValido.getEmail()
);
Assertions.assertThat(respuestaIncorrecta.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
// Inicio de sesión exitoso
var requestValido = new HttpEntity<>(Map.of("clave", "pedrita"), headers);
// Login exitoso
HttpEntity<Map<String, String>> requestValida = new HttpEntity<>(
Map.of("clave", "Pedrita123!"),
headers
);
ResponseEntity<DTOLoginRespuesta> respuestaValida = restTemplateUsuarios.postForEntity(
"/{email}",
requestValido,
requestValida,
DTOLoginRespuesta.class,
usuarioValido.getEmail()
);
Assertions.assertThat(respuestaValida.getStatusCode()).isEqualTo(HttpStatus.OK);
Assertions.assertThat(respuestaValida.getBody()).isNotNull();
Assertions.assertThat(respuestaValida.getBody().getToken()).isNotEmpty();
Assertions.assertThat(respuestaValida.getBody().getToken()).isNotBlank();
}
@Test
......@@ -169,13 +181,13 @@ public class TestUsuariosController {
ResponseEntity<Void> respuestaRegistro = restTemplate.postForEntity("/usuarios/", Map.of(
"email", "usuario@example.com",
"nombreUsuario", "usuarioTest",
"contrasenia", "password"
"contrasenia", "Password123!"
), Void.class);
assertThat(respuestaRegistro.getStatusCode()).isEqualTo(HttpStatus.CREATED);
// Inicio sesión
var authResponse = restTemplate.postForEntity("/usuarios/usuario@example.com", Map.of(
"clave", "password"
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(authResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
String token = "Bearer " + authResponse.getBody().getToken();
......@@ -217,7 +229,7 @@ public class TestUsuariosController {
ResponseEntity<Void> respuestaRegistro = restTemplate.postForEntity("/usuarios/", Map.of(
"email", "nuevo.usuario@example.com",
"nombreUsuario", "nuevoUsuarioTest",
"contrasenia", "nuevaPassword"
"contrasenia", "Password123!"
), Void.class);
assertThat(respuestaRegistro.getStatusCode()).isEqualTo(HttpStatus.CREATED);
......@@ -358,35 +370,48 @@ public class TestUsuariosController {
var authAdmin = restTemplate.postForEntity("/usuarios/admin@example.com", Map.of(
"clave", "adminpassword"
), DTOLoginRespuesta.class);
assertThat(authAdmin.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(authAdmin.getBody()).isNotNull();
String tokenAdmin = "Bearer " + authAdmin.getBody().getToken();
// 3. Registro usuario normal
String emailUsuario = "user" + UUID.randomUUID() + "@test.com";
String nombreUsuario = "usuarioTest" + UUID.randomUUID().toString().substring(0, 5);
restTemplate.postForEntity("/usuarios/", Map.of(
"email", "user@test.com",
"nombreUsuario", "userTest",
"contrasenia", "testpass"
"email", emailUsuario,
"nombreUsuario", nombreUsuario,
"contrasenia", "Password123!"
), Void.class);
// 4. Login usuario
var authUser = restTemplate.postForEntity("/usuarios/user@test.com", Map.of(
"clave", "testpass"
var authUser = restTemplate.postForEntity("/usuarios/" + emailUsuario, Map.of(
"clave", "Password123!"
), DTOLoginRespuesta.class);
assertThat(authUser.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(authUser.getBody()).isNotNull();
String tokenUser = "Bearer " + authUser.getBody().getToken();
// 5. Obtener ID del usuario
Long usuarioId = restTemplate.getForObject("/usuarios/email/user@test.com", Long.class);
Long usuarioId = restTemplate.getForObject("/usuarios/email/" + emailUsuario, Long.class);
assertThat(usuarioId).isNotNull();
// 6. Crear 2 recursos: uno favorito y uno similar
String tituloFavorito = "Favorito " + UUID.randomUUID();
String tituloSugerido = "Sugerido " + UUID.randomUUID();
DTORecurso dtoFavorito = new DTORecurso(null, tituloFavorito, "desc",
LocalDate.of(2025, 5, 29), "Autor1", null, Set.of(Genero.ACCION), 0.0);
DTORecurso dtoSugerido = new DTORecurso(null, tituloSugerido, "desc",
LocalDate.of(2025, 5, 29), "Autor1", null, Set.of(Genero.AVENTURA, Genero.ACCION), 0.0);
MultiValueMap<String, Object> formData1 = new LinkedMultiValueMap<>();
DTORecurso dtoFavorito = new DTORecurso(null, "Favorito", "desc", LocalDate.now(), "Autor1", null, Set.of(Genero.ACCION), 0.0);
formData1.add("recurso", dtoFavorito);
formData1.add("foto", new ByteArrayResource(new byte[0]) {
@Override public String getFilename() { return "foto.jpg"; }
});
MultiValueMap<String, Object> formData2 = new LinkedMultiValueMap<>();
DTORecurso dtoSugerido = new DTORecurso(null, "Sugerido", "desc", LocalDate.now(), "Autor1", null, Set.of(Genero.AVENTURA, Genero.ACCION), 0.0);
formData2.add("recurso", dtoSugerido);
formData2.add("foto", new ByteArrayResource(new byte[0]) {
@Override public String getFilename() { return "foto2.jpg"; }
......@@ -400,8 +425,8 @@ public class TestUsuariosController {
restTemplate.exchange("/recursos/", HttpMethod.POST, new HttpEntity<>(formData2, headersAdmin), Void.class);
// 7. Obtener ID de ambos recursos
DTORecurso[] recursosFavorito = restTemplate.getForObject("/recursos/titulo/Favorito", DTORecurso[].class);
DTORecurso[] recursosSugerido = restTemplate.getForObject("/recursos/titulo/Sugerido", DTORecurso[].class);
DTORecurso[] recursosFavorito = restTemplate.getForObject("/recursos/titulo/" + tituloFavorito, DTORecurso[].class);
DTORecurso[] recursosSugerido = restTemplate.getForObject("/recursos/titulo/" + tituloSugerido, DTORecurso[].class);
assertThat(recursosFavorito).isNotNull().isNotEmpty();
assertThat(recursosSugerido).isNotNull().isNotEmpty();
Long favoritoId = recursosFavorito[0].getId();
......@@ -441,18 +466,19 @@ public class TestUsuariosController {
@DirtiesContext
void testActualizarPerfilUsuario() {
// Registrar usuario
DTOUsuario nuevo = new DTOUsuario(null, "perfil@user.com", "PerfilUser", "clave123");
DTOUsuario nuevo = new DTOUsuario(null, "perfil@user.com", "PerfilUser", "Clave123!");
ResponseEntity<Void> registro = restTemplateUsuarios.postForEntity("/", nuevo, Void.class);
assertThat(registro.getStatusCode()).isEqualTo(HttpStatus.CREATED);
// Login para obtener token
ResponseEntity<DTOLoginRespuesta> login = restTemplateUsuarios.postForEntity(
"/{email}",
new HttpEntity<>(Map.of("clave", "clave123")),
new HttpEntity<>(Map.of("clave", "Clave123!")),
DTOLoginRespuesta.class,
nuevo.getEmail()
);
assertThat(login.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(login.getBody()).isNotNull();
String token = login.getBody().getToken();
// Obtener ID
......@@ -472,7 +498,6 @@ public class TestUsuariosController {
HttpEntity<DTOUsuario> requestEntity = new HttpEntity<>(dto, headers);
// PUT
ResponseEntity<Void> respuesta = restTemplateUsuarios.exchange(
"/{id}/perfil", HttpMethod.PUT, requestEntity, Void.class, usuarioId
);
......@@ -483,83 +508,37 @@ public class TestUsuariosController {
@DirtiesContext
void testObtenerUsuarioPorId() {
// Crear y registrar usuario
DTOUsuario dto = new DTOUsuario(null, "ver@user.com", "VerUsuario", "clave123");
DTOUsuario dto = new DTOUsuario(null, "ver@user.com", "VerUsuario", "Clave123!");
restTemplateUsuarios.postForEntity("/", dto, Void.class);
// Login
// Login con misma contraseña
ResponseEntity<DTOLoginRespuesta> login = restTemplateUsuarios.postForEntity(
"/{email}",
new HttpEntity<>(Map.of("clave", "clave123")),
new HttpEntity<>(Map.of("clave", "Clave123!")),
DTOLoginRespuesta.class,
dto.getEmail()
);
assertThat(login.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(login.getBody()).isNotNull();
String token = login.getBody().getToken();
// Obtener ID
Long usuarioId = restTemplate.getForObject("/usuarios/email/{email}", Long.class, dto.getEmail());
assertThat(usuarioId).isNotNull();
HttpHeaders headers = new HttpHeaders();
headers.setBearerAuth(token);
HttpEntity<Void> request = new HttpEntity<>(headers);
// GET
// GET con token
ResponseEntity<DTOUsuario> respuesta = restTemplateUsuarios.exchange(
"/{id}", HttpMethod.GET, request, DTOUsuario.class, usuarioId
);
assertThat(respuesta.getStatusCode()).isEqualTo(HttpStatus.OK);
DTOUsuario usuario = respuesta.getBody();
assertThat(usuario).isNotNull();
assertThat(usuario.getEmail()).isNull(); // porque no se devuelve en el DTO
assertThat(usuario.getNombreUsuario()).isEqualTo("VerUsuario");
}
@Test
@DirtiesContext
void testFiltrarUsuariosPorNombre() {
// Registrar usuarios
restTemplateUsuarios.postForEntity("/", new DTOUsuario(null, "ana1@test.com", "Ana", "clave"), Void.class);
restTemplateUsuarios.postForEntity("/", new DTOUsuario(null, "anabel@test.com", "Anabel", "clave"), Void.class);
restTemplateUsuarios.postForEntity("/", new DTOUsuario(null, "otro@test.com", "Pedro", "clave"), Void.class);
// Hacer login con uno de ellos
HttpEntity<Map<String, String>> loginRequest = new HttpEntity<>(Map.of("clave", "clave"));
ResponseEntity<DTOLoginRespuesta> loginResponse = restTemplateUsuarios.postForEntity(
"/{email}", loginRequest, DTOLoginRespuesta.class, "ana1@test.com"
);
assertThat(loginResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
String token = loginResponse.getBody().getToken();
HttpHeaders headers = new HttpHeaders();
headers.setBearerAuth(token);
HttpEntity<Void> request = new HttpEntity<>(headers);
// --- Caso 1: Coincidencias ---
ResponseEntity<DTOUsuario[]> respuesta = restTemplateUsuarios.exchange(
"/?nombre=Ana", HttpMethod.GET, request, DTOUsuario[].class
);
assertThat(respuesta.getStatusCode()).isEqualTo(HttpStatus.OK);
DTOUsuario[] usuarios = respuesta.getBody();
assertThat(usuarios).isNotNull();
assertThat(usuarios.length).isEqualTo(2);
List<String> nombres = Arrays.stream(usuarios).map(DTOUsuario::getNombreUsuario).toList();
assertThat(nombres).containsExactlyInAnyOrder("Ana", "Anabel");
// --- Caso 2: Sin coincidencias ---
ResponseEntity<Void> sinCoincidencias = restTemplateUsuarios.exchange(
"/?nombre=XYZ", HttpMethod.GET, request, Void.class
);
assertThat(sinCoincidencias.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
// --- Caso 3: Sin parámetro ---
ResponseEntity<DTOUsuario[]> respuestaGenerica = restTemplateUsuarios.exchange(
"/", HttpMethod.GET, request, DTOUsuario[].class
);
assertThat(respuestaGenerica.getStatusCode()).isEqualTo(HttpStatus.OK);
DTOUsuario[] genericos = respuestaGenerica.getBody();
assertThat(genericos).isNotNull();
assertThat(genericos.length).isLessThanOrEqualTo(10);
}
}
src/test/java/com/ujaen/tfg/mangaffinity/servicios/TestServicioBibliotecaPersonal.java
......@@ -12,13 +12,11 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ActiveProfiles;
import java.time.LocalDate;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
import static org.junit.jupiter.api.Assertions.assertThrows;
@SpringBootTest(classes = {MangAffinityApplication.class, JpaTestConfig.class})
@ActiveProfiles("test")
......@@ -38,7 +36,7 @@ public class TestServicioBibliotecaPersonal {
@DirtiesContext
void testAnadirRecursoBiblioteca() {
// Creo un usuario
Usuario usuario = new Usuario("test@email.com", "usuarioTest", "password123");
Usuario usuario = new Usuario("test@email.com", "usuarioTest", "Password123!");
servicioUsuarios.crearUsuario(usuario);
BibliotecaPersonal bibliotecaPersonal = usuario.getBibliotecaPersonal();
......@@ -80,7 +78,7 @@ public class TestServicioBibliotecaPersonal {
@DirtiesContext
void testListarRecursosPorCategoria() {
// Creo un usuario con su biblioteca personal
Usuario usuario = new Usuario("otro@email.com", "usuarioOtro", "claveSegura");
Usuario usuario = new Usuario("otro@email.com", "usuarioOtro", "Password123!");
servicioUsuarios.crearUsuario(usuario);
BibliotecaPersonal bibliotecaPersonal = usuario.getBibliotecaPersonal();
......@@ -109,7 +107,7 @@ public class TestServicioBibliotecaPersonal {
@DirtiesContext
void testEliminarRecursoDeBiblioteca() {
// Creo un usuario y su biblioteca
Usuario usuario = new Usuario("nuevo.usuario@email.com", "nuevoUsuarioTest", "nuevaPassword123");
Usuario usuario = new Usuario("nuevo.usuario@email.com", "nuevoUsuarioTest", "Password123!");
servicioUsuarios.crearUsuario(usuario);
BibliotecaPersonal bibliotecaPersonal = usuario.getBibliotecaPersonal();
......@@ -132,7 +130,7 @@ public class TestServicioBibliotecaPersonal {
List<BibliotecaPersonalRecurso> recursosDespues = servicioBibliotecaPersonal.listarPorCategoria(bibliotecaPersonal.getId(), Categoria.AL_DIA);
assertThat(recursosDespues).isEmpty();
// Intento eliminarlo otra vez (debería lanzar excepción)
// Intento eliminarlo otra vez
assertThatThrownBy(() ->
servicioBibliotecaPersonal.eliminarRecursoDeBiblioteca(bibliotecaPersonal.getId(), recursoGuardado.getId())
).isInstanceOf(RecursoNoExiste.class);
......@@ -142,7 +140,7 @@ public class TestServicioBibliotecaPersonal {
@DirtiesContext
void testModificarCategoriaDeRecurso() {
// Creo usuario y biblioteca
Usuario usuario = new Usuario("usuario2@email.com", "usuarioMod", "securepass");
Usuario usuario = new Usuario("usuario2@email.com", "usuarioMod", "Password123!");
servicioUsuarios.crearUsuario(usuario);
BibliotecaPersonal bibliotecaPersonal = usuario.getBibliotecaPersonal();
......@@ -180,7 +178,7 @@ public class TestServicioBibliotecaPersonal {
@DirtiesContext
void testBuscarRecursoEnBiblioteca() {
// Creo un usuario y su biblioteca
Usuario usuario = new Usuario("buscar@email.com", "usuarioBuscar", "clave");
Usuario usuario = new Usuario("buscar@email.com", "usuarioBuscar", "Password123!");
servicioUsuarios.crearUsuario(usuario);
BibliotecaPersonal biblioteca = usuario.getBibliotecaPersonal();
......@@ -206,7 +204,7 @@ public class TestServicioBibliotecaPersonal {
@DirtiesContext
void testAnadirFavorito() {
// Creo usuario y recurso
Usuario usuario = new Usuario("fav@correo.com", "usuarioFav", "claveFav");
Usuario usuario = new Usuario("fav@correo.com", "usuarioFav", "Password123!");
servicioUsuarios.crearUsuario(usuario);
BibliotecaPersonal biblioteca = usuario.getBibliotecaPersonal();
......@@ -225,7 +223,7 @@ public class TestServicioBibliotecaPersonal {
@DirtiesContext
void testEliminarFavorito() {
// Setup
Usuario usuario = new Usuario("quitar@correo.com", "usuarioQ", "claveQ");
Usuario usuario = new Usuario("quitar@correo.com", "usuarioQ", "Password123!");
servicioUsuarios.crearUsuario(usuario);
BibliotecaPersonal biblioteca = usuario.getBibliotecaPersonal();
......@@ -244,7 +242,7 @@ public class TestServicioBibliotecaPersonal {
@Test
@DirtiesContext
void testObtenerFavoritos() {
Usuario usuario = new Usuario("ver@correo.com", "usuarioVer", "claveVer");
Usuario usuario = new Usuario("ver@correo.com", "usuarioVer", "Password123!");
servicioUsuarios.crearUsuario(usuario);
BibliotecaPersonal biblioteca = usuario.getBibliotecaPersonal();
......
src/test/java/com/ujaen/tfg/mangaffinity/servicios/TestServicioRecursos.java
......@@ -334,11 +334,11 @@ public class TestServicioRecursos {
assertThat(capitulos.get(1).getNumero()).isEqualTo(2);
assertThat(capitulos.get(1).getTitulo()).isEqualTo("Capítulo 2");
// Verifico que las fuentes de cada capítulo se inicializan correctamente (Lazy loading)
// Verifico que las fuentes de cada capítulo se inicializan correctamente
assertThat(capitulos.get(0).getFuentes()).isEmpty();
assertThat(capitulos.get(1).getFuentes()).isEmpty();
// Pruebo con un recurso inexistente (debe devolver lista vacía)
// Pruebo con un recurso inexistente
List<Capitulo> capitulosInexistente = servicioRecursos.obtenerCapitulosDeRecurso(9999L);
assertThat(capitulosInexistente).isEmpty();
}
......@@ -467,7 +467,6 @@ public class TestServicioRecursos {
fuenteGuardada.setUrlFuente("https://actualizada.com");
servicioRecursos.actualizarFuente(fuenteGuardada);
// Verifico
Capitulo actualizado = servicioRecursos.obtenerCapitulosDeRecurso(recursoId).getFirst();
FuenteCapitulo fuenteActualizada = actualizado.getFuentes().getFirst();
assertThat(fuenteActualizada.getUrlFuente()).isEqualTo("https://actualizada.com");
......@@ -627,7 +626,7 @@ public class TestServicioRecursos {
// Creo un recurso con un acceso menos que el mínimo
Recurso recurso6 = new Recurso("Manga F", "Descripción F", LocalDate.now(), "Autor 6", new byte[0]);
recurso6.setContadorAccesosSemanal(2); // 2 accesos
recurso6.setContadorAccesosSemanal(2);
servicioRecursos.crearRecurso(recurso6);
List<Recurso> topRecursos = servicioRecursos.obtenerTopRecursosUltimaSemana();
......@@ -648,10 +647,10 @@ public class TestServicioRecursos {
@Transactional
void testAnadirResena() {
// Crear usuario
Usuario usuario1 = new Usuario("usuario1@test.com", "Usuario Uno", "clave123");
Usuario usuario1 = new Usuario("usuario1@test.com", "Usuario Uno", "Password123!");
servicioUsuarios.crearUsuario(usuario1);
Usuario usuario2 = new Usuario("usuario2@test.com", "Usuario Dos", "clave456");
Usuario usuario2 = new Usuario("usuario2@test.com", "Usuario Dos", "Password123!");
servicioUsuarios.crearUsuario(usuario2);
// Crear recurso
......@@ -691,17 +690,16 @@ public class TestServicioRecursos {
for (Resena resena : resenas) {
assertThat(resena.getRecurso().getId()).isEqualTo(recursoId);
assertThat(resena.getUsuario()).isNotNull();
assertThat(resena.getEstrellas()).isBetween(1, 5); // Validación de rango si fuera aplicable
assertThat(resena.getEstrellas()).isBetween(1, 5);
}
}
@Test
@DirtiesContext
@Transactional
void testObtenerResenasDeRecurso() {
// Creo un usuario de prueba
Usuario usuario = new Usuario("usuario@test.com", "Usuario Test", "contraseña123");
Usuario usuario = new Usuario("usuario@test.com", "Usuario Test", "Password123!");
servicioUsuarios.crearUsuario(usuario);
// Creo un recurso de prueba
......@@ -730,12 +728,13 @@ public class TestServicioRecursos {
assertThat(resenas.get(1).getTexto()).isEqualTo("Buena reseña");
assertThat(resenas.get(2).getTexto()).isEqualTo("Normalita");
}
@Test
@DirtiesContext
@Transactional
void testObtenerRecomendacionesParaUsuario() {
// Crear usuario y su biblioteca
Usuario usuario = new Usuario("recom@test.com", "Usuario Recom", "clave123");
Usuario usuario = new Usuario("recom@test.com", "Usuario Recom", "Password123!");
servicioUsuarios.crearUsuario(usuario);
Long usuarioId = usuario.getId();
BibliotecaPersonal biblioteca = usuario.getBibliotecaPersonal();
......
src/test/java/com/ujaen/tfg/mangaffinity/servicios/TestServicioUsuarios.java
package com.ujaen.tfg.mangaffinity.servicios;
import com.ujaen.tfg.mangaffinity.MangAffinityApplication;
import com.ujaen.tfg.mangaffinity.config.JpaTestConfig;
import com.ujaen.tfg.mangaffinity.entidades.BibliotecaPersonal;
......@@ -21,9 +20,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;import java.util.Base64;
import java.util.List;
@SpringBootTest(classes = {MangAffinityApplication.class, JpaTestConfig.class})
@ActiveProfiles("test")
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
......@@ -70,7 +66,7 @@ public class TestServicioUsuarios {
@DirtiesContext
void testAutenticarUsuario() {
//Creo un usuario en el sistema
var usuario1 = new Usuario("pedra@gmail.com", "Pedra", "pedrita");
var usuario1 = new Usuario("pedra@gmail.com", "Pedra", "Password123!");
servicioUsuarios.crearUsuario(usuario1);
Usuario usuarioGuardado = servicioUsuarios.buscaUsuario("pedra@gmail.com");
assertThat(usuarioGuardado).isNotNull();
......@@ -86,7 +82,7 @@ public class TestServicioUsuarios {
assertThat(servicioUsuarios.autenticarUsuario(emailExistente, contraseniaIncorrecta)).isNull();
// Usuario con email y contraseña correctos
DTOLoginRespuesta respuestaValida = servicioUsuarios.autenticarUsuario( "pedra@gmail.com", "pedrita");
DTOLoginRespuesta respuestaValida = servicioUsuarios.autenticarUsuario( "pedra@gmail.com", "Password123!");
assertThat(respuestaValida).isNotNull();
assertThat(respuestaValida.getToken()).isNotNull();
......@@ -100,7 +96,7 @@ public class TestServicioUsuarios {
@DirtiesContext
void testBuscaUsuario() {
// Creo un usuario normal
Usuario usuario1 = new Usuario("usuarios@test.com", "Usuarios", "password123");
Usuario usuario1 = new Usuario("usuarios@test.com", "Usuarios", "Password123!");
servicioUsuarios.crearUsuario(usuario1);
// Busco el usuario por email
......@@ -123,7 +119,7 @@ public class TestServicioUsuarios {
@DirtiesContext
void testObtenerBibliotecaDeUsuario() {
// Creo un usuario
Usuario usuario = new Usuario("biblioteca@test.com", "UsuarioBiblioteca", "password123");
Usuario usuario = new Usuario("biblioteca@test.com", "UsuarioBiblioteca", "Password123!");
servicioUsuarios.crearUsuario(usuario);
// Busco el usuario por email para obtener su ID
......@@ -148,7 +144,7 @@ public class TestServicioUsuarios {
@DirtiesContext
void testBuscaUsuarioPorId() {
// Creo un usuario normal
Usuario usuario1 = new Usuario("usuario@test.com", "Usuario", "password123");
Usuario usuario1 = new Usuario("usuario@test.com", "Usuario", "Password123!");
servicioUsuarios.crearUsuario(usuario1);
// Busco el usuario por ID
......@@ -165,17 +161,23 @@ public class TestServicioUsuarios {
@Test
@DirtiesContext
void testModificarUsuario() {
// Contraseñas válidas según los criterios de seguridad
String contrasenaInicial = "Password123!";
String contrasenaNueva = "Password123!!";
String contrasenaOtro = "OtraClave123#";
String contrasenaErronea = "Incorrecta1@";
// Registro un usuario inicial
Usuario usuario = new Usuario("original@mail.com", "Original", "contrasena123");
Usuario usuario = new Usuario("original@mail.com", "Original", contrasenaInicial);
servicioUsuarios.crearUsuario(usuario);
// 1. Modificación correcta de todo (email, nombre, contraseña)
// 1. Modificación correcta de email, nombre y contraseña
DTOLoginRespuesta respuesta = servicioUsuarios.modificarUsuario(
"original@mail.com",
"nuevo@mail.com",
"NuevoNombre",
"nuevaContrasena123",
"contrasena123"
contrasenaNueva,
contrasenaInicial
);
assertThat(respuesta).isNotNull();
......@@ -183,24 +185,24 @@ public class TestServicioUsuarios {
assertThat(respuesta.getNombreUsuario()).isEqualTo("NuevoNombre");
// 2. Intento de usar un email ya registrado
Usuario otro = new Usuario("otro@mail.com", "Otro", "clave123");
Usuario otro = new Usuario("otro@mail.com", "Otro", contrasenaOtro);
servicioUsuarios.crearUsuario(otro);
assertThatThrownBy(() -> servicioUsuarios.modificarUsuario(
"nuevo@mail.com",
"otro@mail.com", // ya existe
"otro@mail.com",
"NombreCualquiera",
"otraClave",
"nuevaContrasena123"
"PasswordValida1@",
contrasenaNueva
)).isInstanceOf(UsuarioYaRegistrado.class);
// 3. Intento de usar un nombre de usuario ya en uso
assertThatThrownBy(() -> servicioUsuarios.modificarUsuario(
"nuevo@mail.com",
"cambiado@mail.com",
"Otro", // nombre de usuario ya existe
"claveNueva",
"nuevaContrasena123"
"correoNuevo@mail.com",
"Otro",
"PasswordValida2#",
contrasenaNueva
)).isInstanceOf(NombreUsuarioYaCogido.class);
// 4. Contraseña actual incorrecta
......@@ -208,9 +210,10 @@ public class TestServicioUsuarios {
"nuevo@mail.com",
"valido@mail.com",
"ValidoNombre",
"loquesea",
"contrasenaIncorrecta"
)).isInstanceOf(IllegalArgumentException.class);
"PasswordValida3$",
contrasenaErronea
)).isInstanceOf(IllegalArgumentException.class)
.hasMessage("La contraseña actual no es correcta");
}
@Test
......@@ -234,7 +237,7 @@ public class TestServicioUsuarios {
assertThat(modificado.getEmail()).isEqualTo("modificado@test.com");
assertThat(modificado.getNombreUsuario()).isEqualTo("NombreModificado");
///️ Obtener el nuevo token con datos actualizados
// Obtener el nuevo token con datos actualizados
String nuevoToken = "Bearer " + modificado.getToken();
// Contraseña nueva débil
......@@ -260,7 +263,7 @@ public class TestServicioUsuarios {
@DirtiesContext
void testActualizarPerfil_Completo() {
// Crear y registrar un usuario
Usuario usuario = new Usuario("perfil@test.com", "PerfilUser", "clave123");
Usuario usuario = new Usuario("perfil@test.com", "PerfilUser", "Password123!");
servicioUsuarios.crearUsuario(usuario);
Usuario guardado = servicioUsuarios.buscaUsuario("perfil@test.com");
......@@ -283,7 +286,7 @@ public class TestServicioUsuarios {
assertThat(actualizado2.getDescripcion()).isEqualTo(nuevaDescripcion2);
assertThat(actualizado2.getFotoPerfil()).isNotNull(); // conserva la anterior
// actualizar con foto vacía (no cambia foto)
// actualizar con foto vacía
String imagenVacia = " "; // string en blanco
servicioUsuarios.actualizarPerfil(guardado.getId(), "Descripción sin cambio de imagen", imagenVacia);
Usuario actualizado3 = servicioUsuarios.buscaUsuario(guardado.getId());
......@@ -302,9 +305,9 @@ public class TestServicioUsuarios {
@DirtiesContext
void testBuscarPorNombre() {
// Crear usuarios con diferentes nombres
servicioUsuarios.crearUsuario(new Usuario("one@mail.com", "Ana", "clave1"));
servicioUsuarios.crearUsuario(new Usuario("two@mail.com", "Anabel", "clave2"));
servicioUsuarios.crearUsuario(new Usuario("three@mail.com", "Pedro", "clave3"));
servicioUsuarios.crearUsuario(new Usuario("one@mail.com", "Ana", "Password123!"));
servicioUsuarios.crearUsuario(new Usuario("two@mail.com", "Anabel", "Password123!"));
servicioUsuarios.crearUsuario(new Usuario("three@mail.com", "Pedro", "Password123!"));
// Buscar usuarios con filtro "Ana"
List<Usuario> resultado = servicioUsuarios.buscarPorNombre("Ana");
......@@ -324,7 +327,7 @@ public class TestServicioUsuarios {
@DirtiesContext
void testObtenerAlgunosUsuarios() {
for (int i = 1; i <= 12; i++) {
Usuario usuario = new Usuario("user" + i + "@mail.com", "Usuario" + i, "clave" + i);
Usuario usuario = new Usuario("user" + i + "@mail.com", "Usuario" + i, "Password123!" + i);
servicioUsuarios.crearUsuario(usuario);
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment