Java JUnit5 assertAll

代码如下所示。我想让它去测试所有的键名元素。 但是，如果任何测试失败并且没有遍历所有数组元素，它就会停止。 我的理解是，在assertAll中，所有断言都被执行，任何失败都应该一起报告

谢谢你的时间和帮助

private void validateData(SearchHit searchResult, String [] line){

        for(Integer key : keyNames){
            String expectedValue = getExpectedValue(line, key);
            String elementName = mappingProperties.getProperty(key.toString());

            if (elementName != null && elementName.contains(HEADER)){
                assertAll(
                        () -> assumingThat((expectedValue != null && expectedValue.length() > 0),
                                () -> {
                                        String actualValue = testHelper.getHeaderData(searchResult, elementName);

                                        if(expectedValue != null) {
                                            assertEquals(expectedValue, actualValue, " ###Element Name -> " + elementName +" :  Excepted Value ### " + expectedValue + " ### Actual Value ###" + actualValue);
                                        }
                                      }
                                 )
                );

            }

        }
    }

---

Assertions.assertAll（）的javadoc声明：

断言所有提供的可执行文件都不会引发异常

实际上，在每次迭代中，您都会在
assertAll（）
中提供一个
可执行文件
。

因此，循环的任何迭代中的失败都会终止测试执行

事实上，您可以多次调用assertAll（）
，每次最多请求一个断言：

if(expectedValue != null) {
    assertEquals(expectedValue, actualValue, " ###Element Name -> " + elementName +" :  Excepted Value ### " + expectedValue + " ### Actual Value ###" + actualValue);
}

您想要做的是相反的：通过传递多个执行所需断言的
可执行文件
实例来调用
assertAll（）

因此，您可以使用经典循环将它们收集到
列表中
，并通过以下方式传递：
assertAll（list.stream（））
或创建一个
流
，而不进行任何收集并直接传递，例如
assertAll（stream）

这是一个带有Stream的版本（根本没有经过测试），但您应该了解：

Stream<Executable> executables = 
keyNames.stream()
        .map(key-> 
               // create an executable for each value of the streamed list
                ()-> {
                        String expectedValue = getExpectedValue(line, key);
                        String elementName = mappingProperties.getProperty(key.toString());

                        if (elementName != null && elementName.contains(HEADER)){
                             assumingThat((expectedValue != null && expectedValue.length() > 0),
                                            () -> {                                             
                                                    String actualValue = testHelper.getHeaderData(searchResult, elementName);
                                                    if(expectedValue != null) {
                                                        assertEquals(expectedValue, actualValue, " ###Element Name -> " + elementName +" :  Excepted Value ### " + expectedValue + " ### Actual Value ###" + actualValue);
                                                    }                                                                            

                                            }
                            );

                        }

                    }
            );
Assertions.assertAll(executables);

流可执行文件=
keyNames.stream（）
.map（键->
//为流式列表的每个值创建一个可执行文件
()-> {
字符串expectedValue=getExpectedValue（行，键）；
String elementName=mappingProperties.getProperty（key.toString（））；
if（elementName！=null&&elementName.contains（标题））{
假设（（expectedValue！=null&&expectedValue.length（）>0），
() -> {                                             
字符串actualValue=testHelper.getHeaderData（searchResult，elementName）；
if（expectedValue！=null）{
assertEquals（期望值，实际值，“######################实际值+实际值）；
}                                                                            
}
);
}
}
);
assertAll（可执行文件）；
assertAll（）
对传递给调用
assertAll（）
的所有断言和错误进行分组。它不会跨测试方法期间发生的所有调用对断言进行分组

在发布的代码中，将单个断言lambda传递到
assertAll（）
。它不会跨多个键对错误进行分组，因为每个
键都有一个单独的
assertAll（）
调用

要确保单独测试集合中的所有值，请查看。
如@所示，参数化测试（请参阅）自动独立测试所有情况

这将导致以下代码（稍微简单一些）：

@ParameterizedTest
@MethodSource（“getKeys”）
无效测试键（字符串键）{
String elementName=mappingProperties.getProperty（key.toString（））；
assumeTrue（elementName！=null）；
assumeTrue（elementName.contains（HEADER））；
字符串expectedValue=getExpectedValue（行，键）；
assumeTrue（expectedValue！=null）；
assumeTrue（expectedValue.length（）>0）；
字符串actualValue=testHelper.getHeaderData（searchResult，elementName）；
String doc=String.format（“名称：%s，预期为%s，实际为%s”，元素名称，预期值，实际值）；
资产质量（期望值、实际值、单据）；
}
私有静态流getKeys（）{
返回keyNames.stream（）
}
我的建议是在测试中不要有这么多逻辑。测试应该是一个文档。它应该让人们更容易理解代码。非常感谢。是的，将最小化测试方法中的逻辑。感谢您的反馈。查看将可执行文件的流或集合传递给assertAll，看看这是否有帮助。Thanks@dossani不客气：）我更新了。不需要收集到列表中，因为assertAll（）可以将流作为参数。所以最后还是比较简单。我已更新。如果您正在创建测试/可执行文件流，则返回
DynamicTest
并将其标记为
@TestFactory
是另一种选择（请参阅），这样就不需要
assertAll
。
@ParameterizedTest
@MethodSource("getKeys")
void testKey(String key) { 
    String elementName = mappingProperties.getProperty(key.toString());
    assumeTrue(elementName != null);
    assumeTrue(elementName.contains(HEADER));

    String expectedValue = getExpectedValue(line, key);
    assumeTrue(expectedValue != null);
    assumeTrue(expectedValue.length() > 0);

    String actualValue = testHelper.getHeaderData(searchResult, elementName);
    String doc = String.format("name: %s, expected %s, actual %s", elementName, expectedValue, actualValue);
    assertEquals(expectedValue, actualValue, doc);
}

private static Stream<String> getKeys() {
    return keyNames.stream()
}