src/test/java/ru/kipke/user/UserServiceTest.java - master - reitz/Minecraft-Skin-Editor

src/test/java/ru/kipke/user/UserServiceTest.java
153 строки5 KB
reitz
upload files
15 янв 2026, 07:54
15 янв 2026, 07:54a0879c4
package ru.kipke.user;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import static org.mockito.ArgumentMatchers.any;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    private User testUser;

    @BeforeEach
    void setUp() {
        testUser = new User("testuser", "hashedPassword");
        testUser = new User("testuser", "hashedPassword");
        // Используем рефлексию для установки ID
        try {
            var idField = User.class.getDeclaredField("id");
            idField.setAccessible(true);
            idField.set(testUser, 1L);
        } catch (Exception e) {
            // Игнорируем ошибки рефлексии
        }
    }

    @Test
    void testRegister_Success() {
        when(userRepository.existsByUsername("newuser")).thenReturn(false);
        when(userRepository.save(any(User.class))).thenAnswer(invocation -> {
            User user = invocation.getArgument(0);
            try {
                var idField = User.class.getDeclaredField("id");
                idField.setAccessible(true);
                idField.set(user, 1L);
            } catch (Exception ignored) {
            }
            return user;
        });

        User result = userService.register("newuser", "password123");

        assertNotNull(result);
        assertEquals("newuser", result.getUsername());
        assertNotNull(result.getPasswordHash());
        assertNotEquals("password123", result.getPasswordHash()); // Пароль должен быть захеширован
        verify(userRepository).existsByUsername("newuser");
        verify(userRepository).save(any(User.class));
    }

    @Test
    void testRegister_UserAlreadyExists() {
        when(userRepository.existsByUsername("existinguser")).thenReturn(true);

        assertThrows(IllegalArgumentException.class, () -> {
            userService.register("existinguser", "password123");
        });

        verify(userRepository).existsByUsername("existinguser");
        verify(userRepository, never()).save(any(User.class));
    }

    @Test
    void testAuthenticate_Success() {
        // Создаём пользователя с реальным BCrypt хешем для "password123"
        org.springframework.security.crypto.password.PasswordEncoder encoder = 
            new org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder();
        String realHash = encoder.encode("password123");
        User userWithRealHash = new User("testuser", realHash);
        try {
            var idField = User.class.getDeclaredField("id");
            idField.setAccessible(true);
            idField.set(userWithRealHash, 1L);
        } catch (Exception ignored) {
        }
        
        when(userRepository.findByUsername("testuser")).thenReturn(Optional.of(userWithRealHash));

        Optional<User> result = userService.authenticate("testuser", "password123");

        assertTrue(result.isPresent());
        assertEquals("testuser", result.get().getUsername());
    }

    @Test
    void testAuthenticate_WrongPassword() {
        testUser = new User("testuser", "$2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy");
        when(userRepository.findByUsername("testuser")).thenReturn(Optional.of(testUser));

        Optional<User> result = userService.authenticate("testuser", "wrongpassword");

        assertFalse(result.isPresent());
    }

    @Test
    void testAuthenticate_UserNotFound() {
        when(userRepository.findByUsername("nonexistent")).thenReturn(Optional.empty());

        Optional<User> result = userService.authenticate("nonexistent", "password123");

        assertFalse(result.isPresent());
    }

    @Test
    void testChangePassword() {
        when(userRepository.save(any(User.class))).thenReturn(testUser);

        userService.changePassword(testUser, "newpassword123");

        verify(userRepository).save(testUser);
        assertNotNull(testUser.getPasswordHash());
        assertNotEquals("newpassword123", testUser.getPasswordHash()); // Пароль должен быть захеширован
    }

    @Test
    void testFindById_Success() {
        when(userRepository.findById(1L)).thenReturn(Optional.of(testUser));

        Optional<User> result = userService.findById(1L);

        assertTrue(result.isPresent());
        assertEquals(testUser, result.get());
    }

    @Test
    void testFindById_NotFound() {
        when(userRepository.findById(999L)).thenReturn(Optional.empty());

        Optional<User> result = userService.findById(999L);

        assertFalse(result.isPresent());
    }
}