TestNG和Junit5测试框架梳理

一、testNG

1. testNG优势

注解驱动： TestNG 使用注解来标识测试方法、测试类和配置方法，使得测试更具可读性。
并行执行： TestNG 支持多线程并行执行测试，可以加速测试套件的执行。
丰富的配置： 可以通过 XML 配置文件来定义测试套件的执行顺序、依赖关系等。
分组测试： 可以将测试方法分组，实现对特定测试分组的执行。
参数化测试： 可以使用 @Parameters 和@ DataProvider注解实现参数化测试
依赖管理： 可以通过 dependsOnMethods 或 dependsOnGroups 设置测试方法之间的依赖关系。
断言灵活： TestNG 提供了丰富的断言方法，用于验证测试结果。

2. testNG常用注解

@Test：用于标识测试方法，执行单元测试。
@BeforeSuite：在测试套件之前执行。
@AfterSuite：在测试套件之后执行。
@BeforeTest：在测试类之前执行。
@AfterTest：在测试类之后执行。
@BeforeClass：在测试类中的所有测试方法之前执行。
@AfterClass：在测试类中的所有测试方法之后执行。
@BeforeMethod：在每个测试方法之前执行。
@AfterMethod：在每个测试方法之后执行。
@DataProvider：用于提供测试数据。
@Parameters：用于参数化测试。
@dependsOnMethods：设置测试方法的依赖关系。

package AI.Test.testNG;

import org.testng.annotations.*;

public class TestNGCheck {

    @BeforeSuite
    public void beforeSuite(){
        System.out.println("beforeSuite");
    }

    @BeforeTest
    public void beforeTest() {
        System.out.println("Before Test");
    }

    @BeforeClass
    public void beforeClass() {
        System.out.println("Before Class");
    }

    @BeforeMethod
    public void beforeMethod() {
        System.out.println("Before Method");
    }

    @Test(groups="Performance")
    public void testMethod1() {
        System.out.println("Test Method 1");
    }

    @AfterMethod
    public void afterMethod() {
        System.out.println("After Method");
    }

    @AfterClass
    public void afterClass() {
        System.out.println("After Class");
    }

    @AfterTest
    public void afterTest() {
        System.out.println("After Test");
    }

    @AfterSuite
    public void afterSuite() {
        System.out.println("After Suite");
    }


}

3. testNG中@Test有哪些参数

1. 常用的：
groups： 用于将测试方法分组，可以在 XML 配置中选择性地执行指定组的测试。
timeOut： 指定方法的超时时间，单位为毫秒。
alwaysRun： 如果设置为 true，则无论依赖的方法是否失败，当前方法都会执行。
dependsOnMethods： 指定测试方法的依赖关系，被依赖的方法会在当前方法之前执行。
enabled： 控制测试方法是否启用，设置为 false 则禁用该方法。
description： 提供关于测试方法的简要描述。
invocationCount： 指定测试方法被调用的次数。


2. 数据驱动，需要结合@DataProvider注解对应获取参数的方法：
dataProvider： 指定使用哪个数据提供者来提供测试数据。
dataProviderClass： 指定数据提供者所在的类。


3.并发：
invocationCount： 指定测试方法被调用的次数。
threadPoolSize： 指定线程池的大小，用于并行执行测试方法。
dataProviderThreadCount： 指定数据提供者线程的数量。

举例：

    @Test(groups="Performance")
    public void testMethod1() {
        System.out.println("Test Method 1");
    }

    @Test(priority=1)
    public void testMethod2() {
        System.out.println("Test Method 2");
    }

    @Test(dependsOnMethods = "testMethod4", alwaysRun = false)
    public void testMethod3(){
        System.out.println("Test Method 3");
    }

    @Test(timeOut = 3000)
    public void testMethod4() throws InterruptedException {
        Thread.sleep(4000);
        System.out.println("Test Method 4");
    }

    @Test(enabled = false, description = "用于测试enable注解")
    public void testMethod5() {
        System.out.println("Test Method 5");
    }

4. 在 TestNG 中实现参数化测试

以Yaml文件为例

创建一个Yaml文件testdata.yaml

testdata:
  - parameters: [2, 3, 5]
  - parameters: [10, 20, 30]

获取测试数据及使用

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import org.yaml.snakeyaml.Yaml;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class ParameterizedTest {

    @DataProvider(name = "testData")
    public Object[][] getYamlData() {
        List<Object[]> testData = new ArrayList<>();

        Yaml yaml = new Yaml();
        InputStream inputStream = getClass().getClassLoader().getResourceAsStream("testdata.yaml");
        Map<String, List<List<Integer>>> dataMap = yaml.load(inputStream);

        List<List<Integer>> parametersList = dataMap.get("testdata");
        for (List<Integer> parameters : parametersList) {
            testData.add(parameters.toArray());
        }

        return testData.toArray(new Object[testData.size()][]);
    }

    @Test(dataProvider = "testData")
    public void testParameterized(int param1, int param2, int param3) {
        System.out.println("Test with parameters: " + param1 + ", " + param2 + ", " + param3);
        // 执行测试逻辑，使用参数化数据进行测试
    }
}

5. 执行顺序

TestNG 默认情况下会按照测试方法的名称升序执行。
可以通过设置 priority 属性来指定执行顺序。
也可以使用dependsOnMethods

6. testNG断言

assertEquals(expected, actual)：
验证两个值是否相等。如果不相等，会抛出 AssertionError。

assertNotEquals(expected, actual)：
验证两个值是否不相等。如果相等，会抛出 AssertionError。

assertTrue(condition)：
验证给定的条件是否为真。如果条件为假，会抛出 AssertionError。

assertFalse(condition)：
验证给定的条件是否为假。如果条件为真，会抛出 AssertionError。

assertNull(object)：
验证给定的对象是否为 null。如果对象不为 null，会抛出 AssertionError。

assertNotNull(object)：
验证给定的对象是否不为 null。如果对象为 null，会抛出 AssertionError。

assertSame(expected, actual)：
验证两个引用是否指向同一个对象。如果不指向同一个对象，会抛出 AssertionError。

assertNotSame(expected, actual)：
验证两个引用是否指向不同的对象。如果指向同一个对象，会抛出 AssertionError。

7. 失败重试

// 1. 实现IRetryAnalyzer类，实名需要的失败重试次数

import org.testng.IRetryAnalyzer;
import org.testng.ITestResult;

public class RetryAnalyzer implements IRetryAnalyzer {
    private int retryCount = 0;
    private static final int MAX_RETRY_COUNT = 3;

    @Override
    public boolean retry(ITestResult result) {
        if (retryCount < MAX_RETRY_COUNT) {
            retryCount++;
            return true;  // 重试
        }
        return false;    // 不再重试
    }
}


// 2. 给测试类的@Test注解增加参数
import org.testng.annotations.Test;

public class TestNGRetryExample {

    @Test(retryAnalyzer = RetryAnalyzer.class)
    public void testRetryExample() {
        // 测试逻辑
    }
}

二、Junit5

1. junit5的优势

现代化的设计： JUnit 5 的架构更加模块化和现代化，采用了模块化体系结构，使得集成和扩展更加容易。它引入了 Jupiter（新的测试引擎）和 Vintage（支持 JUnit 4）两个模块，具有更好的灵活性。

Lambda 表达式支持： JUnit 5 充分利用了 Java 8 的 Lambda 表达式特性，使测试代码更加简洁。TestNG 也支持 Lambda 表达式，但 JUnit 5 的设计更加贴合现代 Java 特性。

参数化测试： JUnit 5 提供了内置的参数化测试功能，使用 @ParameterizedTest 注解，可以轻松地对测试方法使用不同的参数运行。

动态测试： JUnit 5 引入了动态测试，允许在运行时生成和执行测试。使用 @TestFactory 注解，可以动态生成测试方法，以适应更加灵活的测试需求。

扩展机制： JUnit 5 的扩展机制更加强大和灵活，使用 @ExtendWith 注解，可以轻松应用自定义扩展，甚至可以自定义扩展来修改测试运行时的行为。

条件测试： JUnit 5 允许根据条件决定是否执行测试方法，使用 @EnabledOnOs、@DisabledIf 等注解，可以根据操作系统、环境变量等条件来控制测试执行。

并行执行： TestNG 在并行执行方面有很强的功能，但 JUnit 5 也在逐步增强并行执行的支持，对于简单的并行需求，JUnit 5 也可以胜任。

灵活性： JUnit 5 允许更多的自定义配置，使得测试执行的控制更加灵活，可以根据不同的项目需求进行调整。

2. 常用注解

@Test: 用于标记测试方法。

@DisplayName: 为测试方法或测试类指定一个可读的名称。

@BeforeEach: 在每个测试方法之前执行的方法。

@AfterEach: 在每个测试方法之后执行的方法。

@BeforeAll: 在所有测试方法之前执行的方法，必须是静态方法。

@AfterAll: 在所有测试方法之后执行的方法，必须是静态方法。

@Disabled: 标记测试方法或测试类为禁用状态。

@ParameterizedTest: 用于参数化测试的注解。

@RepeatedTest: 用于指定重复执行测试方法的次数。

@Timeout: 用于设置测试方法执行的最大时间。时间是s

@Tag: 为测试方法添加标签，用于分组和过滤测试。

@Nested: 用于嵌套测试类。

@TestFactory: 用于动态测试，返回动态生成的测试方法。

@Order(N): 管理执行顺序

package AI.Test.testNG;

import org.junit.jupiter.api.*;

public class Junit5TestCheck {

    @BeforeAll
    static void beforeAll() throws InterruptedException {
        System.out.println("Before All");
        Thread.sleep(3000);
    }

    @BeforeEach
    void beforeEach(){
        System.out.println("BeforeEach");
    }

    @Test
    @DisplayName("Junit5TestCheck test1")
    void test1(){
        System.out.println("test1");
    }

    @Test
    @RepeatedTest(2)
    @DisplayName("Junit5TestCheck test2")
    void test2(){
        System.out.println("test2");
    }

    @Test
    @Disabled
    @DisplayName("Junit5TestCheck test3")
    void test3(){
        System.out.println("test3");
    }

    @Test
    @Timeout(3)
    void test4() throws InterruptedException {
        Thread.sleep(4);
        System.out.println("test4");
    }


    @AfterEach
    void afterEach(){
        System.out.println("AfterEach");
    }

    @AfterAll
    static void afterAll(){
        System.out.println("After All");
    }

}

3. TestFactory使用示例

TestFactory其实就是参数化执行同一条用例

通常情况下，我们会使用 @ParameterizedTest 注解来参数化执行不同的测试用例，每次测试会使用不同的参数进行运行。而 @TestFactory 则是一种更为动态和灵活的方式，它允许你在运行时生成测试用例。

import org.junit.jupiter.api.TestFactory;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;

import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;

public class DynamicTestExample {

    @TestFactory
    Stream<DynamicTest> dynamicTestFactory() {
        return Stream.of(
            dynamicTest("Test 1", () -> assertEquals(2, add(1, 1))),
            dynamicTest("Test 2", () -> assertEquals(4, add(2, 2))),
            dynamicTest("Test 3", () -> assertEquals(6, add(3, 3)))
        );
    }

    int add(int a, int b) {
        return a + b;
    }
}

4. ParameterizedTest

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

public class ParameterizedTestExample {

    @ParameterizedTest
    @CsvSource({"1, 2, 3", "0, 0, 0", "-1, -2, -3"})
    void testAddition(int a, int b, int result) {
        assertEquals(result, add(a, b));
    }

    int add(int a, int b) {
        return a + b;
    }
}

5. 失败重试

// 创建一个实现了 TestExecutionExceptionHandler 接口的类，用于自定义处理测试方法失败的逻辑。这个类应该实现接口中的 handleTestExecutionException 方法，在方法内实现重试逻辑。

import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.TestExecutionExceptionHandler;

public class RetryExceptionHandler implements TestExecutionExceptionHandler {

    private static final int MAX_RETRY_COUNT = 3;
    private int retryCount = 0;

    @Override
    public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable {
        if (retryCount < MAX_RETRY_COUNT) {
            retryCount++;
            System.out.println("Retrying test: " + context.getDisplayName());
            return;
        }
        throw throwable; // 如果超过最大重试次数，则抛出异常，表示失败
    }
}


// 在需要应用失败重试的测试类上，使用 @ExtendWith 注解，将自定义的异常处理器类添加为扩展。

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;

@ExtendWith(RetryExceptionHandler.class)
public class JUnit5RetryExample {

    @Test
    public void testRetryExample() {
        // 测试逻辑，可能会失败
    }
}