src/test/java/com/packagemanagement/application/service/AuthenticationServiceTest.java - master - Chebarik/PackageManagement

src/test/java/com/packagemanagement/application/service/AuthenticationServiceTest.java
155 строк7 KB
Николай Мехоношин
Implemented tests for non functional requirements
14 апр 2026, 18:50
14 апр 2026, 18:509179c8b
package com.packagemanagement.application.service;

import com.packagemanagement.application.port.AuditService;
import com.packagemanagement.domain.model.User;
import com.packagemanagement.domain.model.UserRole;
import com.packagemanagement.domain.repository.UserRepository;
import com.packagemanagement.infrastructure.security.JwtTokenProvider;
import com.packagemanagement.presentation.response.TokenResponse;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
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.authentication.BadCredentialsException;
import org.springframework.security.crypto.password.PasswordEncoder;

import java.util.Optional;

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

@ExtendWith(MockitoExtension.class)
@DisplayName("AuthenticationService")
class AuthenticationServiceTest {

    @Mock
    private UserRepository userRepository;

    @Mock
    private JwtTokenProvider jwtTokenProvider;

    @Mock
    private PasswordEncoder passwordEncoder;

    @Mock
    private AuditService auditService;

    @InjectMocks
    private AuthenticationService authenticationService;

    private User createTestUser(String username, UserRole role) {
        return User.create(username, "$2a$10$hashedPassword", "test@test.com", role);
    }

    @Nested
    @DisplayName("authenticate")
    class Authenticate {

        @Test
        @DisplayName("should return token for valid credentials")
        void shouldReturnTokenForValidCredentials() {
            User user = createTestUser("john", UserRole.READER);
            when(userRepository.findByUsername("john")).thenReturn(Optional.of(user));
            when(passwordEncoder.matches("password123", user.getPasswordHash())).thenReturn(true);
            when(jwtTokenProvider.generateToken(user)).thenReturn("jwt-token");
            when(jwtTokenProvider.getAccessTokenExpiration()).thenReturn(3600L);

            TokenResponse response = authenticationService.authenticate("john", "password123", "127.0.0.1");

            assertEquals("jwt-token", response.accessToken());
            assertEquals("Bearer", response.tokenType());
            assertEquals(3600L, response.expiresIn());
            verify(auditService).logSecurityEvent(eq("LOGIN_SUCCESS"), eq("john"), eq("127.0.0.1"), anyString());
        }

        @Test
        @DisplayName("should throw BadCredentialsException for unknown user")
        void shouldThrowForUnknownUser() {
            when(userRepository.findByUsername("unknown")).thenReturn(Optional.empty());

            assertThrows(BadCredentialsException.class,
                    () -> authenticationService.authenticate("unknown", "pass", "127.0.0.1"));

            verify(auditService).logSecurityEvent(eq("LOGIN_FAILURE"), eq("unknown"), eq("127.0.0.1"), anyString());
        }

        @Test
        @DisplayName("should throw BadCredentialsException for wrong password")
        void shouldThrowForWrongPassword() {
            User user = createTestUser("john", UserRole.READER);
            when(userRepository.findByUsername("john")).thenReturn(Optional.of(user));
            when(passwordEncoder.matches("wrong", user.getPasswordHash())).thenReturn(false);

            assertThrows(BadCredentialsException.class,
                    () -> authenticationService.authenticate("john", "wrong", "127.0.0.1"));

            verify(auditService).logSecurityEvent(eq("LOGIN_FAILURE"), eq("john"), eq("127.0.0.1"), anyString());
        }

        @Test
        @DisplayName("should audit LOGIN_SUCCESS on successful login")
        void shouldAuditSuccessOnLogin() {
            User user = createTestUser("admin", UserRole.ADMIN);
            when(userRepository.findByUsername("admin")).thenReturn(Optional.of(user));
            when(passwordEncoder.matches(anyString(), anyString())).thenReturn(true);
            when(jwtTokenProvider.generateToken(any())).thenReturn("token");
            when(jwtTokenProvider.getAccessTokenExpiration()).thenReturn(3600L);

            authenticationService.authenticate("admin", "pass", "10.0.0.1");

            verify(auditService).logSecurityEvent("LOGIN_SUCCESS", "admin", "10.0.0.1", "");
        }
    }

    @Nested
    @DisplayName("register")
    class Register {

        @Test
        @DisplayName("should register new user and return token")
        void shouldRegisterNewUser() {
            when(userRepository.existsByUsername("newuser")).thenReturn(false);
            when(passwordEncoder.encode("Password1!")).thenReturn("$2a$10$encoded");
            when(userRepository.save(any(User.class))).thenAnswer(inv -> inv.getArgument(0));
            when(jwtTokenProvider.generateToken(any(User.class))).thenReturn("new-jwt");
            when(jwtTokenProvider.getAccessTokenExpiration()).thenReturn(3600L);

            TokenResponse response = authenticationService.register("newuser", "Password1!", "new@test.com", "127.0.0.1");

            assertEquals("new-jwt", response.accessToken());
            assertEquals("Bearer", response.tokenType());
            verify(userRepository).save(argThat(user ->
                    user.getUsername().equals("newuser") && user.getRole() == UserRole.READER));
            verify(auditService).logSecurityEvent(eq("REGISTRATION"), eq("newuser"), eq("127.0.0.1"), anyString());
        }

        @Test
        @DisplayName("should throw when username already exists")
        void shouldThrowWhenUsernameExists() {
            when(userRepository.existsByUsername("taken")).thenReturn(true);

            assertThrows(IllegalArgumentException.class,
                    () -> authenticationService.register("taken", "Password1!", "e@e.com", "127.0.0.1"));

            verify(userRepository, never()).save(any());
        }

        @Test
        @DisplayName("should assign READER role to new user")
        void shouldAssignReaderRole() {
            when(userRepository.existsByUsername("reader")).thenReturn(false);
            when(passwordEncoder.encode(anyString())).thenReturn("$2a$10$hash");
            when(userRepository.save(any(User.class))).thenAnswer(inv -> inv.getArgument(0));
            when(jwtTokenProvider.generateToken(any())).thenReturn("t");
            when(jwtTokenProvider.getAccessTokenExpiration()).thenReturn(3600L);

            authenticationService.register("reader", "Password1!", "r@r.com", "127.0.0.1");

            verify(userRepository).save(argThat(user -> user.getRole() == UserRole.READER));
        }
    }
}