Skip to content

Rubén Ramírez / MangAffinity

Go to a project
Commit 1a1fa895 by Rubén Ramírez
Options

fix: [TestServicioRecursos]: Mejorados todos los tests para hacer todas las comprobaciones

parent 0c3a74d2
Inline Side-by-side
Showing with 402 additions and 115 deletions
src/test/java/com/ujaen/tfg/mangaffinity/servicios/TestServicioRecursos.java
......@@ -6,6 +6,9 @@ import com.ujaen.tfg.mangaffinity.entidades.Capitulo;
import com.ujaen.tfg.mangaffinity.entidades.Genero;
import com.ujaen.tfg.mangaffinity.entidades.Recurso;
import com.ujaen.tfg.mangaffinity.entidades.TipoRecurso;
import com.ujaen.tfg.mangaffinity.excepciones.CapituloNoExiste;
import com.ujaen.tfg.mangaffinity.excepciones.FotoInvalida;
import com.ujaen.tfg.mangaffinity.excepciones.FuenteNoExiste;
import com.ujaen.tfg.mangaffinity.excepciones.RecursoNoExiste;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
......@@ -14,9 +17,9 @@ import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ActiveProfiles;
import com.ujaen.tfg.mangaffinity.entidades.*;
import java.time.LocalDate;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
......@@ -31,18 +34,18 @@ public class TestServicioRecursos {
@Test
@DirtiesContext
void testCrearRecurso() {
// Crear recurso de prueba
Recurso nuevoRecurso = new Recurso("Titulo Prueba", "Descripción de prueba", LocalDate.now(), "Autor Prueba", "");
// Creo un recurso de prueba
Recurso nuevoRecurso = new Recurso("Titulo Prueba", "Descripción de prueba", LocalDate.now(), "Autor Prueba", new byte[0]);
servicioRecursos.crearRecurso(nuevoRecurso);
// Buscar el recurso en la base de datos después de crearlo
// Busco el recurso en la base de datos después de crearlo
List<Recurso> recursos = servicioRecursos.buscarRecursoPorTitulo("Titulo Prueba");
// Verificar que el recurso fue encontrado
// Verifico que el recurso fue encontrado
assertThat(recursos).isNotEmpty();
Recurso recursoGuardado = recursos.getFirst();
// Verificar que los datos guardados son correctos
// Verifico que los datos guardados son correctos
assertThat(recursoGuardado.getId()).isNotNull();
assertThat(recursoGuardado.getTitulo()).isEqualTo("Titulo Prueba");
assertThat(recursoGuardado.getDescripcion()).isEqualTo("Descripción de prueba");
......@@ -51,17 +54,39 @@ public class TestServicioRecursos {
@Test
@DirtiesContext
void testBuscarRecursoPorId() {
// Creo un recurso de prueba
Recurso recurso = new Recurso("Manga Prueba", "Descripción de prueba", LocalDate.now(), "Autor X", new byte[0]);
servicioRecursos.crearRecurso(recurso);
// Busco el recurso en la base de datos
Recurso recursoEncontrado = servicioRecursos.buscarRecursoPorId(recurso.getId());
// Verifico que el recurso fue encontrado correctamente
assertThat(recursoEncontrado).isNotNull();
assertThat(recursoEncontrado.getId()).isEqualTo(recurso.getId());
assertThat(recursoEncontrado.getTitulo()).isEqualTo("Manga Prueba");
assertThat(recursoEncontrado.getDescripcion()).isEqualTo("Descripción de prueba");
assertThat(recursoEncontrado.getAutor()).isEqualTo("Autor X");
//Verifico uno que no existe
Long idInexistente = 9999L;
assertThrows(RecursoNoExiste.class, () -> servicioRecursos.buscarRecursoPorId(idInexistente));
}
@Test
@DirtiesContext
void testBuscarRecursoPorTitulo() {
// Crear recursos de prueba
Recurso recurso1 = new Recurso("Titulo Uno", "Descripción de prueba 1", LocalDate.now(), "Autor 1", "");
Recurso recurso2 = new Recurso("Titulo Dos", "Descripción de prueba 2", LocalDate.now(), "Autor 2", "");
// Creo unos recursos de prueba
Recurso recurso1 = new Recurso("Titulo Uno", "Descripción de prueba 1", LocalDate.now(), "Autor 1", new byte[0]);
Recurso recurso2 = new Recurso("Titulo Dos", "Descripción de prueba 2", LocalDate.now(), "Autor 2", new byte[0]);
servicioRecursos.crearRecurso(recurso1);
servicioRecursos.crearRecurso(recurso2);
// Buscar por título con diferentes formatos
// Busco por título con diferentes formatos
List<Recurso> resultados = servicioRecursos.buscarRecursoPorTitulo("Titulo unO");
// Verificar que se encuentra el recurso sin importar mayúsculas
// Verifico que se encuentra el recurso sin importar mayúsculas
assertThat(resultados).isNotEmpty();
assertThat(resultados.getFirst().getTitulo()).isEqualTo("Titulo Uno"); // Se mantiene igual en BD
assertThat(resultados.getFirst().getTitulo().equalsIgnoreCase("Titulo unO")).isTrue();
......@@ -70,116 +95,84 @@ public class TestServicioRecursos {
@Test
@DirtiesContext
void testBuscarRecursoPorAutor() {
// Crear recursos con diferentes autores
Recurso recurso1 = new Recurso("Titulo Uno", "Desc 1", LocalDate.now(), "Autor A", "");
Recurso recurso2 = new Recurso("Titulo Dos", "Desc 2", LocalDate.now(), "Autor B", "");
// Creo recursos con diferentes autores
Recurso recurso1 = new Recurso("Titulo Uno", "Desc 1", LocalDate.now(), "Autor A", new byte[0]);
Recurso recurso2 = new Recurso("Titulo Dos", "Desc 2", LocalDate.now(), "Autor B", new byte[0]);
servicioRecursos.crearRecurso(recurso1);
servicioRecursos.crearRecurso(recurso2);
// Buscar por "Autor A"
// Busco por "Autor A"
List<Recurso> resultados = servicioRecursos.buscarRecursoPorAutor("Autor A");
// Validar que solo se obtiene el recurso con Autor A
// Valido que solo se obtiene el recurso con Autor A
assertThat(resultados).isNotEmpty();
assertThat(resultados.size()).isEqualTo(1);
assertThat(resultados.getFirst().getAutor()).isEqualTo("Autor A");
// Intento buscar un autor que no tiene recursos
List<Recurso> vacio = servicioRecursos.buscarRecursoPorAutor("Autor Inexistente");
assertThat(vacio).isEmpty();
}
@Test
@DirtiesContext
void testBuscarRecursoPorGenero() {
// Crear recursos con diferentes géneros
Recurso recurso1 = new Recurso("Manga A", "Desc", LocalDate.now(), "Autor X", "");
// Creo recursos con diferentes géneros
Recurso recurso1 = new Recurso("Manga A", "Desc", LocalDate.now(), "Autor X", new byte[0]);
recurso1.getGeneros().add(Genero.ACCION);
Recurso recurso2 = new Recurso("Manga B", "Desc", LocalDate.now(), "Autor Y", "");
Recurso recurso2 = new Recurso("Manga B", "Desc", LocalDate.now(), "Autor Y", new byte[0]);
recurso2.getGeneros().add(Genero.ROMANCE);
servicioRecursos.crearRecurso(recurso1);
servicioRecursos.crearRecurso(recurso2);
// Buscar por género ACCION
// Busco por género ACCION
List<Recurso> resultados = servicioRecursos.buscarRecursoPorGenero(Genero.ACCION);
// Validar que solo se obtiene el recurso con ACCION
// Valido que solo se obtiene el recurso con ACCION
assertThat(resultados).isNotEmpty();
assertThat(resultados.size()).isEqualTo(1);
assertThat(resultados.getFirst().getGeneros()).contains(Genero.ACCION);
}
@Test
@DirtiesContext
void testBuscarRecursoPorRangoFechas() {
// Crear recursos con diferentes fechas
LocalDate fecha1 = LocalDate.of(2020, 1, 1);
LocalDate fecha2 = LocalDate.of(2022, 6, 15);
LocalDate fecha3 = LocalDate.of(2023, 12, 25);
Recurso recurso1 = new Recurso("Titulo A", "Desc", fecha1, "Autor X", "");
Recurso recurso2 = new Recurso("Titulo B", "Desc", fecha2, "Autor Y", "");
Recurso recurso3 = new Recurso("Titulo C", "Desc", fecha3, "Autor Z", "");
servicioRecursos.crearRecurso(recurso1);
servicioRecursos.crearRecurso(recurso2);
servicioRecursos.crearRecurso(recurso3);
// Buscar entre 2018 y 2020
List<Recurso> resultados = servicioRecursos.buscarRecursoPorRangoFechas(LocalDate.of(2018, 1, 1), LocalDate.of(2020, 1, 1));
// Intento buscar por un género nulo
List<Recurso> nulo = servicioRecursos.buscarRecursoPorGenero(null);
assertThat(nulo).isEmpty();
assertThat(resultados).isNotEmpty();
assertThat(resultados.size()).isEqualTo(1);
}
@Test
@DirtiesContext
void testBuscarRecursoPorId() {
// Crear un recurso de prueba
Recurso recurso = new Recurso("Manga Prueba", "Descripción de prueba", LocalDate.now(), "Autor X", "");
servicioRecursos.crearRecurso(recurso);
// Buscar el recurso en la base de datos
Recurso recursoEncontrado = servicioRecursos.buscarRecursoPorId(recurso.getId());
// Verificar que el recurso fue encontrado correctamente
assertThat(recursoEncontrado).isNotNull();
assertThat(recursoEncontrado.getId()).isEqualTo(recurso.getId());
assertThat(recursoEncontrado.getTitulo()).isEqualTo("Manga Prueba");
assertThat(recursoEncontrado.getDescripcion()).isEqualTo("Descripción de prueba");
assertThat(recursoEncontrado.getAutor()).isEqualTo("Autor X");
//Busco un género que no hay
List<Recurso> inexistente = servicioRecursos.buscarRecursoPorGenero(Genero.HORROR); // Género que no se ha asociado a ningún recurso
assertThat(inexistente).isEmpty();
}
@Test
@DirtiesContext
void testBorrarRecurso() {
// Crear recurso en la base de datos
Recurso recurso = new Recurso("Titulo", "Descripcion", LocalDate.now(), "Autor", "");
// Creo recurso en la base de datos
Recurso recurso = new Recurso("Titulo", "Descripcion", LocalDate.now(), "Autor", new byte[0]);
servicioRecursos.crearRecurso(recurso);
// Buscar el recurso creado y asegurar que tiene un ID
// Busco el recurso creado y asegurar que tiene un ID
List<Recurso> recursos = servicioRecursos.buscarRecursoPorTitulo("Titulo");
assertThat(recursos).isNotEmpty();
Recurso recursoGuardado = recursos.getFirst();
assertThat(recursoGuardado.getId()).isNotNull();
// Borrar el recurso
boolean eliminado = servicioRecursos.borrarRecurso(recursoGuardado.getId());
assertThat(eliminado).isTrue();
// Borro el recurso
servicioRecursos.borrarRecurso(recursoGuardado.getId());
// Verificar que ya no existe
Recurso recursoBorrado = servicioRecursos.buscarRecursoPorId(recursoGuardado.getId());
assertThat(recursoBorrado).isNull();
// Intento buscar el recurso borrado debería lanzar la excepción RecursoNoExiste
assertThrows(RecursoNoExiste.class, () -> servicioRecursos.buscarRecursoPorId(recursoGuardado.getId()));
}
@Test
@DirtiesContext
void testModificarRecurso() {
// Crear un recurso inicial
Recurso recursoOriginal = new Recurso("Titulo 1", "Descripción 1", LocalDate.of(2022, 5, 10), "Autor 1", "");
// Creo un recurso inicial
Recurso recursoOriginal = new Recurso("Titulo 1", "Descripción 1", LocalDate.of(2022, 5, 10), "Autor 1", new byte[0]);
servicioRecursos.crearRecurso(recursoOriginal);
// Buscar el recurso creado para obtener su ID
// Busco el recurso creado para obtener su ID
List<Recurso> recursos = servicioRecursos.buscarRecursoPorTitulo("Titulo 1");
assertThat(recursos).isNotEmpty();
......@@ -187,13 +180,13 @@ public class TestServicioRecursos {
Long recursoId = recursoGuardado.getId();
assertThat(recursoId).isNotNull();
// Crear un objeto con algunos campos en null (solo modificamos la descripción)
Recurso nuevosDatos = new Recurso(null, "Descripción Modificada", null, null, "");
// Creo un objeto con algunos campos en null
Recurso nuevosDatos = new Recurso(null, "Descripción Modificada", null, null, new byte[0]);
// Modificar el recurso
Recurso recursoModificado = servicioRecursos.modificarRecurso(recursoId, nuevosDatos);
// Modifico el recurso
Recurso recursoModificado = servicioRecursos.modificarRecurso(recursoId, nuevosDatos, new byte[0]);
// Verificar que los cambios se guardaron correctamente sin sobrescribir campos con null
// Verifico que los cambios se guardaron correctamente sin sobrescribir campos con null
assertThat(recursoModificado).isNotNull();
assertThat(recursoModificado.getId()).isEqualTo(recursoId);
assertThat(recursoModificado.getTitulo()).isEqualTo("Titulo 1");
......@@ -201,7 +194,7 @@ public class TestServicioRecursos {
assertThat(recursoModificado.getFechaPublicacion()).isEqualTo(LocalDate.of(2022, 5, 10));
assertThat(recursoModificado.getAutor()).isEqualTo("Autor 1");
// Verificar que los datos en la BD siguen siendo los correctos
// Verifico que los datos en la BD siguen siendo los correctos
Recurso recursoFinal = servicioRecursos.buscarRecursoPorId(recursoId);
assertThat(recursoFinal).isNotNull();
assertThat(recursoFinal.getTitulo()).isEqualTo("Titulo 1");
......@@ -212,9 +205,68 @@ public class TestServicioRecursos {
@Test
@DirtiesContext
void testObtenerListadoRecursos() {
// Creo unos recursos de prueba
Recurso recurso1 = new Recurso("Titulo 1", "Descripción 1", LocalDate.now(), "Autor 1", new byte[0]);
Recurso recurso2 = new Recurso("Titulo 2", "Descripción 2", LocalDate.now(), "Autor 2", new byte[0]);
servicioRecursos.crearRecurso(recurso1);
servicioRecursos.crearRecurso(recurso2);
// Obtengo la lista de todos los recursos
List<Recurso> recursos = servicioRecursos.obtenerListadoRecursos();
// Verifico que la lista no esté vacía
assertThat(recursos).isNotEmpty();
// Verifico que los recursos estén correctamente guardados
assertThat(recursos.get(0).getTitulo()).isEqualTo("Titulo 1");
}
@Test
@DirtiesContext
void testActualizarFotoRecurso() {
// Creo un recurso inicial sin foto
Recurso recurso = new Recurso("Mangas de Prueba", "Descripción de pruebas", LocalDate.now(), "Autor X", new byte[0]);
servicioRecursos.crearRecurso(recurso);
// Obtengo el ID del recurso
Long recursoId = recurso.getId();
assertThat(recursoId).isNotNull();
// Creo una nueva foto (array de bytes) para el recurso
byte[] nuevaFoto = "NuevaFoto".getBytes();
// Verifico que la foto actual es vacía
Recurso recursoOriginal = servicioRecursos.buscarRecursoPorId(recursoId);
assertThat(recursoOriginal.getFoto()).isEmpty();
// Actualizo la foto del recurso
servicioRecursos.actualizarFotoRecurso(recursoId, nuevaFoto);
// Busco el recurso actualizado
Recurso recursoActualizado = servicioRecursos.buscarRecursoPorId(recursoId);
// Verifico que la foto del recurso fue actualizada correctamente
assertThat(recursoActualizado.getFoto()).isEqualTo(nuevaFoto);
// Verifico que el resto de los datos del recurso no se modificaron
assertThat(recursoActualizado.getTitulo()).isEqualTo("Mangas de Prueba");
assertThat(recursoActualizado.getDescripcion()).isEqualTo("Descripción de pruebas");
assertThat(recursoActualizado.getAutor()).isEqualTo("Autor X");
// Intento actualizar la foto con un array vacío (foto inválida)
byte[] fotoInvalida = new byte[0];
assertThrows(FotoInvalida.class, () -> servicioRecursos.actualizarFotoRecurso(recursoId, fotoInvalida));
// Intento actualizar la foto de un recurso que no existe
assertThrows(RecursoNoExiste.class, () -> servicioRecursos.actualizarFotoRecurso(9999L, nuevaFoto));
}
@Test
@DirtiesContext
void testAnadirCapitulo() {
// Creo recurso inicial
Recurso recurso = new Recurso("Manga Ejemplo", "Sinopsis", LocalDate.now(), "Autor X", "");
// Creo un recurso inicial
Recurso recurso = new Recurso("Manga Ejemplo", "Sinopsis", LocalDate.now(), "Autor X", new byte[0]);
servicioRecursos.crearRecurso(recurso);
List<Recurso> recursos = servicioRecursos.buscarRecursoPorTitulo("Manga Ejemplo");
assertThat(recursos).isNotEmpty();
......@@ -222,67 +274,302 @@ public class TestServicioRecursos {
Long recursoId = recursoGuardado.getId();
assertThat(recursoId).isNotNull();
// Añado 4 capítulos al recurso
servicioRecursos.anadirCapitulo(recursoId, new Capitulo(1, "Capítulo 1", TipoRecurso.MANGA, Arrays.asList(new FuenteCapitulo("Crunchyroll", "https://crunchyroll.com/cap1")), recursoGuardado));
servicioRecursos.anadirCapitulo(recursoId, new Capitulo(2, "Capítulo 2", TipoRecurso.MANGA, Arrays.asList(new FuenteCapitulo("AnimeFLV", "https://animeflv.com/cap2")), recursoGuardado));
servicioRecursos.anadirCapitulo(recursoId, new Capitulo(3, "Capítulo 3", TipoRecurso.MANGA, Arrays.asList(new FuenteCapitulo("MangaPlus", "https://mangaplus.com/cap3")), recursoGuardado));
servicioRecursos.anadirCapitulo(recursoId, new Capitulo(4, "Capítulo 4", TipoRecurso.MANGA, Arrays.asList(new FuenteCapitulo("Jkanime", "https://jkanime.com/cap4")), recursoGuardado));
// Creo un capítulo
Capitulo capitulo = new Capitulo(1, "Capítulo 1", TipoRecurso.MANGA, new ArrayList<>(), recursoGuardado);
// Obtengo los capítulos guardados
List<Capitulo> capitulos = servicioRecursos.obtenerCapitulosDeRecurso(recursoId);
assertThat(capitulos).hasSize(4);
// Creo una lista de fuentes y las asocio al capítulo
FuenteCapitulo fuente1 = new FuenteCapitulo("Crunchyroll", "https://crunchyroll.com/cap1", capitulo);
FuenteCapitulo fuente2 = new FuenteCapitulo("AnimeFLV", "https://animeflv.com/cap2", capitulo);
capitulo.getFuentes().add(fuente1);
capitulo.getFuentes().add(fuente2);
// Añado un nuevo capítulo, cambio de posiciones
servicioRecursos.anadirCapitulo(recursoId, new Capitulo(5, "Capítulo 5", TipoRecurso.MANGA, Arrays.asList(new FuenteCapitulo("Netflix", "https://netflix.com/cap5")), recursoGuardado));
// Añado el capítulo al recurso
servicioRecursos.anadirCapitulo(recursoId, capitulo);
// Obtengo de nuevo los capítulos y verifico que el 3 fue reemplazado
List<Capitulo> capitulosActualizados = servicioRecursos.obtenerCapitulosDeRecurso(recursoId);
assertThat(capitulosActualizados).hasSize(4);
// Verifico que el capítulo fue agregado correctamente
List<Capitulo> capitulos = servicioRecursos.obtenerCapitulosDeRecurso(recursoId);
assertThat(capitulos).hasSize(1);
// Verifico que los 2 primeros se mantienen
assertThat(capitulosActualizados.get(0).getNumero()).isEqualTo(1);
assertThat(capitulosActualizados.get(1).getNumero()).isEqualTo(2);
// Creo una nueva fuente y la asocio al capítulo existente
FuenteCapitulo nuevaFuente = new FuenteCapitulo("AnimeFLV", "https://animeflv.com/cap3", capitulo);
// Verifico que el nuevo capítulo ha reemplazado al tercero
assertThat(capitulosActualizados.get(2).getNumero()).isEqualTo(4);
assertThat(capitulosActualizados.get(3).getNumero()).isEqualTo(5);
// Añado la nueva fuente al capítulo
capitulo.getFuentes().add(nuevaFuente);
// Intento añadir un capítulo a un recurso inexistente
assertThrows(RecursoNoExiste.class, () -> servicioRecursos.anadirCapitulo(9999L, new Capitulo(6, "Capítulo 6", TipoRecurso.MANGA, Arrays.asList(new FuenteCapitulo("Hulu", "https://hulu.com/cap6")), recursoGuardado)));
// Verifico que la fuente fue agregada correctamente
List<FuenteCapitulo> fuentes = capitulo.getFuentes();
assertThat(fuentes).hasSize(3); // Ahora la lista debe tener 3 fuentes
assertThat(fuentes.get(2).getNombreFuente()).isEqualTo("AnimeFLV");
assertThat(fuentes.get(2).getUrlFuente()).isEqualTo("https://animeflv.com/cap3");
}
@Test
@DirtiesContext
void testObtenerCapitulosDeRecurso() {
// Creo un recurso
Recurso recurso = new Recurso("Manga Prueba", "Sinopsis", LocalDate.now(), "Autor X", "");
Recurso recurso = new Recurso("Mang Prueba", "Sinopsis", LocalDate.now(), "Autor X", new byte[0]);
servicioRecursos.crearRecurso(recurso);
List<Recurso> recursos = servicioRecursos.buscarRecursoPorTitulo("Manga Prueba");
List<Recurso> recursos = servicioRecursos.buscarRecursoPorTitulo("Mang Prueba");
assertThat(recursos).isNotEmpty();
Recurso recursoGuardado = recursos.getFirst();
Long recursoId = recursoGuardado.getId();
assertThat(recursoId).isNotNull();
servicioRecursos.anadirCapitulo(recursoId, new Capitulo(1, "Capítulo 1", TipoRecurso.MANGA,
Arrays.asList(new FuenteCapitulo("Crunchyroll", "https://crunchyroll.com/cap1")), recursoGuardado));
servicioRecursos.anadirCapitulo(recursoId, new Capitulo(2, "Capítulo 2", TipoRecurso.MANGA,
Arrays.asList(new FuenteCapitulo("AnimeFLV", "https://animeflv.com/cap2")), recursoGuardado));
// Creo capítulos y los añado al recurso
Capitulo capitulo1 = new Capitulo(1, "Capítulo 1", TipoRecurso.MANGA, new ArrayList<>(), recursoGuardado);
Capitulo capitulo2 = new Capitulo(2, "Capítulo 2", TipoRecurso.MANGA, new ArrayList<>(), recursoGuardado);
List<Capitulo> capitulos = servicioRecursos.obtenerCapitulosDeRecurso(recursoId);
servicioRecursos.anadirCapitulo(recursoId, capitulo1);
servicioRecursos.anadirCapitulo(recursoId, capitulo2);
// Verifico que los capítulos fueron obtenidos correctamente
// Verifico que los capítulos fueron agregados correctamente
List<Capitulo> capitulos = servicioRecursos.obtenerCapitulosDeRecurso(recursoId);
assertThat(capitulos).hasSize(2);
assertThat(capitulos.get(0).getNumero()).isEqualTo(1);
assertThat(capitulos.get(0).getTitulo()).isEqualTo("Capítulo 1");
assertThat(capitulos.get(0).getFuentes().getFirst().getNombreFuente()).isEqualTo("Crunchyroll");
assertThat(capitulos.get(1).getNumero()).isEqualTo(2);
assertThat(capitulos.get(1).getTitulo()).isEqualTo("Capítulo 2");
assertThat(capitulos.get(1).getFuentes().getFirst().getNombreFuente()).isEqualTo("AnimeFLV");
// Probar con lista vacía
// Verifico que las fuentes de cada capítulo se inicializan correctamente (Lazy loading)
assertThat(capitulos.get(0).getFuentes()).isEmpty();
assertThat(capitulos.get(1).getFuentes()).isEmpty();
// Pruebo con un recurso inexistente (debe devolver lista vacía)
List<Capitulo> capitulosInexistente = servicioRecursos.obtenerCapitulosDeRecurso(9999L);
assertThat(capitulosInexistente).isEmpty();
}
@Test
@DirtiesContext
void testObtenerCapitulosDeRecursoPorTipo() {
// Creo un recurso
Recurso recurso = new Recurso("Manga Ejemplos", "Sinopsis", LocalDate.now(), "Autor X", new byte[0]);
servicioRecursos.crearRecurso(recurso);
List<Recurso> recursos = servicioRecursos.buscarRecursoPorTitulo("Manga Ejemplos");
assertThat(recursos).isNotEmpty();
Recurso recursoGuardado = recursos.getFirst();
Long recursoId = recursoGuardado.getId();
assertThat(recursoId).isNotNull();
// Creo capítulos con los tipos ANIME y MANGA y los añado al recurso
Capitulo capitulo1 = new Capitulo(1, "Capítulo 1", TipoRecurso.MANGA, new ArrayList<>(), recursoGuardado);
Capitulo capitulo2 = new Capitulo(2, "Capítulo 2", TipoRecurso.MANGA, new ArrayList<>(), recursoGuardado);
Capitulo capitulo3 = new Capitulo(3, "Capítulo 3", TipoRecurso.ANIME, new ArrayList<>(), recursoGuardado);
servicioRecursos.anadirCapitulo(recursoId, capitulo1);
servicioRecursos.anadirCapitulo(recursoId, capitulo2);
servicioRecursos.anadirCapitulo(recursoId, capitulo3);
// Verifico que los capítulos de tipo MANGA fueron agregados correctamente
List<Capitulo> capitulosManga = servicioRecursos.obtenerCapitulosDeRecursoPorTipo(recursoId, TipoRecurso.MANGA);
assertThat(capitulosManga).hasSize(2);
// Verifico que los capítulos de tipo ANIME fueron agregados correctamente
List<Capitulo> capitulosAnime = servicioRecursos.obtenerCapitulosDeRecursoPorTipo(recursoId, TipoRecurso.ANIME);
assertThat(capitulosAnime).hasSize(1);
}
@Test
@DirtiesContext
void testModificarCapitulo() {
// Creo y guardo un recurso
Recurso recurso = new Recurso("Manga Original", "Sinopsis", LocalDate.now(), "Autor", new byte[0]);
servicioRecursos.crearRecurso(recurso);
Long recursoId = recurso.getId();
// Creo y añado un capítulo
Capitulo capitulo = new Capitulo(1, "Capítulo Original", TipoRecurso.MANGA, new ArrayList<>(), recurso);
servicioRecursos.anadirCapitulo(recursoId, capitulo);
// Recupero el capítulo para obtener su ID
List<Capitulo> capitulosIniciales = servicioRecursos.obtenerCapitulosDeRecurso(recursoId);
assertThat(capitulosIniciales).hasSize(1);
Capitulo capituloOriginal = capitulosIniciales.getFirst();
Long capituloId = capituloOriginal.getId();
// Creo nuevas fuentes para el capítulo
FuenteCapitulo nuevaFuente = new FuenteCapitulo("NuevaFuente", "https://nueva.com", capituloOriginal);
List<FuenteCapitulo> nuevasFuentes = List.of(nuevaFuente);
// Modifico el capítulo
Capitulo capituloModificado = new Capitulo(2, "Capítulo Modificado", TipoRecurso.ANIME, nuevasFuentes, recurso);
capituloModificado.setId(capituloId);
capituloModificado.setActivo(false);
servicioRecursos.modificarCapitulo(recursoId, capituloModificado);
// Recupero el capítulo actualizado
List<Capitulo> capitulosFinales = servicioRecursos.obtenerCapitulosDeRecurso(recursoId);
assertThat(capitulosFinales).hasSize(1);
Capitulo capituloActualizado = capitulosFinales.getFirst();
assertThat(capituloActualizado.getNumero()).isEqualTo(2);
assertThat(capituloActualizado.getTitulo()).isEqualTo("Capítulo Modificado");
assertThat(capituloActualizado.getTipo()).isEqualTo(TipoRecurso.ANIME);
assertThat(capituloActualizado.getActivo()).isFalse();
assertThat(capituloActualizado.getFuentes()).hasSize(1);
assertThat(capituloActualizado.getFuentes().getFirst().getNombreFuente()).isEqualTo("NuevaFuente");
}
@Test
@DirtiesContext
void testBuscarCapituloPorId() {
// Creo y guardo un recurso
Recurso recurso = new Recurso("Manga Test", "Descripción", LocalDate.now(), "Autor", new byte[0]);
servicioRecursos.crearRecurso(recurso);
Long recursoId = recurso.getId();
// Creo y añado un capítulo
Capitulo capitulo = new Capitulo(1, "Capítulo 1", TipoRecurso.MANGA, new ArrayList<>(), recurso);
servicioRecursos.anadirCapitulo(recursoId, capitulo);
// Recupero los capítulos del recurso
List<Capitulo> capitulos = servicioRecursos.obtenerCapitulosDeRecurso(recursoId);
assertThat(capitulos).hasSize(1);
Capitulo encontrado = servicioRecursos.buscarCapituloPorId(capitulos.getFirst().getId());
// Verifico los datos
assertThat(encontrado).isNotNull();
assertThat(encontrado.getTitulo()).isEqualTo("Capítulo 1");
assertThat(encontrado.getNumero()).isEqualTo(1);
assertThat(encontrado.getTipo()).isEqualTo(TipoRecurso.MANGA);
// Verifico que lanza excepción si el ID no existe
assertThrows(CapituloNoExiste.class, () -> servicioRecursos.buscarCapituloPorId(9999L));
}
@Test
@DirtiesContext
void testActualizarFuente() {
// Creo y guardo un recurso
Recurso recurso = new Recurso("Mangas Fuentes", "Sinopsis", LocalDate.now(), "Autor", new byte[0]);
servicioRecursos.crearRecurso(recurso);
Long recursoId = recurso.getId();
Capitulo capitulo = new Capitulo(1, "Capítulo Fuente", TipoRecurso.MANGA, new ArrayList<>(), recurso);
servicioRecursos.anadirCapitulo(recursoId, capitulo);
// Obtengo el capítulo guardado
Capitulo capituloGuardado = servicioRecursos.obtenerCapitulosDeRecurso(recursoId).getFirst();
FuenteCapitulo fuente = new FuenteCapitulo("OriginalSource", "https://original.com", capituloGuardado);
servicioRecursos.agregarFuente(fuente);
// Obtengo la fuente guardada
Capitulo capituloConFuente = servicioRecursos.obtenerCapitulosDeRecurso(recursoId).getFirst();
FuenteCapitulo fuenteGuardada = capituloConFuente.getFuentes().getFirst();
Long fuenteId = fuenteGuardada.getId();
// Modifico la URL de la fuente
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");
// Verifico que lanza excepción si la fuente no existe
FuenteCapitulo fuenteInexistente = new FuenteCapitulo("Inexistente", "https://nada.com", capituloGuardado);
fuenteInexistente.setId(9999L);
assertThrows(FuenteNoExiste.class, () -> servicioRecursos.actualizarFuente(fuenteInexistente));
}
@Test
@DirtiesContext
void testEliminarFuentePorId() {
// Creo y guardo un recurso
Recurso recurso = new Recurso("Manga Fuente", "Sinopsis", LocalDate.now(), "Autor", new byte[0]);
servicioRecursos.crearRecurso(recurso);
Long recursoId = recurso.getId();
Capitulo capitulo = new Capitulo(1, "Capítulo con Fuente", TipoRecurso.MANGA, new ArrayList<>(), recurso);
servicioRecursos.anadirCapitulo(recursoId, capitulo);
Capitulo capituloGuardado = servicioRecursos.obtenerCapitulosDeRecurso(recursoId).getFirst();
// Creo y agrego una fuente
FuenteCapitulo fuente = new FuenteCapitulo("FuenteX", "https://fuente.com", capituloGuardado);
servicioRecursos.agregarFuente(fuente);
// Obtengo la fuente guardada
Capitulo conFuente = servicioRecursos.obtenerCapitulosDeRecurso(recursoId).getFirst();
List<FuenteCapitulo> fuentesAntes = conFuente.getFuentes();
assertThat(fuentesAntes).hasSize(1);
Long fuenteId = fuentesAntes.getFirst().getId();
// Elimino la fuente
servicioRecursos.eliminarFuentePorId(fuenteId);
// Verifico que la fuente ha sido eliminada
Capitulo actualizado = servicioRecursos.obtenerCapitulosDeRecurso(recursoId).getFirst();
assertThat(actualizado.getFuentes()).isEmpty();
// No debe lanzar excepción si intento eliminar una fuente inexistente
servicioRecursos.eliminarFuentePorId(9999L);
}
@Test
@DirtiesContext
void testEliminarFuente() {
// Creo y guardo un recurso
Recurso recurso = new Recurso("Manga Fuente Ex", "Sinopsis", LocalDate.now(), "Autor", new byte[0]);
servicioRecursos.crearRecurso(recurso);
Long recursoId = recurso.getId();
// Creo un capítulo y lo asocio
Capitulo capitulo = new Capitulo(1, "Capítulo con Fuente", TipoRecurso.MANGA, new ArrayList<>(), recurso);
servicioRecursos.anadirCapitulo(recursoId, capitulo);
Capitulo capituloGuardado = servicioRecursos.obtenerCapitulosDeRecurso(recursoId).getFirst();
// Creo y agrego una fuente
FuenteCapitulo fuente = new FuenteCapitulo("FuenteZ", "https://fuentez.com", capituloGuardado);
servicioRecursos.agregarFuente(fuente);
// Verifico que la fuente está presente
Capitulo conFuente = servicioRecursos.obtenerCapitulosDeRecurso(recursoId).getFirst();
assertThat(conFuente.getFuentes()).hasSize(1);
Long fuenteId = conFuente.getFuentes().getFirst().getId();
// Elimino la fuente
servicioRecursos.eliminarFuente(fuenteId);
// Verifico que ha sido eliminada
Capitulo actualizado = servicioRecursos.obtenerCapitulosDeRecurso(recursoId).getFirst();
assertThat(actualizado.getFuentes()).isEmpty();
// Verifico que lanza excepción si la fuente no existe
assertThrows(FuenteNoExiste.class, () -> servicioRecursos.eliminarFuente(9999L));
}
@Test
@DirtiesContext
void testExisteRecurso() {
// Creo un recurso y lo guardo
Recurso recurso = new Recurso("Manga Existente", "Sinopsis", LocalDate.now(), "Autor", new byte[0]);
servicioRecursos.crearRecurso(recurso);
Long recursoId = recurso.getId();
// Verifico que el recurso existe
boolean existe = servicioRecursos.existeRecurso(recursoId);
assertThat(existe).isTrue();
// Verifico que uno inexistente devuelve false
boolean noExiste = servicioRecursos.existeRecurso(9999L);
assertThat(noExiste).isFalse();
}
@Test
@DirtiesContext
void testObtenerGeneros() {
// Obtengo la lista de géneros desde el servicio
List<String> generos = servicioRecursos.obtenerGeneros();
// Verifico que contiene todos los valores del enum Genero
List<String> generosEsperados = Arrays.stream(Genero.values())
.map(Enum::name)
.toList();
assertThat(generos).containsExactlyInAnyOrderElementsOf(generosEsperados);
assertThat(generos).isNotEmpty();
}
}
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