test(user): implementados test unitarios para repositorios, servicios y controladores de usuario

src/main/java/com/example/apprecetas/user/application/impl/CreateUserUseCaseImpl.java

@@ -3,10 +3,7 @@ package com.example.apprecetas.user.application.impl;
 import com.example.apprecetas.user.application.CreateUserUseCase;
 import com.example.apprecetas.user.application.CreateUserUseCase;
 import com.example.apprecetas.user.domain.entity.User;
 import com.example.apprecetas.user.domain.entity.User;
 import com.example.apprecetas.user.domain.repository.CreateUserRepository;
 import com.example.apprecetas.user.domain.repository.CreateUserRepository;
-import com.example.apprecetas.user.infrastructure.mapper.UserMapper;
 import lombok.RequiredArgsConstructor;
 import lombok.RequiredArgsConstructor;
-import org.mapstruct.factory.Mappers;
-import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 
 
 @Service
 @Service
@@ -14,9 +11,6 @@ import org.springframework.stereotype.Service;
 public class CreateUserUseCaseImpl implements CreateUserUseCase {
 public class CreateUserUseCaseImpl implements CreateUserUseCase {
 
 
     private final CreateUserRepository repository;
     private final CreateUserRepository repository;
-    private final UserMapper mapper = Mappers.getMapper(UserMapper.class);
-
-    private final PasswordEncoder passwordEncoder;
 
 
     @Override
     @Override
     public User create(User user) {
     public User create(User user) {

src/main/java/com/example/apprecetas/user/infrastructure/controller/dto/input/LoginRequest.java

 package com.example.apprecetas.user.infrastructure.controller.dto.input;
 package com.example.apprecetas.user.infrastructure.controller.dto.input;
 
 
 import jakarta.validation.constraints.NotEmpty;
 import jakarta.validation.constraints.NotEmpty;
+import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.Data;
 
 
 @Data
 @Data
+@AllArgsConstructor
 public class LoginRequest {
 public class LoginRequest {
     @NotEmpty(message = "Email obligatorio")
     @NotEmpty(message = "Email obligatorio")
     private String email;
     private String email;

src/main/java/com/example/apprecetas/user/infrastructure/controller/dto/input/PasswordChangeDto.java

@@ -3,11 +3,13 @@ package com.example.apprecetas.user.infrastructure.controller.dto.input;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.Pattern;
 import jakarta.validation.constraints.Pattern;
 import jakarta.validation.constraints.Size;
 import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.Setter;
 
 
 @Getter
 @Getter
 @Setter
 @Setter
+@AllArgsConstructor
 public class PasswordChangeDto {
 public class PasswordChangeDto {
 
 
     @NotBlank(message = "La contraseña no debe estar vacía")
     @NotBlank(message = "La contraseña no debe estar vacía")

src/main/java/com/example/apprecetas/user/infrastructure/controller/dto/input/UserUpdateInputDto.java

 package com.example.apprecetas.user.infrastructure.controller.dto.input;
 package com.example.apprecetas.user.infrastructure.controller.dto.input;
 
 
 import jakarta.validation.constraints.Size;
 import jakarta.validation.constraints.Size;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.Setter;
@@ -8,6 +9,7 @@ import lombok.Setter;
 @NoArgsConstructor
 @NoArgsConstructor
 @Getter
 @Getter
 @Setter
 @Setter
+@AllArgsConstructor
 public class UserUpdateInputDto {
 public class UserUpdateInputDto {
     @Size(min = 2, max = 20, message = "El nombre debe tener entre 2 y 20 caracteres")
     @Size(min = 2, max = 20, message = "El nombre debe tener entre 2 y 20 caracteres")
     private String name;
     private String name;

src/main/java/com/example/apprecetas/user/infrastructure/repository/mongodb/UserDocument.java

 package com.example.apprecetas.user.infrastructure.repository.mongodb;
 package com.example.apprecetas.user.infrastructure.repository.mongodb;
 
 
 import com.example.apprecetas.user.domain.entity.Role;
 import com.example.apprecetas.user.domain.entity.Role;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.Setter;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.annotation.Id;
@@ -12,6 +13,7 @@ import java.time.LocalDate;
 @Document(collection = "users")
 @Document(collection = "users")
 @Getter
 @Getter
 @Setter
 @Setter
+@AllArgsConstructor
 public class UserDocument {
 public class UserDocument {
 
 
     @Id
     @Id

src/test/java/com/example/apprecetas/security/service/CustomUserDetailsServiceImplTest.java

+package com.example.apprecetas.security.service;
+
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.domain.repository.ReadUserRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class CustomUserDetailsServiceImplTest {
+
+    @Mock
+    private ReadUserRepository readUserRepository;
+
+    @InjectMocks
+    private CustomUserDetailsServiceImpl service;
+
+    @Test
+    void testLoadUserByUsername() {
+        User user = createUser();
+        when(readUserRepository.readById(anyString())).thenReturn(user);
+        UserDetails result = service.loadUserByUsername(user.getId());
+        assertNotNull(result);
+        verify(readUserRepository).readById(anyString());
+    }
+
+    @Test
+    void testLoadUserByUsername_ThrowsException() {
+        User user = createUser();
+        when(readUserRepository.readById(anyString())).thenReturn(null);
+        assertThrows(UsernameNotFoundException.class, () -> service.loadUserByUsername(user.getId()));
+        verify(readUserRepository).readById(anyString());
+    }
+
+}

src/test/java/com/example/apprecetas/user/application/CreateUserUseCaseImplTest.java

+package com.example.apprecetas.user.application;
+
+import com.example.apprecetas.user.application.impl.CreateUserUseCaseImpl;
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.domain.repository.CreateUserRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class CreateUserUseCaseImplTest {
+
+    @Mock
+    private CreateUserRepository repository;
+
+    @InjectMocks
+    private CreateUserUseCaseImpl createUserUseCaseImpl;
+
+    @Test
+    void testCreate() {
+        User user = createUser();
+
+        when(repository.create(any(User.class))).thenReturn(user);
+
+        User result = createUserUseCaseImpl.create(user);
+        assertNotNull(result);
+
+        verify(repository).create(any(User.class));
+    }
+
+}

src/test/java/com/example/apprecetas/user/application/DeleteUserUseCaseImplTest.java

+package com.example.apprecetas.user.application;
+
+import com.example.apprecetas.user.application.impl.DeleteUserUseCaseImpl;
+import com.example.apprecetas.user.domain.repository.DeleteUserRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class DeleteUserUseCaseImplTest {
+
+    @Mock
+    private DeleteUserRepository deleteUserRepository;
+
+    @InjectMocks
+    private DeleteUserUseCaseImpl deleteUserUseCaseImpl;
+
+    @Test
+    void testDelete() {
+        doNothing().when(deleteUserRepository).deleteById(anyString());
+        deleteUserUseCaseImpl.deleteById("test");
+        verify(deleteUserRepository).deleteById(anyString());
+    }
+}

src/test/java/com/example/apprecetas/user/application/ReadUserUseCaseImplTest.java

+package com.example.apprecetas.user.application;
+
+import com.example.apprecetas.user.application.impl.ReadUserUseCaseImpl;
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.domain.repository.ReadUserRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class ReadUserUseCaseImplTest {
+
+    @Mock
+    private ReadUserRepository repository;
+
+    @InjectMocks
+    private ReadUserUseCaseImpl readUserUseCaseImpl;
+
+    @Test
+    void testReadById() {
+        User user = createUser();
+        when(repository.readById(anyString())).thenReturn(user);
+
+        User result = readUserUseCaseImpl.readById(user.getId());
+        assertNotNull(result);
+        assertEquals(user.getName(), result.getName());
+
+        verify(repository).readById(anyString());
+    }
+
+    @Test
+    void testReadByEmail() {
+        User user = createUser();
+        when(repository.readByEmail(anyString())).thenReturn(user);
+
+        User result = readUserUseCaseImpl.readByEmail(user.getEmail());
+        assertNotNull(result);
+        assertEquals(user.getSurname(), result.getSurname());
+
+        verify(repository).readByEmail(anyString());
+    }
+
+    @Test
+    void testReadByNameOrEmail() {
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<User> page = new PageImpl<>(List.of(createUser()));
+
+        when(repository.readByNameOrEmail(anyString(), anyString(), any(Pageable.class))).thenReturn(page);
+
+        Page<User> result = readUserUseCaseImpl.readByNameOrEmail("usu", pageable);
+        assertNotNull(result);
+        assertEquals(1, result.getTotalElements());
+
+        verify(repository).readByNameOrEmail(anyString(), anyString(), any(Pageable.class));
+    }
+
+    @Test
+    void testReadAll() {
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<User> page = new PageImpl<>(List.of(createUser()));
+
+        when(repository.readAll(any(Pageable.class))).thenReturn(page);
+
+        Page<User> result = readUserUseCaseImpl.readAll(pageable);
+        assertNotNull(result);
+        assertEquals(1, result.getTotalElements());
+
+        verify(repository).readAll(any(Pageable.class));
+    }
+
+}

src/test/java/com/example/apprecetas/user/application/UpdateUserUseCaseImplTest.java

+package com.example.apprecetas.user.application;
+
+import com.example.apprecetas.user.application.impl.UpdateUserUseCaseImpl;
+import com.example.apprecetas.user.domain.entity.Role;
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.domain.repository.UpdateUserRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class UpdateUserUseCaseImplTest {
+
+    @Mock
+    private UpdateUserRepository repository;
+
+    @InjectMocks
+    private UpdateUserUseCaseImpl updateUseCaseImpl;
+
+    @Test
+    void updateUser() {
+        User user = createUser();
+
+        when(repository.updateById(anyString(), any(User.class))).thenReturn(user);
+
+        User result = updateUseCaseImpl.updateById(user.getId(), user);
+        assertNotNull(result);
+
+        verify(repository).updateById(anyString(), any(User.class));
+    }
+
+    @Test
+    void testChangePassword() {
+        when(repository.changePassword(anyString(), anyString(), anyString())).thenReturn(true);
+        boolean result = updateUseCaseImpl.changePassword("test", "test", "test");
+        assertTrue(result);
+        verify(repository).changePassword(anyString(), anyString(), anyString());
+    }
+
+    @Test
+    void testDeactivateUser() {
+        doNothing().when(repository).deactivateById(anyString());
+        updateUseCaseImpl.deactivateById("test");
+        verify(repository).deactivateById(anyString());
+    }
+
+    @Test
+    void testActivateUser() {
+        doNothing().when(repository).activateById(anyString());
+        updateUseCaseImpl.activateById("test");
+        verify(repository).activateById(anyString());
+    }
+
+    @Test
+    void testChangeRole() {
+        doNothing().when(repository).changeRole(anyString(), any(Role.class));
+        updateUseCaseImpl.changeRole("test", Role.ADMIN);
+        verify(repository).changeRole(anyString(), any(Role.class));
+    }
+
+}

src/test/java/com/example/apprecetas/user/infrastructure/controller/AuthControllerTest.java

+package com.example.apprecetas.user.infrastructure.controller;
+
+import com.example.apprecetas.exception.EntityNotFoundException;
+import com.example.apprecetas.exception.UnprocessableEntityException;
+import com.example.apprecetas.security.jwt.JwtTokenProvider;
+import com.example.apprecetas.user.application.CreateUserUseCase;
+import com.example.apprecetas.user.application.ReadUserUseCase;
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.infrastructure.controller.dto.input.LoginRequest;
+import com.example.apprecetas.user.infrastructure.controller.dto.input.UserInputDto;
+import com.example.apprecetas.user.infrastructure.controller.dto.output.AuthResponse;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.validation.BindingResult;
+
+import java.time.LocalDate;
+
+import static com.example.apprecetas.utils.UserTestFactory.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class AuthControllerTest {
+
+    @Mock
+    private CreateUserUseCase service;
+
+    @Mock
+    private BindingResult result;
+
+    @Mock
+    private PasswordEncoder encoder;
+
+    @Mock
+    private JwtTokenProvider tokenProvider;
+
+    @Mock
+    private ReadUserUseCase readService;
+
+    @InjectMocks
+    private AuthController controller;
+
+    @Test
+    void testLogin_Catch() {
+        LoginRequest loginRequest = createLoginRequest();
+        when(result.hasErrors()).thenReturn(false);
+        when(readService.readByEmail(anyString())).thenThrow(EntityNotFoundException.class);
+
+        ResponseEntity<?> response = controller.login(loginRequest, result);
+        assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
+
+        verify(result).hasErrors();
+        verify(readService).readByEmail(anyString());
+    }
+
+    @Test
+    void testLogin_WithErrors() {
+        LoginRequest loginRequest = createLoginRequest();
+        when(result.hasErrors()).thenReturn(true);
+        assertThrows(UnprocessableEntityException.class, () -> controller.login(loginRequest, result));
+        verify(result).hasErrors();
+    }
+
+    @Test
+    void testLogin_Inactive() {
+        User user = createUser();
+        user.setDeletedAt(LocalDate.now());
+        LoginRequest loginRequest = createLoginRequest();
+
+        when(result.hasErrors()).thenReturn(false);
+        when(readService.readByEmail(anyString())).thenReturn(user);
+
+        ResponseEntity<?> response = controller.login(loginRequest, result);
+        assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
+
+        verify(result).hasErrors();
+        verify(readService).readByEmail(anyString());
+    }
+
+    @Test
+    void testLogin_PasswordIncorrect() {
+        User user = createUser();
+        LoginRequest loginRequest = createLoginRequest();
+
+        when(result.hasErrors()).thenReturn(false);
+        when(readService.readByEmail(anyString())).thenReturn(user);
+        when(encoder.matches(anyString(), anyString())).thenReturn(false);
+
+        ResponseEntity<?> response = controller.login(loginRequest, result);
+        assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
+
+        verify(result).hasErrors();
+        verify(readService).readByEmail(anyString());
+        verify(encoder).matches(anyString(), anyString());
+    }
+
+    @Test
+    void testLogin() {
+        User user = createUser();
+        LoginRequest loginRequest = createLoginRequest();
+
+        when(result.hasErrors()).thenReturn(false);
+        when(readService.readByEmail(anyString())).thenReturn(user);
+        when(encoder.matches(anyString(), anyString())).thenReturn(true);
+        when(tokenProvider.generateToken(anyString(), anyString())).thenReturn("token");
+
+        ResponseEntity<?> response = controller.login(loginRequest, result);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(result).hasErrors();
+        verify(readService).readByEmail(anyString());
+        verify(encoder).matches(anyString(), anyString());
+        verify(tokenProvider).generateToken(anyString(), anyString());
+    }
+
+    @Test
+    void testRegister_WithErrors() {
+        UserInputDto userInputDto = createUserInputDto();
+        when(result.hasErrors()).thenReturn(true);
+        assertThrows(UnprocessableEntityException.class, () -> controller.register(userInputDto, result));
+        verify(result).hasErrors();
+    }
+
+    @Test
+    void testRegister_Catch() {
+        when(result.hasErrors()).thenReturn(false);
+        when(service.create(any(User.class))).thenThrow(EntityNotFoundException.class);
+
+        assertThrows(UnprocessableEntityException.class, () -> controller.register(createUserInputDto(), result));
+
+        verify(result).hasErrors();
+        verify(service).create(any(User.class));
+    }
+
+    @Test
+    void testRegister() {
+        when(result.hasErrors()).thenReturn(false);
+        when(service.create(any(User.class))).thenReturn(createUser());
+        when(tokenProvider.generateToken(anyString(), anyString())).thenReturn("token");
+
+        ResponseEntity<AuthResponse> response = controller.register(createUserInputDto(), result);
+        assertEquals(HttpStatus.CREATED, response.getStatusCode());
+
+        verify(result).hasErrors();
+        verify(service).create(any(User.class));
+        verify(tokenProvider).generateToken(anyString(), anyString());
+    }
+
+}

src/test/java/com/example/apprecetas/user/infrastructure/controller/DeleteUserControllerTest.java

+package com.example.apprecetas.user.infrastructure.controller;
+
+import com.example.apprecetas.user.application.DeleteUserUseCase;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import java.util.Objects;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class DeleteUserControllerTest {
+
+    @Mock
+    private DeleteUserUseCase deleteUserUseCase;
+
+    @InjectMocks
+    private DeleteUserController deleteUserController;
+
+    @Test
+    void testDelete() {
+        doNothing().when(deleteUserUseCase).deleteById(anyString());
+
+        ResponseEntity<String> response = deleteUserController.deleteById("test");
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertTrue(Objects.requireNonNull(response.getBody()).contains("Usuario con id test"));
+
+        verify(deleteUserUseCase, times(1)).deleteById(anyString());
+    }
+
+}

src/test/java/com/example/apprecetas/user/infrastructure/controller/ReadUserControllerTest.java

+package com.example.apprecetas.user.infrastructure.controller;
+
+import com.example.apprecetas.user.application.ReadUserUseCase;
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.infrastructure.controller.dto.output.UserOutputDto;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.*;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+
+import java.util.Collections;
+import java.util.List;
+
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class ReadUserControllerTest {
+
+    @Mock
+    private ReadUserUseCase service;
+
+    @Mock
+    private SecurityContext securityContext;
+
+    @Mock
+    private Authentication authentication;
+
+    @InjectMocks
+    private ReadUserController controller;
+
+    @BeforeEach
+    void setUp() {
+        SecurityContextHolder.setContext(securityContext);
+    }
+
+    @AfterEach
+    void clearContext() {
+        SecurityContextHolder.clearContext();
+    }
+
+    @Test
+    void testReadMe() {
+        User user = createUser();
+
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+        when(service.readById(anyString())).thenReturn(user);
+
+        ResponseEntity<UserOutputDto> response = controller.readMe();
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+        verify(service).readById(anyString());
+    }
+
+    @Test
+    void testReadByNameOrEmail() {
+        User user = createUser();
+        Page<User> page = new PageImpl<>(Collections.singletonList(user));
+
+        when(service.readByNameOrEmail(anyString(), any(Pageable.class))).thenReturn(page);
+
+        ResponseEntity<Page<UserOutputDto>> response = controller.readByNameOrEmail("usu", 0, 10);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(service).readByNameOrEmail(anyString(), any(Pageable.class));
+    }
+
+
+    @Test
+    void testReadAll_WithoutSortBy() {
+        // Arrange
+        User user = createUser();
+        //UserOutputDto userOutputDto = new UserOutputDto("1", "testUser", "test@email.com");
+        Pageable pageable = PageRequest.of(0, 5);
+        Page<User> userPage = new PageImpl<>(List.of(user), pageable, 1);
+
+        when(service.readAll(pageable)).thenReturn(userPage);
+
+        // Act
+        ResponseEntity<Page<UserOutputDto>> response =
+                controller.readAll(0, 5, null, "ASC");
+
+        // Assert
+        assertNotNull(response);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(1, response.getBody().getTotalElements());
+        assertEquals("Usuario prueba", response.getBody().getContent().get(0).getName());
+
+        verify(service).readAll(pageable);
+    }
+
+    @Test
+    void testReadAll_WithSortBy() {
+        // Arrange
+        User user = createUser();
+        //UserOutputDto dto = new UserOutputDto("2", "anotherUser", "user@email.com");
+        Pageable pageable = PageRequest.of(0, 5, Sort.by(Sort.Direction.ASC, "name"));
+        Page<User> userPage = new PageImpl<>(List.of(user), pageable, 1);
+
+        when(service.readAll(pageable)).thenReturn(userPage);
+
+        // Act
+        ResponseEntity<Page<UserOutputDto>> response =
+                controller.readAll(0, 5, "name", "ASC");
+
+        // Assert
+        assertNotNull(response);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(1, response.getBody().getTotalElements());
+        assertEquals("Usuario prueba", response.getBody().getContent().get(0).getName());
+
+        verify(service).readAll(pageable);
+    }
+
+}

src/test/java/com/example/apprecetas/user/infrastructure/controller/UpdateUserControllerTest.java

+package com.example.apprecetas.user.infrastructure.controller;
+
+import com.example.apprecetas.exception.UnprocessableEntityException;
+import com.example.apprecetas.user.application.UpdateUserUseCase;
+import com.example.apprecetas.user.domain.entity.Role;
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.infrastructure.controller.dto.input.PasswordChangeDto;
+import com.example.apprecetas.user.infrastructure.controller.dto.input.UserUpdateInputDto;
+import com.example.apprecetas.user.infrastructure.controller.dto.output.UserOutputDto;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.validation.BindingResult;
+
+import static com.example.apprecetas.utils.UserTestFactory.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class UpdateUserControllerTest {
+
+    @Mock
+    private UpdateUserUseCase service;
+
+    @Mock
+    private BindingResult bindingResult;
+
+    @Mock
+    private SecurityContext securityContext;
+
+    @Mock
+    private Authentication authentication;
+
+    @InjectMocks
+    private UpdateUserController controller;
+
+    @BeforeEach
+    void setUp() {
+        SecurityContextHolder.setContext(securityContext);
+    }
+
+    @AfterEach
+    void clearContext() {
+        SecurityContextHolder.clearContext();
+    }
+
+    @Test
+    void testUpdate() {
+        User user = createUser();
+        UserUpdateInputDto userInputDto = createUserUpdateInputDto();
+
+        when(bindingResult.hasErrors()).thenReturn(false);
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+        when(service.updateById(anyString(), any(User.class))).thenReturn(user);
+
+        ResponseEntity<UserOutputDto> response = controller.update(userInputDto, bindingResult);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(bindingResult).hasErrors();
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+        verify(service).updateById(anyString(), any(User.class));
+    }
+
+    @Test
+    void testUpdate_WithErrors() {
+        UserUpdateInputDto userInputDto = createUserUpdateInputDto();
+        when(bindingResult.hasErrors()).thenReturn(true);
+        assertThrows(UnprocessableEntityException.class, () -> controller.update(userInputDto, bindingResult));
+        verify(bindingResult).hasErrors();
+    }
+
+    @Test
+    void testChangePassword_True() {
+        User user = createUser();
+        PasswordChangeDto passwordChangeDto = createPasswordChangeDto();
+
+        when(bindingResult.hasErrors()).thenReturn(false);
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+        when(service.changePassword(anyString(), anyString(), anyString())).thenReturn(true);
+
+        ResponseEntity<String> response = controller.changePassword(passwordChangeDto, bindingResult);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(bindingResult).hasErrors();
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+        verify(service).changePassword(anyString(), anyString(), anyString());
+    }
+
+    @Test
+    void testChangePassword_False() {
+        User user = createUser();
+        PasswordChangeDto passwordChangeDto = createPasswordChangeDto();
+
+        when(bindingResult.hasErrors()).thenReturn(false);
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+        when(service.changePassword(anyString(), anyString(), anyString())).thenReturn(false);
+
+        ResponseEntity<String> response = controller.changePassword(passwordChangeDto, bindingResult);
+        assertEquals(HttpStatus.CONFLICT, response.getStatusCode());
+
+        verify(bindingResult).hasErrors();
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+        verify(service).changePassword(anyString(), anyString(), anyString());
+    }
+
+    @Test
+    void testChangePassword_WithErrors() {
+        PasswordChangeDto passwordChangeDto = createPasswordChangeDto();
+        when(bindingResult.hasErrors()).thenReturn(true);
+        assertThrows(UnprocessableEntityException.class, () -> controller.changePassword(passwordChangeDto, bindingResult));
+        verify(bindingResult).hasErrors();
+    }
+
+    @Test
+    void testDeactivateMe() {
+        User user = createUser();
+
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+        doNothing().when(service).deactivateById(anyString());
+
+        ResponseEntity<String> response = controller.deactivateMe();
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+        verify(service).deactivateById(anyString());
+    }
+
+    @Test
+    void testDeactivate() {
+        User user = createUser();
+
+        doNothing().when(service).deactivateById(anyString());
+
+        ResponseEntity<String> response = controller.deactivate(user.getId());
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(service).deactivateById(anyString());
+    }
+
+    @Test
+    void testActivate() {
+        User user = createUser();
+
+        doNothing().when(service).activateById(anyString());
+
+        ResponseEntity<String> response = controller.activate(user.getId());
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(service).activateById(anyString());
+    }
+
+    @Test
+    void testChangeRole() {
+        User user = createUser();
+
+        doNothing().when(service).changeRole(anyString(), any(Role.class));
+
+        ResponseEntity<String> response = controller.changeRole(user.getId(), Role.ADMIN);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(service).changeRole(anyString(), any(Role.class));
+    }
+}

src/test/java/com/example/apprecetas/user/infrastructure/repository/CreateUserRepositoryImplTest.java

+package com.example.apprecetas.user.infrastructure.repository;
+
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.infrastructure.repository.impl.CreateUserRepositoryImpl;
+import com.example.apprecetas.user.infrastructure.repository.mongodb.UserDocument;
+import com.example.apprecetas.user.infrastructure.repository.mongodb.UserRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static com.example.apprecetas.utils.UserTestFactory.createUserDocument;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class CreateUserRepositoryImplTest {
+
+    @Mock
+    private UserRepository userRepository;
+
+    @Mock
+    private PasswordEncoder passwordEncoder;
+
+    @InjectMocks
+    private CreateUserRepositoryImpl createUserRepositoryImpl;
+
+    @Test
+    void testCreate() {
+        User user = createUser();
+        UserDocument userDocument = createUserDocument();
+
+        when(passwordEncoder.encode(anyString())).thenReturn("encodedPassword");
+        when(userRepository.save(any(UserDocument.class))).thenReturn(userDocument);
+
+        User result = createUserRepositoryImpl.create(user);
+        assertNotNull(result);
+        assertEquals(userDocument.getId(), result.getId());
+
+        verify(passwordEncoder).encode(anyString());
+        verify(userRepository).save(any(UserDocument.class));
+    }
+
+}

src/test/java/com/example/apprecetas/user/infrastructure/repository/DeleteUserRepositoryImplTest.java

+package com.example.apprecetas.user.infrastructure.repository;
+
+import com.example.apprecetas.user.infrastructure.repository.impl.DeleteUserRepositoryImpl;
+import com.example.apprecetas.user.infrastructure.repository.mongodb.UserDocument;
+import com.example.apprecetas.user.infrastructure.repository.mongodb.UserRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Optional;
+
+import static com.example.apprecetas.utils.UserTestFactory.createUserDocument;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+
+@ExtendWith(MockitoExtension.class)
+class DeleteUserRepositoryImplTest {
+
+    @Mock
+    private UserRepository userRepository;
+
+    @InjectMocks
+    private DeleteUserRepositoryImpl deleteUserRepository;
+
+    @Test
+    void testDeleteById() {
+        UserDocument userDocument = createUserDocument();
+
+        when(userRepository.findById(anyString())).thenReturn(Optional.of(userDocument));
+        doNothing().when(userRepository).deleteById(anyString());
+
+        deleteUserRepository.deleteById(userDocument.getId());
+
+        verify(userRepository).findById(anyString());
+        verify(userRepository).deleteById(anyString());
+    }
+
+}

src/test/java/com/example/apprecetas/user/infrastructure/repository/ReadUserRepositoryImplTest.java

+package com.example.apprecetas.user.infrastructure.repository;
+
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.infrastructure.repository.impl.ReadUserRepositoryImpl;
+import com.example.apprecetas.user.infrastructure.repository.mongodb.UserDocument;
+import com.example.apprecetas.user.infrastructure.repository.mongodb.UserRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import static com.example.apprecetas.utils.UserTestFactory.createUserDocument;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class ReadUserRepositoryImplTest {
+
+    @Mock
+    private UserRepository userRepository;
+
+    @InjectMocks
+    private ReadUserRepositoryImpl readUserRepository;
+
+    @Test
+    void testReadById() {
+        UserDocument userDocument = createUserDocument();
+
+        when(userRepository.findById(anyString())).thenReturn(Optional.of(userDocument));
+
+        User result = readUserRepository.readById(userDocument.getId());
+        assertNotNull(result);
+        assertEquals(result.getEmail(), userDocument.getEmail());
+
+        verify(userRepository).findById(anyString());
+    }
+
+    @Test
+    void testReadByEmail() {
+        UserDocument userDocument = createUserDocument();
+
+        when(userRepository.findByEmail(anyString())).thenReturn(Optional.of(userDocument));
+
+        User result = readUserRepository.readByEmail(userDocument.getEmail());
+        assertNotNull(result);
+        assertEquals(result.getId(), userDocument.getId());
+
+        verify(userRepository).findByEmail(anyString());
+    }
+
+    @Test
+    void testReadByNameOrEmail() {
+        UserDocument userDocument = createUserDocument();
+        Pageable pageable = PageRequest.of(0, 2);
+        List<UserDocument> list = new ArrayList<>();
+        list.add(userDocument);
+
+        Page<UserDocument> page = new PageImpl<>(list, pageable, list.size());
+
+        when(userRepository.findByNameIgnoreCaseContainingOrEmailIgnoreCaseContaining(anyString(), anyString(), any(Pageable.class)))
+                .thenReturn(page);
+
+        Page<User> result = readUserRepository.readByNameOrEmail(userDocument.getName(), userDocument.getEmail(), pageable);
+        assertNotNull(result);
+        assertEquals(result.getTotalElements(), page.getTotalElements());
+
+        verify(userRepository).findByNameIgnoreCaseContainingOrEmailIgnoreCaseContaining(anyString(), anyString(), any(Pageable.class));
+    }
+
+    @Test
+    void testReadAll() {
+        UserDocument userDocument = createUserDocument();
+        Pageable pageable = PageRequest.of(0, 2);
+        List<UserDocument> list = new ArrayList<>();
+        list.add(userDocument);
+
+        Page<UserDocument> page = new PageImpl<>(list, pageable, list.size());
+
+        when(userRepository.findAll(any(Pageable.class)))
+                .thenReturn(page);
+
+        Page<User> result = readUserRepository.readAll(pageable);
+        assertNotNull(result);
+        assertEquals(result.getTotalElements(), page.getTotalElements());
+
+        verify(userRepository).findAll(any(Pageable.class));
+    }
+
+}

src/test/java/com/example/apprecetas/user/infrastructure/repository/UpdateUserRepositoryImplTest.java

+package com.example.apprecetas.user.infrastructure.repository;
+
+import com.example.apprecetas.user.domain.entity.Role;
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.infrastructure.repository.impl.UpdateUserRepositoryImpl;
+import com.example.apprecetas.user.infrastructure.repository.mongodb.UserDocument;
+import com.example.apprecetas.user.infrastructure.repository.mongodb.UserRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+import java.time.LocalDate;
+import java.util.Optional;
+
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static com.example.apprecetas.utils.UserTestFactory.createUserDocument;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class UpdateUserRepositoryImplTest {
+
+    @Mock
+    private UserRepository userRepository;
+
+    @Mock
+    private PasswordEncoder passwordEncoder;
+
+    @InjectMocks
+    private UpdateUserRepositoryImpl updateUserRepository;
+
+    @Test
+    void testUpdateById() {
+        UserDocument userDocument = createUserDocument();
+        User user = createUser();
+        user.setName("nombre modificado");
+
+        when(userRepository.findById(anyString())).thenReturn(Optional.of(userDocument));
+        userDocument.setName("nombre modificado");
+        when(userRepository.save(any(UserDocument.class))).thenReturn(userDocument);
+
+        User result = updateUserRepository.updateById(userDocument.getId(), user);
+        assertNotNull(result);
+        assertEquals("nombre modificado", result.getName());
+
+        verify(userRepository).findById(anyString());
+        verify(userRepository).save(any(UserDocument.class));
+    }
+
+    @Test
+    void testChangePassword() {
+        UserDocument userDocument = createUserDocument();
+        userDocument.setPassword("passwordEncoder");
+
+        when(userRepository.findById(anyString())).thenReturn(Optional.of(userDocument));
+        when(passwordEncoder.matches(anyString(), anyString())).thenReturn(true);
+        when(passwordEncoder.encode(anyString())).thenReturn("passwordEncoder");
+        userDocument.setPassword("passwordEncoder");
+        when(userRepository.save(any(UserDocument.class))).thenReturn(userDocument);
+
+        boolean result = updateUserRepository.changePassword(userDocument.getId(), "passwordEncoder", "password");
+        assertTrue(result);
+
+        verify(userRepository).findById(anyString());
+        verify(passwordEncoder).encode(anyString());
+        verify(userRepository).save(any(UserDocument.class));
+    }
+
+    @Test
+    void testChangePassword_PasswordMismatch() {
+        UserDocument userDocument = createUserDocument();
+        userDocument.setPassword("encodedPassword");
+
+        when(userRepository.findById(anyString())).thenReturn(Optional.of(userDocument));
+        when(passwordEncoder.matches(anyString(), anyString())).thenReturn(false);
+
+        boolean result = updateUserRepository.changePassword(
+                userDocument.getId(), "wrongPassword", "newPassword");
+
+        assertFalse(result);
+
+        verify(userRepository).findById(anyString());
+        verify(passwordEncoder).matches(anyString(), anyString());
+    }
+
+
+    @Test
+    void testDeactivateById() {
+        UserDocument userDocument = createUserDocument();
+
+        when(userRepository.findById(anyString())).thenReturn(Optional.of(userDocument));
+        userDocument.setDeletedAt(LocalDate.now());
+        when(userRepository.save(any(UserDocument.class))).thenReturn(userDocument);
+
+        updateUserRepository.deactivateById(userDocument.getId());
+        assertEquals(userDocument.getDeletedAt(), LocalDate.now());
+
+        verify(userRepository).findById(anyString());
+        verify(userRepository).save(any(UserDocument.class));
+    }
+
+    @Test
+    void testActivateById() {
+        UserDocument userDocument = createUserDocument();
+
+        when(userRepository.findById(anyString())).thenReturn(Optional.of(userDocument));
+        when(userRepository.save(any(UserDocument.class))).thenReturn(userDocument);
+
+        updateUserRepository.activateById(userDocument.getId());
+        assertNull(userDocument.getDeletedAt());
+
+        verify(userRepository).findById(anyString());
+        verify(userRepository).save(any(UserDocument.class));
+    }
+
+    @Test
+    void testChangeRole() {
+        UserDocument userDocument = createUserDocument();
+
+        when(userRepository.findById(anyString())).thenReturn(Optional.of(userDocument));
+        userDocument.setRole(Role.ADMIN);
+        when(userRepository.save(any(UserDocument.class))).thenReturn(userDocument);
+
+        updateUserRepository.changeRole(userDocument.getId(), Role.ADMIN);
+        assertEquals(Role.ADMIN, userDocument.getRole());
+
+        verify(userRepository).findById(anyString());
+        verify(userRepository).save(any(UserDocument.class));
+    }
+
+}

src/test/java/com/example/apprecetas/utils/UserTestFactory.java

+package com.example.apprecetas.utils;
+
+import com.example.apprecetas.user.domain.entity.Role;
+import com.example.apprecetas.user.domain.entity.User;
+import com.example.apprecetas.user.infrastructure.controller.dto.input.LoginRequest;
+import com.example.apprecetas.user.infrastructure.controller.dto.input.PasswordChangeDto;
+import com.example.apprecetas.user.infrastructure.controller.dto.input.UserInputDto;
+import com.example.apprecetas.user.infrastructure.controller.dto.input.UserUpdateInputDto;
+import com.example.apprecetas.user.infrastructure.repository.mongodb.UserDocument;
+
+public class UserTestFactory {
+
+    public static UserDocument createUserDocument() {
+        return new UserDocument(
+                "123456789",
+                "Usuario prueba",
+                "Apellidos usuario",
+                "usuario@gmail.com",
+                "Segura.1",
+                Role.USER,
+                null
+        );
+    }
+
+    public static User createUser() {
+        return new User(
+                "123456789",
+                "Usuario prueba",
+                "Apellidos usuario",
+                "usuario@gmail.com",
+                "Segura.1",
+                Role.USER,
+                null
+        );
+    }
+
+    public static UserInputDto createUserInputDto() {
+        return new UserInputDto(
+                "Usuario prueba",
+                "Apellidos usuario",
+                "usuario@gmail.com",
+                "Segura.1"
+        );
+    }
+
+    public static UserUpdateInputDto createUserUpdateInputDto() {
+        return new UserUpdateInputDto(
+                "Usuario prueba",
+                "Apellidos usuario"
+        );
+    }
+
+    public static PasswordChangeDto createPasswordChangeDto() {
+        return new PasswordChangeDto("oldPassword", "newPassword");
+    }
+
+    public static LoginRequest createLoginRequest() {
+        return new LoginRequest("email", "contraseña");
+    }
+
+}