时间戳

首页 > 解决方案 > 如何编写断言以确保为 AOP spring 类捕获我的异常

spring - 如何编写断言以确保为 AOP spring 类捕获我的异常

问题描述

我正在尝试为此类编写一些测试，这些测试应该捕获异常并记录它们。但是，当我运行测试时，它们失败了。我的测试如下所示。我不太确定应该如何编写测试，我只是在这里展示了我的尝试。我想要实现的是确保我设置的方面通过执行 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??
    }
}

标签： springspring-bootspring-aopspring-test

解决方案

以下测试代码可用于验证

  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));
    }

}

推荐阅读