• 11. Junit

    我们主要学习的是 Junit5.

    1. selenium 和 Junit 之间的关系

    selenium 和 Junit 之间的关系 就像 Java 和 JavaScript 之间的关系，也就是没有关系。

    为什么学习了 selenium 还要学习 Junit 呢？

    举个例子，如果 Selenium 编写的自动化测试用例是灯，Junit 则是控制灯如何让去亮等。

    通过 Junit 来管理测试用例。

    2. 常用的注解

    2.1 添加依赖
    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.  
    7.     <groupId>org.examplegroupId>
    8.     <artifactId>TestCodeartifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.  
    11.     <dependencies>
    12.         <dependency>
    13.             <groupId>org.seleniumhq.seleniumgroupId>
    14.             <artifactId>selenium-javaartifactId>
    15.             <version>3.141.59version>
    16.         dependency>
    17.         
    18.         <dependency>
    19.             <groupId>commons-iogroupId>
    20.             <artifactId>commons-ioartifactId>
    21.             <version>2.4version>
    22.         dependency>
    23.         <dependency>
    24.             <groupId>org.junit.jupitergroupId>
    25.             <artifactId>junit-jupiter-apiartifactId>
    26.             <version>5.9.2version>
    27.         dependency>
    28.         <dependency>
    29.             <groupId>org.junit.jupitergroupId>
    30.             <artifactId>junit-jupiter-paramsartifactId>
    31.             <version>5.9.2version>
    32.         dependency>
    33.         <dependency>
    34.             <groupId>org.junit.platformgroupId>
    35.             <artifactId>junit-platform-suiteartifactId>
    36.             <version>1.9.1version>
    37.             <scope>testscope>
    38.         dependency>
    39.         <dependency>
    40.             <groupId>org.junit.platformgroupId>
    41.             <artifactId>junit-platform-suiteartifactId>
    42.             <version>1.9.1version>
    43.         dependency>
    44.         <dependency>
    45.             <groupId>org.junit.jupitergroupId>
    46.             <artifactId>junit-jupiter-engineartifactId>
    47.             <version>5.9.1version>
    48.             <scope>testscope>
    49.         dependency>
    50.     dependencies>
    51.  
    52.     <properties>
    53.         <maven.compiler.source>8maven.compiler.source>
    54.         <maven.compiler.target>8maven.compiler.target>
    55.     properties>
    56.  
    57. project>
    2.2 @Test
    1. public class JunitTest {
    2.     @Test
    3.     // @Test 表明当前的方法是一个测试用例
    4.     void test01(){
    5.         WebDriver webDriver = new ChromeDriver();
    6.         webDriver.get("https://www.baidu.com/");
    7.     }
    8. }

    1.     @Test
    2.     void test02(){
    3.         System.out.println("这是第二个测试用例");
    4.     }

    2.3 @BeforeAll @AfterAll
    1.  @BeforeAll
    2.     // 当前所有的测试用例执行之前执行这个方法
    3.     static void setUp(){
    4.         System.out.println("开始执行 @BeforeAll 修饰的方法");
    5.     }
    6.     @AfterAll
    7.     // 当前所有的测试用例执行之后执行这个方法
    8.     static void tearDown(){
    9.         System.out.println("开始执行 @AfterAll 修饰的方法");
    10.     }

    2.4 @BeforeEach @AfterEach
    1. @BeforeEach
    2.     // 当前每个测试用例执行之前执行这个方法
    3.     void boforeTest(){
    4.         System.out.println("开始执行 @BeforeEach 修饰的方法");
    5.     }
    6.     @AfterEach
    7.     // 当前每个测试用例执行之后执行这个方法
    8.     void afterTest(){
    9.         System.out.println("开始执行 @AfterEach 修饰的方法");
    10.     }

    2.5 @Disabled
    1. @Disabled
    2.     // 忽略当前测试用例（当前这个测试用例不执行）
    3.     @Test
    4.     // @Test 表明当前的方法是一个测试用例
    5.     void test01(){
    6.         WebDriver webDriver = new ChromeDriver();
    7.         webDriver.get("https://www.baidu.com/");
    8.     }
    9.     @Test
    10.     void test02(){
    11.         System.out.println("这是第二个测试用例");
    12.     }

    3. Junit 测试用例的执行顺序

    是从上到下执行测试用例吗？

    我们先来看以下的测试用例的执行情况：

    1. public class JunitTest {
    2.     @Disabled
    3.     // 忽略当前测试用例（当前这个测试用例不执行）
    4.     @Test
    5.     // @Test 表明当前的方法是一个测试用例
    6.     void test01(){
    7.         WebDriver webDriver = new ChromeDriver();
    8.         webDriver.get("https://www.baidu.com/");
    9.     }
    10.     @Test
    11.     void test02(){
    12.         System.out.println("这是第2个测试用例");
    13.     }
    14.     @Test
    15.     void test03(){
    16.         System.out.println("这是第3个测试用例");
    17.     }
    18.     @Test
    19.     void test04(){
    20.         System.out.println("这是第4个测试用例");
    21.     }
    22. }

    可以看到确实是从上往下执行的，那么此时我们改变一下测试用例的顺序：

    1. public class JunitTest {
    2.     @Test
    3.     void test04(){
    4.         System.out.println("这是第4个测试用例");
    5.     }
    6.     @Disabled
    7.     // 忽略当前测试用例（当前这个测试用例不执行）
    8.     @Test
    9.     // @Test 表明当前的方法是一个测试用例
    10.     void test01(){
    11.         WebDriver webDriver = new ChromeDriver();
    12.         webDriver.get("https://www.baidu.com/");
    13.     }
    14.     @Test
    15.     void test02(){
    16.         System.out.println("这是第2个测试用例");
    17.     }
    18.     @Test
    19.     void test03(){
    20.         System.out.println("这是第3个测试用例");
    21.     }
    22. }

    可以看到依旧是从上往下执行的。

    那么，我们如何根据指定的顺序来执行测试用例呢？

    1. // 根据指定的顺序来执行测试用例
    2. @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
    3. public class JunitTest {
    4.     @Order(4)
    5.     @Test
    6.     void test04(){
    7.         System.out.println("这是第4个测试用例");
    8.     }
    9.     @Disabled
    10.     // 忽略当前测试用例（当前这个测试用例不执行）
    11.     @Test
    12.     // @Test 表明当前的方法是一个测试用例
    13.     void test01(){
    14.         WebDriver webDriver = new ChromeDriver();
    15.         webDriver.get("https://www.baidu.com/");
    16.     }
    17.     @Order(2)
    18.     @Test
    19.     void test02(){
    20.         System.out.println("这是第2个测试用例");
    21.     }
    22.     @Order(3)
    23.     @Test
    24.     void test03(){
    25.         System.out.println("这是第3个测试用例");
    26.     }
    27. }

    可以看到，我们是通过注解 @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 设定为根据指定的顺序来执行测试用例，通过 @Order 来指定具体的测试用例执行的顺序，没有被 @Order修饰的测试用例默认最后执行 。

    接下来，我们来了解一下通过随机的顺序来执行测试用例：

    1. // 根据随机的顺序来执行测试用例
    2. @TestMethodOrder(MethodOrderer.Random.class)
    3. public class JunitTest {
    4.     @Order(4)
    5.     @Test
    6.     void test04(){
    7.         System.out.println("这是第4个测试用例");
    8.     }
    9.     @Disabled
    10.     // 忽略当前测试用例（当前这个测试用例不执行）
    11.     @Test
    12.     // @Test 表明当前的方法是一个测试用例
    13.     void test01(){
    14.         WebDriver webDriver = new ChromeDriver();
    15.         webDriver.get("https://www.baidu.com/");
    16.     }
    17.     @Order(2)
    18.     @Test
    19.     void test02(){
    20.         System.out.println("这是第2个测试用例");
    21.     }
    22.     @Order(3)
    23.     @Test
    24.     void test03(){
    25.         System.out.println("这是第3个测试用例");
    26.     }
    27. }

     可以看到每次执行的测试用例顺序不同。

    4. 参数化

    参数化中有单参数、多参数、CSV、方法。

    4.1 单参数

    注意，以下两个注解不能同时用来修饰一个方法。

    1.     @ParameterizedTest
    2.     @ValueSource(strings = {"1","2","3"})
    3.     void test05(String str){
    4.         System.out.println(str);
    5.     }

    4.2 多参数
    4.2.1 CSV
    1. @ParameterizedTest
    2.     @CsvSource({"1,2","3,4"})
    3.     void test06(String str,int num){
    4.         System.out.println(str + " " + num);
    5.     }

    接下来，在 resources 中新建文件：

    编写代码：

    1.     @ParameterizedTest
    2.     @CsvFileSource(resources = "test01.csv")
    3.     void test07(int id,String name){
    4.         System.out.println("id" + id + ",name" + name);
    5.     }
    4.2.2 方法

    编写方法：

    1. public static Stream Generator(){
    2.         return Stream.of(Arguments.arguments("1,小张","2,小李"));
    3.     }

    代码： 

    1. // 注册参数
    2.     @ParameterizedTest
    3.     // 注册的参数
    4.     @MethodSource("Generator")
    5.     void test08(String num,String name){
    6.         System.out.println(num + " " + name);
    7.     }

    5. 断言

    断言相等和断言不相等：

    1.     @ParameterizedTest
    2.     @ValueSource(ints = {10})
    3.     void test09(int num){
    4.         // 断言相等
    5.         Assertions.assertEquals(num,10);
    6.         // 断言不相等
    7.         Assertions.assertNotEquals(num,11);
    8.     }

     可以看到运行正确，此时我们修改代码：

    1.     @ParameterizedTest
    2.     @ValueSource(ints = {10})
    3.     void test09(int num){
    4.         // 断言相等
    5.         Assertions.assertEquals(num,10);
    6.         // 断言不相等
    7.         Assertions.assertNotEquals(num,10);
    8.     }

    可以看到此时报错，因为我们断言是不相等的，而实际是相等的。 

    断言为空和断言不为空：

    1.     @ParameterizedTest
    2.     @ValueSource(strings = "1")
    3.     void test10(String num){
    4.         // 断言相等
    5.         Assertions.assertEquals(num,"1");
    6.         // 断言不相等
    7.         Assertions.assertNotEquals(num,"11");
    8.         // 断言为空
    9.         Assertions.assertNull(num);
    10.     }

    1.     @ParameterizedTest
    2.     @ValueSource(strings = "1")
    3.     void test10(String num){
    4.         // 断言相等
    5.         Assertions.assertEquals(num,"1");
    6.         // 断言不相等
    7.         Assertions.assertNotEquals(num,"11");
    8.         // 断言为空
    9. //        Assertions.assertNull(num);
    10.         // 断言不为空
    11.         Assertions.assertNotNull(num);
    12.     }

     

    6. 测试套件

    测试套件：通过一段代码直接将所有的测试用例跑起来。

    1. @Suite
    2. @SelectClasses({JunitTest.class,JunitTest02.class})
    3. public class RunSuite {
    4.     
    5. }

    通过添加以上两个注解就可以将所有需要测试的类运行起来。

    执行指定的包：

    1. @Suite
    2. // 按照指定的类执行
    3. //@SelectClasses({JunitTest.class, JunitTest02.class})
    4. // 按照指定的包执行
    5. @SelectPackages({"Junitlearn","Junitlearn02"})
    6. public class RunSuite {
    7.  
    8. }

     

  • 相关阅读:
    SpringBoot+Swagger详细使用方法
    就是这个问题，感觉就是硬件不兼容
    shell脚本中getopt介绍
    JavaScript笔记(本文中将JavaScript简写为JS)
    数据湖浅析(以hudi为例)
    python笔记二【string】
    Linux make编译
    Vue封装全局SVG组件
    LeetCode 144 二叉树的前序遍历 - Java 实现
    Yolov系列之各个版本区别
  • 原文地址：https://blog.csdn.net/qq_58969626/article/details/132638332