Unit Testing 을 위해서 Repository를 Mock했는데 먹지를 않습니다.

안녕하세요.

Unit Testing 을 처음 해보는데 일단 Service의 로직을 먼저 테스트하기 위해 Repository를 Mock해서 Service 내에 @InsertMocks 어노테이션을 걸어서 when 조건을 삽입했습니다.

이후 Service 내에서 findById(1L)을 실행하면 when문에서 걸어준대로 User 객체를 반환해야 한다고 생각했으나, 계속 Optional이 비어있다고 나오네요.

그래서 Service로 들어간것이 아니라 직접 Test 내에서 Repository를 불러본 결과 Mock가 문제없이 잘 되고 있었습니다. 제가 Configuration 한 것에 문제가 있는지 고견 부탁드립니다.

UserServiceTest

import com.politicia.coreservice.domain.User;
import com.politicia.coreservice.dto.request.UserRequestDto;
import com.politicia.coreservice.dto.response.UserResponseDto;
import com.politicia.coreservice.repository.UserRepository;
import org.junit.jupiter.api.Assertions;
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.MockitoAnnotations;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

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

@ExtendWith(MockitoExtension.class)
class UserServiceTest {


    @InjectMocks
    UserServiceImpl userService;

    @Mock
    private UserRepository userRepository;


    @BeforeEach
    public void setUp() {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    void testSignUp() {
        //given
        UserRequestDto newUser = UserRequestDto.builder()
                .name("newUser")
                .profilePic("https://profile.pic")
                .nationality("korea")
                .build();
        User expectedUser = User.builder()
                .id(1L)
                .name("newUser")
                .nationality("korea")
                .profilePic("https://profile.pic")
                .build();
        UserResponseDto expectedUserDto = UserResponseDto.builder()
                .id(1L)
                .name("newUser")
                .nationality("korea")
                .profilePic("https://profile.pic")
                .createdAt(expectedUser.getCreatedAt())
                .updatedAt(expectedUser.getUpdatedAt())
                .build();
        when(userRepository.save(any(User.class))).thenReturn(expectedUser);

        //when
        UserResponseDto actualUser = userService.createUser(newUser);

        // Verify
        assertEquals(expectedUserDto, actualUser);
    }

    @Test
    void testGetUser() {
        //given
        User user = User.builder()
                .id(1L)
                .name("user")
                .nationality("korea")
                .profilePic("profilePic")
                .build();
        List<User> userList = new ArrayList<>();
        userList.add(user);
        when(userRepository.findById(any(Long.class))).thenReturn(Optional.of(user));
        UserResponseDto expectedUserDto = UserResponseDto.builder()
                .id(1L)
                .name("user")
                .nationality("korea")
                .profilePic("profilePic")
                .createdAt(user.getCreatedAt())
                .updatedAt(user.getUpdatedAt())
                .build();
        //when
        UserResponseDto actualUserDto = userService.getUser(1L);
        //then
        Assertions.assertEquals(actualUserDto, expectedUserDto);

    }
}

UserServiceImpl

package com.politicia.coreservice.service;

import com.politicia.coreservice.domain.User;
import com.politicia.coreservice.dto.request.UserRequestDto;
import com.politicia.coreservice.dto.response.UserResponseDto;
import com.politicia.coreservice.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {

    private final UserRepository userRepository;

    @Override
    public UserResponseDto createUser(UserRequestDto userRequestDto) {

        User user = userRequestDto.toEntity();
        User newUser = userRepository.save(user);
        return UserResponseDto.builder()
                .id(newUser.getId())
                .name(newUser.getName())
                .nationality(newUser.getNationality())
                .profilePic(newUser.getProfilePic())
                .createdAt(newUser.getCreatedAt())
                .updatedAt(newUser.getUpdatedAt())
                .build();
    }
    @Override
    public UserResponseDto getUser(Long userId) {
        User foundUser = userRepository.findById(userId).get();
        return UserResponseDto.builder()
                .id(foundUser.getId())
                .name(foundUser.getName())
                .nationality(foundUser.getNationality())
                .profilePic(foundUser.getProfilePic())
                .createdAt(foundUser.getCreatedAt())
                .updatedAt(foundUser.getUpdatedAt())
                .build();
    }
}

에러문구