JUnit 与 TestNG 快速比较 | Baeldung

使用 OpenRewrite 安全且自动地重构 Java 代码。

手动重构大型代码库既缓慢、有风险，又容易拖延。OpenRewrite 应运而生。这个用于大规模、自动化代码转换的开源框架可以帮助团队安全、一致地进行现代化改造。

每个月，OpenRewrite 的创建者和维护者 Moderne 都会举办现场、实践培训课程——一个面向初学者，一个面向经验丰富的用户。您将了解配方的运作方式、如何将其应用于项目，以及如何自信地进行代码现代化改造。

参加下一次课程，带来您的问题，并学习如何自动化通常会占用您 sprint 时间的工作。

回归测试是发布流程中的重要步骤，以确保新代码不会破坏现有功能。随着代码库的不断发展，我们希望频繁运行这些测试，以便尽早发现任何问题。

确保这些测试以自动化的方式频繁运行的最佳方法当然是将其包含在 CI/CD 管道中。 这样，每次向仓库提交代码时，回归测试将自动执行。

在本教程中，我们将学习如何使用 Selenium 创建回归测试，然后使用 GitHub Actions 将它们包含在我们的管道中，在 LambdaTest 云网格上运行

>> 如何使用 GitHub Actions 运行 Selenium 回归测试

确保这些测试以自动化的方式频繁运行的最佳方法当然是将其包含在 CI/CD 管道中。 这样，每次向仓库提交代码时，回归测试将自动执行。

在本教程中，我们将学习如何使用 Selenium 创建回归测试，然后使用 GitHub Actions 将它们包含在我们的管道中，在 LambdaTest 云网格上运行

>> 如何使用 GitHub Actions 运行 Selenium 回归测试

1. 概述

JUnit 和 TestNG 毫无疑问是 Java 生态系统中两种最流行的单元测试框架。虽然 TestNG 本身受 JUnit 的启发，但它提供了独特的功能，并且与 JUnit 不同，它适用于功能测试和更高层次的测试。

在这篇文章中，我们将通过介绍它们的功能和常见用例来讨论和比较这两个框架。

2. 测试设置

在编写测试用例时，我们通常需要在测试执行之前执行一些配置或初始化指令，并在测试完成后执行一些清理工作。让我们在这两个框架中评估这些功能。

JUnit 在方法和类级别提供初始化和清理功能，分别使用 @BeforeEach 和 @AfterEach 注解在方法级别，以及 @BeforeAll 和 @AfterAll 在类级别。

class SummationServiceTest {

    private static List<Integer> numbers;

    @BeforeAll
    static void initialize() {
        numbers = new ArrayList<>();
    }

    @AfterAll
    static void tearDown() {
        numbers = null;
    }

    @BeforeEach
    void runBeforeEachTest() {
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
    }

    @AfterEach
    void runAfterEachTest() {
        numbers.clear();
    }

    @Test
    void givenNumbers_sumEquals_thenCorrect() {
        int sum = numbers.stream().reduce(0, Integer::sum);
        assertEquals(6, sum);
    }
}

请注意，此示例使用了 JUnit 5。在之前的 JUnit 4 版本中，我们需要使用 @Before 和 @After 注解，它们分别等同于 @BeforeEach 和 @AfterEach。同样，@BeforeAll 和 @AfterAll 是 JUnit 4 的 @BeforeClass 和 @AfterClass 的替代品。

与 JUnit 类似，TestNG 也提供方法和类级别的初始化和清理功能。虽然 @BeforeClass 和 @AfterClass 在类级别保持不变，但方法级别的注解是 @BeforeMethod 和 @AfterMethod:

@BeforeClass
public void initialize() {
    numbers = new ArrayList<>();
}

@AfterClass
public void tearDown() {
    numbers = null;
}

@BeforeMethod
public void runBeforeEachTest() {
    numbers.add(1);
    numbers.add(2);
    numbers.add(3);
}

@AfterMethod
public void runAfterEachTest() {
    numbers.clear();
}

TestNG 还提供 @BeforeSuite, @AfterSuite, @BeforeGroup 和 @AfterGroup 注解，用于在套件和组级别进行配置

@BeforeGroups("positive_tests")
public void runBeforeEachGroup() {
    numbers.add(1);
    numbers.add(2);
    numbers.add(3);
}

@AfterGroups("negative_tests")
public void runAfterEachGroup() {
    numbers.clear(); 
}

此外，如果我们需要在 TestNG XML 配置文件中的 <test> 标签中包含的测试用例之前或之后进行任何配置，我们可以使用 @BeforeTest 和 @AfterTest

<test name="test setup">
    <classes>
        <class name="SummationServiceTest">
            <methods>
                <include name="givenNumbers_sumEquals_thenCorrect" />
            </methods>
        </class>
    </classes>
</test>

请注意，JUnit 中 @BeforeClass 和 @AfterClass 方法的声明必须是静态的。相比之下，TestNG 方法声明没有这些限制。

3. 忽略测试

两个框架都支持忽略测试用例，但它们的操作方式略有不同。 JUnit5 提供了 @Disabled 注解

@Disabled
@Test
void givenEmptyList_sumEqualsZero_thenCorrect() {
    int sum = numbers.stream().reduce(0, Integer::sum);
    Assert.assertEquals(6, sum);
}

使用 JUnit4 时，我们使用了 @Ignore 注解

@Ignore
@Test
public void givenNumbers_sumEquals_thenCorrect() {
    int sum = numbers.stream().reduce(0, Integer::sum);
    Assert.assertEquals(6, sum);
}

另一方面，TestNG 使用 @Test 注解，并带有一个参数“enabled”，值为布尔值 true 或 false

@Test(enabled=false)
public void givenNumbers_sumEquals_thenCorrect() {
    int sum = numbers.stream.reduce(0, Integer::sum);
    Assert.assertEquals(6, sum);
}

4. 一起运行测试

在 JUnit 和 TestNG 中都可以将测试作为一个集合一起运行，但它们的操作方式不同。

我们可以使用 @Suite, @SelectPackages 和 @SelectClasses 注解来分组测试用例并在 JUnit 5 中将它们作为套件运行。 套件是我们能够组合在一起并作为单个测试运行的测试用例集合。

如果我们要将不同包中的测试用例分组在一起并在 Suite 中运行，我们需要使用 @SelectPackages 注解

@Suite
@SelectPackages({ "org.baeldung.java.suite.childpackage1", "org.baeldung.java.suite.childpackage2" })
class SelectPackagesSuiteUnitTest {

}

如果我们要让特定的测试类一起运行，JUnit 5 通过 @SelectClasses 提供了灵活性

@Suite
@SelectClasses({Class1UnitTest.class, Class2UnitTest.class})
class SelectClassesSuiteUnitTest {

}

以前使用 JUnit 4 时，我们使用 @RunWith 和 @Suite 注解来实现分组和一起运行多个测试

@RunWith(Suite.class)
@Suite.SuiteClasses({ RegistrationTest.class, SignInTest.class })
public class SuiteTest {

}

在 TestNG 中，我们可以使用 XML 文件来分组测试

<suite name="suite">
    <test name="test suite">
        <classes>
            <class name="com.baeldung.RegistrationTest" />
            <class name="com.baeldung.SignInTest" />
        </classes>
    </test>
</suite>

这表明 RegistrationTest 和 SignInTest 将一起运行。

除了分组类之外，TestNG 还可以使用 @Test(groups=”groupName”) 注解来分组方法

@Test(groups = "regression")
public void givenNegativeNumber_sumLessthanZero_thenCorrect() {
    int sum = numbers.stream().reduce(0, Integer::sum);
    Assert.assertTrue(sum < 0);
}

让我们使用 XML 来执行这些组

<test name="test groups">
    <groups>
        <run>
            <include name="regression" />
        </run>
    </groups>
    <classes>
        <class 
          name="com.baeldung.SummationServiceTest" />
    </classes>
</test>

这将执行标记为 regression 组的测试方法。

5. 测试异常

JUnit 和 TestNG 都提供了使用注解测试异常的功能。

让我们首先创建一个包含一个抛出异常的方法的类

public class Calculator {
    public double divide(double a, double b) {
        if (b == 0) {
            throw new DivideByZeroException("Divider cannot be equal to zero!");
        }
        return a/b;
    }
}

在 JUnit 5 中，我们可以使用 assertThrows API 来测试异常

@Test
void whenDividerIsZero_thenDivideByZeroExceptionIsThrown() {
    Calculator calculator = new Calculator();
    assertThrows(DivideByZeroException.class, () -> calculator.divide(10, 0));
}

在 JUnit 4 中，我们可以通过使用 @Test(expected = DivideByZeroException.class) 在测试 API 上来实现这一点。

并且使用 TestNG 也可以实现相同的功能

@Test(expectedExceptions = ArithmeticException.class) 
public void givenNumber_whenThrowsException_thenCorrect() { 
    int i = 1 / 0;
}

此特性意味着在测试过程中，一段代码会抛出什么类型的异常。

6. 参数化测试

参数化的单元测试对于在多种条件下测试相同的代码很有帮助。借助参数化的单元测试，我们可以设置一个从某些数据源获取数据的测试方法。其主要思想是使单元测试方法可重用，并使用不同的输入进行测试。

在 JUnit 5 中，我们有优势在于测试方法可以直接从配置的源处获取数据参数。 默认情况下，JUnit 5 提供了几个 source 注解，例如：

@ValueSource： 我们可以将其与 Short、Byte、Int、Long、Float、Double、Char 和 String 类型的值数组一起使用：

@ParameterizedTest
@ValueSource(strings = { "Hello", "World" })
void givenString_TestNullOrNot(String word) {
    assertNotNull(word);
}

@EnumSource – 将 Enum 常量作为参数传递给测试方法

@ParameterizedTest
@EnumSource(value = PizzaDeliveryStrategy.class, names = {"EXPRESS", "NORMAL"})
void givenEnum_TestContainsOrNot(PizzaDeliveryStrategy timeUnit) {
    assertTrue(EnumSet.of(PizzaDeliveryStrategy.EXPRESS, PizzaDeliveryStrategy.NORMAL).contains(timeUnit));
}

@MethodSource – 传递生成流的外部方法

static Stream<String> wordDataProvider() {
    return Stream.of("foo", "bar");
}

@ParameterizedTest
@MethodSource("wordDataProvider")
void givenMethodSource_TestInputStream(String argument) {
    assertNotNull(argument);
}

@CsvSource – 使用 CSV 值作为参数的来源

@ParameterizedTest
@CsvSource({ "1, Car", "2, House", "3, Train" })
void givenCSVSource_TestContent(int id, String word) {
	assertNotNull(id);
	assertNotNull(word);
}

类似地，我们还有其他来源，例如 @CsvFileSource，如果我们需要从类路径中读取 CSV 文件，以及 @ArgumentSource，以指定自定义的可重用 ArgumentsProvider。

在 JUnit 4 中，测试类必须使用 @RunWith 注解才能使其成为参数化类，并使用 @Parameter 来表示单元测试的参数值。

在 TestNG 中，我们可以使用 @Parameter 或 @DataProvider 注解来参数化测试。 在使用 XML 文件时，使用 @Parameter 注解来标注测试方法：

@Test
@Parameters({"value", "isEven"})
public void 
  givenNumberFromXML_ifEvenCheckOK_thenCorrect(int value, boolean isEven) {
    Assert.assertEquals(isEven, value % 2 == 0);
}

并在 XML 文件中提供数据

<suite name="My test suite">
    <test name="numbersXML">
        <parameter name="value" value="1"/>
        <parameter name="isEven" value="false"/>
        <classes>
            <class name="baeldung.com.ParametrizedTests"/>
        </classes>
    </test>
</suite>

虽然使用 XML 文件中的信息既简单又实用，但在某些情况下，您可能需要提供更复杂的数据。

为此，我们可以使用 @DataProvider 注解，它允许我们将复杂的参数类型映射到测试方法。

这里有一个使用 @DataProvider 进行原始数据类型测试的示例

@DataProvider(name = "numbers")
public static Object[][] evenNumbers() {
    return new Object[][]{{1, false}, {2, true}, {4, true}};
}

@Test(dataProvider = "numbers")
public void givenNumberFromDataProvider_ifEvenCheckOK_thenCorrect
  (Integer number, boolean expected) {
    Assert.assertEquals(expected, number % 2 == 0);
}

以及 @DataProvider 用于对象

@Test(dataProvider = "numbersObject")
public void givenNumberObjectFromDataProvider_ifEvenCheckOK_thenCorrect
  (EvenNumber number) {
    Assert.assertEquals(number.isEven(), number.getValue() % 2 == 0);
}

@DataProvider(name = "numbersObject")
public Object[][] parameterProvider() {
    return new Object[][]{{new EvenNumber(1, false)},
      {new EvenNumber(2, true)}, {new EvenNumber(4, true)}};
}

以相同的方式，可以使用数据提供程序创建和返回任何要测试的特定对象。在与 Spring 等框架集成时很有用。

请注意，在 TestNG 中，由于 @DataProvider 方法不必是静态的，因此我们可以在同一个测试类中使用多个数据提供程序方法。

7. 测试超时

超时测试意味着，如果执行未在指定的特定时间内完成，则测试用例应失败。 JUnit 和 TestNG 都支持超时测试。在 JUnit 5 中，我们可以将超时测试编写为：

@Test
void givenExecution_takeMoreTime_thenFail() throws InterruptedException {
    Assertions.assertTimeout(Duration.ofMillis(1000), () -> Thread.sleep(10000));
}

在 JUnit 4 和 TestNG 中，我们可以使用 @Test(timeout=1000) 来进行相同的测试

@Test(timeOut = 1000)
public void givenExecution_takeMoreTime_thenFail() {
    while (true);
}

8. 依赖测试

TestNG 支持依赖测试。这意味着在一组测试方法中，如果初始测试失败，则所有后续依赖测试将被跳过，而不是像 JUnit 那样标记为失败。

让我们来看一个场景，我们需要验证电子邮件，如果成功，将继续登录

@Test
public void givenEmail_ifValid_thenTrue() {
    boolean valid = email.contains("@");
    Assert.assertEquals(valid, true);
}

@Test(dependsOnMethods = {"givenEmail_ifValid_thenTrue"})
public void givenValidEmail_whenLoggedIn_thenTrue() {
    LOGGER.info("Email {} valid >> logging in", email);
}

9. 测试执行顺序

JUnit 或 TestNG 中没有定义明确的测试方法执行顺序。 这些方法只是由 Java Reflection API 返回的方式调用。从 JUnit 4 开始，它使用更确定但不可预测的顺序。

为了获得更多控制，我们将使用 @TestMethodOrder 注解标注测试类，并指定方法排序器

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class SortedUnitTest {
    
    @Test
    @Order(2)
    void a_givenString_whenChangedtoInt_thenTrue() {
        assertTrue(Integer.valueOf("10") instanceof Integer);
    }

    @Test
    @Order(1)
    void b_givenInt_whenChangedtoString_thenTrue() {
        assertTrue(String.valueOf(10) instanceof String);
    }

}

MethodOrderer.OrderAnnotation.class 参数启用 @Order 注解的使用。然后，JUnit 5 将从最低到最高的顺序值运行测试。在 JUnit4 中，没有这么简单的方法。但是，我们可以通过 @FixMethodOrder(MethodSorters.NAME_ASCENDING) 注解按词法顺序运行测试：

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class SortedUnitTest {

    @Test
    public void a_givenString_whenChangedtoInt_thenTrue() {
        assertTrue(Integer.valueOf("10") instanceof Integer);
    }

    @Test
    public void b_givenInt_whenChangedtoString_thenTrue() {
        assertTrue(String.valueOf(10) instanceof String);
    }

}

虽然 TestNG 也提供了几种控制测试方法执行顺序的方法。我们在 @Test 注解中提供 priority 参数

@Test(priority = 1)
public void givenString_whenChangedToInt_thenCorrect() {
    Assert.assertTrue(
      Integer.valueOf("10") instanceof Integer);
}

@Test(priority = 2)
public void givenInt_whenChangedToString_thenCorrect() {
    Assert.assertTrue(
      String.valueOf(23) instanceof String);
}

请注意，优先级会根据优先级调用测试方法，但不能保证在一个优先级级别中的测试完成之后，才会调用下一个优先级级别。

在 TestNG 中编写功能测试用例时，我们有时可能会遇到一个相互依赖的测试，其执行顺序在每次测试运行中都必须相同。为了实现这一点，我们应该使用 @Test 注解的 dependsOnMethods 参数，如我们之前所见。

10. 自定义测试名称

默认情况下，每当我们运行一个测试时，测试类和测试方法名称都会打印到控制台或 IDE 中。JUnit 5 提供了一个独特的功能，我们可以使用 @DisplayName 注解为类和测试方法指定自定义描述性名称。

此注解不提供任何测试优势，但它为非技术人员带来了易于阅读和理解的测试结果。

@ParameterizedTest
@ValueSource(strings = { "Hello", "World" })
@DisplayName("Test Method to check that the inputs are not nullable")
void givenString_TestNullOrNot(String word) {
    assertNotNull(word);
}

每当我们运行测试时，输出将显示显示名称而不是方法名称。

目前，在 TestNG 中没有提供自定义名称的方法。