Question

在JUnit 4中，使用@Parameterized注释很容易在一堆类中测试不变量。关键是对一个参数列表运行一组测试。

如何在不使用JUnit-vintage的情况下在JUnit 5中复制它？

@ParameterizedTest不适用于测试类。 @TestTemplate听起来很合适，但是注释的目标也是一种方法。

这种JUnit 4测试的一个例子是：

@RunWith( Parameterized.class )
public class FooInvariantsTest{

   @Parameterized.Parameters
   public static Collection<Object[]> data(){
       return new Arrays.asList(
               new Object[]{ new CsvFoo() ),
               new Object[]{ new SqlFoo() ),
               new Object[]{ new XmlFoo() ),
           );
   }

   private Foo fooUnderTest;


   public FooInvariantsTest( Foo fooToTest ){
        fooUnderTest = fooToTest;
   }

   @Test
   public void testInvariant1(){
       ...
   }

   @Test
   public void testInvariant2(){
       ...
   } 
}

Answer 1

JUnit 5中的参数化测试功能并不提供与JUnit 4提供的功能完全相同的功能。
引入了更多灵活性的新功能......但它也失去了JUnit4功能，其中参数化测试类在类级别使用参数化装置/断言，适用于该类的所有测试方法。
通过指定＆＃34;输入＆＃34;为每个测试方法定义@ParameterizedTest。是如此需要。
除此之外，我将介绍两个版本之间的主要区别以及如何在JUnit 5中使用参数化测试。

<强> TL; DR

要编写一个参数化测试，该测试根据您的问题指定一个值来测试， org.junit.jupiter.params.provider.MethodSource应该做的工作。

@MethodSource允许您引用一种或多种测试方法   类。每种方法都必须返回Stream，Iterable，Iterator或数组   论点。此外，每个方法都不能接受任何参数。   默认情况下，除非测试类是，否则此类方法必须是静态的   用@TestInstance(Lifecycle.PER_CLASS)注释。

如果您只需要一个参数，则可以返回该实例   直接参数类型，如以下示例所示。

作为JUnit 4，@MethodSource依赖于工厂方法，也可用于指定多个参数的测试方法。

在JUnit 5中，它是编写最接近JUnit 4的参数化测试的方法。

JUnit 4：

@Parameters
public static Collection<Object[]> data() {

JUnit 5：

private static Stream<Arguments> data() {

主要改进：

Collection<Object[]>变为Stream<Arguments>，提供更大的灵活性。
将工厂方法绑定到测试方法的方式稍有不同它现在更短，更不容易出错：不再需要创建构造函数并声明字段来设置每个参数的值。源的绑定直接在测试方法的参数上完成。
使用JUnit 4，在同一个类中，必须使用@Parameters声明一个且只有一个工厂方法。
使用JUnit 5，解除了这个限制：确实可以使用多种方法作为工厂方法。
因此，在课堂内，我们可以声明一些用@MethodSource("..")注释的测试方法，这些测试方法引用了不同的工厂方法。

例如，这里是一个示例测试类，用于断言一些加法计算：

import java.util.stream.Stream;

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;    
import org.junit.jupiter.api.Assertions;

public class ParameterizedMethodSourceWithArgumentsTest {

  @ParameterizedTest
  @MethodSource("addFixture")
  void add(int a, int b, int result) {
     Assertions.assertEquals(result, a + b);
  }

  private static Stream<Arguments> addFixture() {
    return Stream.of(
      Arguments.of(1, 2, 3),
      Arguments.of(4, -4, 0),
      Arguments.of(-3, -3, -6));
  }
}

要将现有的参数化测试从JUnit 4升级到JUnit 5，@MethodSource是一个值得考虑的候选者。

<强>综述

@MethodSource有一些优点，但也有一些弱点在JUnit 5中引入了指定参数化测试源的新方法。
这里有一些关于他们的其他信息（非常详尽），我希望能够以一般的方式对如何处理提出一个广泛的想法。

<强>简介

JUnit 5在这些术语中引入了parameterized tests feature：

参数化测试可以多次运行测试不同的论点。它们被声明为常规@Test方法但请改用@ParameterizedTest注释。另外，你必须声明至少一个将提供参数的源每次调用。

依赖性要求

参数化测试功能未包含在junit-jupiter-engine核心依赖项中您应该添加一个特定的依赖项来使用它：junit-jupiter-params。

如果你使用Maven，这是声明的依赖：

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-params</artifactId>
    <version>5.0.0</version>
    <scope>test</scope>
</dependency>

可用于创建数据的来源

与JUnit 4相反，JUnit 5提供了多种风格和工件来编写参数化测试支持的方式通常取决于您想要使用的数据来源。

以下是框架提出并在documentation中描述的源类型：

@ValueSource
@EnumSource
@MethodSource
@CsvSource
@CsvFileSource
@ArgumentsSource

以下是我实际使用JUnit 5的3个主要来源，我将介绍：

@MethodSource
@ValueSource
@CsvSource

我认为它们是我编写参数化测试的基础。他们应该允许在JUnit 5中编写，你所描述的JUnit 4测试的类型 @EnumSource，@ArgumentsSource和@CsvFileSource当然可能会有所帮助，但它们更专业。

@MethodSource，@ValueSource及@CsvSource

的演示文稿

1）@MethodSource

此类来源需要定义工厂方法但它也提供了很大的灵活性。

在JUnit 5中，它是编写最接近JUnit 4的参数化测试的方法。

如果您在测试方法中有单一方法参数，并且您想使用任何类型作为来源，@MethodSource是一个非常好的候选人。<登记/> 要实现它，请定义一个方法，该方法返回每个案例的值的Stream，并使用@MethodSource("methodName")注释测试方法，其中methodName是此数据源方法的名称。

例如，你可以写：

import java.util.stream.Stream;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

public class ParameterizedMethodSourceTest {

    @ParameterizedTest
    @MethodSource("getValue_is_never_null_fixture")
    void getValue_is_never_null(Foo foo) {
       Assertions.assertNotNull(foo.getValue());
    }

    private static Stream<Foo> getValue_is_never_null_fixture() {
       return Stream.of(new CsvFoo(), new SqlFoo(), new XmlFoo());
    }

}

如果您在测试方法中有多个方法参数，并且您想使用任何类型作为来源，@MethodSource也是一个非常好的候选人。<登记/> 要实现它，请定义一个方法，为每个案例返回一个org.junit.jupiter.params.provider.Arguments的Stream进行测试。

例如，你可以写：

import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;    
import org.junit.jupiter.api.Assertions;

public class ParameterizedMethodSourceWithArgumentsTest {

    @ParameterizedTest
    @MethodSource("getFormatFixture")
    void getFormat(Foo foo, String extension) {
        Assertions.assertEquals(extension, foo.getExtension());
    }

    private static Stream<Arguments> getFormatFixture() {
    return Stream.of(
        Arguments.of(new SqlFoo(), ".sql"),
        Arguments.of(new CsvFoo(), ".csv"),
        Arguments.of(new XmlFoo(), ".xml"));
    }
}

2）@ValueSource

如果测试方法中有单个方法参数，并且您可以从这些内置类型之一（String，int，long，double）表示参数的来源，@ValueSource适合。

@ValueSource确实定义了这些属性：

String[] strings() default {};
int[] ints() default {};
long[] longs() default {};
double[] doubles() default {};

例如，你可以这样使用它：

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

public class ParameterizedValueSourceTest {

    @ParameterizedTest
    @ValueSource(ints = { 1, 2, 3 })
    void sillyTestWithValueSource(int argument) {
        Assertions.assertNotNull(argument);
    }

}

注意1）您不能指定多个注释属性。
注意2）方法的源和参数之间的映射可以在两种不同的类型之间完成。
用作数据源的类型String特别允许将其解析为多种其他类型。

3）@CsvSource

如果测试方法中有多个方法参数，@CsvSource可能适用。
要使用它，请使用@CsvSource对测试进行注释，并在每个案例的String数组中指定。
每个案例的值用逗号分隔。

与@ValueSource类似，方法的源和参数之间的映射可以在两种不同的类型之间完成。
这是一个例子，说明了：

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

public class ParameterizedCsvSourceTest {

    @ParameterizedTest
    @CsvSource({ "12,3,4", "12,2,6" })
    public void divideTest(int n, int d, int q) {
       Assertions.assertEquals(q, n / d);
    }

}

@CsvSource VS @MethodSource

这些源类型提供了一个非常经典的要求：在测试方法中从源映射到多个方法参数。
但他们的方法不同。

@CsvSource有一些优点：它更清晰，更短实际上，参数是在测试方法的正上方定义的，没有要求创建一个可能另外生成＆＃34;未使用的＆＃34;警告。
但它对地图类型也有一个重要的限制您必须提供一个String数组。该框架提供转换功能，但它是有限的。

总结一下，虽然作为源提供的String和测试方法的参数具有相同的类型（String - ＆gt; String）或依赖于内置转换（ String - ＆gt; int例如），@CsvSource显示为使用方式。

由于情况并非如此，您必须在两者之间做出选择通过创建自定义转换器（@CsvSource子类）来保持ArgumentConverter的灵活性，该转换不是由框架或使用@MethodSource使用工厂方法执行的转换返回Stream<Arguments>。
它有上述缺点，但它也有很大的好处，可以从源到参数的任何类型开箱即用。

参数转换

关于源（例如@CsvSource或@ValueSource）与测试方法的参数之间的映射，如图所示，如果类型不同，框架允许进行一些转换。

Here介绍了两种类型的转换：

<强> 3.13.3。参数转换

隐式转换

为了支持@CsvSource之类的用例，JUnit Jupiter提供了一个数字   内置隐式转换器。转换过程取决于   在每个方法参数的声明类型上。

.....

String个实例目前已隐式转换为以下内容   目标类型。
Target Type          |  Example
boolean/Boolean      |  "true" → true
byte/Byte            |  "1" → (byte) 1
char/Character       |  "o" → 'o'
short/Short          |  "1" → (short) 1
int/Integer          |  "1" → 1
.....

例如，在上一个示例中，隐式转换是在源String和int之间进行的，定义为参数：

@CsvSource({ "12,3,4", "12,2,6" })
public void divideTest(int n, int d, int q) {
   Assertions.assertEquals(q, n / d);
}

此处，隐式转换是从String源到LocalDate参数完成的：

@ParameterizedTest
@ValueSource(strings = { "2018-01-01", "2018-02-01", "2018-03-01" })
void testWithValueSource(LocalDate date) {
    Assertions.assertTrue(date.getYear() == 2018);
}

如果对于两种类型，框架不提供转换，对于自定义类型，您应该使用ArgumentConverter。

明确转换

您可以明确地使用隐式参数转换   使用。指定要用于某个参数的ArgumentConverter   @ConvertWith注释，如下例所示。

JUnit为需要创建特定ArgumentConverter的客户提供参考实现。

显式参数转换器应通过测试实现作者。因此，junit-jupiter-params只提供一个显式参数转换器，也可以作为参考实现： JavaTimeArgumentConverter。它通过组合注释使用 JavaTimeConversionPattern。

使用此转换器的测试方法：

@ParameterizedTest
@ValueSource(strings = { "01.01.2017", "31.12.2017" })
void testWithExplicitJavaTimeConverter(@JavaTimeConversionPattern("dd.MM.yyyy") LocalDate argument) {
    assertEquals(2017, argument.getYear());
}

JavaTimeArgumentConverter转换器类：

package org.junit.jupiter.params.converter;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.Year;
import java.time.YearMonth;
import java.time.ZonedDateTime;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.ChronoLocalDateTime;
import java.time.chrono.ChronoZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalQuery;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;

import org.junit.jupiter.params.support.AnnotationConsumer;

/**
 * @since 5.0
 */
class JavaTimeArgumentConverter extends SimpleArgumentConverter
        implements AnnotationConsumer<JavaTimeConversionPattern> {

    private static final Map<Class<?>, TemporalQuery<?>> TEMPORAL_QUERIES;
    static {
        Map<Class<?>, TemporalQuery<?>> queries = new LinkedHashMap<>();
        queries.put(ChronoLocalDate.class, ChronoLocalDate::from);
        queries.put(ChronoLocalDateTime.class, ChronoLocalDateTime::from);
        queries.put(ChronoZonedDateTime.class, ChronoZonedDateTime::from);
        queries.put(LocalDate.class, LocalDate::from);
        queries.put(LocalDateTime.class, LocalDateTime::from);
        queries.put(LocalTime.class, LocalTime::from);
        queries.put(OffsetDateTime.class, OffsetDateTime::from);
        queries.put(OffsetTime.class, OffsetTime::from);
        queries.put(Year.class, Year::from);
        queries.put(YearMonth.class, YearMonth::from);
        queries.put(ZonedDateTime.class, ZonedDateTime::from);
        TEMPORAL_QUERIES = Collections.unmodifiableMap(queries);
    }

    private String pattern;

    @Override
    public void accept(JavaTimeConversionPattern annotation) {
        pattern = annotation.value();
    }

    @Override
    public Object convert(Object input, Class<?> targetClass) throws ArgumentConversionException {
        if (!TEMPORAL_QUERIES.containsKey(targetClass)) {
            throw new ArgumentConversionException("Cannot convert to " + targetClass.getName() + ": " + input);
        }
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        TemporalQuery<?> temporalQuery = TEMPORAL_QUERIES.get(targetClass);
        return formatter.parse(input.toString(), temporalQuery);
    }

}

如何在JUnit 5中实现JUnit 4参数化测试？

1 个答案: