TestNG 实用教程

【1、TestNg 安装、运行、报告】

1、Idea 生成 maven 项目，启动 File--New--Project

2、在 maven 项目中，在 pom 文件中引入 TestNG 依赖（maven 项目的好处是，不再需要我们再单独做 jar 包引用）文章源自玩技e族-https://www.playezu.com/190839.html

<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>6.14.3</version>
</dependency>

文章源自玩技e族-https://www.playezu.com/190839.html

3、新建一个测试类文章源自玩技e族-https://www.playezu.com/190839.html

import org.testng.annotations.Test;
public class testcase {
@Test
public void test1() {
System.out.println("测试用例1被执行");
}
}

4、来执行我们的测试用例

执行 testng 框架的测试用例，会生成测试报告 ，但是在 idea 中看不到，可以更改如下配置，执行完后，查看测试报告

选择要执行的用例，更改默认配置

再次执行测试用例后，可以查看到自动生成的测试报告
文章源自玩技e族-https://www.playezu.com/190839.html

5、运行 TestNG 测试脚本有两种方式：一种是直接通过 IDE 运行，另一种是从命令行运行（通过使用 xml 配置文件）。
通过执行 xml 文件或者命令行执行 xml 配置进行用例执行。文章源自玩技e族-https://www.playezu.com/190839.html

idea 也有一个 testng 插件，用于辅助生成 xml 文件

在对应的类，右键可以辅助生成 testng.xml 文件
文章源自玩技e族-https://www.playezu.com/190839.html

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="All Test Suite">
<test verbose="2" preserve-order="true" name="E:/testngProject/src/main/java/testcase.java">
<classes>
<class name="testcase"></class>
</classes>
</test>
</suite>

在我们的工程中，右键直接执行 testng.xml。文章源自玩技e族-https://www.playezu.com/190839.html

testng 除了上述执行方式外，还提供了 java 方法运行、maven 运行方式，非常灵活的支持自定义以及 CI/CD：文章源自玩技e族-https://www.playezu.com/190839.html

使用 main 方法执行用例，同时也可以设置报告输出目录文章源自玩技e族-https://www.playezu.com/190839.html

import org.testng.TestNG;
public class testngRun {
public static void main(String[] args){
TestNG tng = new TestNG();
tng.setTestClasses(new Class[] {testcase.class,testcase2.class
tng.setOutputDirectory("E:\testngProject\report");
tng.run();
}
}

文章源自玩技e族-https://www.playezu.com/190839.html

使用 main 方法指定测试套件 xml，执行测试用例

import org.testng.TestNG;
import org.testng.xml.XmlSuite;
import java.util.ArrayList;
import java.util.List;
public class testngXmlRun {
public static void main(String[] args){
TestNG tng = new TestNG();
//配置xml执行文件路径
XmlSuite xmlSuite = new XmlSuite();
List<String> filepath = new ArrayList<String>();
filepath.add("E:\testngProject\testng.xml");
xmlSuite.setSuiteFiles(filepath);
//设置xml执行套件
List<XmlSuite> suites = new ArrayList<XmlSuite>();
suites.add(xmlSuite);
tng.setXmlSuites(suites);
tng.setTestClasses(new Class[] {testcase.class,testcase2.class
tng.setOutputDirectory("E:\testngProject\report");
tng.run();
}
}

使用 maven 执行用例
在 pom 文件添加 Surefire 插件配置

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M6</version>
<configuration>
<suiteXmlFiles>
<suiteXmlFile>${suiteXmlFile}</suiteXmlFile>
</suiteXmlFiles>
</configuration>
</plugin>
</plugins>
</build>

这里将套件名称定义为了 ${suiteXmlFile} ，可以方便我们在后续执行中，调用不同的 xml 测试套件

通过 mvn 直接调用 testng 测试用例

mvn clean test -DsuiteXmlFile=testng.xml

执行完成后，也会生成对应的测试报告

TestNG 实用教程【2、TestNg 注解】

TestNG 注解
这些是用于控制方法流的程序或业务逻辑。它们在 TestNG 中起着非常重要的作用。这些注释根据项目要求会有所不同，但注释的流程在每个程序中保持不变。

注解	描述
@BeforeSuite	注释的方法将在这个套件中的所有测试运行之前被运行
@AfterSuite:	注释的方法将在该套件中的所有测试运行后运行
@BeforeTest	注释的方法将在任何属于标签内的类的测试方法运行之前运行
@AfterTest	注释的方法将在所有属于标签内的类的测试方法运行后运行
@BeforeGroups	这个配置方法将在之前运行的组的列表。该方法保证在属于这些组的第一个测试方法被调用前不久运行
@AfterGroups	这个配置方法将在之后运行的组的列表。该方法保证在最后一个属于这些组的测试方法被调用后不久运行
@BeforeClass	该注释方法将在当前类的第一个测试方法被调用之前运行
@AfterClass	注释的方法将在当前类的所有测试方法运行后运行
@BeforeMethod	注释的方法将在每个测试方法之前运行
@AfterMethod	被注解的方法将在每个测试方法之后运行

注解的工作流程
在执行 TestNG.xml 文件时，注解将按这样的顺序执行。
Before Suite-> Before Test-> Before Class->Before Method-> Test -> After Method-> After Class-> After Test-> After Suite

@Test 标记一个类或一个方法作为测试的一部分。
他有非常多的其他属性，能够帮助我们进行有效的测试。下面列举了一些常用的属性

属性	描述
alwaysRun	如果设置为 true，这个测试方法将总是被运行，即使它依赖的方法执行失败
dataProvider	这个测试方法，提供参数数据的方法名称
dataProviderClass	如果指定了这个属性，数据方法需要静态化
dependsOnGroups	这个方法依赖的组的列表
dependsOnMethods	这个方法依赖的方法列表
description	这个方法的描述
enabled	这个类/方法上的方法是否被启用
expectedExceptions	预计测试方法会抛出的异常列表。如果没有抛出任何异常或与此列表中的异常不同，这个测试将被标记为失败
groups	这个类/方法所属的组的列表
invocationCount	这个方法应该被调用的次数
invocationTimeOut	这个测试应该在所有 invocationcount 的累积时间内花费的最大毫秒数。如果没有指定 invocationCount，这个属性将被忽略。
priority	优先级 这个测试方法的优先级。较低的优先级将被首先安排。
successPercentage	该方法的预期成功百分比
singleThreaded	如果设置为 true，这个测试类的所有方法都保证在同一个线程中运行，即使当前测试正在以 parallel="methods "运行。这个属性只能在类的层面上使用，如果在方法层面上使用，它将被忽略。注意：这个属性曾经被称为 sequential（现在已经废弃了）。
timeOut	这个测试应该花费的最大毫秒数
threadPoolSize	这个方法的线程池的大小。该方法将从多个线程中调用，由 invocationCount 指定，如果没有指定 invocationCount，这个属性会被忽略

alwaysRun 样例
当 alwaysRun 为 ture 时，就算 errMethods 方法执行失败，也会执行。 为 flase 时，由于 errMethods 执行失败，test1 未被执行

public class testcase {
@Test
public void errMethods() {
int a = 1;
int b = 0 ;
System.out.println("我是被依赖的方法"+a/b);
}
@Test(alwaysRun = true,dependsOnMethods = {"errMethods"})
public void test1() {
System.out.println("测试用例1被执行");
}
}

dataProvider 样例
执行用例后，可以看到分别会打印：我的姓名是张三；我的姓名是李四

@DataProvider(name = "namedata")
public Object[][] createData1() {
return new Object[][] {
{ "张三" },
{ "李四"},
};
}
@Test(dataProvider = "namedata")
public void test1(String name) {
System.out.println("我的姓名是" +name);
}

dataProviderClass 样例
还可以在找定的类中，查找参数数据源，执行用例可以发现，打印的内容为：我的姓名是王五；我的姓名是赵六

@DataProvider(name = "namedata")
public Object[][] createData1() {
return new Object[][] {
{ "张三" },
{ "李四"},
};
}
@Test(dataProvider = "namedata",dataProviderClass = nameData.class)
public void test1(String name) {
System.out.println("我的姓名是" +name);
}

public class nameData {
@DataProvider(name = "namedata")
public static Object[][] createData1() {
return new Object[][] {
{ "王五" },
{ "赵六"},
};
}
}

dependsOnGroups 样例
这个属性依赖于组列表，测试方法只有在依赖组执行后才会开始执行，如果依赖的组中的任何测试失败，那么它将跳过该测试
当将 fun2 打开后，会发现 test1 阻塞了执行

@Test(groups= "group1")
public void fun1(){
System.out.println("我fun1属于工作组group1");
}
//@Test(groups= "group1")
// public void fun2(){
//  int a = 0;
// int b = a;
//  System.out.println("我是fun2属于工作组group1"+b/a);
//  }
@Test(dependsOnGroups = "group1")
public void test1() {
System.out.println("我是用例test1");
}

*dependsOnMethods *
这个属性依赖的方法列表，同上一样，只有在依赖方法执行后才会开始执行，如果依赖的方法中的任何测试失败，那么它将跳过该测试

expectedExceptions 样例
这个方法就比较有意思了
提前预计测试方法会抛出的异常。如果没有标识的异常，测试将被标记为失败

@Test(expectedExceptions = {ArithmeticException.class})
public void test2(){
int a = 0;
int b = a;
System.out.println("我是test2"+b/a);
}

invocationCount 样例
运行一下来看，可以明显看出这个方法执行了 2 次

@Test(invocationCount = 2)
public void test1() {
System.out.println("我是用例test1");
}

priority 样例
这也是一个非常有用的属性，可以帮助我们调置方法执行的优先顺序。test1 没有分配数字，它的默认优先级为 0。
运行结果可以看到：我是用例 test1--》我是用例 test2--》我是用例 test3
是按照升序进行执行的

@Test()
public void test1() {
System.out.println("我是用例test1");
}
@Test(priority = 1)
public void test2() {
System.out.println("我是用例test2");
}
@Test(priority = 2)
public void test3() {
System.out.println("我是用例test3");
}

@DataProvider：标记一个方法为一个测试方法提供数据。被注解的方法必须返回一个 Object[][]，其中每个 Object[] 可以被分配给测试方法的参数列表。想要从这个 DataProvider 中接收数据的@Test方法需要使用一个与这个注解的名称相等的 DataProvider 名称。。
可以参照我们上面的
dataProvider 样例
执行用例后，可以看到分别会打印：我的姓名是张三；我的姓名是李四

@DataProvider(name = "namedata")
public Object[][] createData1() {
return new Object[][] {
{ "张三" },
{ "李四"},
};
}
@Test(dataProvider = "namedata")
public void test1(String name) {
System.out.println("我的姓名是" +name);
}

@Factory 标记一个方法为工厂，返回将被 TestNG 作为测试类使用的对象。该方法必须返回 Object[]。

执行 factoryTest 类时，能够发现我们可以使用工厂类组织各种不同数据，进行多次测试
当然使用单个测试类运行多个测试类时，TestNG Factory 非常有用。

public class factoryTest {
@Factory()
public Object[] createUsernames() {
Object[] result = new Object[10];
for (int i = 0; i < 10; i++) {
result[i] = new testcase("张三"+i); //在这里可以加入多个测试
}
return result;
}
}

public class testcase {
private String usernames;
public testcase(String username) {
usernames = username;
}
@Test()
public void test1() {
System.out.println("我的名字是："+usernames);
}
}

TestNG 实用教程【3、TestNg 监听器】

@Listeners 允许在一个测试类上定义监听器。
简单来说，监听用例中定义的事件。也能够根据事件创建日志和自定义 TestNG 报告。

有几个接口允许修改 TestNG 的行为，这些接口被广泛称为 "TestNG 监听器"。

下面是几个监听器。

接口	说明
IAnnotationTransformer	TestNG 将调用此方法，修改从测试类读取的 TestNG 注释。可以操作@Test注解的内容
IAnnotationTransformer2	可以操作@Configuration标注、@DataProvider标注和@Factory标注
IInvokedMethodListener	在 TestNG 调用方法之前和之后调用的监听器。这个监听器只会被配置和测试方法调用
IMethodInterceptor	用于更改 TestNG 即将运行的测试方法列表
IReporter	测试报告监听器，可以获取用例执行结果
ISuiteListener	测试套件的监听器
ITestListener	测试运行的监听器

测试用例代码

@Listeners({MyListener.class})
public class testcase {
@Test(priority = 1)
public void test1(){
System.out.println("我是test1");
}
}

IAnnotationTransformer 样例
可以操作@test注解的内容，下面代码可以看出，test1() 的 priority = 1，运行过程中将 priority 设置为了 3

public class MyListener implements IAnnotationTransformer {
public void transform(ITestAnnotation iTestAnnotation, Class aClass, Constructor constructor, Method method) {
System.out.println("当前用例优先级别为："+iTestAnnotation.getPriority());
iTestAnnotation.setPriority(3);
System.out.println("重新设置后的优先级别为："+iTestAnnotation.getPriority());
}
}

ISuiteListener 样例
测试套件的监听器，有两个主要方法：
onFinish 在运行所有测试套件后调用此方法。
onStart 在启动之前调用此方法。

运行过程中我们可以看到执行顺序：用例执行前调用--》我是 test1--》用例执行完成后调用

public class MyListener implements ISuiteListener {
public void onStart(ISuite iSuite) {
System.out.println("用例执行前调用");
}
public void onFinish(ISuite iSuite) {
System.out.println("用例执行完成后调用");
}
}

ITestListener 样例
测试运行的监听器，有七个主要方法：
onFinish 在所有测试运行并调用所有配置方法后调用
onStart 在实例化测试类之后和调用任何配置方法之前调用
onTestFailedButWithinSuccessPercentage 每次方法失败时调用
onTestFailure 每次测试失败时调用
onTestSkipped 每次跳过测试时调用
onTestStart 每次在调用测试之前调用
onTestSuccess 每次测试成功时调用

IMethodInterceptor 样例
用于更改 TestNG 即将运行的测试方法列表，只有没有依赖项且不依赖于任何其他测试方法的方法才会传入参数。TestNG 将按照返回值中的相同顺序运行这些方法。

对 testcase 进行执行顺序混乱后，可以发现，用例执行顺序变更了，这里我们可以重新调整我们用例执行顺序

public class MyListener implements IMethodInterceptor {
public List<IMethodInstance> intercept(List<IMethodInstance> list, ITestContext iTestContext) {
Collections.shuffle(list); // 混乱list
return list;
}
}

@Listeners({MyListener.class})
public class testcase {
@Test
public void testa(){
System.out.println("我是testa");
}
@Test
public void testc(){
System.out.println("我是testc");
}
@Test
public void testb(){
System.out.println("我是testb");
}
}

IInvokedMethodListener 样例
在 TestNG 调用方法之前和之后调用的监听器。这个监听器只会被配置和测试方法调用 ，有两个方法：
afterInvocation 调用前执行
beforeInvocation 调用后执行

运行过程中我们可以看到执行顺序：调用前执行--》我是 test1--》调用后执行

public class MyListener implements IInvokedMethodListener {
public void beforeInvocation(IInvokedMethod iInvokedMethod, ITestResult iTestResult) {
System.out.println("调用前执行");
}
public void afterInvocation(IInvokedMethod iInvokedMethod, ITestResult iTestResult) {
System.out.println("调用后执行");
}
}

IReporter 样例
测试报告监听器，可以获取用例执行结果，通过这些数据，我们也可以用于自定义生成测试报告
运行后可以获取的，所有成功和失败的用例信息，同时也有非常多的方法，获取结果信息（这里就不一一介绍了，感兴趣的可以查看对应 api）

public class MyListener implements IReporter {
public void generateReport(List<XmlSuite> list, List<ISuite> list1, String s) {
for (ISuite x :list1) {
Map<String, ISuiteResult> xResults = x.getResults();
for (ISuiteResult isresult : xResults.values()) {
ITestContext itx = isresult.getTestContext();
System.out.println("获取执行成功的用例数据："+itx.getPassedTests());
System.out.println("获取执行失败的用例数据："+itx.getFailedTests());
}
}
}
}

注意
光配置执行过程中，会发现未生效，需要对运行的用例进行监听器配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="All Test Suite">
<listeners>
<listener class-name="MyListener" />
</listeners>
<test verbose="2" preserve-order="true" name="testcaseone">
<classes >
<class name="testcase"></class>
<class name="testcase2"></class>
</classes>
</test>
</suite>

TestNG 实用教程【4、如何使用 TestNG.Xml 文件】

常用属性说明

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<!--suite（测试套件）为根路径，仅允许出现1次，是多个test（测试用例）的集合，以下为各属性含义及取值
@name 必填，标记suite的名称
@parallel 选填，是否多线程并发运行测试，可选值(false | methods | tests | classes | instances)，默认 "false"
@thread-count 选填，填写值为正整数，当为并发执行时的线程池数量，默认为"5"
@configfailurepolicy 一旦Before/After Class/Methods这些方法失败后，是继续执行测试还是跳过测试；可选值 (skip | continue)，默认"skip
@time-out 为具体执行单元设定一个超时时间，具体参照parallel的执行单元设置；单位为毫秒
@skipfailedinvocationcounts 是否跳过失败的调用，可选值(true | false)，默认"false"
@data-provider-thread-count 并发执行时data-provider的线程池数量，默认为"10"
@object-factory 一个实现IObjectFactory接口的类，用来实例测试对象
@allow-return-values="true" 是否允许返回函数值，可选值(true | false)，默认"false"
@preserve-order：顺序执行开关，可选值(true | false) "true"
@group-by-instances：是否按实例分组，可选值(true | false) "false"
-->
<suite name="suitename"  parallel="false" thread-count="5" configfailurepolicy="skip"
annotations="javadoc" time-out="10000" skipfailedinvocationcounts="true" data-provider-thread-count="5"
object-factory="classname" allow-return-values="true" preserve-order="true" group-by-instances="false">
<!--可以执行多个suite，@path 必填，欲引用的suitefile的绝对路径-->
<suite-files>
<suite-file path="/path/to/suitefile1"></suite-file>
</suite-files>
<!--全局参数，@name和@value必填，分别为参数名和参数值-->
<parameter name="par1" value="value1"></parameter>
<parameter name="par2" value="value2"></parameter>
<!--方法选择器，在suite/test中增加需要额外执行的类（根据父标签而定），及安排执行优先级-->
<method-selectors>
<method-selector>
<!--
@name 必填
@priority 选填
-->
<selector-class name="classname" priority="1"></selector-class>
<!--
@language 必填
-->
<script language="java"></script>
</method-selector>
</method-selectors>
<!--test定义一次测试执行，以下为各属性含义及取值
@name：必填，test的名字，测试报告中会有体现
@parallel：选填，是否多线程并发运行测试；可选值(false | methods | tests | classes | instances)，默认 "false"
@thread-count：选填，当为并发执行时的线程池数量，默认为"5"
@time-out：选填，为具体执行单元设定一个超时时间，具体参照parallel的执行单元设置；单位为毫秒
@enabled：选填，设置当前test是否生效，可选值(true | false)，默认"true"
@skipfailedinvocationcounts：选填，是否跳过失败的调用，可选值(true | false)，默认"false"
@preserve-order：选填，顺序执行开关，可选值(true | false) "true"
@group-by-instances：选填，是否按实例分组，可选值(true | false) "false"
@allow-return-values：选填，是否允许返回函数值，可选值(true | false)，默认"false"
-->
<test name="testename"  parallel="false" thread-count="5"
time-out="10000" enabled="true" skipfailedinvocationcounts="true" preserve-order="true"
allow-return-values="true">
<!--局部参数，@name和@value必填，分别为参数名和参数值，如果参数名与全局参数一致，则覆盖全局参数取值-->
<parameter name="par1" value="value1"></parameter>
<parameter name="par2" value="value2"></parameter>
<!--搭配class使用，执行class内指定组-->
<groups>
<!--定义执行组名，在run中使用
@name 必填，组中组的名称
-->
<define name="xxx">
<!--定义包含的测试组，测试方法属于哪个测试组在测试代码注释中定义。
@name 必填，需要包含进组中组的组名
@description 选填，关于组的描述
@invocation-numbers 选填，执行次序或者执行次数——TODO
-->
<include name="" description="" invocation-numbers=""/>
<include name="" description="" invocation-numbers=""/>
</define>
<!--运行组中组的配置-->
<run>
<!--执行指定的组中组，@name必填，与define name一致-->
<include name=""/>
<!--排除指定的组中组，@name必填，与define name一致-->
<exclude name=""/>
</run>
<!--组中组的依赖配置-->
<dependencies>
<!--配置依赖
@name 必填，需要依赖其他组的组名，define中设置
@depends-on 必填，被依赖的组名，define中设置，可以有多个，用空格隔开
-->
<group name="" depends-on=""></group>
<group name="" depends-on=""></group>
</dependencies>
</groups>
<!--配置要执行的类，是多个class的集合-->
<classes>
<!--局部参数，@name和@value必填，分别为参数名和参数值，如果参数名与全局参数和父标签的局部参数一致，则覆盖全局参数和父标签的局部参数取值-->
<parameter name="par1" value="value1"></parameter>
<parameter name="par2" value="value2"></parameter>
<!--多个methods的集合，@name 必填，对应class的名称，如com.example.autotest.testcase-->
<class name="classname">
<!--要执行的方法，如为空，则执行整个class内包含的全部方法-->
<methods>
<!--局部参数，@name和@value必填，分别为参数名和参数值，如果参数名与全局参数和父标签的局部参数一致，则覆盖全局参数和父标签的局部参数取值-->
<parameter name="par3" value="value3"></parameter>
<!--类内要执行的测试方法名，在测试代码注释中配置，如设置inclde，则只执行该方法，其他跳过
@name 必填，执行方法名
@description 选填，方法描述
@invocation-number 选填，宣发执行顺序或执行次数——TODO
-->
<include name="" description="" invocation-numbers=""></include>
<!--除了该方法外，类内其他方法都执行，@name 必填，不执行的方法名-->
<exclude name=""></exclude>
</methods>
<methods></methods>
</class>
</classes>
<!--可以执行指定包下面所有类，是多个package的汇聚-->
<packages>
<!--配置要执行的包，@name 必填，要执行的package名-->
<package name="">
<!--包内要执行的测试方法名，在测试代码注释中配置，如设置inclde，则只执行该方法，其他跳过
@name 必填，执行方法名
@description 选填，方法描述
@invocation-number 选填，宣发执行顺序或执行次数——TODO
-->
<include name="" description="" invocation-numbers=""></include>
<!--除了该方法外，包内其他方法都执行，name 必填，不执行的方法名-->
<exclude name=""></exclude>
</package>
</packages>
</test>
<!--设置监听的类名，可设置多个，class-name 必填，类名-->
<listeners>
<listener class-name="MyListener"/>
<listener class-name="xxxxx"/>
</listeners>
</suite>

TestNG 实用教程【5、使用 TestNG 进行单元测试】

1、 模拟实际工程，新建一个简易的 springboot 项目

2、在 pom 文件中，加入服务所需依赖（只是演示如何进行单元测试，依赖并不需要向开发那么多，真实项目 POM 文件中依赖是非常多的）

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>6.14.3</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.maven.surefire</groupId>
<artifactId>surefire-testng</artifactId>
<version>3.0.0-M6</version>
</dependency>
</dependencies>

3、在 application.properties 中添加数据库信息

server.port=8001
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboottest 
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.max-idle=10
spring.datasource.max-wait=10000
spring.datasource.min-idle=5
spring.datasource.initial-size=5

4、编写服务端项目代码

我的目录结构：

定义一个简单接口，通过 id 查询数据库表 test_table 中的信息，并返回给前端

package com.example.demo.controller;
import com.example.demo.dto.TestTable;
import com.example.demo.mapper.TestTableMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping(value = "/test")
public class TestTableController {
@Autowired
private TestTableMapper testTableMapper;
//根据id查询数据表user_table对应的数据信息
@GetMapping(value = "/getValues/{id}")
public TestTable getValues(@PathVariable(value = "id") int id){
TestTable testTable = testTableMapper.getById(id);
return testTable;
}
}

定义一个数据库操作对象，里面有两个方法，一个是能过 id 查询，一个是能过 id 和 name 进行修改数据库记录

package com.example.demo.mapper;
import com.example.demo.dto.TestTable;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
@Mapper
public interface  TestTableMapper {
@Select("select * from user_table where id = #{id}")
TestTable getById(int id) ;
@Update("update user_table set name = #{name} where id = #{id}")
int updateName(int id,String name) ;
}

数据传输对象

package com.example.demo.dto;
import lombok.Data;
@Data
public class TestTable {
private int id;
private String name;
private String msg;
}

数据库表也非常简单

id	name	msg
1	张三	我是张三
2	李四	我是李四

启动 springboot 项目

编写的接口可被正常调用，并且返回了数据库 id=1 的信息

对 TestTableController 和 TestTableMapper 类进行单元测试

可以直接使用@SpringBootTest ,使用 Test 结尾的注解，具有加载 applicationContext 的能力

在 test 目录下，新建 TestTableController 测试类-TestTableControllerTestCase
验证 TestTableController 的 getValues 方法，返回的数据是否为我们预期的数据

package com.example.demo.controller;
import com.example.demo.dto.TestTable;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.Test;
import static org.testng.Assert.assertEquals;
@SpringBootTest
public class TestTableControllerTestCase extends AbstractTestNGSpringContextTests {
@Autowired
private TestTableController testTableController;
@Test
public void test1 () throws Exception {
TestTable testTable = testTableController.getValues(1);
assertEquals(testTable.getName(),"张三");
assertEquals(testTable.getMsg(),"我是张三");
}
}

在 test 目录下，新建 TestTableMapper 测试类-TestTableMapperTestCase
验证 TestTableMapper 的 update 方法，是否能成功修改数据库
执行了 update 方法，然后使用了 TestTableController 的 getValues 方法获取了返回值，进行了比较

package com.example.demo.controller;
import com.example.demo.dto.TestTable;
import com.example.demo.mapper.TestTableMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.Test;
import static org.testng.Assert.assertEquals;
@SpringBootTest
public class TestTableMapperTestCase extends AbstractTestNGSpringContextTests {
@Autowired
private TestTableController testTableController;
@Autowired
private TestTableMapper testTableMapper;
@Test
public void test1 () throws Exception {
testTableMapper.updateName(2,"赵五");
TestTable testTable = testTableController.getValues(2);
assertEquals(testTable.getName(),"赵五");
assertEquals(testTable.getMsg(),"我是李四");
}
}

我们也可以生成一个 xml 文件，对测试用例进行管理

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="All Test Suite">
<test verbose="2" preserve-order="true" name="testcaseone">
<classes >
<class name="com.example.demo.controller.TestTableMapperTestCase"></class>
<class name="com.example.demo.controller.TestTableControllerTestCase"></class>
</classes>
</test>
</suite>

集成测试

我们写好的单元测试脚本也可以集成在流程中，在指定的环节进行执行
注：这里强制指定了 testng ,如果不进行指定，会自动使用 Junit 执行 testng 测试脚本

在 pom 文件中添加

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M6</version>
<configuration>
<suiteXmlFiles>
<suiteXmlFile>src/test/testng.xml</suiteXmlFile>
</suiteXmlFiles>
<!--mvn test命令输出默认报告的文件目录 -->
<reportsDirectory>${basedir}/test-out</reportsDirectory>
</configuration>
<!--  这里强制指定了testng ,如果不进行指定，有时候会自动指向Junit执行测试脚本 -->
<dependencies>
<dependency>
<groupId>org.apache.maven.surefire</groupId>
<artifactId>surefire-testng</artifactId>
<version>3.0.0-M6</version>
</dependency>
</dependencies>
</plugin>

这样我们可以直接使用 mvn 命令一键执行，我们单元测试脚本

mvn clean test

同时 idea 也提供了一个很有意思的一个运行方式：run with coverage

可以查看到我们单元测试脚本，代码覆盖率
澳门软件功能测试