ServiceUzyTUsuarioTests.java 16.4 KB
Newer Older
1 2 3 4 5 6 7 8
package ec.edu.espe.movilidad.MovilidadWS.Service;

import ec.edu.espe.movilidad.MovilidadWS.Dao.DaoUzyTPerfil;
import ec.edu.espe.movilidad.MovilidadWS.Dao.DaoUzyTUsuario;
import ec.edu.espe.movilidad.MovilidadWS.Dto.DtoUzyTUsuario;
import ec.edu.espe.movilidad.MovilidadWS.Exceptions.ResourceNotFoundException;
import ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class.UzyTPerfilMapper;
import ec.edu.espe.movilidad.MovilidadWS.Mapper.Components_Class.UzyTUsuarioMapper;
9
import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTPerfil;
10 11
import ec.edu.espe.movilidad.MovilidadWS.Model.ModelUzyTUsuario;
import ec.edu.espe.movilidad.MovilidadWS.Service.UzyTUsuario.ServiceUzyTUsuario;
12
import org.junit.jupiter.api.Assertions;
13
import org.junit.jupiter.api.BeforeEach;
14 15 16
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
17

18 19 20 21 22 23 24 25 26 27
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.*;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class ServiceUzyTUsuarioTests {
28

29 30 31 32 33 34 35 36 37 38 39 40 41 42
    @Mock
    private DaoUzyTUsuario daoUzyTUsuario;

    @Mock
    private DaoUzyTPerfil daoUzyTPerfil;

    @Mock
    private UzyTUsuarioMapper mapper;

    @Mock
    private UzyTPerfilMapper mapperPerfil;

    private ServiceUzyTUsuario serviceUzyTUsuario;

43 44 45 46 47
    @BeforeEach
    void setUp() {
        serviceUzyTUsuario = new ServiceUzyTUsuario(daoUzyTUsuario, daoUzyTPerfil, mapper, mapperPerfil);
    }

48
    //LISTAR USUARIO POR ID
49 50 51 52 53 54 55 56 57 58 59 60 61 62
    @DisplayName("Test para listar a los usuarios por el ID")
    @Test
    void testListarPorID() {
        Long id = 1L;
        ModelUzyTUsuario usuario = new ModelUzyTUsuario();
        DtoUzyTUsuario dtoUsuario = new DtoUzyTUsuario();
        dtoUsuario.setUzytusuario_id(id);

        when(daoUzyTUsuario.findById(id)).thenReturn(Optional.of(usuario));
        when(mapper.entityToDto(usuario)).thenReturn(dtoUsuario);

        DtoUzyTUsuario result = serviceUzyTUsuario.ListarPorID(id);
        assertEquals(id, result.getUzytusuario_id());
    }
63 64 65 66 67 68 69 70 71 72 73 74 75


    @DisplayName("Test para listar a los usuarios por el ID (Caso de error: ID negativo o nulo)")
    @Test
    void testListarPorID_CasoError_IDNegativoONulo() {
        assertThrows(IllegalArgumentException.class, () -> serviceUzyTUsuario.ListarPorID(0L));
        assertThrows(IllegalArgumentException.class, () -> serviceUzyTUsuario.ListarPorID(-1L));
    }

    @DisplayName("Test para listar a los usuarios por el ID (Caso de error: usuario no encontrado)")
    @Test
    void testListarPorID_CasoError_UsuarioNoEncontrado() {
        Long id = 1L;
76
        when(daoUzyTUsuario.findById(id)).thenReturn(Optional.empty()); // se devulve vacío
77 78 79
        assertThrows(ResourceNotFoundException.class, () -> serviceUzyTUsuario.ListarPorID(id));
    }

80 81
    //LISTAR REGISTROS

82
    @DisplayName("Test para listar todos los usuarios existentes (Caso exitoso)")
83
    @Test
84
    void testListarRegistros_CasoExitoso() {
85

86
        List<ModelUzyTUsuario> usuarios = Arrays.asList(new ModelUzyTUsuario(), new ModelUzyTUsuario());
87 88 89
        DtoUzyTUsuario dtoUsuario = new DtoUzyTUsuario();

        when(daoUzyTUsuario.findAll()).thenReturn(usuarios);
90
        when(mapper.entitiesToDtos(usuarios)).thenReturn(Arrays.asList(dtoUsuario, dtoUsuario));
91 92 93

        List<DtoUzyTUsuario> result = serviceUzyTUsuario.ListarRegistros();

94
        assertEquals(2, result.size());
95
        assertEquals(dtoUsuario, result.get(0));
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
        assertEquals(dtoUsuario, result.get(1));
    }

    @DisplayName("Test para listar usuarios registrados - Sin resultados")
    @Test
    void testListarRegistros_SinResultados() {
        List<ModelUzyTUsuario> usuarios = Collections.emptyList();

        when(daoUzyTUsuario.findAll()).thenReturn(usuarios);

        List<DtoUzyTUsuario> result = serviceUzyTUsuario.ListarRegistros();

        assertTrue(result.isEmpty());
    }

    @DisplayName("Test para listar usuarios registrados - Excepción en el servicio")
    @Test
    void testListarRegistros_ExcepcionEnServicio() {
        when(daoUzyTUsuario.findAll()).thenThrow(new RuntimeException("Error en el servicio"));

        assertThrows(RuntimeException.class, () -> serviceUzyTUsuario.ListarRegistros());
117
    }
118 119


120 121
    //BUSCAR USUARIOS

122
    @DisplayName("Test para buscar usuarios por nombre (Caso exitoso)")
123
    @Test
124
    void testFindByUsuario_CasoExitoso() {
125
        String usuario = "Joel";
126 127 128 129 130 131 132 133 134 135 136
        ModelUzyTUsuario modelUzyTUsuario = new ModelUzyTUsuario();
        DtoUzyTUsuario dtoUzyTUsuario = new DtoUzyTUsuario();

        when(daoUzyTUsuario.findByUsuario(usuario)).thenReturn(Collections.singletonList(modelUzyTUsuario));
        when(mapper.entitiesToDtos(Collections.singletonList(modelUzyTUsuario))).thenReturn(Collections.singletonList(dtoUzyTUsuario));

        List<DtoUzyTUsuario> result = serviceUzyTUsuario.findByUsuario(usuario);

        assertEquals(1, result.size());
        assertEquals(dtoUzyTUsuario, result.get(0));
    }
137 138

    @DisplayName("Test para buscar usuarios por nombre (Caso de error: nombre de usuario nulo o vacío)")
139
    @Test
140 141 142 143
    void testFindByUsuario_CasoError_NombreNuloOVacio() {
        assertThrows(IllegalArgumentException.class, () -> serviceUzyTUsuario.findByUsuario(null));
        assertThrows(IllegalArgumentException.class, () -> serviceUzyTUsuario.findByUsuario(""));
    }
144

145 146 147 148
    @DisplayName("Test para buscar usuarios por nombre (Caso de error: usuarios no encontrados)")
    @Test
    void testFindByUsuario_CasoError_UsuariosNoEncontrados() {
        String usuario = "example";
149

150 151 152
        when(daoUzyTUsuario.findByUsuario(usuario)).thenReturn(Collections.emptyList());

        assertThrows(ResourceNotFoundException.class, () -> serviceUzyTUsuario.findByUsuario(usuario));
153 154
    }

155 156
    //GUARDAR USUARIO

157
    @DisplayName("Test para guardar un nuevo usuario correctamente (Caso exitoso)")
158
    @Test
159
    void testGuardar_CasoExitoso() throws Exception {
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
        // Datos del usuario a simular
        DtoUzyTUsuario dtoUzyTUsuario = new DtoUzyTUsuario();
        dtoUzyTUsuario.setUzytusuario_nombres("NombreUsuario");
        dtoUzyTUsuario.setUzytusuario_apellidos("ApellidosUsuario");
        dtoUzyTUsuario.setUzytusuario_email("usuario@example.com");

        // Convertir el objeto DtoUzyTUsuario a ModelUzyTUsuario
        ModelUzyTUsuario modelUzyTUsuario = new ModelUzyTUsuario();
        modelUzyTUsuario.setUzytusuario_nombres(dtoUzyTUsuario.getUzytusuario_nombres());
        modelUzyTUsuario.setUzytusuario_apellidos(dtoUzyTUsuario.getUzytusuario_apellidos());
        modelUzyTUsuario.setUzytusuario_email(dtoUzyTUsuario.getUzytusuario_email());

        // Configurar el comportamiento esperado del mapper y el daoUzyTUsuario
        when(mapper.dtoToEntity(dtoUzyTUsuario)).thenReturn(modelUzyTUsuario);
        when(daoUzyTUsuario.save(modelUzyTUsuario)).thenReturn(modelUzyTUsuario);
        when(mapper.entityToDto(modelUzyTUsuario)).thenReturn(dtoUzyTUsuario);

        // Ejecutar el método a probar
        DtoUzyTUsuario result = serviceUzyTUsuario.guardar(dtoUzyTUsuario);

        // Verificar el resultado
        assertNotNull(result);
        assertEquals(dtoUzyTUsuario, result);
    }

185 186 187 188 189 190 191 192 193 194 195 196
    @DisplayName("Test para guardar un nuevo usuario - Apellido nulo (Caso de error)")
    @Test
    void testGuardar_ApellidoNulo() {
        // Datos del usuario a simular con apellido nulo
        DtoUzyTUsuario dtoUzyTUsuario = new DtoUzyTUsuario();
        dtoUzyTUsuario.setUzytusuario_nombres("NombreUsuario");
        dtoUzyTUsuario.setUzytusuario_apellidos(null);
        dtoUzyTUsuario.setUzytusuario_email("usuario@example.com");

        // Ejecutar el método a probar y verificar que se lance la excepción
        assertThrows(IllegalArgumentException.class, () -> serviceUzyTUsuario.guardar(dtoUzyTUsuario));
    }
197

198
    @DisplayName("Test para guardar un nuevo usuario - Excepción en el servicio (Caso de error)")
199
    @Test
200 201
    void testGuardar_ExcepcionEnServicio()  {
        // Datos del usuario a simular
202
        DtoUzyTUsuario dtoUzyTUsuario = new DtoUzyTUsuario();
203 204 205
        dtoUzyTUsuario.setUzytusuario_nombres("NombreUsuario");
        dtoUzyTUsuario.setUzytusuario_apellidos("ApellidosUsuario");
        dtoUzyTUsuario.setUzytusuario_email("usuario@example.com");
206

207 208 209 210 211 212 213 214 215
        // Convertir el objeto DtoUzyTUsuario a ModelUzyTUsuario
        ModelUzyTUsuario modelUzyTUsuario = new ModelUzyTUsuario();
        modelUzyTUsuario.setUzytusuario_nombres(dtoUzyTUsuario.getUzytusuario_nombres());
        modelUzyTUsuario.setUzytusuario_apellidos(dtoUzyTUsuario.getUzytusuario_apellidos());
        modelUzyTUsuario.setUzytusuario_email(dtoUzyTUsuario.getUzytusuario_email());

        // Configurar el comportamiento esperado del mapper y el daoUzyTUsuario
        when(mapper.dtoToEntity(dtoUzyTUsuario)).thenReturn(modelUzyTUsuario);
        when(daoUzyTUsuario.save(modelUzyTUsuario)).thenThrow(new RuntimeException("Error en el servicio"));
216 217

        // Ejecutar el método a probar y verificar que se lance la excepción
218
        assertThrows(Exception.class, () -> serviceUzyTUsuario.guardar(dtoUzyTUsuario));
219 220 221
    }


222
    @DisplayName("Test para editar un usuario inexistente (Caso de error)")
223
    @Test
224 225 226 227 228
    void testEditar_UsuarioNoExiste() {
        // Datos del usuario a simular
        Long id = 1L;
        DtoUzyTUsuario dtoUzyTUsuario = new DtoUzyTUsuario();
        dtoUzyTUsuario.setUzytusuario_nombres("NuevoNombre");
229

230 231 232
        // Ejecutar el método a probar y verificar que se lance la excepción
        assertThrows(ResourceNotFoundException.class, () -> serviceUzyTUsuario.editar(id, dtoUzyTUsuario));
    }
233 234


235
    //EDITAR USUARIO
236 237 238 239 240 241 242
    @DisplayName("Test para editar un usuario - ID negativo (Caso de error)")
    @Test
    void testEditar_IdNegativo() {
        // Datos del usuario a simular con ID negativo
        Long id = -1L;
        DtoUzyTUsuario dtoUzyTUsuario = new DtoUzyTUsuario();
        dtoUzyTUsuario.setUzytusuario_nombres("NuevoNombre");
243

244 245
        // Ejecutar el método a probar y verificar que se lance la excepción
        assertThrows(IllegalArgumentException.class, () -> serviceUzyTUsuario.editar(id, dtoUzyTUsuario));
246
    }
247 248

    @DisplayName("Test para actualizar un empleado")
249
    @Test
250 251 252 253 254
    void testActualizarEmpleado() {
        // Datos del usuario a simular
        Long id = 1L;
        DtoUzyTUsuario dtoUzyTUsuario = new DtoUzyTUsuario();
        dtoUzyTUsuario.setUzytusuario_id(id);
255 256
        dtoUzyTUsuario.setUzytusuario_nombres("Nuevo Nombre");
        dtoUzyTUsuario.setUzytusuario_apellidos("Nuevo Apellido");
257

258 259 260
        // Obtener el usuario existente a través del ID
        ModelUzyTUsuario usuarioExistente = new ModelUzyTUsuario();
        usuarioExistente.setUzytusuario_id(id);
261 262
        usuarioExistente.setUzytusuario_nombres("Nombre U");
        usuarioExistente.setUzytusuario_apellidos("Apellido U");
263

264 265 266 267 268 269
        // Configurar el comportamiento esperado del método findById del daoUzyTUsuario
        when(daoUzyTUsuario.findById(id)).thenReturn(Optional.of(usuarioExistente));
        // Configurar el comportamiento esperado del método existsById del daoUzyTUsuario
        when(daoUzyTUsuario.existsById(id)).thenReturn(true);
        // Configurar el comportamiento esperado del método save del daoUzyTUsuario
        when(daoUzyTUsuario.save(any())).thenReturn(usuarioExistente);
270

271 272 273 274 275 276 277
        // Configurar el comportamiento esperado del método entityToDto del mapper
        when(mapper.entityToDto(any())).thenReturn(dtoUzyTUsuario);

        // Ejecutar el método a probar
        DtoUzyTUsuario result = serviceUzyTUsuario.editar(id, dtoUzyTUsuario);

        // Verificar el resultado
278
        assertNotNull(result);
279 280 281 282 283 284 285 286 287 288 289 290
        assertEquals(dtoUzyTUsuario.getUzytusuario_id(), result.getUzytusuario_id());
        assertEquals(dtoUzyTUsuario.getUzytusuario_nombres(), result.getUzytusuario_nombres());
        assertEquals(dtoUzyTUsuario.getUzytusuario_apellidos(), result.getUzytusuario_apellidos());

        // Verificar que el método findById del daoUzyTUsuario fue llamado con el ID correcto
        verify(daoUzyTUsuario).findById(id);
        // Verificar que el método existsById del daoUzyTUsuario fue llamado con el ID correcto
        verify(daoUzyTUsuario).existsById(id);
        // Verificar que el método save del daoUzyTUsuario fue llamado con el usuario actualizado
        verify(daoUzyTUsuario).save(any());
        // Verificar que el método entityToDto del mapper fue llamado con el usuario actualizado
        verify(mapper).entityToDto(usuarioExistente);
291
    }
292

293
    //ELIMINAR USUARIO
294
    @Test
295 296
    void testEliminar_CasoExitoso() {
        // Datos del usuario a simular
297
        Long id = 1L;
298 299
        ModelUzyTUsuario usuarioExistente = new ModelUzyTUsuario();
        usuarioExistente.setUzytusuario_id(id);
300

301 302 303
        // Configurar el comportamiento del daoUzyTUsuario para findById y delete
        when(daoUzyTUsuario.findById(id)).thenReturn(Optional.of(usuarioExistente));
        doNothing().when(daoUzyTUsuario).delete(usuarioExistente);
304

305
        // Ejecutar el método a probar
306 307
        boolean result = serviceUzyTUsuario.eliminar(id);

308
        // Verificar que el usuario fue eliminado
309
        assertTrue(result);
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
        // Verificar que el método findById fue llamado
        verify(daoUzyTUsuario, times(1)).findById(id);
        // Verificar que el método delete fue llamado
        verify(daoUzyTUsuario, times(1)).delete(usuarioExistente);
    }


    @Test
    void testEliminar_IDNuloOMenorOIgualACero() {
        // Datos del usuario a simular
        Long id = null;

        // Ejecutar el método a probar y verificar que se lance la excepción
        assertThrows(IllegalArgumentException.class, () -> serviceUzyTUsuario.eliminar(id));
    }


    @Test
    void testEliminar_UsuarioNoExiste() {
        // Datos del usuario a simular
        Long id = 1L;

        // Configurar el comportamiento del daoUzyTUsuario para findById
        when(daoUzyTUsuario.findById(id)).thenReturn(Optional.empty());

        // Ejecutar el método a probar y verificar que se lanza una ResourceNotFoundException
        assertThrows(ResourceNotFoundException.class, () -> serviceUzyTUsuario.eliminar(id));

        // Verificar que el método findById fue llamado
        verify(daoUzyTUsuario, times(1)).findById(id);
    }

342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
    //ASIGNAR PERFIL USUARIO

    @Test
    void testAsignarPerfilAUsuario_PerfilYaAsignado() {

        Long uzytusuario_id = 1L;
        Long uzytperfil_id = 2L;
        ModelUzyTUsuario usuario = new ModelUzyTUsuario();
        usuario.setUzytusuario_id(uzytusuario_id);
        usuario.setUzytusuario_nombres("Usuario de Prueba");

        ModelUzyTPerfil perfil = new ModelUzyTPerfil();
        perfil.setUzytperfil_id(uzytperfil_id);
        perfil.setUzytperfil_nombre("Perfil de Prueba");

        usuario.getUzytperfils().add(perfil);

        when(daoUzyTUsuario.findById(uzytusuario_id)).thenReturn(Optional.of(usuario));
        when(daoUzyTPerfil.findById(uzytperfil_id)).thenReturn(Optional.of(perfil));

        // Se ejecuta el método a probar y verifica que se lanza la excepción
        Assertions.assertThrows(IllegalArgumentException.class, () -> serviceUzyTUsuario.asignarPerfilAUsuario(uzytusuario_id, uzytperfil_id));

        //  Verifica que el perfil no se agregó nuevamente al usuario
        Assertions.assertEquals(1, usuario.getUzytperfils().size());
    }

369 370 371
    @DisplayName("Test para asignar un perfil a un usuario - Usuario o Perfil no existen (Caso de error)")
    @Test
    void testAsignarPerfilAUsuario_UsuarioOPerfilNoExiste() {
372
        // Datos de usuario y perfil a simular (ID inválidos)
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
        Long usuarioId = 1L;
        Long perfilId = 1L;

        // Configurar el comportamiento del daoUzyTUsuario y daoUzyTPerfil para findById (usar lenient)
        lenient().when(daoUzyTUsuario.findById(usuarioId)).thenReturn(Optional.empty());
        lenient().when(daoUzyTPerfil.findById(perfilId)).thenReturn(Optional.empty());

        // Ejecutar el método a probar y verificar que se lance la excepción
        assertThrows(ResourceNotFoundException.class, () -> serviceUzyTUsuario.asignarPerfilAUsuario(usuarioId, perfilId));
    }


    @DisplayName("Test para asignar un perfil a un usuario - ID negativo (Caso de error)")
    @Test
    void testAsignarPerfilAUsuario_IdNegativo() {
        // Datos de usuario y perfil a simular (IDs negativos)
        Long usuarioId = -1L;
        Long perfilId = -1L;

        // Ejecutar el método a probar y verificar que se lance la excepción
        assertThrows(IllegalArgumentException.class, () -> serviceUzyTUsuario.asignarPerfilAUsuario(usuarioId, perfilId));
394
    }
395
}