如何编写断言以确保AOP弹簧类捕获到我的异常

Question

我正在尝试为此类编写一些测试，这些测试应捕获异常并将其记录下来。但是，当我运行测试时，它们将失败。我的测试如下所示。我不太确定应该如何编写测试，我只是在这里展示了我的尝试。我试图实现的目的是通过执行JUnit断言来确保我设置的方面能够捕获异常。我也知道正确的方法与切入点匹配，因为当我单击IDE左侧的符号时，IntelliJ IDEA会跳转到与切入点匹配的方法。当我刚开始为AOP编写测试时，我的测试是否有意义？此外，运行测试时不会调用方面。

interface UserSearch {
    User findUser(long userId); 
    // ...  
}

@Service
public class UserSearchImpl implements UserSearch{
     UserRepository userRepository;

     @Autowired
     UserSearchImpl(UserRepository userRepository){
         this.userRepository = userRepository;
     }

    public User findUser(long userId){
       User user = userRepository.findById(userId);
       if(Objects.isNull(user))){
          throw new UserNotFoundException("User with id "+userId);
       }
    } 
}

@Aspect
@Component 
 public class UserSearchAspect {

  @AfterThrowing(
    pointcut = "execution(* com.isf.services.findUser(..))",
    throwing = "userNotFoundException"
  )
  public void logForUser(JoinPoint joinPoint , UserNotFoundException userNotFoundException) 
  {
  }
}

@ExtendWith({SpringExtension.class , MockitoExtension.class})
@SpringBootTest
public class UserSearchAspectTest {

    @MockBean
    UserRepository userRepository;
    UserSearch userSearch;
    UserSearch proxyService;

    @BeforeEach
    public void setup(){
        userSearch = new UserSearchImpl(userRepository);
        AspectJProxyFactory factory = new AspectJProxyFactory();
        factory.setTarget(userSearch);
        factory.addAspectUserSearchAspect.class);
        proxyService = factory.getProxy();
    }

    @Test //this passes
    public void test(){
        assertTrue(AopUtils.isAopProxy(proxyService));
    }

    @Test
    public void testSome(){
        when(userRepository.findById(123L))
            .thenThrow(new UserNotFoundException("User not found "+123));
        /// How do I assert the exception is caught??
    }
}

Answer 1

以下测试代码可用于验证

1. 建议被触发
2. 找不到用户例外

希望这会有所帮助

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.aspectj.lang.JoinPoint;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.boot.test.mock.mockito.SpyBean;

@SpringBootTest
class UserSearchTest {

    @MockBean
    UserRepository repository;

    @Autowired
    UserSearch search;

    @SpyBean
    UserSearchAspect aspect;

    @Test
    void test() {
        UserNotFoundException unfEx = new UserNotFoundException("User not found " + 123);
        when(repository.findById(123L)).thenThrow(unfEx);
        Exception exception = assertThrows(UserNotFoundException.class, () -> {
            search.findUser(123L);
        });
        String expectedMessage = "User not found 123";

        // Verify the exception message
        assertTrue(exception.getMessage().contains(expectedMessage));

        ArgumentCaptor<JoinPoint> arg1 = ArgumentCaptor.forClass(JoinPoint.class);
        ArgumentCaptor<UserNotFoundException> arg2 = ArgumentCaptor.forClass(UserNotFoundException.class);
        // Verify the aspect on exception
        verify(aspect, times(1)).logForUser(arg1.capture(), arg2.capture());
        assertTrue(arg2.getValue().getMessage().contains(expectedMessage));
    }

}