本文分享在编写测试中“依赖注入、测试接口、重复测试”三节内容的方法。

依赖注入

重要性：★★☆☆☆

JUnit Jupiter允许测试类的构造函数、测试方法和生命周期方法接受参数。这些参数在运行时通过预先注册的参数解析器的实例进行解析。

1. 内建的参数解析器

有3个内建的参数解析器，在JUnit中它们是自动注册的：

如果测试类的构造函数、测试方法或生命周期方法的参数类型是，内建的参数解析器将提供一个的实例作为这些方法的参数值。可以使用这个实例来检索当前测试容器或测试方法的相关信息，例如显示名称、测试类、测试方法以及相关的标签等。

下面的代码显示如何获取注入构造函数、生命周期函数和测试方法的的内容：

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() {
    }
}

如果测试类的构造函数、测试方法或生命周期方法拥有注解、、，并且接受类型为的参数，参数解析器将提供一个实例作为这些方法的参数值。可以从中获取当前重复次数以及总重复次数等相关信息。

下面是示例代码：

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

如果测试类的构造函数、测试方法或生命周期方法的参数类型是，参数解析器将提供一个实例作为这些方法的参数值。可以使用这个向当前测试的测试报告添加额外的数据。这些数据可以被的方法消费，使它们可以显示在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 values = new HashMap<>();
        values.put("user name", "dk38");
        values.put("award year", "1974");
        testReporter.publishEntry(values);
    }
}

2. 自定义参数解析器

可以通过创建自定义的参数解析器并通过注解注册到被测试类，来让测试类构造函数、测试方法、生命周期方法注入特定类型的参数。

下面创建一个自定义的参数解析器，这个参数解析器在测试方法中查找拥有注解的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);
    }
}

下面的代码显示通过注册参数解析器，给测试方法注入随机整数：

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允许在接口的默认方法上声明, , , , , , 和注解，在接口的静态方法上声明  和  注解。如果采用生命周期的话，也可以在接口的默认方法上声明  和  注解。实现这些接口的测试方法将继承这些方法和注解。

注解和也可以声明在接口上，由实现这些接口的测试类继承。

下面的代码创建一个接口，定义了生命周期相关方法。

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

下面的代码创建接口，定义了注解为的动态测试生成方法：

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

下面的代码创建测试类，它继承了上面的几个接口：

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

当测试类执行时，它所实现的各个接口上定义的测试方法、生命周期方法、测试工厂方法也会执行，就如同这些方法是直接定义在测试类上面一样。

重复测试

重要性：★★☆☆☆

通过声明注解取代@Test`注解，JUnit可以让一个测试方法重复执行若干次。

@RepeatedTest(10)
void repeatedTest() {
    // ...
}

上面的测试方法会重复执行10次。

还可以通过注解的属性给测试方法定制显示名：

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() {
    }
}

方法的最终显示名可以是通过注解定义的静态显示名和通过注解的属性定义的动态显示名的组合。

在通过注解的属性定义的动态显示名，可以获取下面的静态内容：

• ：方法上的注解  的值。

• ：当前是第几次执行。

• ：总重复次数。

这一节就讲到这里，下一节我们讲讲"参数化测试"。