Streamline Your Testing Workflow with JUnit 5 Dynamic Tests
Let’s discuss JUnit5’s @TestFactory and use the new feature to dynamically generate and run many unit tests.
Overview
Let’s assume we have a file with specifications about how our application should behave: many input and expected output values. This can be, for example, data exported from another system or an old application that we are refactoring or migrating. Moreover, these specifications should be easy to understand and the business team can potentially validate them.
If the data comes in a CSV format, we can use JUnit5’s out-of-the-box features: @ParameterizedTest and @CsvValue. If you want to dive deeper into the subject, I have written an article exploring various usages of this feature: Unleash The True Potential Of JUnit5 And B.D.D. Though, if the file has a different format or the data has a different structure, our only option will be the @TestFactory.
The Test Data
For this article, we’ll use the grid from this website to validate the BmiCalculator application we wrote last week. Reading through the test data, we can see that, for example, for an individual with a height of 70 inches and a weight of 160 pounds, we’ll expect a BMI of 23:
Parse The Test Data
Parsing the data will be different from one project to another. Therefore, this section is not as important, but still, I will quickly walk through the steps I followed.
Firstly, we need to read and parse this file. Therefore, I have added the two tables from the website to my scr/test/resources directory.
Now, let’s read the file: the first row will contain the expected BMI values and the rows that follow will start with the height followed by many columns containing values for the weight:
List<String> allLines = Files.readAllLines(Paths.get(testDataFile));
String lineWithExpectedBmi = allLines.get(0);
List<String> lineWithHeightAndWeights = allLines.stream().skip(1l).toList();Of course, we’ll have to split the string by tabs, and parse the strings to integer values. Moreover, for the heights and weights, we can group them together into pair objects:
List<Integer> expectedBmiValues = Stream.of(lineWithExpectedBmi.split("\t"))
.skip(1)
.map(Integer::parseInt)
.toList();
List<List<Pair<Integer, Integer>>> weightsByHeight = lineWithHeightAndWeights.stream()
.map(this::splitAndParse)
.map(testValues -> testValues.stream().skip(1l).map(weight -> Pair.of(testValues.get(0), weight)).toList())
.toList();After that, we can create our test data by zipping the two lists together. As a result, we’ll create a map with the Weight-Height pair as the key and the expected BMI as the value:
Map<Pair<Integer, Integer>, Integer> expectedBmiByWeightAndHeight = weightsByHeight.stream()
.flatMap(line -> zip(line.stream(), expectedBmiValues.stream()))
.collect(Collectors.toMap(Pair::getFirst, Pair::getSecond));Generating The Tests
It is very simple to generate a DynamicTest: we only need to specify a name and a runnable code with an assertion. In our case, it can look like this:
private DynamicTest createTest(int height, int weight, int expectedBmi) {
String testName = MessageFormat.format("WHEN height={0} and weight={0} THEN bmi={2}",
height, weight, expectedBmi);
return DynamicTest.dynamicTest(testName,
() -> assertThat(BmiCalculator.calculateBmi(Weight.ofPounds(weight), Height.ofInches(height)))
.isCloseTo(valueOf(expectedBmi), withPercentage(5d)));
}PS: Because the website where I found the grid with all the values is doing some approximations, I have added a short marge of error of 5% in the assertion.
Now, let’s map the parsed test data to DyanmicTest objects:
expectedBmiByWeightAndHeight.entrySet().stream()
.map(testArgs -> createTest(
testArgs.getKey().getFirst(),
testArgs.getKey().getSecond(),
testArgs.getValue()));Running The DynamicTests
To run the dynamically-generated tests, we need to create a method that returns either a List or a Stream of DyanmicTest and annotate it with @TestFactory:
@TestFactory
Stream<DynamicTest> calculateBmi() throws IOException {
var testData1 = generateTests("src//test//resources//bmi_data.txt");
var testData2 = generateTests("src//test//resources//bmi_data_2.txt");
return Stream.concat(testData1, testData2);
}If we run it, it should generate a test for each combination of weight and height for each of the two tables. This will be 18*18*2, so we’ll expect a total of 684 tests to be generated and executed:
Full Source Code
Here is the full test code for generating and running the dynamic tests. As we can see, most of the code is just parsing the test data from our file, after that, JUnit is doing everything else for us:
public class DynamicTests {
@TestFactory
Stream<DynamicTest> calculateBmi() throws IOException {
var testData1 = generateTests("src//test//resources//bmi_data.txt");
var testData2 = generateTests("src//test//resources//bmi_data_2.txt");
return Stream.concat(testData1, testData2);
}
private Stream<DynamicTest> generateTests(String testDataFile) throws IOException {
List<String> allLines = Files.readAllLines(Paths.get(testDataFile));
String lineWithExpectedBmi = allLines.get(0);
List<String> lineWithHeightAndWeights = allLines.stream().skip(1l).toList();
List<Integer> expectedBmiValues = Stream.of(lineWithExpectedBmi.split("\t"))
.skip(1)
.map(Integer::parseInt)
.toList();
List<List<Pair<Integer, Integer>>> weightsByHeight = lineWithHeightAndWeights.stream()
.map(this::splitAndParse)
.map(testValues -> testValues.stream().skip(1l).map(weight -> Pair.of(testValues.get(0), weight)).toList())
.toList();
Map<Pair<Integer, Integer>, Integer> expectedBmiByWeightAndHeight = weightsByHeight.stream()
.flatMap(line -> zip(line.stream(), expectedBmiValues.stream()))
.collect(Collectors.toMap(Pair::getFirst, Pair::getSecond));
return expectedBmiByWeightAndHeight.entrySet().stream()
.map(testArgs -> createTest(
testArgs.getKey().getFirst(),
testArgs.getKey().getSecond(),
testArgs.getValue()));
}
private DynamicTest createTest(int height, int weight, int expectedBmi) {
String testName = MessageFormat.format("WHEN height={0} and weight={0} THEN bmi={2}",
height, weight, expectedBmi);
return DynamicTest.dynamicTest(testName,
() -> assertThat(BmiCalculator.calculateBmi(Weight.ofPounds(weight), Height.ofInches(height)))
.isCloseTo(valueOf(expectedBmi), withPercentage(5d)));
}
private List<Integer> splitAndParse(String testLine) {
return stream(testLine.split("\t"))
.map(Integer::parseInt)
.toList();
}
static <A, B> Stream<Pair<A, B>> zip(Stream<A> as, Stream<B> bs) {
Iterator<A> i = as.iterator();
return bs.filter(x -> i.hasNext()).map(b -> Pair.of(i.next(), b));
}
}
Thank You!
Thanks for reading the article and please let me know what you think! Any feedback is welcome.
If you want to read more about clean code, design, unit testing, functional programming, and many others, make sure to check out my other articles. Do you like the content? Consider following or subscribing to the email list.
Finally, if you consider becoming a Medium member and supporting my blog, here’s my referral.
Happy Coding!
