【知识科普】单元测试框架TestNG介绍

文章目录

• • TestNG概述
  • 常用注解说明
  • springboot项目集成
  • 比较完整的示例
  • • [步骤 1: 创建被测试的类](#步骤 1: 创建被测试的类)
    • [步骤 2: 编写TestNG测试用例](#步骤 2: 编写TestNG测试用例)
    • [步骤 3: 运行测试](#步骤 3: 运行测试)
    • [步骤 4: 查看测试报告](#步骤 4: 查看测试报告)

TestNG概述

TestNG是一个开源的自动化测试框架，它在JUnit和NUnit的基础上增加了很多强大的功能，使其更加灵活和强大。TestNG的灵感来源于JUnit，但它并不是JUnit的扩展，而是一个全新的框架。TestNG的创建者是Cedric Beust，它的设计目标是消除旧框架的大部分限制，使开发人员能够编写更灵活、更强大的测试。

TestNG的主要特点包括：

1. 注解驱动：TestNG使用注解来配置测试用例，使得测试代码更加简洁明了。
2. 支持多种测试类型：TestNG不仅支持单元测试，还支持集成测试、端到端测试等多种类型，满足更广泛的测试需求。
3. 灵活的测试配置：TestNG提供了丰富的配置选项，如测试套件管理、参数化测试、依赖注入等，使得TestNG能够应对各种复杂的测试场景。
4. 强大的断言库：TestNG提供了丰富的断言库，包括常见的数值断言、字符串断言、对象状态断言等，帮助准确判断测试结果是否符合预期。
5. 集成第三方库和工具：TestNG可以轻松地与第三方库和工具集成，如Selenium、Appium等，支持各种自动化测试场景。
6. 多线程测试：TestNG支持在线程池中运行测试，并提供各种可用策略，如单线程、多线程等，验证代码的多线程安全性。
7. 数据驱动的测试 ：通过@DataProvider注解，TestNG支持数据驱动的测试，允许使用不同的输入参数执行相同的测试。
8. 测试分组：TestNG的分组功能允许你根据需求将测试用例分类，然后按组执行，提供了高度的灵活性和控制力。
9. 依赖测试 ：使用dependsOnMethods和dependsOnGroups属性，可以指定测试方法之间的依赖关系，确保按照特定顺序执行测试。
10. 并行测试：TestNG支持并行执行测试，大大减少了测试套件的运行时间。

TestNG通过注解来标识测试方法，如@Test注解用于标记测试方法，@BeforeClass和@AfterClass用于标记测试类的初始化和清理方法。TestNG还支持参数化测试，可以通过@Parameters注解传递参数给测试方法。此外，TestNG还提供了@DataProvider注解，用于为测试方法提供复杂的参数或从Java创建的参数。

安装TestNG通常通过Maven或Gradle集成到项目中。在Eclipse或IntelliJ IDEA等IDE中，也可以安装TestNG插件来支持TestNG的编写和运行。编写TestNG测试用例的基本步骤包括：使用IDE生成TestNG的测试程序框架、编写测试代码逻辑、插入TestNG注解标签、配置testng.xml文件设定测试类、测试方法、测试分组的执行信息，以及执行TestNG的测试程序。

总的来说，TestNG是一个功能丰富、灵活的测试框架，它提供了JUnit之外的多种测试特性，适用于各种类型的测试需求。通过使用TestNG，可以编写更加高效和可靠的自动化测试用例，提高软件测试的质量和效率。

常用注解说明

TestNG 使用注解来定义测试用例和测试配置。以下是一些常用的 TestNG 注解及其说明：

1. @Test：

   • 用于标记一个方法为测试方法。
   • 属性包括：
     • groups：指定测试方法所属的组。
     • dataProvider：指定提供测试数据的方法。
     • dependsOnMethods：指定测试方法依赖的其他方法。
     • enabled：指定测试方法是否启用。
     • invocationCount：指定测试方法被调用的次数。
     • threadPoolSize：指定测试方法调用的线程池大小。

2. @BeforeSuite：

   • 在套件中的所有测试运行之前执行一次。
   • 常用于初始化测试环境。

3. @AfterSuite：

   • 在套件中的所有测试运行之后执行一次。
   • 常用于清理测试环境。

4. @BeforeTest：

   • 在每个<test>标签内的类的所有测试方法运行之前执行。
   • 常用于测试类的初始化。

5. @AfterTest：

   • 在每个<test>标签内的类的所有测试方法运行之后执行。
   • 常用于测试类的清理。

6. @BeforeClass：

   • 在当前类的第一个测试方法执行之前执行一次。
   • 常用于类的初始化。

7. @AfterClass：

   • 在当前类的所有测试方法执行之后执行一次。
   • 常用于类的清理。

8. @BeforeMethod：

   • 在每个测试方法执行之前执行。
   • 常用于设置测试方法的前置条件。

9. @AfterMethod：

   • 在每个测试方法执行之后执行。
   • 常用于清理测试方法的后置条件。

10. @Factory：

    • 用于标记一个方法，该方法返回一个当前测试类的对象数组。
    • 用于动态创建测试实例。

11. @Parameters：

    • 用于标记测试方法或@BeforeMethod、@AfterMethod等，指示这些方法需要参数注入。
    • 参数值通常从testng.xml配置文件中获取。

12. @DataProvider：

    • 用于标记一个方法，该方法提供测试数据给测试方法。
    • 方法返回值是一个二维Object[][]数组，或者是一个Iterator<Object[]>。

13. @Listeners：

    • 用于指定自定义的监听器类，这些监听器类可以监听测试的执行并执行特定的操作。

14. @IRetryAnalyzer：

    • 用于标记一个类，该类实现了重试策略，当测试失败时，TestNG会使用这个策略来决定是否重试测试。

15. @Optional：

    • 用于标记@Parameters注解的参数，表示该参数是可选的，如果参数未提供，则使用注解中指定的默认值。

这些注解可以组合使用，以满足不同的测试需求和配置。通过这些注解，TestNG 提供了强大的测试配置能力和灵活性。

springboot项目集成

在Spring Boot项目中集成TestNG并使用Maven作为构建工具，你需要执行以下步骤：

1. 添加TestNG依赖 ：

   在项目的pom.xml文件中，添加TestNG的依赖。确保使用最新版本的TestNG。

   <dependencies>
       <!-- 添加TestNG依赖 -->
       <dependency>
           <groupId>org.testng</groupId>
           <artifactId>testng</artifactId>
           <version>7.4.0</version> <!-- 使用最新版本 -->
           <scope>test</scope>
       </dependency>
       <!-- 其他依赖 -->
   </dependencies>

2. 配置Maven Surefire Plugin ：

   在pom.xml中配置Maven Surefire Plugin，以确保Maven可以运行TestNG测试。如果你使用的是Spring Boot，通常不需要额外配置，因为Spring Boot的parent POM已经包含了必要的配置。但是，如果你需要自定义配置，可以按照以下方式进行：

   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-surefire-plugin</artifactId>
               <version>3.0.0-M7</version> <!-- 使用最新版本 -->
               <configuration>
                   <!-- 配置TestNG的XML文件 -->
                   <suiteXmlFiles>
                       <suiteXmlFile>src/test/resources/testng.xml</suiteXmlFile>
                   </suiteXmlFiles>
                   <!-- 其他配置 -->
               </configuration>
           </plugin>
       </plugins>
   </build>

3. 创建TestNG测试用例 ：

   创建测试类和方法，使用TestNG的注解来标记它们。例如：

   package com.example.demo;
   
   import org.testng.annotations.Test;
   
   public class DemoTest {
       @Test
       public void testDemo() {
           // 测试逻辑
       }
   }

4. 创建TestNG配置文件 （可选）：

   如果你需要更复杂的测试配置，可以创建一个TestNG配置文件（例如testng.xml），并将其放在src/test/resources目录下。例如：

   <!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
   <suite name="My Test Suite">
       <test name="My Test">
           <classes>
               <class name="com.example.demo.DemoTest"/>
           </classes>
       </test>
   </suite>

5. 运行测试 ：

   使用Maven命令运行测试：

   mvn clean test

   这个命令会编译项目，运行测试，并且生成测试报告。

6. 查看测试报告 ：

   测试完成后，Maven Surefire Plugin会在target/surefire-reports目录下生成测试报告。你可以在浏览器中打开index.html文件来查看测试结果。

通过以上步骤，你可以在Spring Boot项目中集成TestNG，并使用Maven来运行测试。这些步骤提供了一个基本的集成流程，你可以根据项目的具体需求进行调整和扩展。

比较完整的示例

下面是一个使用TestNG注解的编码示例，这个例子中我们将使用多个TestNG注解来展示它们的用法。我们将创建一个简单的计算器类SimpleCalculator，然后编写一个测试类SimpleCalculatorTest，该测试类将使用各种TestNG注解来组织和执行测试。

步骤 1: 创建被测试的类

首先，我们创建一个简单的计算器类SimpleCalculator，包含加、减、乘、除的方法。

package com.example.demo;

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

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public double divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Divider cannot be zero");
        }
        return (double) a / b;
    }
}

步骤 2: 编写TestNG测试用例

接下来，我们编写测试类SimpleCalculatorTest，并使用TestNG注解。

package com.example.demo;

import org.testng.annotations.BeforeSuite;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterTest;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.Test;
import org.testng.annotations.DataProvider;
import org.testng.Assert;
import java.util.Arrays;
import java.util.List;

public class SimpleCalculatorTest {
    private SimpleCalculator calculator;

    @BeforeSuite
    public void initSuite() {
        System.out.println("Suite starts");
    }

    @AfterSuite
    public void finishSuite() {
        System.out.println("Suite ends");
    }

    @BeforeTest
    public void initTest() {
        System.out.println("Test starts");
    }

    @AfterTest
    public void finishTest() {
        System.out.println("Test ends");
    }

    @BeforeClass
    public void initClass() {
        System.out.println("Class starts");
        calculator = new SimpleCalculator();
    }

    @AfterClass
    public void finishClass() {
        System.out.println("Class ends");
    }

    @BeforeMethod
    public void initMethod() {
        System.out.println("Method starts");
    }

    @AfterMethod
    public void finishMethod() {
        System.out.println("Method ends");
    }

    @Test(dataProvider = "addProvider", groups = "arithmetic")
    public void testAdd(int a, int b, int expected) {
        int result = calculator.add(a, b);
        Assert.assertEquals(result, expected, "Add method failed");
    }

    @DataProvider(name = "addProvider")
    public Object[][] addProvider() {
        return new Object[][] {
            { 1, 1, 2 },
            { 2, 2, 4 },
            { -1, -1, -2 }
        };
    }

    @Test(dataProvider = "subtractProvider", groups = "arithmetic")
    public void testSubtract(int a, int b, int expected) {
        int result = calculator.subtract(a, b);
        Assert.assertEquals(result, expected, "Subtract method failed");
    }

    @DataProvider(name = "subtractProvider")
    public Object[][] subtractProvider() {
        return new Object[][] {
            { 10, 5, 5 },
            { 0, 5, -5 },
            { -5, 5, -10 }
        };
    }

    @Test(dataProvider = "multiplyProvider", groups = "arithmetic")
    public void testMultiply(int a, int b, int expected) {
        int result = calculator.multiply(a, b);
        Assert.assertEquals(result, expected, "Multiply method failed");
    }

    @DataProvider(name = "multiplyProvider")
    public Object[][] multiplyProvider() {
        return new Object[][] {
            { 3, 7, 21 },
            { 0, 5, 0 },
            { -3, -7, 21 }
        };
    }

    @Test(dataProvider = "divideProvider", groups = "arithmetic")
    public void testDivide(int a, int b, double expected) {
        double result = calculator.divide(a, b);
        Assert.assertEquals(result, expected, 0.0001, "Divide method failed");
    }

    @DataProvider(name = "divideProvider")
    public Object[][] divideProvider() {
        return new Object[][] {
            { 10, 2, 5.0 },
            { 10, 5, 2.0 },
            { -6, 3, -2.0 }
        };
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testDivideByZero() {
        calculator.divide(1, 0);
    }
}

步骤 3: 运行测试

在命令行中，运行以下Maven命令来执行测试：

mvn clean test

这个命令会编译项目，运行TestNG测试，并生成测试报告。测试报告默认位于target/surefire-reports目录下。

步骤 4: 查看测试报告

打开target/surefire-reports目录下的index.html文件，查看测试结果。

这个例子中，我们使用了以下TestNG注解：

• @BeforeSuite 和 @AfterSuite：在所有测试之前和之后执行。
• @BeforeTest 和 @AfterTest：在每个测试之前和之后执行。
• @BeforeClass 和 @AfterClass：在当前类的所有测试之前和之后执行。
• @BeforeMethod 和 @AfterMethod：在每个测试方法之前和之后执行。
• @Test：标记一个方法为测试方法，可以指定数据提供者和测试组。
• @DataProvider：提供测试数据给测试方法。
• @ExpectedExceptions：指定测试中预期抛出的异常。

这个例子展示了如何使用TestNG的各种注解来组织和管理测试用例，以及如何使用数据提供者来为测试方法提供参数。