0
0

Selenium Python自动化测试案例详解

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Selenium是一个用于Web应用程序测试的自动化工具，支持Python等多种编程语言。本文将详细介绍如何使用Selenium和Python进行网页自动化操作，内容涵盖基本元素操作、等待策略、页面对象模式、框架集成、多浏览器支持、处理弹出窗口、表格操作、JavaScript交互、文件上传、断言验证、异常处理、并行测试、登录和会话管理、CSS选择器和XPath使用，以及动态元素处理等实践案例。读者通过学习这些案例，可以掌握Selenium在Python环境下的高级应用技巧。 Selenium各种案例

1. Selenium基础自动化操作

Selenium作为自动化测试工具，能够模拟用户与Web浏览器的交互。其核心是WebDriver，提供了一系列的API，让测试者能够编写脚本来控制浏览器，从而实现自动化测试的需求。本章将介绍如何搭建Selenium环境，并执行一些基础的自动化操作，如打开网页、查找元素、输入数据和提交表单等，为之后更深入的自动化测试技巧奠定基础。 

from selenium import webdriver

# 配置WebDriver路径
driver_path = '/path/to/webdriver'
# 创建WebDriver实例
driver = webdriver.Chrome(driver_path)

# 访问网页
driver.get('http://www.example.com')

# 查找页面元素
element = driver.find_element_by_id('search_query')

# 输入查询内容并提交
element.send_keys('自动化测试')
element.submit()

# 关闭浏览器
driver.quit()

Selenium环境的搭建简单，但在进行自动化操作时，选择合适的元素定位策略对于提高脚本的稳定性和效率至关重要。随后的章节会深入探讨这些策略和方法。

2. 元素定位与交互技巧

2.1 元素定位策略

2.1.1 标签名、ID、类名定位

定位页面元素是自动化测试中的基本技能。通过标签名、ID、类名是常用的三种定位方法。标签名通常适用于定位一类元素，如所有 

 <input>

标签。使用标签名定位时，可能需要额外的筛选条件，因为仅凭标签名通常无法精确定位到单个元素。

ID定位是最为精确的一种方式，因为ID在一个页面中应该是唯一的。例如，在HTML中，你可以通过如下代码定位ID为 

 username

的元素： 

WebElement username = driver.findElement(By.id("username"));

类名定位可以选中具有相同类属性的所有元素。需要注意的是，如果页面上有多个元素具有相同的类名，那么这个定位方法将返回第一个匹配的元素。 

WebElement element = driver.findElement(By.className("classname"));

2.1.2 属性和值定位

除了使用标签名、ID和类名，还可以根据元素的其他属性进行定位，如 

 name

、 

 placeholder

等。属性定位通常与其他属性值结合使用，比如根据邮箱输入框的 

 type

属性值定位。 

WebElement emailInput = driver.findElement(By.xpath("//input[@type='email']"));

属性值定位是通过匹配元素的某个属性及其值来实现的，使用Xpath的 

 [@attribute='value']

语法可以精确地定位到具有特定属性值的元素。

2.1.3 CSS选择器和XPath定位

CSS选择器和XPath是更复杂的定位技术，适用于更复杂的元素定位场景。

CSS选择器通过元素的类、ID、类型等选择器和组合选择器，可以快速定位到元素。例如，使用CSS选择器定位一个ID为 

 username

的输入框： 

WebElement username = driver.findElement(By.cssSelector("#username"));

XPath是一种在XML文档中查找信息的语言，也可以用于HTML文档。它提供了非常灵活的元素定位方法。下面是一个通过XPath定位具有特定属性值的元素的例子： 

WebElement element = driver.findElement(By.xpath("//input[@type='text'][@name='firstname']"));

2.2 高级定位技巧

2.2.1 父子关系与兄弟关系定位

在HTML文档中，元素之间的父子、兄弟关系可以用来精确定位。通过XPath可以方便地使用这种关系进行定位。

  • 父子关系定位：
WebElement childElement = driver.findElement(By.xpath("//parentTag/childTag"));
  • 兄弟关系定位：
WebElement nextSibling = driver.findElement(By.xpath("//element/following-sibling::tag"));
2.2.2 动态和静态元素定位

动态元素是在页面加载过程中动态生成的元素，它们的出现是依赖于某些动作或条件的，比如点击一个按钮后弹出的提示框。静态元素则是页面上一开始就加载好的元素。

动态元素的定位可以使用Selenium提供的等待机制，如显式等待或隐式等待，来确保元素在进行操作前是可见或可操作的。比如，等待一个动态生成的元素变为可见： 

WebElement dynamicElement = new WebDriverWait(driver, 10).until(ExpectedConditions.visibilityOfElementLocated(By.id("dynamicElement")));

静态元素的定位则相对简单，通常可以直接使用前面提到的定位方法。

2.3 元素交互方法

2.3.1 输入、选择和点击操作
  • 输入操作：
WebElement inputField = driver.findElement(By.id("inputFieldId"));
inputField.sendKeys("Hello, world!");
  • 选择操作：
WebElement dropdown = driver.findElement(By.id("dropdownId"));
Select dropdownElement = new Select(dropdown);
dropdownElement.selectByVisibleText("Option 1");
  • 点击操作：
WebElement button = driver.findElement(By.id("buttonId"));
button.click();
2.3.2 JavaScript执行交互

在某些情况下，我们可能需要通过JavaScript来实现某些操作，比如点击不可见的元素或进行复杂的DOM操作。这时可以使用Selenium提供的 

 executeScript

方法。 

JavascriptExecutor executor = (JavascriptExecutor)driver;
executor.executeScript("arguments[0].click();", element);

通过JavaScript执行交互时，需要确保元素在执行脚本之前已经加载到DOM中，否则脚本将无法定位到元素。

3. 等待策略实现

自动化测试中，等待策略是确保测试稳定性和准确性的关键因素之一。由于网络延迟、页面加载时间等因素的影响，没有合理的等待策略，自动化测试可能会因为元素未能及时加载而产生不稳定的结果。Selenium提供了三种主要的等待策略：显式等待、隐式等待和强制等待。每种策略都有其适用场景和优缺点，熟练掌握这些等待机制对于编写高效的自动化脚本至关重要。

3.1 显式等待

显式等待是一种有策略的等待方式，它允许测试者指定等待条件，并设置等待的最大时长。显式等待在等待过程中会不断检查条件是否满足，并在条件满足时继续执行，或者在超时后抛出异常。显式等待比隐式等待更加灵活和强大。

3.1.1 设置等待条件和超时

Selenium WebDriver提供了 

 WebDriverWait

类来实现显式等待，配合 

 ExpectedConditions

类来定义等待条件。例如，我们可以等待一个元素变为可点击状态： 

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

wait = WebDriverWait(driver, 10)
element = wait.until(EC.element_to_be_clickable((By.ID, "someID")))
element.click()

在上述代码中，我们使用了 

 element_to_be_clickable

这一条件，这意味着WebDriver会持续检查指定的元素是否可点击，最长等待10秒。如果在10秒内元素变为可点击状态，则继续执行后续的点击操作；如果10秒后元素仍然不可点击，则抛出超时异常。

3.1.2 等待特定元素的出现和消失

除了等待元素可点击之外，我们还可以等待元素的其他状态。例如，等待一个元素的出现或消失： 

element = wait.until(EC.presence_of_element_located((By.ID, "someID")))

这段代码会等待直到页面上出现具有ID为 

 someID

的元素。相对地，如果我们要等待某个元素消失，可以使用 

 invisibility_of_element_located

： 

element = wait.until(EC.invisibility_of_element_located((By.ID, "someID")))

显式等待提供了多种条件，如文本出现、元素选中、框架可切换等，根据具体的测试需求灵活使用。

3.2 隐式等待

隐式等待是一种全局等待机制，当设置隐式等待后，WebDriver会在尝试查找任何元素之前等待指定的时间，直到元素出现。

3.2.1 设置全局等待时间

隐式等待的时间设置通常在初始化WebDriver时进行： 

driver = webdriver.Chrome()
driver.implicitly_wait(10)  # 设置最长等待时间

在这段代码中，WebDriver将等待最多10秒来查找任何元素。需要注意的是，一旦设置了隐式等待，该等待时间会被应用到所有元素查找操作中，直到显式地调用 

 driver.implicitly_wait(0)

取消隐式等待。

3.2.2 隐式等待的局限性

尽管隐式等待在某些场景下提供了便利，但它也有明显的局限性。首先，隐式等待是全局性的，意味着它会影响脚本中所有的元素查找，这可能导致一些不必要的等待，从而降低测试执行效率。其次，隐式等待不能对特定条件进行等待，它只能简单地等待元素在DOM中出现。

3.3 强制等待

强制等待是最直接且低效的一种等待方式，它通过简单地暂停执行脚本来实现等待效果。

3.3.1 使用time.sleep()实现

强制等待通常使用Python标准库中的 

 time.sleep()

函数实现： 

import time

time.sleep(5)  # 程序暂停5秒

3.3.2 强制等待的影响与弊端

强制等待不考虑元素状态或条件，直接暂停脚本指定时间。这使得脚本的执行效率极低，因为即使元素在1秒内已经出现，脚本仍会等待满5秒。此外，强制等待还会使测试脚本的响应时间大大增加，不利于持续集成和并行测试。

综上所述，在实际应用中，应当优先考虑使用显式等待来处理元素的加载和条件检查，尽量避免使用隐式等待和强制等待，以提高自动化测试的效率和可靠性。

4. 页面对象模式应用

4.1 页面对象模式概述

4.1.1 什么是页面对象模式

页面对象模式（Page Object Pattern）是一种在自动化测试中使用的设计模式，旨在将Web页面抽象为一个对象，并将其界面元素和行为封装起来。这样做可以减少代码的重复性，提高测试脚本的可维护性。页面对象模式鼓励我们定义页面上的UI元素和执行页面交互的方法，使得测试代码与页面的实现细节分离，从而在未来对页面进行更改时，不需要修改测试脚本。

4.1.2 页面对象模式的优势

使用页面对象模式的优势包括但不限于以下几点： - ** 可维护性 ** ：页面细节的变更只需修改页面对象代码，而不是每个测试脚本。 - ** 可重用性 ** ：相同页面的元素和方法可以在多个测试场景中被重用。 - ** 清晰性 ** ：测试脚本只关注于业务流程，而具体的元素定位和操作细节则被封装在页面对象内。 - ** 分离关注点 ** ：测试逻辑和页面交互逻辑分离，使得阅读和理解测试用例更加容易。

4.2 实现页面对象模式

4.2.1 封装页面元素和方法

在实现页面对象模式时，首先需要创建一个页面类，它包含了页面上所有相关的元素以及操作这些元素的方法。这些方法通常包括获取页面标题、填写表单、点击按钮、验证页面数据等。

例如，一个简单的登录页面对象类可能如下所示： 

public class LoginPage {

    // 页面元素定位
    @FindBy(how = How.ID, using = "username")
    private WebElement usernameField;

    @FindBy(how = How.ID, using = "password")
    private WebElement passwordField;

    @FindBy(how = How.ID, using = "login")
    private WebElement loginButton;

    // 页面操作方法
    public void enterUsername(String username) {
        usernameField.sendKeys(username);
    }

    public void enterPassword(String password) {
        passwordField.sendKeys(password);
    }

    public void clickLoginButton() {
        loginButton.click();
    }
}

4.2.2 PageFactory模式与@FindBy注解

PageFactory是Selenium WebDriver提供的一个类，它支持页面对象模式，并提供了一些实用的注解和方法来初始化页面元素。 

 @FindBy

注解可以用来声明元素定位器，而 

 initElements

方法则用来初始化这些元素。 

public class MyPage {
    WebDriver driver;
    // 使用PageFactory模式
    @FindBy(css = "div.header")
    private WebElement header;

    public MyPage(WebDriver driver) {
        this.driver = driver;
        // 初始化页面元素
        PageFactory.initElements(driver, this);
    }
}

4.3 页面对象模式实践案例

4.3.1 创建页面类和元素类

在实践中，我们需要根据实际的页面结构来定义相应的页面类。比如一个电子商务网站的首页，可能包含搜索框、产品列表和购物车链接等元素。 

public class HomePage {
    private WebDriver driver;

    @FindBy(css = "input#search_query_top")
    private WebElement searchBox;

    @FindBy(css = "button[name='submit_search']")
    private WebElement searchButton;

    // ...其他元素和方法

    public HomePage(WebDriver driver) {
        this.driver = driver;
        PageFactory.initElements(driver, this);
    }

    // ...其他方法
}

4.3.2 方法封装和测试代码组织

封装后的页面对象可以简化测试代码的编写。测试类中只需要调用页面对象提供的方法即可进行测试，从而保持测试代码的简洁和清晰。 

public class SearchTest {
    WebDriver driver;

    @BeforeClass
    public void setUp() {
        // 初始化WebDriver
        driver = new ChromeDriver();
        driver.manage().window().maximize();
        driver.get("http://www.example.com");
    }

    @Test
    public void testProductSearch() {
        HomePage homePage = new HomePage(driver);
        homePage.searchBox.sendKeys("Selenium WebDriver");
        homePage.searchButton.click();

        // 验证搜索结果
        // ...验证逻辑
    }
}

这种组织方式提高了代码的可维护性和可读性，使得测试逻辑和页面交互逻辑之间界限分明。在实际的项目中，页面对象模式可以极大地提升代码的质量和测试的效率。

5. 框架集成实践

5.1 测试框架介绍

5.1.1 单元测试框架JUnit

JUnit 是 Java 语言中一个非常流行的单元测试框架，它为开发者提供了一系列用于编写测试用例的工具和注解。JUnit 测试用例通常以类的形式存在，并使用注解如 @Test 标记测试方法。JUnit 可以被集成到多数的IDE（集成开发环境）中，允许开发人员轻松编写和运行测试代码。

JUnit 注解和测试方法

JUnit 注解 

 @Test

标识了测试方法，它不仅能够标记测试方法，还可以配合其他注解使用，比如 

 @Before

, 

 @After

, 

 @BeforeClass

, 

 @AfterClass

等，分别对应着测试用例执行前后的初始化和清理操作，以及测试类执行前后的静态初始化和静态清理操作。 

import org.junit.*;

public class CalculatorTest {
    private Calculator calculator;
    @Before
    public void setUp() {
        calculator = new Calculator();
    }
    @Test
    public void testAddition() {
        Assert.assertEquals(3, calculator.add(1, 2));
    }
    @After
    public void tearDown() {
        calculator = null;
    }
}
参数化测试

JUnit 支持参数化测试，允许用同样的测试逻辑测试不同的输入输出。使用 

 @ParameterizedTest

注解可以实现这一功能，并且可以使用 

 @ValueSource

, 

 @CsvSource

, 

 @MethodSource

等注解指定测试方法的输入参数。 

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

public class ParameterizedTests {
    @ParameterizedTest
    @CsvSource({
        "1, 2, 3",
        "4, 5, 9",
        "6, 7, 13"
    })
    void testAdd(int a, int b, int expected) {
        assertEquals(expected, a + b);
    }
}

5.1.2 测试管理工具TestNG

TestNG 是一个功能全面的测试框架，旨在简化复杂的测试场景。它允许执行单元测试、集成测试、端到端测试等，并支持并发测试执行。TestNG 具有灵活的配置选项，能够自定义测试方法优先级和依赖关系，并且提供了丰富的运行时信息。

TestNG 特点

TestNG 提供了一个强大的注解系统，可以用来定义测试套件、测试组以及测试方法的依赖关系。使用 

 @Test

注解标记测试方法， 

 @BeforeMethod

和 

 @AfterMethod

来定义测试方法执行前后的行为， 

 @BeforeClass

和 

 @AfterClass

来定义测试类的初始化和清理操作。 

import org.testng.annotations.*;

public class TestNGTest {
    @BeforeClass
    public void beforeClass() {
        System.out.println("Before class");
    }

    @Test
    public void testMethod() {
        System.out.println("Test method is running");
    }

    @AfterClass
    public void afterClass() {
        System.out.println("After class");
    }
}
并行测试

TestNG 支持并行测试，允许同时运行多个测试方法，提高了测试执行效率。通过配置 

 parallel

属性为 

 methods

或 

 tests

，可以控制并行执行的粒度。此外，TestNG 还允许你指定运行的线程数。 

<suite name="Test Suite" parallel="methods" thread-count="3">
    <test name="Test">
        <classes>
            <class name="TestNGTest"/>
        </classes>
    </test>
</suite>

5.2 集成Selenium与测试框架

5.2.1 配置测试环境和依赖

要集成 Selenium WebDriver 与 JUnit 或 TestNG，首先需要在项目中引入对应的库依赖。这通常通过构建工具如 Maven 或 Gradle 完成，它们会自动管理项目依赖并下载必要的库文件。

Maven 依赖配置

在项目的 

 pom.xml

文件中添加以下依赖，以引入 Selenium WebDriver、JUnit 和其他相关库。 

<dependencies>
    <!-- Selenium WebDriver -->
    <dependency>
        <groupId>org.seleniumhq.selenium</groupId>
        <artifactId>selenium-java</artifactId>
        <version>3.141.59</version>
    </dependency>

    <!-- JUnit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

5.2.2 编写测试用例和执行测试

编写测试用例时，需要利用 WebDriver 对象进行浏览器操作，并结合测试框架的注解定义测试方法。在 JUnit 中，测试方法被 

 @Test

注解标记。在 TestNG 中，可以通过 

 @Test

以及其它如 

 @BeforeMethod

等注解来组织测试逻辑。

JUnit 测试类示例

以下是一个使用 JUnit 4 编写的简单测试类例子： 

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

public class SeleniumJUnitTest {
    private WebDriver driver;

    @Before
    public void setUp() {
        System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver");
        driver = new ChromeDriver();
        driver.get("http://www.example.com");
    }

    @Test
    public void testSearch() {
        driver.findElement(By.name("q")).sendKeys("Selenium");
        driver.findElement(By.name("btnG")).click();
        WebElement result = driver.findElement(By.id("result"));
        Assert.assertTrue(result.isDisplayed());
    }

    @After
    public void tearDown() {
        driver.quit();
    }
}
TestNG 测试类示例

以下是一个使用 TestNG 编写的简单测试类例子： 

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.*;

public class SeleniumTestNGTest {
    private WebDriver driver;

    @BeforeClass
    public void setUpClass() {
        System.setProperty("webdriver.chrome.driver", "/path/to/chromedriver");
        driver = new ChromeDriver();
        driver.get("http://www.example.com");
    }

    @Test
    public void testSearch() {
        driver.findElement(By.name("q")).sendKeys("Selenium");
        driver.findElement(By.name("btnG")).click();
        WebElement result = driver.findElement(By.id("result"));
        Assert.assertTrue(result.isDisplayed());
    }

    @AfterClass
    public void tearDownClass() {
        driver.quit();
    }
}

5.3 集成实践案例分析

5.3.1 案例选择与需求分析

选择一个合适的案例是集成测试的关键。选择案例时，需要考虑测试的目的、预期结果和可能遇到的问题。对于自动化测试的案例，可以是网站功能测试、数据校验测试或接口调用测试等。

需求分析

假设有一个电商平台的注册流程，需要验证整个注册流程是否正常工作。这个案例要求在不同的浏览器中验证注册表单的输入、错误处理、以及成功注册后的页面跳转等功能。

5.3.2 测试流程与框架应用

测试流程应该先进行需求分析，确定测试的步骤和预期结果。接着编写测试用例并使用集成好的框架执行测试。对于框架的使用，可以按照已经配置好的环境来运行测试。

测试用例设计

针对上述注册流程，设计测试用例可能包括：

  1. 输入合法的注册信息并检查是否能够成功创建账户。
  2. 输入无效的邮箱格式，验证邮箱输入框的校验逻辑。
  3. 输入重复的用户名，检查是否显示错误信息。
  4. 注册完成后，验证是否跳转到用户登录页面。
框架应用

结合 JUnit 或 TestNG，编写对应的测试代码，并执行测试。以 TestNG 为例，可以利用 

 @Test

注解标记测试方法，并通过 XML 测试套件配置来控制执行。 

@Test
public void testRegistrationWithValidCredentials() {
    // 测试用例代码
}

通过框架的应用，可以实现测试的自动化执行，并收集测试结果用于分析和报告。集成测试框架和 Selenium WebDriver，可以实现快速、有效的自动化测试流程。

6. 多浏览器自动化测试支持

随着自动化测试技术的普及和丰富，跨浏览器测试已成为web应用测试的重要组成部分。为了确保我们的web应用在不同的浏览器环境下都能正常工作，多浏览器自动化测试支持就显得尤为关键。

6.1 支持的浏览器类型

6.1.1 常用浏览器介绍

Web浏览器是用户浏览网页的主要工具。对于自动化测试而言，我们需要关注几款最常用和最流行的浏览器，包括Chrome、Firefox、Edge、Safari等。这些浏览器可能使用不同的内核，如Chromium、Gecko、Blink等，这要求Selenium有能力与这些不同的浏览器进行交互。

6.1.2 浏览器驱动配置

为了使Selenium能与不同的浏览器进行交互，需要安装对应浏览器的驱动程序。驱动程序相当于浏览器与Selenium之间的桥梁，负责接收Selenium发送的指令，并将操作结果反馈回去。下面表格展示了主流浏览器及其驱动程序的配置方法。

| 浏览器名称 | 驱动程序名称 | 官网链接 | 下载方式 | 配置提示 | | ------------ | -------------- | ---------- | ---------- | ---------- | | Chrome | ChromeDriver | 下载链接 | 从官网下载对应浏览器版本的驱动程序 | 驱动路径需添加到系统环境变量中 | | Firefox | GeckoDriver | 下载链接 | 从GitHub或官网下载最新版本的驱动程序 | 同上 | | Edge | EdgeDriver | 下载链接 | 通过Microsoft Edge Developer工具下载 | 同上 | | Safari | WebdriverAgent | 通过CocoaPods安装(仅限Mac用户) | 使用CocoaPods进行安装 | 需要配置Safari的开发者模式 |

接下来，我们用代码块演示如何在Python中配置ChromeDriver进行自动化测试。 

from selenium import webdriver

# 设置ChromeDriver的路径
chrome_driver_path = '/path/to/chromedriver'

# 创建webdriver实例
driver = webdriver.Chrome(executable_path=chrome_driver_path)

# 打开网页进行测试
driver.get('https://www.example.com')

# 关闭driver，结束测试
driver.quit()

代码逻辑解读：

  • 首先，从 selenium 模块导入 webdriver 类。
  • 其次，设置变量 chrome_driver_path 为本地的ChromeDriver可执行文件的路径。
  • 然后，创建 webdriver 实例，并将ChromeDriver的路径传递给 executable_path 参数。
  • 接下来，使用 get 方法打开指定的网页。
  • 最后，调用 quit 方法来关闭浏览器，并释放所有相关资源。

6.2 跨浏览器测试策略

6.2.1 并行测试与串行测试

在进行跨浏览器测试时，有两种主要的测试执行策略：并行测试和串行测试。并行测试意味着同时在多个浏览器上运行测试用例，这可以显著缩短整体测试时间。相对的，串行测试则按照顺序依次在不同浏览器上执行测试用例。

并行测试通常要求测试服务器具备较高的处理能力，以及较高的资源分配能力，这可能会增加测试的成本。而串行测试则对硬件资源的需求较低，但总体的测试完成时间会比较长。

6.2.2 浏览器兼容性测试

浏览器兼容性测试是跨浏览器测试中最核心的部分。我们需要检查页面元素在不同浏览器中的表现，确保布局、功能、交互在所有目标浏览器中保持一致。

进行浏览器兼容性测试时，可以使用Selenium Grid功能。Selenium Grid允许我们在多个服务器上运行测试用例，每个服务器都安装了不同版本或不同类型的浏览器。这样可以模拟更广泛的浏览器环境，并且更易于管理大规模的测试需求。

6.3 浏览器自动化测试实践

6.3.1 配置多浏览器环境

要配置一个可以支持多浏览器的自动化测试环境，通常需要安装和配置每个浏览器的驱动程序。这里以配置Chrome、Firefox、Edge为例，我们已经展示了如何安装ChromeDriver，并用类似的方法可以安装GeckoDriver和EdgeDriver。

接下来，我们将展示如何用Selenium选择不同的浏览器驱动进行测试。 

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# Chrome浏览器配置
chrome_options = Options()
chrome_options.add_argument('--headless')  # 无头模式

# Firefox浏览器配置
from selenium.webdriver.firefox.options import Options
firefox_options = Options()
firefox_options.add_argument('--headless')

# Edge浏览器配置
from msedge.selenium_tools import EdgeOptions
edge_options = EdgeOptions()

# 选择并创建Chrome驱动实例
chrome_driver_path = '/path/to/chromedriver'
chrome_driver = webdriver.Chrome(executable_path=chrome_driver_path, options=chrome_options)

# 选择并创建Firefox驱动实例
firefox_driver_path = '/path/to/geckodriver'
firefox_driver = webdriver.Firefox(executable_path=firefox_driver_path, options=firefox_options)

# 选择并创建Edge驱动实例
edge_driver_path = '/path/to/msedgedriver'
edge_driver = webdriver.Edge(executable_path=edge_driver_path, options=edge_options)

# 分别打开网页进行测试
chrome_driver.get('https://www.example.com')
firefox_driver.get('https://www.example.com')
edge_driver.get('https://www.example.com')

# 关闭所有驱动实例
chrome_driver.quit()
firefox_driver.quit()
edge_driver.quit()

6.3.2 实现浏览器独立测试案例

在完成多浏览器环境配置后，下一步是针对每个浏览器编写和执行独立的测试案例。在实践中，我们通常创建一个测试基类，并为每个浏览器创建一个子类，通过继承基类来实现测试用例。

以下是用Python和unittest框架演示的一个简单测试案例，它检查了不同浏览器下网页标题的一致性。 

import unittest

class BaseTestCase(unittest.TestCase):
    def setUp(self):
        # 初始化测试前的环境
        self.driver = None

    def tearDown(self):
        # 清理测试后的环境
        if self.driver:
            self.driver.quit()

class ChromeTestCase(BaseTestCase):
    def setUp(self):
        super().setUp()
        chrome_options = Options()
        chrome_options.add_argument('--headless')
        chrome_driver_path = '/path/to/chromedriver'
        self.driver = webdriver.Chrome(executable_path=chrome_driver_path, options=chrome_options)

    def test_page_title(self):
        self.driver.get('https://www.example.com')
        self.assertEqual(self.driver.title, "Example Domain")

class FirefoxTestCase(BaseTestCase):
    def setUp(self):
        super().setUp()
        firefox_options = Options()
        firefox_options.add_argument('--headless')
        firefox_driver_path = '/path/to/geckodriver'
        self.driver = webdriver.Firefox(executable_path=firefox_driver_path, options=firefox_options)

    def test_page_title(self):
        self.driver.get('https://www.example.com')
        self.assertEqual(self.driver.title, "Example Domain")

class EdgeTestCase(BaseTestCase):
    def setUp(self):
        super().setUp()
        edge_options = EdgeOptions()
        edge_driver_path = '/path/to/msedgedriver'
        self.driver = webdriver.Edge(executable_path=edge_driver_path, options=edge_options)

    def test_page_title(self):
        self.driver.get('https://www.example.com')
        self.assertEqual(self.driver.title, "Example Domain")

if __name__ == '__main__':
    unittest.main()

在这个示例中，我们创建了三个测试类： 

 ChromeTestCase

、 

 FirefoxTestCase

和 

 EdgeTestCase

，它们分别代表三种不同的浏览器测试环境。在各自的测试类中，我们覆盖了 

 setUp

和 

 tearDown

方法，以初始化和清理每个测试类的环境。每个类的 

 test_page_title

方法负责打开指定的网页，并检查网页的标题是否正确。

通过这种方式，我们可以在不同的浏览器中执行相同的测试用例，并验证应用在不同环境下的表现。这有助于发现和修复兼容性问题，确保应用在所有支持的浏览器上都能正常工作。

7. 异常处理与优化技巧

7.1 异常处理机制

在自动化测试中，处理异常是一个不可或缺的部分，它可以确保测试脚本在遇到意外情况时仍能继续执行或者提供足够的信息以便于后续分析。Selenium WebDriver提供了丰富的异常类来帮助开发者识别和处理各种异常情况。

7.1.1 WebDriver异常与处理

Selenium的异常处理主要集中在 

 org.openqa.selenium

包下的异常类中。常见的异常类有 

 NoSuchElementException

， 

 TimeoutException

， 

 StaleElementReferenceException

等。这些异常类都继承自 

 WebDriverException

。处理这些异常通常包括两种方式：异常捕获和异常抛出。

一个基本的异常处理逻辑可以通过try-catch块来实现： 

try {
    // 测试脚本代码块
    driver.findElement(By.id("someId"));
} catch (NoSuchElementException e) {
    // 异常处理代码块
    System.out.println("元素未找到");
} catch (TimeoutException e) {
    System.out.println("等待超时");
} catch (Exception e) {
    // 捕获其他异常
    System.out.println("发生异常：" + e.getMessage());
}

在实际测试中，开发者应根据具体异常的类型来决定后续的操作，如打印错误信息、重试测试、或者将错误记录到日志文件中。

7.1.2 异常捕获和记录

异常的捕获是为了让测试能够在出错时仍能继续运行，并且不会影响到其他测试用例的执行。而异常的记录，则是将错误信息保存到日志文件中，便于后续的调试和分析。

日志记录通常使用日志框架，如Log4j或SLF4J等。下面是一个简单的日志记录异常的示例： 

import org.apache.log4j.Logger;

public class TestLog {
    private static final Logger logger = Logger.getLogger(TestLog.class);

    public void testMethod() {
        try {
            // 测试脚本代码块
        } catch (Exception e) {
            logger.error("发生异常：" + e.getMessage(), e);
            // 这里还可以记录更多的上下文信息，如堆栈追踪、输入的参数等
        }
    }
}

7.2 测试代码优化

自动化测试脚本的效率和可维护性对于测试的长期运行至关重要。代码优化不仅仅是让测试运行得更快，还包括确保测试易于理解和扩展。

7.2.1 代码复用与模块化

代码复用和模块化是优化测试脚本的关键。通过将公共代码封装到单独的方法或类中，可以减少重复代码，提高测试的可维护性。页面对象模式是实现代码复用和模块化的一种常用模式，它将页面上的元素和行为封装成对象。

例如，以下是一个使用页面对象模式封装的登录页面对象类： 

public class LoginPage {
    WebDriver driver;

    public LoginPage(WebDriver driver) {
        this.driver = driver;
        PageFactory.initElements(driver, this);
    }

    public void login(String username, String password) {
        driver.findElement(By.id("username")).sendKeys(username);
        driver.findElement(By.id("password")).sendKeys(password);
        driver.findElement(By.id("loginButton")).click();
    }
}

使用此类进行测试时，只需创建一个 

 LoginPage

对象，并调用 

 login

方法。

7.2.2 优化测试脚本的可读性和可维护性

良好的代码注释和清晰的代码结构可以大大提升测试脚本的可读性和可维护性。为每个方法、关键的代码块或复杂的逻辑添加注释，说明其作用和工作方式，将有助于其他开发者快速理解和维护代码。

测试脚本的命名也非常关键，应使用清晰且描述性的名称，避免使用模糊或简短的命名方式。例如，命名一个测试方法时，可以使用如下命名方式： 

 testLoginWithValidCredentials()

，这比 

 test1()

更加清晰地表达了测试的目的。

7.3 测试性能优化

随着测试用例数量的增加，测试执行的速度和稳定性变得越来越重要。性能优化可以帮助减少等待时间和提高测试的可靠性。

7.3.1 测试用例优化策略

为了提升测试脚本的性能，可以采取一系列的策略：

  • ** 减少页面加载时间 ** ：通过使用Ajax和JSON技术，减少页面元素的加载时间，优化网络请求。
  • ** 缓存静态资源 ** ：例如，页面上的图片、JavaScript和CSS文件等，可以通过缓存机制避免重复加载。
  • ** 使用显式等待 ** ：显式等待比隐式等待更精确，它允许测试在特定条件满足时继续执行，而不必等待固定的超时时间。

7.3.2 优化测试执行速度和稳定性

  • ** 并行测试 ** ：在多核处理器的支持下，可以同时运行多个测试用例，以减少总体的测试执行时间。
  • ** 使用正确的等待策略 ** ：显式等待的使用可以避免因页面元素尚未加载完成就执行操作而导致的错误。
  • ** 资源清理 ** ：确保在测试用例结束时释放所有资源，比如关闭浏览器窗口。

通过上述策略，可以提高自动化测试的效率和稳定性，从而提供更加可靠的测试结果。

（此部分结尾）

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Selenium是一个用于Web应用程序测试的自动化工具，支持Python等多种编程语言。本文将详细介绍如何使用Selenium和Python进行网页自动化操作，内容涵盖基本元素操作、等待策略、页面对象模式、框架集成、多浏览器支持、处理弹出窗口、表格操作、JavaScript交互、文件上传、断言验证、异常处理、并行测试、登录和会话管理、CSS选择器和XPath使用，以及动态元素处理等实践案例。读者通过学习这些案例，可以掌握Selenium在Python环境下的高级应用技巧。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

标签：
本文转载自: https://blog.csdn.net/weixin_35019679/article/details/143929818
版权归原作者 馥郁恒久 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Selenium Python自动化测试案例详解”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航