本文分享在编写测试中“依赖注入、测试接口、重复测试”三节内容的方法。
依赖注入
重要性：★★☆☆☆
JUnit Jupiter允许测试类的构造函数、测试方法和生命周期方法接受参数。这些参数在运行时通过预先注册的参数解析器ParameterResolver的实例进行解析。
1. 内建的参数解析器
有3个内建的参数解析器，在JUnit中它们是自动注册的：
TestInfoParameterResolver
如果测试类的构造函数、测试方法或生命周期方法的参数类型是TestInfo，内建的参数解析器TestInfoParameterResolver将提供一个TestInfo的实例作为这些方法的参数值。可以使用这个TestInfo实例来检索当前测试容器或测试方法的相关信息，例如显示名称、测试类、测试方法以及相关的标签等。
下面的代码显示如何获取注入构造函数、生命周期函数和测试方法的TestInfo的内容：
package yang.yu.tdd.di;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;
@DisplayName("TestInfo Demo")
class TestInfoDemo {
TestInfoDemo(TestInfo testInfo) {
assertThat(testInfo.getDisplayName()).isEqualTo("TestInfo Demo");
}
@BeforeEach
void init(TestInfo testInfo) {
String displayName = testInfo.getDisplayName();
assertThat(displayName).isIn("TEST 1", "test2()");
}
@Test
@DisplayName("TEST 1")
@Tag("my-tag")
void test1(TestInfo testInfo) {
assertThat(testInfo.getDisplayName()).isEqualTo("TEST 1");
assertThat(testInfo.getTags()).contains("my-tag");
}
@Test
void test2() {
}
}
RepetitionInfoParameterResolver
如果测试类的构造函数、测试方法或生命周期方法拥有注解@RepeatedTest、@BeforeEach、@AfterEach，并且接受类型为RepetitionInfo的参数，参数解析器RepetitionInfoParameterResolver将提供一个RepetitionInfo实例作为这些方法的参数值。可以从RepetitionInfo中获取当前重复次数以及总重复次数等相关信息。
下面是示例代码：
package yang.yu.tdd.di;
import org.junit.jupiter.api.RepeatedTest;
import org.junit.jupiter.api.RepetitionInfo;
public class RepetitionInfoDemo {
@RepeatedTest(5)
void repeat(RepetitionInfo repetitionInfo) {
System.out.println("Current Repetition: " + repetitionInfo.getCurrentRepetition());
System.out.println("Total Repetitions: " + repetitionInfo.getTotalRepetitions());
}
}
TestReporterParameterResolver
如果测试类的构造函数、测试方法或生命周期方法的参数类型是TestReporter，参数解析器TestReporterParameterResolver将提供一个TestReporter实例作为这些方法的参数值。可以使用这个TestReporter向当前测试的测试报告添加额外的数据。这些数据可以被TestExecutionListener的reportingEntryPublished()方法消费，使它们可以显示在IDE视图和测试报告中。
下面是示例代码：
package yang.yu.tdd.di;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestReporter;
import java.util.HashMap;
import java.util.Map;
class TestReporterDemo {
@Test
void reportSingleValue(TestReporter testReporter) {
testReporter.publishEntry("a status message");
}
@Test
void reportKeyValuePair(TestReporter testReporter) {
testReporter.publishEntry("a key", "a value");
}
@Test
void reportMultipleKeyValuePairs(TestReporter testReporter) {
Map<String, String> values = new HashMap<>();
values.put("user name", "dk38");
values.put("award year", "1974");
testReporter.publishEntry(values);
}
}
2. 自定义参数解析器
可以通过创建自定义的参数解析器并通过@ExtendWith注解注册到被测试类，来让测试类构造函数、测试方法、生命周期方法注入特定类型的参数。
下面创建一个自定义的参数解析器RandomParametersExtension，这个参数解析器在测试方法中查找拥有@Random注解的int型参数，提供一个随机整数值：
package yang.yu.tdd.di;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Parameter;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
import org.junit.jupiter.api.extension.ParameterContext;
import org.junit.jupiter.api.extension.ParameterResolutionException;
import org.junit.jupiter.api.extension.ParameterResolver;
public class RandomParametersExtension implements ParameterResolver {
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface Random {
}
@Override
public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
return parameterContext.isAnnotated(Random.class);
}
@Override
public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
return getRandomValue(parameterContext.getParameter(), extensionContext);
}
private Object getRandomValue(Parameter parameter, ExtensionContext extensionContext) {
Class<?> type = parameter.getType();
java.util.Random random = extensionContext.getRoot().getStore(Namespace.GLOBAL)//
.getOrComputeIfAbsent(java.util.Random.class);
if (int.class.equals(type)) {
return random.nextInt();
}
if (double.class.equals(type)) {
return random.nextDouble();
}
throw new ParameterResolutionException("No random generator implemented for " + type);
}
}
下面的代码显示通过注册RandomParametersExtension参数解析器，给测试方法注入随机整数：
package yang.yu.tdd.di;
import org.assertj.core.data.Offset;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import static org.assertj.core.api.Assertions.assertThat;
import static yang.yu.tdd.di.RandomParametersExtension.*;
@ExtendWith(RandomParametersExtension.class)
class MyRandomParametersTest {
@Test
void injectsInteger(@Random int i, @Random int j) {
assertThat(i).isNotEqualTo(j);
}
@Test
void injectsDouble(@Random double d) {
assertThat(d).isCloseTo(0.0, Offset.offset(1.0));
}
}
测试接口
重要性：★★★☆☆
从Java 8开始，可以在接口上定义默认方法和静态方法，包含实现代码。
JUnit Jupiter允许在接口的默认方法上声明@Test, @RepeatedTest, @ParameterizedTest, @TestFactory, @TestTemplate, @BeforeEach, 和@AfterEach注解，在接口的静态方法上声明 @BeforeAll 和 @AfterAll 注解。如果采用PER_CLASS生命周期的话，也可以在接口的默认方法上声明 @BeforeAll 和 @AfterAll 注解。实现这些接口的测试方法将继承这些方法和注解。
注解@Tag和@ExtendWith也可以声明在接口上，由实现这些接口的测试类继承。
下面的代码创建一个TestLifecycleLogger接口，定义了生命周期相关方法。
package yang.yu.tdd.iface;
import org.junit.jupiter.api.*;
import java.util.logging.Logger;
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
interface TestLifecycleLogger {
static final Logger logger = Logger.getLogger(TestLifecycleLogger.class.getName());
@BeforeAll
default void beforeAllTests() {
logger.info("Before all tests");
}
@AfterAll
default void afterAllTests() {
logger.info("After all tests");
}
@BeforeEach
default void beforeEachTest(TestInfo testInfo) {
logger.info(() -> String.format("About to execute [%s]",
testInfo.getDisplayName()));
}
@AfterEach
default void afterEachTest(TestInfo testInfo) {
logger.info(() -> String.format("Finished executing [%s]",
testInfo.getDisplayName()));
}
}
下面的代码创建TestInterfaceDynamicTestsDemo接口，定义了注解为@TestFactory的动态测试生成方法dynamicTestsForPalindromes()：
package yang.yu.tdd.iface;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;
interface TestInterfaceDynamicTestsDemo {
@TestFactory
default Stream<DynamicTest> dynamicTestsForPalindromes() {
return Stream.of("racecar", "radar", "mom", "dad")
.map(text -> dynamicTest(text, () -> assertTrue(isPalindrome(text))));
}
static boolean isPalindrome(String raw) {
String str = "";
for (int i = 0; i < raw.length(); i++) {
char ch = raw.charAt(i);
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
str += ch;
}
}
str = str.toLowerCase();
int end = str.length();
for (int i = 0; i < end / 2; i++) {
if (str.charAt(i) != str.charAt(end - i - 1)) {
return false;
}
}
return true;
}
}
下面的代码创建测试类TestInterfaceDemo，它继承了上面的几个接口：
package yang.yu.tdd.iface;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class TestInterfaceDemo implements TestInterfaceDynamicTestsDemo, TestLifecycleLogger {
@Test
void isEqualValue() {
assertThat("a".length()).as("is always equal").isEqualTo(1);
}
}
当测试类TestInterfaceDemo执行时，它所实现的各个接口上定义的测试方法、生命周期方法、测试工厂方法也会执行，就如同这些方法是直接定义在测试类上面一样。
重复测试
重要性：★★☆☆☆
通过声明@RepeatedTest注解取代@Test`注解，JUnit可以让一个测试方法重复执行若干次。
@RepeatedTest(10)
void repeatedTest() {
// ...
}
上面的测试方法repeatedTest()会重复执行10次。
还可以通过RepeatedTest注解的name属性给测试方法定制显示名：
package yang.yu.tdd.repeated;
import java.util.logging.Logger;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.RepeatedTest;
import org.junit.jupiter.api.RepetitionInfo;
import org.junit.jupiter.api.TestInfo;
import static org.assertj.core.api.Assertions.assertThat;
class RepeatedTestsDemo {
private Logger logger = Logger.getLogger(RepeatedTestsDemo.class.getName());
@BeforeEach
void beforeEach(TestInfo testInfo, RepetitionInfo repetitionInfo) {
int currentRepetition = repetitionInfo.getCurrentRepetition();
int totalRepetitions = repetitionInfo.getTotalRepetitions();
String methodName = testInfo.getTestMethod().get().getName();
logger.info(String.format("About to execute repetition %d of %d for %s", //
currentRepetition, totalRepetitions, methodName));
}
@RepeatedTest(10)
void repeatedTest() {
// ...
}
@RepeatedTest(5)
void repeatedTestWithRepetitionInfo(RepetitionInfo repetitionInfo) {
assertThat(repetitionInfo.getTotalRepetitions()).isEqualTo(5);
}
@RepeatedTest(value = 1, name = "{displayName} {currentRepetition}/{totalRepetitions}")
@DisplayName("Repeat!")
void customDisplayName(TestInfo testInfo) {
assertThat(testInfo.getDisplayName()).isEqualTo("Repeat! 1/1");
}
@RepeatedTest(value = 1, name = RepeatedTest.LONG_DISPLAY_NAME)
@DisplayName("Details...")
void customDisplayNameWithLongPattern(TestInfo testInfo) {
assertThat(testInfo.getDisplayName()).isEqualTo("Details... :: repetition 1 of 1");
}
@RepeatedTest(value = 5, name = "Wiederholung {currentRepetition} von {totalRepetitions}")
void repeatedTestInGerman() {
}
}
方法的最终显示名可以是通过@DisplayName注解定义的静态显示名和通过@RepeatedTest注解的name属性定义的动态显示名的组合。
在通过@RepeatedTest注解的name属性定义的动态显示名，可以获取下面的静态内容：
{displayName}：方法上的注解@RepeatedTest的值。{currentRepetition}：当前是第几次执行。{totalRepetitions}：总重复次数。
这一节就讲到这里，下一节我们讲讲"参数化测试"。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
