AspectJ的集成测试

Question

我正在尝试为自定义特性编写Integration测试。这是方面类代码段。

@Aspect
@Component
public class SampleAspect {
private static Logger log = LoggerFactory.getLogger(SampleAspect.class);
private int count;
public int getCount(){
return count;
}
public void setCount(){
this.count= count;
}

@Around("execution(* org.springframework.data.mongodb.core.MongoOperations.*(..)) || execution(* org.springframework.web.client.RestOperations.*(..))")
public Object intercept(final ProceedingJoinPoint point) throws Throwable {
logger.info("invoked Cutom aspect");
setCount(1);
return point.proceed();
}
}

因此，只要jointpoint与切入点匹配，上面的方面就会拦截。它运行良好。但我的问题是如何进行集成测试。

我所做的是在Aspect中创建了用于跟踪的属性"count"，并在我的Junit中断言了它。我不确定这是否好，或者是否有更好的方法来对方面进行集成测试。

这是Junit我所做的事情的片段。我的表现很糟糕，但我希望这与我为集成测试所做的不一样。

@Test
public void testSamepleAspect(){
sampleAspect.intercept(mockJointPoint);
Assert.assertEquals(simpleAspect.getCount(),1);
}

Answer 1

让我们使用与我对相关AspectJ单元测试问题的回答中相同的示例代码：

方面要针对的Java类：

package de.scrum_master.app;
public class Application {
public void doSomething(int number) {
System.out.println("Doing something with number " + number);
}
}

测试中的方面：

package de.scrum_master.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class SampleAspect {
@Around("execution(* doSomething(int)) && args(number)")
public Object intercept(final ProceedingJoinPoint thisJoinPoint, int number) throws Throwable {
System.out.println(thisJoinPoint + " -> " + number);
if (number < 0)
return thisJoinPoint.proceed(new Object[] { -number });
if (number > 99)
throw new RuntimeException("oops");
return thisJoinPoint.proceed();
}
}

您有几个选项，具体取决于您想要测试的内容：

1. 您可以运行AspectJ编译器并验证其控制台输出(启用编织信息)，以确保预期的连接点实际上是编织的，而其他连接点则不是。但这更愿意是对AspectJ配置和构建过程的测试，而不是真正的集成测试
2. 类似地，您可以创建一个新的编织类加载器，加载方面，然后加载几个类(加载时编织，LTW)，以便动态检查哪些被编织，哪些没有被编织。在这种情况下，您测试的是切入点是否正确，而不是由核心+方面代码组成的集成应用程序
3. 最后，但同样重要的是，您可以执行一个正常的集成测试，假设在正确编织了core+方面代码之后应用程序应该如何运行。如何做到这一点，取决于您的具体情况，特别是您的方面向核心代码添加了什么样的副作用

随后我将描述选项3。查看上面的示例代码，我们看到以下副作用：

• 对于小正数，方面通过原始参数值传递到截获的方法，唯一的副作用是额外的日志输出
• 对于负数，方面通过否定的参数值(例如，将-22变为22)传递到截获的方法，这是很好的测试
• 对于较大的正数，方面抛出异常，有效地阻止了原始方法的执行

方面的集成测试：

package de.scrum_master.aspect;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.matches;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import java.io.PrintStream;
import org.junit.*;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
import de.scrum_master.app.Application;
public class SampleAspectIT {
@Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
private Application application = new Application();
private PrintStream originalSystemOut;
@Mock private PrintStream fakeSystemOut;
@Before
public void setUp() throws Exception {
originalSystemOut = System.out;
System.setOut(fakeSystemOut);
}
@After
public void tearDown() throws Exception {
System.setOut(originalSystemOut);
}
@Test
public void testPositiveSmallNumber() throws Throwable {
application.doSomething(11);
verify(System.out, times(1)).println(matches("execution.*doSomething.* 11"));
verify(System.out, times(1)).println(matches("Doing something with number 11"));
}
@Test
public void testNegativeNumber() throws Throwable {
application.doSomething(-22);
verify(System.out, times(1)).println(matches("execution.*doSomething.* -22"));
verify(System.out, times(1)).println(matches("Doing something with number 22"));
}
@Test(expected = RuntimeException.class)
public void testPositiveLargeNumber() throws Throwable {
try {
application.doSomething(333);
}
catch (Exception e) {
verify(System.out, times(1)).println(matches("execution.*doSomething.* 333"));
verify(System.out, times(0)).println(matches("Doing something with number"));
assertEquals("oops", e.getMessage());
throw e;
}
}
}

此外，我们正在通过检查System.out的模拟实例的日志输出，并确保为较大的正数抛出预期的异常，来测试我们的示例方面所具有的三种类型的副作用。

Answer 2

@kriegaex以下代码的测试用例实现应该是什么

@Aspect
@Component
@Slf4j
public class SampleAspect {
@Value("${timeout:10}")
private long timeout;
@Around("@annotation(com.packagename.TrackExecutionTime)")
public Object intercept( ProceedingJoinPoint point) throws Throwable {
long startTime = System.currentTimeMillis();
Object obj = point.proceed();
long endTime  = System.currentTimeMillis();
long timeOut = endTime-startTime;
if(timeOut > timeout) 
{
log.error("Error occured");
}
return obj;
}
}

链接：AOP Spring 的Junit集成测试