autoflow-server-mgmt/src/test/java/kr/re/etri/autoflow/AuthControllerTest.java

package kr.re.etri.autoflow.controllers;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.times;

import java.util.Optional;
import java.util.Set;

import kr.re.etri.autoflow.models.ERole;
import kr.re.etri.autoflow.models.Role;
import kr.re.etri.autoflow.models.User;
import kr.re.etri.autoflow.payload.request.SignupRequest;
import kr.re.etri.autoflow.payload.response.MessageResponse;
import kr.re.etri.autoflow.repository.RoleRepository;
import kr.re.etri.autoflow.repository.UserRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.*;
import org.springframework.http.ResponseEntity;
import org.springframework.security.crypto.password.PasswordEncoder;

class AuthControllerTest {

    @InjectMocks
    private AuthController authController;

    @Mock
    private UserRepository userRepository;

    @Mock
    private RoleRepository roleRepository;

    @Mock
    private PasswordEncoder encoder;

    @BeforeEach
    void setup() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void testRegisterUser_Success() {
        SignupRequest request = new SignupRequest();
        request.setUsername("testuser");
        request.setEmail("test@example.com");
        request.setPassword("password");
        request.setRole(Set.of("ROLE_USER"));

        when(userRepository.existsByUsername("testuser")).thenReturn(false);
        when(userRepository.existsByEmail("test@example.com")).thenReturn(false);
        when(encoder.encode("password")).thenReturn("encodedPassword");

        Role roleUser = new Role();
        roleUser.setName(ERole.ROLE_USER);
        when(roleRepository.findByName(ERole.ROLE_USER)).thenReturn(Optional.of(roleUser));

        when(userRepository.save(any(User.class))).thenAnswer(i -> i.getArguments()[0]);

        ResponseEntity<?> response = authController.registerUser(request);

        assert response.getStatusCode().is2xxSuccessful();
        assert response.getBody() instanceof MessageResponse;
        assert ((MessageResponse)response.getBody()).getMessage().equals("사용자 등록이 완료되었습니다.");

        verify(userRepository, times(1)).save(any(User.class));
    }

    @Test
    void testRegisterUser_UsernameExists() {
        SignupRequest request = new SignupRequest();
        request.setUsername("testuser");
        request.setEmail("test@example.com");

        when(userRepository.existsByUsername("testuser")).thenReturn(true);

        ResponseEntity<?> response = authController.registerUser(request);

        assert response.getStatusCode().is4xxClientError();
        assert response.getBody() instanceof MessageResponse;
        assert ((MessageResponse)response.getBody()).getMessage().contains("이미 사용 중인 사용자 이름입니다.");
    }

    @Test
    void testRegisterUser_EmailExists() {
        SignupRequest request = new SignupRequest();
        request.setUsername("testuser");
        request.setEmail("test@example.com");

        when(userRepository.existsByUsername("testuser")).thenReturn(false);
        when(userRepository.existsByEmail("test@example.com")).thenReturn(true);

        ResponseEntity<?> response = authController.registerUser(request);

        assert response.getStatusCode().is4xxClientError();
        assert response.getBody() instanceof MessageResponse;
        assert ((MessageResponse)response.getBody()).getMessage().contains("이미 사용 중인 이메일입니다.");
    }

    @Test
    void testRegisterUser_InvalidRole() {
        SignupRequest request = new SignupRequest();
        request.setUsername("testuser");
        request.setEmail("test@example.com");
        request.setPassword("password");
        request.setRole(Set.of("INVALID_ROLE"));

        when(userRepository.existsByUsername("testuser")).thenReturn(false);
        when(userRepository.existsByEmail("test@example.com")).thenReturn(false);
        when(encoder.encode("password")).thenReturn("encodedPassword");

        ResponseEntity<?> response = authController.registerUser(request);

        assert response.getStatusCode().is4xxClientError();
        assert response.getBody() instanceof MessageResponse;
        assert ((MessageResponse)response.getBody()).getMessage().contains("역할은 유효하지 않습니다.");
    }

    @Test
    void testRegisterUser_RoleNotFoundInDb() {
        SignupRequest request = new SignupRequest();
        request.setUsername("testuser");
        request.setEmail("test@example.com");
        request.setPassword("password");
        request.setRole(Set.of("ROLE_ADMIN"));

        when(userRepository.existsByUsername("testuser")).thenReturn(false);
        when(userRepository.existsByEmail("test@example.com")).thenReturn(false);
        when(encoder.encode("password")).thenReturn("encodedPassword");

        when(roleRepository.findByName(ERole.ROLE_ADMIN)).thenReturn(Optional.empty());

        ResponseEntity<?> response;
        try {
            response = authController.registerUser(request);
            assert false; // 예외가 발생해야 함
        } catch (RuntimeException e) {
            assert e.getMessage().contains("역할이 DB에 존재하지 않습니다.");
        }
    }
}