自动化测试Junit

Junit5

1. 为什么学了selenium还需要学习Junit

• selenium是一个自动化测试框架
• Junit是一个单元测试框架，适用于Java

拿着一个技术写自动化测试用例（selenium3）
拿着一个技术管理已经编写好的测试用例（Junit5）

2. Junit相关技术

Junit是针对Java的单元测试框架

注解：

• @Test
• @Disabled
• @BeforeAll、@AfterAll、@BeforeEach、@AfterEach

参数化：

• 单参数
• 多参数
• CSV获取参数
• 方法获取参数

测试套件

• 通过class运行测试用例
• 通过包（package）运行测试用例

2.1 注解

@Test

@Test注解：表示当前的这个方法是一个测试用例

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

public class JunitTest {
    @Test
    public void Test01() {
        System.out.println("this is test01");
    }

    @Test
    public void Test02() {
        System.out.println("this is Test02");
    }

    @Disabled
    public void Test03() {
        WebDriver webDriver = new ChromeDriver();
        webDriver.get("https://www.baidu.com/");
        webDriver.findElement(By.cssSelector("#s-top-left > a:nth-child(3)")).click();
    }
}

@Disabled

@Disabled注解：忽略此测试用例

@BeforeAll、@AfterAll、@BeforeEach、@AfterEach

@BeforeAll：在所有测试用例之前跑对应的方法
@AfterAll：在所有测试用例之后跑对应的方法
@BeforeEach：在每个测试用例执行之前执行对应的方法
@AfterEach：在每个测试用例执行之后执行对应的方法
如果做UI自动化，通常情况下，创建驱动、打开网页等初始化操作放在BeforeAll；
关闭浏览器等操作放在AfterAll

如果有5个测试用例：
@BeforeAll、@AfterAll：各跑一次
@BeforeEach、@AfterEach：各跑五次

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

public class JunitTest {
    @Test
    public void Test01() {
        System.out.println("这是JunitTest 的 Test01");
    }

    @Test
    void Test02() {
        System.out.println("这是JunitTest 的 Test02");
    }


    @Disabled   //忽略此测试用例
    void Test03() {
        WebDriver webDriver = new ChromeDriver();
        webDriver.get("https://www.baidu.com");
        webDriver.findElement(By.cssSelector("#s-top-left > a:nth-child(6)"));
    }

    //在所有测试用例之前跑的
    @BeforeAll
    static void SetUp() {
        System.out.println("BeforeAll");
    }

    //在所有测试用例之后跑的
    @AfterAll
    static void TearDown() {
        System.out.println("AfterAll");
    }

    @BeforeEach
    void BeforeEachTest() {
        System.out.println("BeforeEach");
    }

    @AfterEach
    void AfterEachTest() {
        System.out.println("AfterEach");
    }
}

BeforeAll
BeforeEach
这是JunitTest 的 Test01
AfterEach
BeforeEach
这是JunitTest 的 Test02
AfterEach
AfterAll

2.2 参数化

单参数

    @ParameterizedTest
    @ValueSource(ints = {1,2,3})
    void Test04(int num) {
        System.out.println(num);
    }

    @ParameterizedTest
    @ValueSource(strings = {"1","2","3"})
    void Test05(String num) {
        System.out.println(num);
    }

1
2
3

多参数

    //多参数
    @ParameterizedTest
    @CsvSource({"1, 2, 3, ''"})
    void Test02(String x, String y, String z, String q) {
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
        System.out.println(q);
        System.out.println("--");
    }

CSV获取参数

张三，李四，王五
张三1，李四1，王五1
张三2，李四2，王五2

    //CSV获取参数
    @ParameterizedTest
    @CsvFileSource(resources = "test01.csv")
    void Test06(String name1) {
        System.out.println(name1);
    }

方法获取参数

    public static Stream<Arguments> Generator() {
        return Stream.of(Arguments.arguments(1, "zhang san"),
                Arguments.arguments(2, "li si"),
                Arguments.arguments(3, "wang wu")
        );
    }

    // 方法获取参数
    @ParameterizedTest
    @MethodSource("Generator")
    void Test07(int num, String name) {
        System.out.println(num + " : " + name);
    }

2.3 测试用例执行顺序

1. 指定顺序

表明现在这个测试用例不需要按照默认的顺序执行

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)  

按照order的顺序执行 TestA --> Test01 --> TestB --> Test02

import org.junit.jupiter.api.*;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)  // 表明现在这个测试用例不需要按照默认的顺序执行,按照指定顺序执行
public class JunitTest01 {

    @Order(1)
    @Test
    void TestA() {
        System.out.println("这是testA测试用例");
    }

    @Order(2)
    @Test
    void Test01() {
        System.out.println("这是test01测试用例");
    }

    @Order(4)
    @Test
    void Test02() {
//        System.out.println("这是test02测试用例, 被忽略的测试用例");
        System.out.println("这是test02测试用例");
    }

    @Order(3)
    @Test
    void TestB() {
        System.out.println("这是testB测试用例");
    }
}

2. 随机运行

随机的运行方式

@TestMethodOrder(MethodOrderer.Random.class)  

每次的测试用例执行顺序都不一样

2.4 断言 assert

断言相等

Assertions.assertEquals(预期, 实际)

断言不相等

    // 单参数
    @ParameterizedTest
    @ValueSource(ints = {1})
    void Test01(int num) {
        System.out.println(num);
        Assertions.assertNotEquals(2, num);   // 断言不相等
    }

断言为空

    // 单参数
    @ParameterizedTest
    @ValueSource(ints = {1})
    void Test01(int num) {
        System.out.println(num);
        String str = "sad";
        Assertions.assertNull(str);
    }

断言不为空

    // 单参数
    @ParameterizedTest
    @ValueSource(ints = {1})
    void Test01(int num) {
        System.out.println(num);
        String str = "sad";
        Assertions.assertNotNull(str);
    }

2.5 测试套件

1. 通过class进行测试用例的运行

@Suite
@SelectClasses({JunitTest.class, JunitTest01.class, JunitTest03.class})
// 通过class进行测试用例的运行
// 先去跑 JunitTest 的全部测试用例，再跑JunitTest01， 最后JunitTest03 按照这里写的顺序执行
public class RunSuite {
}

2. 通过包名进行测试用例的运行

@Suite
// 通过包进行测试用例的运行
@SelectPackages(value = {"Package01", "Package02"})
public class RunSuite {
}

自动化测试项目

1. 熟悉项目
2. 针对核心流程设计测试用例（手工测试用例）
3. 将手工测试用例转换成自动化测试用例
4. 部署

1. 熟悉项目

2. 针对核心流程设计手工测试用例

3. 将手工测试用例转换成自动化测试用例

设计代码结构：
初始化：BeforeAll （创建驱动）
退出：AfterAll （退出浏览器）

4. 部署