While testing DefaultUserDtoServiceTest using Mockito , service doesn't want to save. But while testing it threw api - it works

I'm testing DefaultUserDtoServiceTest and after mocking all services that are located in it, method save doesn't working. I don't have any idea why it throws me java.lang.NullPointerException, because I tested all methods using Postman of DefaultUserDtoService and all worked fine.

DefaultUserDtoServiceTest

@SpringBootTest
class DefaultUserDtoServiceTest {
    @InjectMocks
    private DefaultUserDtoService defaultUserDtoService;

    @Mock
    private UserMapper userMapper;

    @Mock
    private UserService userService;

    @Mock
    private CounterpartyTypeService counterpartyTypeService;

    @Mock
    private RoleService roleService;

    @Mock
    private TitleService titleService;

    private User user;
    private Role role;
    private Title title;
    private CounterpartyType counterpartyType;

    private RoleDto roleDto;
    private UserDto userDto;
    private TitleDto titleDto;
    private CreateUserDto createUserDto;
    private UpdateUserDto updateUserDto;
    private CounterpartyTypeDto counterpartyTypeDto;

    @BeforeEach
    public void setUp () {
        defaultUserDtoService = new DefaultUserDtoService(userMapper, userService, counterpartyTypeService, roleService, titleService);

        roleDto = new RoleDto();
        roleDto.setId(1L);
        roleDto.setPrivilege(1L);
        roleDto.setDescription("Administrator");
        roleDto.setName("ADMIN");

        role = new Role();
        role.setId(1L);
        role.setPrivilege(1L);
        role.setDescription("Administrator");
        role.setName("ADMIN");

        counterpartyType = new CounterpartyType();
        counterpartyType.setId(1L);
        counterpartyType.setType("Investor");

        title = new Title();
        title.setId(1L);
        title.setTitle("Mr.");

        counterpartyTypeDto = new CounterpartyTypeDto();
        counterpartyTypeDto.setType("Investor");
        counterpartyTypeDto.setId(1L);

        titleDto = new TitleDto();
        titleDto.setId(1L);
        titleDto.setTitle("Mr.");

        user = new User();
        user.setId(1L);
        user.setEmail("jp@mail.ru");
        user.setFirstName("Johnny");
        user.setPassword("johnny");
        user.setCounterpartyType(counterpartyType);
        user.setPosition("Position");
        user.setTitle(title);
        user.setLastName("Depp");
        user.setUsername("jp");
        user.setId(1L);

        userDto = new UserDto();
        userDto.setId(1L);
        userDto.setEmail("jp@mail.ru");
        userDto.setFirstName("Johnny");
        userDto.setPassword("johnny");
        userDto.setCounterpartyTypeDto(counterpartyTypeDto);
        userDto.setPosition("Position");
        userDto.setRoleDto(roleDto);
        userDto.setTitleDto(titleDto);
        userDto.setLastName("Depp");
        userDto.setUsername("jp");
        userDto.setId(1L);

        createUserDto = new CreateUserDto();
        createUserDto.setEmail("jp@mail.ru");
        createUserDto.setFirstName("Johnny");
        createUserDto.setPassword("johnny");
        createUserDto.setCounterpartyTypeDtoId(1L);
        createUserDto.setPosition("Position");
        createUserDto.setRoleDtoId(1L);
        createUserDto.setTitleDtoId(1L);
        createUserDto.setLastName("Depp");
        createUserDto.setUsername("jp");

        updateUserDto = new UpdateUserDto();
        updateUserDto.setEmail("jp@mail.ru");
        updateUserDto.setFirstName("Johnny");
        updateUserDto.setPassword("johnny");
        updateUserDto.setCounterpartyTypeDtoId(1L);
        createUserDto.setPosition("Position");
        updateUserDto.setRoleDtoId(1L);
        updateUserDto.setTitleDtoId(1L);
        updateUserDto.setLastName("Depp");
        updateUserDto.setUsername("jp");
    }

    @AfterEach
    public void tearDown() {
        user = null;
        role = null;
        title = null;
        counterpartyType = null;

        roleDto = null;
        userDto = null;
        titleDto = null;
        createUserDto = null;
        updateUserDto = null;
        counterpartyTypeDto = null;
    }

    @Test
    void create_withValidUserDto_shouldReturnUserDto() {
        when(counterpartyTypeService.getById(createUserDto.getCounterpartyTypeDtoId())).thenReturn(counterpartyType);
        when(roleService.getById(createUserDto.getRoleDtoId())).thenReturn(role);
        when(titleService.getById(createUserDto.getTitleDtoId())).thenReturn(title);
        when(userService.create(user)).thenReturn(user);
        when(userMapper.toUserDto(user)).thenReturn(userDto);

        UserDto responseUserDto = defaultUserDtoService.create(createUserDto);

        assertEquals(1L, responseUserDto.getId());
        assertEquals("jp@mail.ru", responseUserDto.getEmail());
        assertEquals("Johnny", responseUserDto.getFirstName());
        assertEquals("Depp", responseUserDto.getLastName());
        assertEquals("jp", responseUserDto.getUsername());
        assertEquals("Position", responseUserDto.getPosition());
        // Role
        assertEquals(1L, responseUserDto.getRoleDto().getId());
        assertEquals(2L, responseUserDto.getRoleDto().getPrivilege());
        assertEquals("Administrator", responseUserDto.getRoleDto().getDescription());
        // CounterpartyType
        assertEquals(1L, responseUserDto.getCounterpartyTypeDto().getId());
        assertEquals("Investor", responseUserDto.getCounterpartyTypeDto().getType());
        // Title
        assertEquals(1L, responseUserDto.getTitleDto().getId());
        assertEquals("Mr.", responseUserDto.getTitleDto().getTitle());

        verify(userService, times(1)).create(user);
    }
}

DefaultUserDtoService

@Service
public class DefaultUserDtoService implements UserDtoService {
    private final UserMapper userMapper;
    private final UserService userService;
    private final CounterpartyTypeService counterpartyTypeService;
    private final RoleService roleService;
    private final TitleService titleService;

    public DefaultUserDtoService(UserMapper userMapper, UserService userService, CounterpartyTypeService counterpartyTypeService, RoleService roleService, TitleService titleService) {
        this.userMapper = userMapper;
        this.userService = userService;
        this.counterpartyTypeService = counterpartyTypeService;
        this.roleService = roleService;
        this.titleService = titleService;
    }

    @Override
    public List<UserDto> getAll() {
        List<User> users = userService.getAll();
        List<UserDto> userDtoList = new ArrayList<>();

        users.forEach(user -> {
            UserDto userDto = userMapper.toUserDto(user);

            userDtoList.add(userDto);
        });

        return userDtoList;
    }

    @Override
    public UserDto getById(Long id) {
        User user = userService.getById(id);

        return userMapper.toUserDto(user);
    }

    @Override
    public void delete(Long id) {
        userService.delete(id);
    }

    @Override
    public UserDto create(CreateUserDto createUserDto) {
        // getting entities by id
        CounterpartyType counterpartyType = counterpartyTypeService.getById(createUserDto.getCounterpartyTypeDtoId());
        Role role = roleService.getById(createUserDto.getRoleDtoId());
        Title title = titleService.getById(createUserDto.getTitleDtoId());

        // converting createUserDto to user
        User createUser = new User();
        createUser.setCounterpartyType(counterpartyType);
        createUser.setTitle(title);
        createUser.getRoles().add(role);
        createUser.setFirstName(createUserDto.getFirstName());
        createUser.setLastName(createUserDto.getLastName());
        createUser.setPosition(createUserDto.getPosition());
        createUser.setEmail(createUserDto.getEmail());
        createUser.setMobilePhone(createUserDto.getMobilePhone());
        createUser.setOfficePhone(createUserDto.getOfficePhone());
        createUser.setSkype(createUserDto.getSkype());
        createUser.setHomeAddress(createUserDto.getHomeAddress());
        createUser.setWorkAddress(createUserDto.getWorkAddress());
        createUser.setUsername(createUserDto.getUsername());
        createUser.setPassword(createUserDto.getPassword());

        // getting response
        User responseUser = userService.create(createUser);

        return userMapper.toUserDto(responseUser);
    }
}

What shows me debugger: