JUnit 5的参数化测试功能不提供与JUnit 4完全相同的功能。它引入了更灵活的新功能......但也失去了JUnit 4的参数化测试类在类级别使用参数化固定值/断言,即适用于类的所有测试方法的特性。
需要为每个测试方法定义@ParameterizedTest
并指定“输入”值。
除此之外,我将介绍这两个版本之间的主要差异以及如何在JUnit 5中使用参数化测试。
TL;DR
要编写一个参数化测试以指定要测试的案例值,可以使用org.junit.jupiter.params.provider.MethodSource
。
@MethodSource
允许您引用测试类的一个或多个方法。每个方法必须返回Stream、Iterable、Iterator或参数数组。此外,每个方法都不能接受任何参数。默认情况下,这些方法必须是静态的,除非测试类被注释为
如果您只需要一个参数,可以直接返回参数类型的实例,正如以下示例所示。
与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在这些术语中引入了参数化测试特性:
参数化测试使得用不同的参数多次运行一个测试成为可能。它们的声明方式与常规的@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提供了多种风格和构件来编写参数化测试。
通常有几种方式可以选择,具体取决于您想要使用的数据源。
以下是框架提供的源类型,并在文档中进行了描述:
@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
是非常好的选择。
为了实现这一点,请定义一个方法,该方法返回每种情况的值的流,并用@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
流。
例如,您可以编写以下内容:
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
有一些优点:它更清晰、更简短。
实际上,参数只需在被测试的方法上方进行定义,无需创建一个fixture方法,从而导致"未使用"警告。
但是,它在映射类型方面也有一个重要的限制。
您必须提供一个String
数组。该框架提供了转换功能,但是有限制。
总之,当提供的源和测试方法的参数具有相同类型(例如:String
->String
),或者依赖于内置转换(例如:String
->int
)时,@CsvSource
看起来是使用的方式。
如果不是这种情况,则需要在灵活性(通过创建自定义转换器ArgumentConverter
子类,用于由框架未执行的转换)和使用工厂方法返回Stream<Arguments>
的@MethodSource
之间进行选择。它具有上述缺点,但是它也有一个很大的好处:@MethodSource
可以直接映射任何类型的数据到参数中。
参数转换
关于源(例如:@CsvSource
或@ValueSource
)和测试方法的参数之间的映射,正如所见,如果类型不同,框架允许进行一些转换。
这篇文章介绍了两种类型的转换:
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
。而不是使用隐式参数转换,您可以使用
@ConvertWith
注解明确指定要使用的
ArgumentConverter
,如以下示例所示。JUnit为需要创建特定
ArgumentConverter
的客户端提供了一个参考实现。
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;
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);
}
}