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:设置测试方法的依赖关系。
java 复制代码
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有哪些参数

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


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


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

举例:

java 复制代码
    @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

XML 复制代码
testdata:
  - parameters: [2, 3, 5]
  - parameters: [10, 20, 30]

获取测试数据及使用

java 复制代码
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. 执行顺序

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

6. testNG断言

java 复制代码
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. 失败重试

java 复制代码
// 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的优势

java 复制代码
现代化的设计: 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. 常用注解

java 复制代码
@Test: 用于标记测试方法。

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

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

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

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

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

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

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

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

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

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

@Nested: 用于嵌套测试类。

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

@Order(N): 管理执行顺序
java 复制代码
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 则是一种更为动态和灵活的方式,它允许你在运行时生成测试用例。

java 复制代码
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

java 复制代码
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;
    }
}
  1. 失败重试
java 复制代码
// 创建一个实现了 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() {
        // 测试逻辑,可能会失败
    }
}
相关推荐
wjs20244 分钟前
R 数据框
开发语言
TangKenny8 分钟前
计算网络信号
java·算法·华为
肘击鸣的百k路9 分钟前
Java 代理模式详解
java·开发语言·代理模式
城南vision15 分钟前
Docker学习—Docker核心概念总结
java·学习·docker
捕鲸叉19 分钟前
MVC(Model-View-Controller)模式概述
开发语言·c++·设计模式
wyh要好好学习22 分钟前
SpringMVC快速上手
java·spring
尢词24 分钟前
SpringMVC
java·spring·java-ee·tomcat·maven
Mr. zhihao31 分钟前
享元模式在 JDK 中的应用解析
java·享元模式
茶馆大橘34 分钟前
微服务系列五:避免雪崩问题的限流、隔离、熔断措施
java·jmeter·spring cloud·微服务·云原生·架构·sentinel
wrx繁星点点35 分钟前
享元模式:高效管理共享对象的设计模式
java·开发语言·spring·设计模式·maven·intellij-idea·享元模式