全栈自动化第二期—基于Selenium实现UI自动化教程

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: Selenium 是一款基于Web应用程序自动化测试的工具集合,Selenium 测试直接运行在浏览器中,本质是通过驱动浏览器,模拟用户的操作。工具的主要功能包括:测试与浏览器的兼容性,进行系统功能测试。

Selenium教程

一、安装SeleniumWebdrive

1、下载selenium webdrive

2、下载地址:chromedrive

3、找到与谷歌浏览器版本号一致的包,下载chromedriver_win32.zip

可以通过浏览器右上角,点击设置,找到关于谷歌,即可查看本地谷歌浏览器的版本号

随后在淘宝镜像网中,找到与浏览器版本号开头一致的数字包即可.

4、配置环境变量,将chromedriver_win32.zip文件解压地址添加到Path变量

Selenium驱动程序需要环境变量配置

二、Pycharm安装selenium

  • 控制台Terminal输入安装命令
pip install selenium

三、测试Demo

from selenium import webdriver


driver = webdriver.Chrome(port=8800)
url = "https://www.colablog.top"
driver.get(url)
配置port端口可以用于多浏览器运行自动化,例如A电脑谷歌浏览器端口为8800

B电脑谷歌浏览器端口为9900

四、浏览器操作

  • driver.back() 上一个页面
  • driver.forward() 前进下一个页面
  • driver.refresh() 刷新
  • driver.minimize_window() 窗口最小化
  • driver.maximize_window() 窗口最大化
  • driver.fullscreen_window() 全屏
  • 在新窗口打开链接
new_win = "window.open('https://taobao.com')"
driver.execute_script(new_win)
  • driver.get_screenshot_as_file() 截屏
  • driver.quit() 退出
from selenium import webdriver
from time import sleep

# 获得浏览器对象
driver = webdriver.Chrome(port=8800)
# 访问的URL
url = "https://www.colablog.top"
# 浏览器对象进行访问
driver.get(url)
sleep(2)
# 跳转操作
driver.get("https://www.bilibili.com")
sleep(2)

# 上一个页面
driver.back()

# 刷新
driver.refresh()

# 前进下一个页面
driver.forward()

# 窗口最小化
driver.minimize_window()

# 窗口最大化
driver.maximize_window()

# 在新窗口打开链接
new_win = "window.open('https://taobao.com')"
driver.execute_script(new_win)

# 截屏
driver.get_screenshot_as_file("E://PythonWorkSpace//SeleniumProject//screen.png")

# 退出
driver.quit()

五、Python、Selenium、Chrome之间的关系

Python通过Selenium实例对象调用API去访问Webdriver接口,再通过Webdriver使用js代码去控制浏览器

六、8种元素定位方式

提醒:

通过webdriver对象的find_element_by_xx(" ")(在selenium的4.0版本中此种用法已经抛弃,不推荐使用)

4.0版本语法解析

def find_element(self, by=By.ID, value=None)
或
def find_elements(self, by=By.ID, value=None)
find_element 和 find_elements的区别如下:

1、find_element查找元素返回的是一个对象,而find_elements返回的是一个列表

2、当find_element找到多个元素时,返回第一个,find_elements返回一个列表

3、当find_element找不到元素时,报错,find_elements返回空列表

其中By.ID在源码中存在映射关系,关系如下,一共有八种定位方式。

class By:
    """
    Set of supported locator strategies.
    """

    ID = "id"
    XPATH = "xpath"
    LINK_TEXT = "link text"
    PARTIAL_LINK_TEXT = "partial link text"
    NAME = "name"
    TAG_NAME = "tag name"
    CLASS_NAME = "class name"
    CSS_SELECTOR = "css selector"

value传需要定位的元素,如xpath语句,最终调用find_element方法

也可直接传参str类型的数据,代表元素查找方式

input_element = browser.find_element('xpath', '表达式')

当使用By.ID或者其他时,需要导入from selenium.webdriver.common.by import By

最终返回一个WebElement对象,对象包含以下属性和方法:

  • tag_name 获取对象标签名
  • size 获得标签的宽高
  • text 获取标签文本
  • location 获得标签x,y轴坐标
  • rect 获得标签宽高和坐标
  • id 获取标签的标识
  • text 获取标签文本内容
  • click() 点击方法
  • submit() 提交方法
  • clear() 清空输入的内容
  • is_selected() 是否被选中
  • is_enabled() 是否可用
  • send_keys() 输入内容
  • is_displayed() 是否显示
  • get_attribute() 该元素指定属性的值

(一)、xpath

input_element = browser.find_element('xpath', '//*[@id="nav-searchform"]/div[1]/input')

Xpath常用方法详解:

  • 基础语法:
表达式 描述 举例
node_name 选取此节点的所有子节点。
/ 绝对路径匹配,从根节点选取。
// 相对路径匹配,从所有节点中查找当前选择的节点,包括子节点和后代节点,其第一个 / 表示根节点。 //li
. 选取当前节点。
.. 选取当前节点的父节点。
@ 选取属性值,通过属性值选取数据。常用元素属性有 @id 、@name、@type、@class、@tittle、@href。 //a[@class="参数"]

  • xpath通配符:
通配符 描述说明 举例
* 匹配任意元素节点 //li/*
@* 匹配任意属性节点 //li/@*
node() 匹配任意类型的节点 //li/node()
  • 多路径匹配

xpath表达式1 | xpath表达式2 | xpath表达式3

//ul/li[@class="book2"]/p[@class="price"]|//ul/li/@href
  • 进阶用法

1、contains(包含某内容)

contains通常配合text一起使用,//a[contains(text(), '关闭')]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BBbFEdL6-1661627512771)(http://colablog.top/imagechrome_M8vYQQuoaB.png)]

2、starts-with(以某内容开头)

3、or(或)

4、and(与)

5、text(包含某文本)

contains通常配合text一起使用,//a[contains(text(), '关闭')]

6、ancestor(查找节点前)

首先查找到在ancestor声明之前的那个元素,然后将这个元素设为顶端节点,最后查找这个节点内所有符合规则的元素

7、following(查找节点后)

8、following-sibling(当前节点之后的所有同级节点)

9、preceding-sibling(当前节点之前的所有同级节点)

(二)、css

# 通过css选择器
lis = driver.browser.find_element('By.CSS_SELECTOR', 'body > div > ul > li:nth-child(2)')
print(lis.text) 
选择器 示例 示例说明
.class .intro 选择所有class="intro"的元素
*id #firstname 选择所有id="firstname"的元素
* * 选择所有元素
element p 选择所有

元素

element,element div,p 选择所有
元素和

元素

element element div p 选择
元素内的所有

元素

element>element div>p 选择所有父级是
元素的

元素

element+element div+p 选择所有紧跟在
元素之后的第一个

元素

[attribute] [target] 选择所有带有target属性元素

(三)、id

# 找到id = username的元素
username = driver.find_element('By.ID',"username")
# 输入值 张三
username.send_keys("张三")
# 找到od = password的元素
password = driver.find_element('By.ID',"password")
# 输入值 123
password.send_keys("123")

(四)、class

# =====通过 元素Class查找(仅返回匹配到的第一个)
login_btn = driver.find_element('By.CLASS_NAME',"login")

# 点击
login_btn.click() 
element在找到多个class为login时,只返回第一个,若有多个标签使用同一个class属性值,建议使用elements

(五)、name

# =====通过 元素name查找元素(仅返回匹配到的第一个)
password = drive.find_element('By.NAME',"password")

# =====输入值 123
password.send_keys("123")

(六)、tag_name(标签名)

# 通过元素标签(仅返回匹配到的第一个)
p = driver.find_element('By.TAG_NAME',"p")
# 打印元素的文本值
print(p.text)

(七)、link_text(超链接文本—全量匹配)

# 通过超链接的文本查找元素
news_text = driver.find_element('By.LINK_TEXT ',"新闻")
print(news_text.text)

(八)、partial_link_text(超链接文本—模糊匹配)

# =====通过 超链接的文本查找元素(支持模糊匹配)
news_text = driver.find_element('By.PARTIAL_LINK_TEXT',"新")
print(news_text.text)

七、三种等待方式

  • 强制等待
time.sleep(10)

停止代码运行,直到指定时间才继续运行代码,全局无限次数使用。

  • 隐性等待
browser.implicitly_wait(10)

隐性等待只能等待目标元素加载完毕,不能等待页面内容加载,即每一个driver.find_element或driver.find_elements寻找的元素,全局只能使用一次此方法。

  • 显性等待
wait = WebDriverWait(browser, 10)

基于强制等待和隐性等待的综合体,全局无限使用,在某个需要等待的元素后面添加即可,分三个步骤

第一个步骤是获得显性等待器,传入两个参数,第一个是浏览器驱动对象,第二个是超时时长,在固定时间内如果超时,则不再等待。第三个为可选参数,每隔多长时长查看是否得到等待结果,poll_frequency=时长

第二个步骤是设置等待器的等待条件,wait.until(),导入expected_conditions包,里面有等待条件的各种方法。如查询是否包含在标题中,wait.until(expected_conditions.title_contains()

显性等待不仅可以等待页面内容的出现,也可以等待页面元素的加载,如下代码实现

locator可传元组或者列表。

locator = ['id', 'kw']
baidu_element = wait.until(expected_conditions.presence_of_element_located(locator))

窗口等待案例:

窗口等待方法为:expected_conditions.new_window_is_opened(current_handles)

在窗口切换之前获得当前handlers,在源码中,判断当前与新开窗口的handles列表长度,如果长度大于打开之前的handles,则说明新窗口打开成功。

    def test_setting(self):
        # 实例化浏览器对象
        browser = webdriver.Chrome()
        # 隐性等待
        browser.implicitly_wait(10)
        # 自定义URL
        url = "https://www.baidu.com"
        # 访问url
        browser.get(url)
        time.sleep(2)
        # 获取当前窗口句柄
        current_handles = browser.window_handles
        # 鼠标操作
        action = ActionChains(browser)
        setting = browser.find_element(By.ID, 's-usersetting-top')
        action.move_to_element(setting).perform()
        time.sleep(2)
        weather = browser.find_element('xpath', '//a[contains(text(), "隐私")]')
        action.click(weather).perform()
        # 新窗口显性等待
        wait = WebDriverWait(driver=browser, timeout=5)
        wait.until(expected_conditions.new_window_is_opened(current_handles))
        browser.switch_to.window(browser.window_handles[-1])
        qr_code = browser.find_element('xpath', "//p[contains(text(),'用户名密码') and @class='pass-form-logo']")
        time.sleep(2)
        print(qr_code.tag_name)

总结:使用等待优先级—隐形等待 > 强制等待 > 显性等待

八、三种切换

(一)、窗口切换

browser.switch_to.window()

窗口的切换根据窗口句柄进行切换,窗口句柄就是窗口的标识码,多个窗口通过browser.window_handles获得窗口列表,通过下标获取指定窗口。

(二)、iframe切换

browser.switch_to.frame()

参数可传index(下标0开始),name(name属性值),以及iframe_element(通过find_element获得),表示具体切换的iframe

        # iframe切换
        # 通过name
        browser.switch_to.frame('iframeResult')
        # 通过index
        browser.switch_to.frame(0)
        # 通过element
        iframe_element = browser.find_element('id', 'iframeResult')
        browser.switch_to.frame(iframe_element)

(三)、alert切换

alert = browser.switch_to.alert
  • accetp()
1.先用switch_to_alert方法切换到alert弹出框上

2.可以用text方法获取弹出的文本信息

3.accept()点击确认按钮

  • dismiss()
1.先用switch_to_alert方法切换到alert弹出框上

2.可以用text方法获取弹出的文本信息

3.dismiss()相当于点右上角x,取消弹出框

  • send_keys()— 仅限于prompt
1.先用switch_to_alert方法切换到alert弹出框上

2.可以用text方法获取弹出的文本信息

3.send_keys()这里多个输入框,可以用send_keys()方法输入文本内容

4.accept()点击确认按钮

九、鼠标操作

  • 导包
from selenium.webdriver import ActionChains

初始化动作链条

action = ActionChains(browser)

ActionChains支持连续操作(链式调用),但是perfrom结尾将不能再进行连续操作,如:

action.click(weather).click().move_to_element().send_keys().perform()

  • 单击操作()
方式一:action.click(driver).perform()

方拾二:browser.find_element(By.ID, 's-usersetting-top').click()

区别:第一种方式可操作性更高,第二种方式简洁明了

  • 移动操作
action.move_to_element(element_name).perform()
  • 双击操作
action.double_click(element_name)
  • 右击操作
action.context_click(element_name)
  • 拖拽操作
action.drag_and_drop(element_name1, element_name2)

十、键盘操作

  • 指定元素键盘操作—Keys
from selenium.webdriver import Keys

baidu_element.send_keys(Keys.ENTER)
  • 全局键盘操作—ActionChains
from selenium.webdriver import ActionChains

baidu_element.send_keys(Keys.ESC).perform()

十一、下拉元素选择操作

  • 第一种方式:直接选择元素
    def test_choice(self):
        # 实例化浏览器对象
        browser = webdriver.Chrome()
        # 隐性等待
        browser.implicitly_wait(10)
        # 自定义URL
        url = "E:/PythonWorkSpace/SeleniumProject/test.html"
        # 访问url
        browser.get(url)
        time.sleep(2)
        select_ele = browser.find_element('xpath', '//option[@value="women"]')
        select_ele.click()

  • 方式二:通过Select

导包:

from selenium.webdriver.support.select import Select

先找到下拉框元素ID,传入Select,再根据返回的对象去根据方法找对应的下拉元素

        select_ele = browser.find_element('id', 'choice')
        select_ele2 = Select(select_ele)
        select_ele2.select_by_visible_text("女")
        time.sleep(2)
        select_ele2.select_by_value("man")
        time.sleep(2)

十二、JS操作

当下拉框元素不是select时,直接选择元素或通过Select将无法选择,可以通过JS操作

  • browser.execute_script(dom_script)
    def test_dmo(self):

        # 实例化浏览器对象
        browser = webdriver.Chrome()
        # 隐性等待
        browser.implicitly_wait(10)
        # 自定义URL
        url = "https://www.12306.cn/index/"
        # 访问url
        browser.get(url)
        time.sleep(2)
        # 当下拉框为Select时,此方法生效
        # elem = browser.find_element('id', 'train_date')
        # elem_select = Select(elem)
        # elem_select.select_by_visible_text('31')
        # time.sleep(2)
        # 当下拉框为其他元素,如div时,可用dom操作
        dom_script = "let date = document.getElementById('train_date');date.readOnly = false;date.value = '2022-05-01'"
        browser.execute_script(dom_script)
        time.sleep(2)
  • Python 与 JS 混用
        # python 与 JS 混用
        elem = browser.find_element('id', 'train_date')
        time.sleep(2)
        js_script = "arguments[0].readOnly = false; arguments[0].value = '2022-05-01'"
        browser.execute_script(js_script, elem)
        time.sleep(5)
  • JS操作滚动条
window.scrollTo(0, document.body.scrollHeight)

十三、文件上传

  • 上传元素为input时
    def test_file(self):
        # 实例化浏览器对象
        browser = webdriver.Chrome()
        # 隐性等待
        browser.implicitly_wait(10)
        # 自定义URL
        url = "http://www.zuohaotu.com/image-converter.aspx"
        # 访问url
        browser.get(url)
        time.sleep(2)
        file_elem = browser.find_element('id', 'newFile')
        file_elem.send_keys(r'D:\壁纸.jpg')
        time.sleep(2)
  • 元素为非input时,使用第三付库—win32gui
# 打开上传网站
driver.get("https://tinypng.com/")
paths = Path.cwd().parent

# 触发文件上传的操作
driver.find_element_by_css_selector("section.target").click()

time.sleep(2)
# 一级顶层窗口
dialog = win32gui.FindWindow("#32770", "打开")

# 二级窗口
comboBoxEx32 = win32gui.FindWindowEx(dialog, 0, "ComboBoxEx32", None)

# 三级窗口
comboBox = win32gui.FindWindowEx(comboBoxEx32, 0, "ComboBox", None)

# 四级窗口 -- 文件路径输入区域
edit = win32gui.FindWindowEx(comboBox, 0, "Edit", None)

# 二级窗口 -- 打开按钮
button = win32gui.FindWindowEx(dialog, 0, "Button", None)

# 1、输入文件路径
filepath = f"{paths}\\resources\\11.png"
win32gui.SendMessage(edit, win32con.WM_SETTEXT, None, filepath)

# 2、点击打开按钮
win32gui.SendMessage(dialog, win32con.WM_COMMAND, 1, button)

注意:当涉及文件路径时,有三种办法防止路径转义报错

(一):使用正斜杠/

(二):使用双反斜杠\\

(三):前面加r参数

多文件上传只需要写多几个send_keys方法即可

十四、PO(POM)模式

简介:PO模式是page object model的缩写,Page Object模式是Selenium中的一种测试设计模式,主要是将每一个页面设计为一个Class(封装在一个class类中),其中包含页面中需要测试的所有元素(按钮,输入框,标题等)的属性和操作,这样在Selenium测试页面中可以通过调用页面类来获取页面元素,这样巧妙的避免了当页面元素id或者位置变化时,需要改测试页面代码的情况。当页面元素id变化时,只需要更改测试页Class中页面的属性即可。

(一)、为何使用PO模式?

少数的自动化测试用例维护起来看起来是很容易的。但随着时间的迁移,测试套件将持续地增长脚本也将变得越来越臃肿庞大。如果变成我们需要维护10个页面,100个页面,甚至1000个呢?且页面元素很多是公用的,所以页面元素的任何改变都会让我们的脚本维护变得繁琐复杂,且变得耗时易出错。

也就是说页面中有一个按钮 元素A"。该元素A在十个测试用例中都被用到了,如果元素A被前端更新了,我就要去修改这十个自动化用例所用道元素A的地方。如果有100个、1000个用例用到了元素A,那我可就疯了。

而POM设计模式,会把公共的元素抽取出来,该元素被前端修改,只需要更新该元素的定位方式即可,用例不需要改动。换句话说,不管我多少测试用例,用到了该元素,我只重新修改元素的定位方式,重新能够获得该元素即可。

(二)、PO模式的优势?

  • 代码冗余明显降低:二次封装Selenium方法和提取公共方法,提高代码复用性
  • 代码的阅读性明显提升:因为三层分级,将不同内容进行不同的封装,整体代码阅读性提升
  • 代码维护性明显提升UI测试中,页面若经常变动,代码的维护量随之增多;因为三层分级,我们只需要修改页面对象的代码,如元素对象或者操作对象的方法,不用修改测试用例的代码,也不影响测试用例的正常执行
  • 降低代码耦合性

(三)、PO模式三层详解

  • 基础层 : 二次封装Selenium的方法
包括一些点击操作、find_element/find_elements操作,send_keys操作等

此层主要是针对Selenium的方法进行二次封装,方便调用

目前市面上的包括Helium、playwright等框架都是基于Selenium进行二次封装

  • 页面对象层: 用于放页面的元素和页面的动作
一个页面即为一个Object对象,这个是PO模型的特征,一个页面对象里面包含有属性和方法,属性就是页面上的所有HTML标签,一个标签即理解为一个元素,一个find_element,HTML标签的点击事件则为一个方法
  • 测试用例层: 多个页面操作完成一个业务测试
通过调用基础层(BasePage)对Selenium二次封装的方法,操作页面对象层中的动作,将多个动作连成一个业务测试流程,完成UI自动化测试。

(四)、实战案例

前言:以黑马的博学谷网站为例,使用PO模型,设计一个对于登录流程的UI自动化用例。

(1)、项目整体架构

  • Common:公共层,存放通用方法,如Selenium二次封装,即基础层,BasePages
  • Config: 项目配置层,存放项目配置文件,如conf.yaml,db.ini
  • Data: 数据层,存放测试数据,或者数据驱动文件,关键字驱动等等
  • Logs: 日志层,存放项目运行日志,按照日期区分
  • Reports: 测试报告层,存放测试用例执行的HTML报告文件
  • Pages: 页面层,一个网页即为一个页面.py文件,封装页面的元素及方法
  • TestCases: 测试用例层,存放测试用例,按照pytest命名规则,以test_开头
  • Utils: 工具层,封装工具类方法,如读取yaml,获取绝对路径,日志类封装等
  • conftest.py: 夹具层,存放测试类或者测试方法的全局测试前置步骤和后置步骤
  • run.py: 执行测试用例,生成测试报告

(2)、编写BasePage

from selenium.webdriver.support import expected_conditions
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver import Chrome
from Utils.GetPath import GetPath


class BasePage:

    """selenium操作二次封装"""

    def __init__(self, driver: Chrome):
        self.driver = driver

    # 访问链接
    def get_url(self, url, path=None):
        """
        :param url: 后缀地址
        :param path: 需要拼接的yaml文件地址
        :return:
        """
        url = GetPath.get_url(url, path)
        self.driver.get(url)
        return self

    # 点击操作封装
    def click(self, locator: tuple):
        elem = self.driver.find_element(*locator)
        self.wait_elem(locator)
        # 此操作为强制点击
        self.driver.execute_script("arguments[0].click({force:true})", elem)
        return self

    # 输入操作封装
    def send_keys(self, locator: tuple, text):
        self.driver.find_element(*locator).send_keys(text)
        return self

    # 显性等待封装
    def wait_elem(self, locator, timeout=10, poll=0.5):
        wait = WebDriverWait(self.driver, timeout=timeout, poll_frequency=poll)
        wait.until(expected_conditions.presence_of_element_located(locator))
        return self

(3)、编写Utils

封装绝对路径

import os.path
import yaml


class GetPath:
    @classmethod
    def get_abs_path(cls, path):
        system_path = os.path.dirname(os.path.dirname(__file__))
        data_path = os.path.oin(system_path, 'Config', path)
        return data_path

    @classmethod
    def get_url(cls, url, path):
        if path:
            path = cls.get_abs_path(path)
            with open(file=path, mode="r", encoding="utf-8") as file:
                url_data = yaml.load(stream=file, Loader=yaml.FullLoader)
            front_url = url_data[0]["host"]
            behind_url = url
            fill_url = front_url + behind_url
            return fill_url
        else:
            return url

    @classmethod
    def get_log_path(cls):
        system_path = os.path.dirname(os.path.dirname(__file__))
        log_path = os.path.join(system_path, "Logs", "")
        return log_path

日志类封装

import logging
import datetime
import os

from Utils.GetPath import GetPath

log_level_dict = {
    "debug": logging.DEBUG,
    "info": logging.INFO,
    "warning": logging.WARNING,
    "error": logging.ERROR,
    "critical": logging.CRITICAL
}


class LogUtil:
    def __init__(self, log_name, file_name, log_level, **kwargs):
        self.log_name = log_name
        self.file_name = file_name
        self.log_level = log_level

    def log(self):
        # 1、创建日志对象
        my_log = logging.getLogger(self.log_name)
        # 2、设置日志级别
        my_log.setLevel(log_level_dict[self.log_level])
        # 3、创建控制台输出Handler,不存在才创建,存在直接用
        if not my_log.handlers:
            handler = logging.StreamHandler()
            # 4.设置控制台Handler输出日志级别
            handler.setLevel(log_level_dict[self.log_level])
            # 5.设置日志输出格式
            formatter = logging.Formatter('%(asctime)s %(levelname)s [%(filename)s(%(funcName)s:%(lineno)d)] - %(message)s')
            # 6.绑定handler输出格式
            handler.setFormatter(formatter)
            # 7.添加到logger对象中
            my_log.addHandler(handler)
            # 8.级别排序:CRITICAL >ERROR >WARNING >INFO >DEBUG
            # 9.写入文件
            file_handler = logging.FileHandler(self.file_name, encoding='utf-8')
            # 10.设置日志文件级别
            file_handler.setLevel(log_level_dict[self.log_level])
            # 11.设置日志文件输出格式
            file_handler.setFormatter(formatter)
            # 12.添加到logger对象中
            my_log.addHandler(file_handler)
        return my_log


def log_util():
    log_path = GetPath.get_log_path()
    current_time = datetime.datetime.now().strftime("%Y-%m-%d")
    log_file = os.path.join(log_path + "AutoUI" + current_time + ".log")
    print(log_file)
    util = LogUtil("log", log_file, "debug").log()
    return util

读取Yaml封装

import yaml

from Utils.GetPath import GetPath


class ReadYamlUtils:
    @classmethod
    def read_data(cls, path, key):
        path = GetPath.get_abs_path(path)
        with open(file=path, mode="r", encoding="utf-8") as file:
            data = yaml.load(stream=file, Loader=yaml.FullLoader)
        return data[0][key]

(4)、编写Pages

以页面为对象把元素和方法进行封装

from selenium.webdriver.common.by import By
from Common.BasePage import BasePage
from Utils.Logger import log_util


class OnlineClass(BasePage):

    # 定义类属性
    url = "/user/login?refer=https%3A%2F%2Fwww.boxuegu.com%2F"
    button_locator = (By.XPATH, "//span[text()='登录']")
    submit_locator = (By.XPATH, "//button[text()='登录']")
    username_locator = (By.XPATH, '//*[@placeholder="请输入手机号或邮箱" and @class="el-input__inner"]')
    password_locator = (By.XPATH, '//*[@placeholder="请输入密码" and @class="el-input__inner"]')

    # 登录操作封装
    def login(self, username, password):
        """
        :param username: 账号
        :param password: 密码
        :return: 对象本身
        """
        self.click(self.button_locator)
        locator = ['xpath', "//button[text()='登录']"]
        self.wait_elem(locator).send_keys(self.username_locator, username)\
            .send_keys(self.password_locator, password)\
            .click(self.submit_locator)
        log_util().debug("登录操作")
        return self

    # 加载
    def load(self):
        self.get_url(self.url, path="conf.yaml")
        log_util().debug("加载操作")
        return self

    # 获取操作提示
    def get_errmsg(self):
        tips = self.driver.find_elements(By.XPATH, '//div[@class="el-form-item__error"]')
        log_util().debug("提示符文字获取操作")
        return [index.text for index in tips]

    # 清除内容
    def clear(self):
        log_util().debug("清楚输入框内容操作")
        self.driver.find_element(By.XPATH, '//*[@placeholder="请输入手机号或邮箱" and @class="el-input__inner"]').clear()
        self.driver.find_element(By.XPATH, '//*[@placeholder="请输入密码" and @class="el-input__inner"]').clear()

(5)、编写Data

为了方便获取参数,没有使用yaml文件,使用了py文件

login_data = [
    ('', '', ['请输入手机号或邮箱!', '请输入密码!']),
    ('13536237223', '', ['请输入密码!']),
    ('13536237223', '123456', ['请输入正确密码,连续输入错误密码,账号将被锁定'])
]

(6)、编写Config

此文件主要是控制项目的切换,可自行添加参数,包括项目环境,地址等等

-
  host: "https://passport.boxuegu.com"
  enviorment: "TEST"

(7)、编写TestCases

由于Pages封装的方法返回值为Page类对象本身,所以在测试用例设计中,可以使用链式调用

import pytest
from Data import Login
from Pages.OnlineClass import OnlineClass


class TestClass:

    @pytest.mark.parametrize("login_data", Login.login_data)
    def test_login(self, get_driver, login_data):
        # 解包
        username, password, result = login_data
        # 全局夹具对象
        browser = get_driver
        # po模型对象
        login_page = OnlineClass(driver=browser)
        # 链式调用
        value = login_page.load().login(username, password).get_errmsg()
        assert value == result

(8)、编写conftest.py

当有多个不同身份登录时,可以写不同身份的夹具方法,如学生和老师,在登录测试用例中,对于老师和学生不同的登录,就可以按照不同的夹具实现,因为夹具里面可能会定义一些登录账号和密码,需要注意的是scope参数,如果是class,则一个类里面所有测试用例必须是在同一个页面进行操作,否则找不到元素,这是因为driver对应着一个页面,如果上一个页面跳转到其他页面,而其他用例的dirver还是原来的,那么肯定是找不到元素的

import pytest
from selenium import webdriver


@pytest.fixture(scope="class")
# 必须是测同一个页面才能用class,否则不要设置作用域,会找不到元素哦
def get_driver():
    # 实例化浏览器对象
    browser = webdriver.Chrome()
    # 隐性等待
    browser.implicitly_wait(10)
    browser.maximize_window()
    yield browser
    browser.quit()

相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
目录
相关文章
|
19天前
|
数据采集 测试技术 Python
自动化淘宝秒杀:使用Selenium WebDriver的实战指南
本文详细介绍了如何利用Selenium WebDriver自动化淘宝秒杀操作,包括环境配置、代码实现及注意事项,旨在帮助读者提升秒杀成功率,同时提醒合理使用以遵守平台规则。
67 8
|
2月前
|
数据采集 存储 JavaScript
自动化数据处理:使用Selenium与Excel打造的数据爬取管道
本文介绍了一种使用Selenium和Excel结合代理IP技术从WIPO品牌数据库(branddb.wipo.int)自动化爬取专利信息的方法。通过Selenium模拟用户操作,处理JavaScript动态加载页面,利用代理IP避免IP封禁,确保数据爬取稳定性和隐私性。爬取的数据将存储在Excel中,便于后续分析。此外,文章还详细介绍了Selenium的基本设置、代理IP配置及使用技巧,并探讨了未来可能采用的更多防反爬策略,以提升爬虫效率和稳定性。
111 4
|
29天前
|
Java 测试技术 持续交付
【入门思路】基于Python+Unittest+Appium+Excel+BeautifulReport的App/移动端UI自动化测试框架搭建思路
本文重点讲解如何搭建App自动化测试框架的思路,而非完整源码。主要内容包括实现目的、框架设计、环境依赖和框架的主要组成部分。适用于初学者,旨在帮助其快速掌握App自动化测试的基本技能。文中详细介绍了从需求分析到技术栈选择,再到具体模块的封装与实现,包括登录、截图、日志、测试报告和邮件服务等。同时提供了运行效果的展示,便于理解和实践。
84 4
【入门思路】基于Python+Unittest+Appium+Excel+BeautifulReport的App/移动端UI自动化测试框架搭建思路
|
2月前
|
Java 测试技术 C#
自动化测试之美:从Selenium到Appium
【10月更文挑战第3天】在软件开发的海洋中,自动化测试如同一艘航船,引领着质量保证的方向。本文将带你领略自动化测试的魅力,从Web端的Selenium到移动端的Appium,我们将一探究竟,看看这些工具如何帮助我们高效地进行软件测试。你将了解到,自动化测试不仅仅是技术的展示,更是一种提升开发效率和产品质量的智慧选择。让我们一起启航,探索自动化测试的世界!
|
2月前
|
JavaScript 前端开发 测试技术
精通Selenium:从基础到高级的网页自动化测试策略
【10月更文挑战第6天】随着Web应用变得越来越复杂,手动进行功能和兼容性测试变得既耗时又容易出错。自动化测试因此成为了现代软件开发不可或缺的一部分。Selenium是一个强大的工具集,它支持多种编程语言(包括Python),允许开发者编写脚本来模拟用户与Web页面的交互。本文将带领读者从Selenium的基础知识出发,逐步深入到高级的应用场景,通过丰富的代码示例来展示如何高效地进行网页自动化测试。
415 5
|
2月前
|
Web App开发 IDE 测试技术
自动化测试的利器:Selenium 框架深度解析
【10月更文挑战第2天】在软件开发的海洋中,自动化测试犹如一艘救生艇,让质量保证的过程更加高效与精准。本文将深入探索Selenium这一强大的自动化测试框架,从其架构到实际应用,带领读者领略自动化测试的魅力和力量。通过直观的示例和清晰的步骤,我们将一起学习如何利用Selenium来提升软件测试的效率和覆盖率。
|
1月前
|
Web App开发 设计模式 JavaScript
自动化测试之美:如何利用Selenium实现Web应用的高效测试
【10月更文挑战第29天】在软件开发的世界中,测试是确保产品质量的关键步骤。本文将带你了解如何使用Selenium这一强大的自动化测试工具,提高Web应用测试的效率和准确性。通过实际案例,我们将探索Selenium的核心功能及其在现代软件开发中的应用,旨在帮助读者掌握自动化测试的精髓,从而提升软件测试工作的整体效能。
37 0
|
2月前
|
消息中间件 存储 JSON
rabbitmq基础教程(ui,java,springamqp)
本文提供了RabbitMQ的基础教程,包括如何使用UI创建队列和交换机、Java代码操作RabbitMQ、Spring AMQP进行消息发送和接收,以及如何使用不同的交换机类型(fanout、direct、topic)进行消息路由。
30 0
rabbitmq基础教程(ui,java,springamqp)
|
3月前
|
数据采集 Web App开发 测试技术
使用Selenium与WebDriver实现跨浏览器自动化数据抓取
在网络爬虫领域,Selenium与WebDriver是实现跨浏览器自动化数据抓取的利器。本文详细介绍了如何利用Selenium和WebDriver结合代理IP技术提升数据抓取的稳定性和效率。通过设置user-agent和cookie来模拟真实用户行为,避免被网站检测和阻止。文章提供了具体的代码示例,展示了如何配置代理IP、设置user-agent和cookie,并实现了跨浏览器的数据抓取。合理的参数配置能有效减少爬虫被封禁的风险,提高数据抓取效率。
364 6
使用Selenium与WebDriver实现跨浏览器自动化数据抓取
|
2月前
|
测试技术 数据安全/隐私保护 开发者
自动化测试的奥秘:如何用Selenium和Python提升软件质量
【9月更文挑战第35天】在软件开发的海洋中,自动化测试是那艘能引领我们穿越波涛的帆船。本文将揭开自动化测试的神秘面纱,以Selenium和Python为工具,展示如何构建一个简单而强大的自动化测试框架。我们将从基础出发,逐步深入到高级应用,让读者能够理解并实现自动化测试脚本,从而提升软件的质量与可靠性。

热门文章

最新文章