SoftwareTest7 - JUnit 是个啥 ? 他跟 Selenium 有什么关系 ?

Hello , 大家好 , 又给大家带来新的专栏喽 ~

这个专栏是专门为零基础小白从 0 到 1 了解软件测试基础理论设计的 , 虽然还不足以让你成为软件测试行业的佼佼者 , 但是可以让你了解一下软件测试行业的相关知识 , 具有一定的竞争实力 .

那这篇文章 , 就开始 Selenium 实战了 , 我们可以通过代码来操控浏览器来去做一些操作了 , 这个过程非常有趣 , 敬请期待

那也欢迎大家订阅此专栏 : https://blog.csdn.net/m0_53117341/category_12427509.html

希望大家都能够拿到好的 Offer

我们之前讲过 , 自动化不就是通过 selenium 去实现的吗 , 怎么又引入了个 JUnit 呢 ?
JUnit 是 Java 中的单元测试工具 , 但是我们可以借用 JUnit 库中一些非常好的方法让我们的自动化锦上添花
我们给大家介绍的是 JUnit 5 , 需要我们至少是 JDK 1.8 版本才可以使用
先把 JUnit 的依赖贴在这里

<dependency>
  <groupId>org.junit.jupitergroupId>
  <artifactId>junit-jupiterartifactId>
  <version>5.8.2version>
  <scope>testscope>
dependency>

<dependency>
  <groupId>org.junit.platformgroupId>
  <artifactId>junit-platform-suiteartifactId>
  <version>1.8.2version>
  <scope>testscope>
dependency>

如果之前使用过 JUnit4 的话 , 那么这次下载 Junit5 可能就会失败
解决方法是找到之前下载好的 JUnit4 依赖 , 删掉之后再重新下载 JUnit5
那引入了 JUnit 之后 , 我们就不需要再创建 main 去调用各个方法了

一 . 相关注解

JUnit 中提供了非常强大的注解功能
我们常用的注解都有 : @Test、@BeforeEach、@BeforeAll、@AfterEach、@AfterAll

1.1 @Test

在方法上面加上 @Test 就代表该方法是测试方法
我们看看加上这个注解有什么用处 ?


@Test表示该方法是测试方法 , 执行当前这个类的时候 , 会自动执行该类下所有带 @Test注解的用例

在写自动化的时候 , 我们通常把每个方法都叫做每个自动化的测试用例

package com.ethan3;

import org.junit.jupiter.api.Test;

public class junitTest {

    @Test
    public void testAnnotation() {
        System.out.println("测试 @Test 注解");
    }
}

我们通过控制台也能发现好多信息

1.2 @BeforeEach

@BeforeEach 指的是当我们的方法被 @BeforeEach 修饰的时候 , 就意味着当前的方法需要在每个用例执行之前都执行一次

package com.ethan3;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

public class junitTest {
    
    @BeforeEach
    public void testAnnotation() {
        System.out.println("测试 @Test 注解");
    }

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

    @Test
    public void test2() {
        System.out.println("test2");
    }
}

1.3 @BeforeAll

@BeforeAll 的作用是当前的方法需要在当前类下所有用例之前执行一次
但是加到方法上面 , 运行还报错了

它提示我们要想使用 @BeforeAll 的话 , 这个方法需要是静态的

package com.ethan3;

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

public class junitTest {

    @BeforeAll
    public static void testAnnotation() {
        System.out.println("测试 @Test 注解");
    }

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

    @Test
    public void test2() {
        System.out.println("test2");
    }
}

我们也可以参考 类变量 , 整个类只有一个 , 所以只会打印一次

1.4 @AfterEach

@AfterEach 指的是 当前的方法需要在每个用例执行之后都执行一次

package com.ethan3;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

public class junitTest {

    @AfterEach
    public void testAnnotation() {
        System.out.println("测试 @Test 注解");
    }

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

    @Test
    public void test2() {
        System.out.println("test2");
    }
}

1.5 @AfterAll

@AfterAll 指的是 当前的方法在当前类下所有的用例执行之后执行一次
注意 : 被该注解修饰的方法必须是静态的

二 . 断言

2.1 assertEquals

当我们获取到文本的时候 , 我们可以判断该文本对不对
比如这个案例 :

那我们就可以通过断言来站在机器的角度上看一下到底是否正确

package com.ethan3;

import org.junit.jupiter.api.*;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;

public class junitTest {
    @Test
    public void review() {
        ChromeDriver driver = new ChromeDriver();
        driver.get("https://www.baidu.com");
        String text = driver.findElement(By.cssSelector("#su")).getAttribute("value");// 得到"百度一下"

        // 假如我们获取到的不是百度一下,而是百度两下
        // 对于测试人员来说,就是 Bug
        // 但是对于程序来说,是正确的,因为他并未报错
        System.out.println(text);

        // 使用 Assertions.assertEquals 进行断言
        Assertions.assertEquals("期盼值", text);

        driver.quit();
    }
}

如果跟我们设定的预期值不符 , 就会报错 , 测试人员就会立马排查问题

2.2 assertNotEquals

assertNotEquals 的作用就是当实际值和预期值不符的时候 , 程序才不报错 , 运行成功

package com.ethan3;

import org.junit.jupiter.api.*;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;

public class junitTest {

    @Test
    public void review() {
        ChromeDriver driver = new ChromeDriver();
        driver.get("https://www.baidu.com");
        String text = driver.findElement(By.cssSelector("#su")).getAttribute("value");// 得到"百度一下"
    
        // 假如我们获取到的不是百度一下,而是百度两下
        // 对于测试人员来说,就是 Bug
        // 但是对于程序来说,是正确的,因为他并未报错
        System.out.println(text);
    
        // 使用 Assertions.assertEquals 进行断言
        Assertions.assertNotEquals("期盼值", text);
    
        driver.quit();
    }

}

2.3 assertTrue / assertFalse : 断言结果为真/假

package com.ethan3;

import org.junit.jupiter.api.*;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;

public class junitTest {
    @Test
    public void assertDemo() {
        Assertions.assertTrue(1 == 1);
    }
}

2.4 assertNull / assertNotNull : 断言结果为空 / 不为空

package com.ethan3;

import org.junit.jupiter.api.*;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;

public class junitTest {

    @Test
    public void assertDemo2() {
        Assertions.assertNull("","你好");// 断言失败
    }

    @Test
    public void assertDemo3() {
        Assertions.assertNotNull("","你好");// 断言成功
    }
}

三 . 用例的执行顺序

官方网站没有明确说明默认的执行顺序的规则 , 测试用例的执行并不会按照我们编写用例的顺序来执行

那就会存在一定问题 :
比如我们的博客系统 , 我们想要对登录功能进行测试 , 需要编写测试用例

1. 检查登录页面展现是否正确
2. 检查正常登录
3. 检查异常登陆

如果先执行了第二个测试用例 , 页面就跳转到了博客列表页 . 那接下来再去执行第一条测试用例 , 就肯定会报错
我们只有先检查登录页面展现是否正确之后 , 再去检查第三条

3.1 通过 Order 注解来排序

我们的当前类中 , 有非常多的用例 , 那么在这个类中 , 按照什么顺序来执行呢 ?
我们首先需要在类上加上一个注解 : @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
这个注解的作用是强调(声明)用 order 来进行排序
接下来在每个用例上面加上 @Order(顺序) 来决定每个用例的执行顺序

package com.ethan4;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class junitTest {
    @Test
    @Order(1)
    public void loginTest() {
        System.out.println("1::loginTest");
    }
    @Test
    @Order(2)
    public void editTest() {
        System.out.println("2::editTest");
    }
    @Test
    @Order(3)
    public void indexTest() {
        System.out.println("3::indexTest");
    }

}

注意 : 用例上面的 @Test 注解是不能删掉的

四 . 参数化

针对于博客系统的登录功能 , 每个用户的用户名和密码是各不相同的 . 这样的话就会导致参数各不相同
这样的话我们就需要写出无穷无尽的方法去解决他

我们就可以使用参数化的方式来处理各式各样的参数问题 , 尽可能通过一个用例 , 多组参数来模拟用户的行为

4.1 单参数注解手动编写数据源

在使用参数化注解之前 , 需要先声明该方法为参数化方法 , 使用注解 : @ParameterizedTest
那这个参数从哪里来 , 我们还需要声明一个注解 : @ValueSource(strings = {“甄嬛”,“沈眉庄”,“安陵容”})

这就是我们的参数化 , 通过参数化注解 , 我们就把参数传递给测试用例中 , 供测试用例使用

package com.ethan4;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class junitTest {

    @ParameterizedTest
    @ValueSource(strings = {"甄嬛","沈眉庄","安陵容"})
    public void sparamTest(String name) {
        System.out.println("name:" + name);
    }
}

那这个 @ValueSource() 到底是怎么回事 ?
@ValueSource(数据类型方法 = {“参数1”,“参数2”,“参数3”…})
其中 , 数据类型支持 : short、byte、int、long、double、char…

这几个数据类型在 JUnit 中不单单是简单的数据类型 , JUnit 将这些数据类型封装成了一个方法
我们回到 IDEA 也可以看一下

但是 @ValueSource() 只支持单参数

4.2 多参数从 csv 文件获取数据来源

package com.ethan4;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;

public class junitTest {

    @ParameterizedTest
    @CsvSource({"甄嬛,20", "沈眉庄,25", "安陵容,26"})
    public void moreParamsTest(String name,int age) {
        System.out.println("name:" + name + " age:" + age);
    }

}

---

那要是我们有非常多的数据 , 我们难不成要写非常多的 “” , 这肯定不行
我们就可以在其他文件写好 , 让我们的注解直接调用到这个文件 , 执行里面的数据
我们创建一个 csv 文件 , 在里面写好数据

然后使用 @CsvFileSource(files = “路径名”) 导入文件

package com.ethan4;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvFileSource;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class junitTest {

    @ParameterizedTest // 表示该方法是参数化方法
    @CsvFileSource(files = "D:\\study\\JavaCode\\selenium_demo\\test.csv") // 导入第三方文件
    public void csvFileParamsTest(String name,int age) {
        System.out.println("name:" + name + " age:" + age);
    }


}

如果发生乱码导致报错的话 , 手动创建一个 txt 文件 , 按照这种格式来编辑数据 , 然后再修改后缀名为 csv

zhangsan,18
lisi,20
wangwu,26

4.3 动态参数方法

通过动态方法提供数据源 , 构造出动态的数据

package com.ethan4;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.*;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;

import java.util.stream.Stream;

public class junitTest {

    @ParameterizedTest // 先声明该方法是参数化方法
    @MethodSource("methodParams") // 指定动态数据来源
    public void dynamicParamsTest(String name,int age) {
        System.out.println("name:" + name + " age:" + age);

    }

    /**
     * 1. 方法必须是静态的
     * 2. 返回值是 Stream
     * 3. 返回 Stream.of 对象
     * @return
     * @throws InterruptedException
     */
    static Stream<Arguments> methodParams() throws InterruptedException {
        // 构造动态参数
        String[] arr = new String[5];
        for (int i = 0; i < arr.length; i++) {
            Thread.sleep(500);
            arr[i] = System.currentTimeMillis() + "";
        }
        return Stream.of(
                Arguments.arguments(arr[0],20),
                Arguments.arguments(arr[1],20),
                Arguments.arguments(arr[2],20),
                Arguments.arguments(arr[3],20),
                Arguments.arguments(arr[4],20)
        );
    }

}

我们运行一下

---

那我们把刚才写好的数据来源注释掉 , 然后编写一个新的数据来源 , 与我们打印的用例同名 , 但是上面的 @MethodSource() 注解 , 我们就不写括号里面的数据来源了 , 这样也是可以的

package com.ethan4;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.*;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;

import java.util.stream.Stream;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class junitTest {

    @ParameterizedTest // 先声明该方法是参数化方法
    @MethodSource // 指定动态数据来源
    public void dynamicParamsTest(String name,int age) {
        System.out.println("name:" + name + " age:" + age);

    }

    static Stream<Arguments> dynamicParamsTest() throws InterruptedException {
        // 构造动态参数
        String[] arr = new String[5];
        for (int i = 0; i < arr.length; i++) {
            Thread.sleep(500);
            arr[i] = System.currentTimeMillis() + "";
        }
        return Stream.of(
                Arguments.arguments(arr[0],20),
                Arguments.arguments(arr[1],20),
                Arguments.arguments(arr[2],20),
                Arguments.arguments(arr[3],20),
                Arguments.arguments(arr[4],20)
        );
    }
}

也是可以运行的

---

最后注意一点 , 使用了参数化注解的方法不能再用 @Test 注解了 , 也就意味着 @Test 只能作用在非参数化的用例上

五 . 测试套件

为了模拟测试套件 , 我们新创建三个类 , 每个类中都写上一些最基础的测试方法

我们之前都是运行一个类中的所有方法 , 那我们要是想运行多个类中的多个方法 , 意思就是我们怎么一起运行 test1 test2 test3 呢 ?
我们就可以使用测试套件

5.1 指定类来运行包下所有用例

我们首先需要创建一个测试套件 , 实际上就是创建一个新的类 , 加上注解 : @Suite , 标识这是一个测试套件类而不是测试类

接下来 , 我们需要指定我们需要跑哪些类 , 使用注解 : @SelectClasses() , 里面使用 {} 把我们需要测试的类加进去

运行一下

那如果我们 @SelectClasses() 里面的某一个类里面的某个用例没加 @Test , 那么就不会执行这个方法

我们刚刚还介绍了参数化的用例 , 他并没有用 @Test 注解啊 ?
其实参数化用例 , 测试套件也是能扫描到的

5.2 指定包来运行包下所有用例

使用 : @SelectPackages("包的路径) 来指定要执行的方法集合

运行一下

他为什么只跑了 junitTest 了呢 ?
这是因为我们指定包来运行范围的话 , 文件名命名规则需要以 Test/Tests 结尾 (T 还得必须大写)