可乐Cola_社区达人页_阿里云开发者社区

全栈自动化第四期—接口自动化requests详解与进阶封装

requests详解与封装一、基本概念requests 模块是 python 基于 urllib，采用 Apache2 Licensed 开源协议的 HTTP 库。它比 urllib 更加方便，可以节约我们大量的工作，完全满足 HTTP 测试需求。二、安装通过 pip install requests 安装 requests 库三、快速入门（一）导包import requests（二）常用HTTP请求方法说明GET请求获取URL位置的资源HEAD请求获取URL位置资源的响应消息报告，即获得资源的头部信息POST请求向URL位置的资源后附加新的消息PUT请求向URL位置存储一个资源，覆盖原URL位置的资源PATCH请求局部更新URL位置的资源,即改变该处资源的部分内容DELETE请求删除URL位置存储的资源GET,HEAD是从服务器获取信息到本地，一般用于获取资源等场景PUT,POST,PATCH,DELETE是从本地向服务器提交信息。一般用于操作数据等场景其中GET，POST为常用方法,本期重点讲解代码演示：import requests requsts.requst() requsts.get() requsts.post() requsts.head() requsts.put() requsts.patch() requsts.delete() （三）Get详解常用参数参数类型作用params字典url为基准的url地址，不包含查询参数；该方法会自动对params字典编码,然后和url拼接url字符串requests 发起请求的地址headers字典请求头，发送请求的过程中请求的附加内容携带着一些必要的参数cookies字典携带登录状态proxies字典用来设置代理 ip 服务器timeout整型用于设定超时时间，单位为秒代码演示：import requests resp = requests.get(url="https://www.baidu.com") print(resp) （四）Post详解常用参数参数类型作用data字典作为向服务器提供或提交资源时提交，主要用于 post 请求json字典json格式的数据， json合适在相关的htmlfiles文件向服务器接口提交文件数据files演示：import requests file = {'file': open('C://Users//hello.txt', 'rb')} res = requests.post(url="http://localhost:8081/uploadfile",files=file) print(r.json())data和json主要区别是请求数据的不同，data一般是表单数据，json是字典格式。（五）response详解属性说明resp.status_codehttp请求的返回状态，若为200则表示请求成功。resp.raise_for_status()该语句在方法内部判断resp.status_code是否等于200，如果不等于，则抛出异常resp.texthttp响应内容的字符串形式，即返回的页面内容resp.encoding从http header 中猜测的相应内容编码方式resp.apparent_encoding从内容中分析出的响应内容编码方式（备选编码方式）resp.contenthttp响应内容的二进制形式resp.json()得到对应的 json 格式的数据，类似于字典源码分析：requests请求调用的是session请求，session和requests请求的区别在于，Session可以自动管理cookie，而requests在需要cookie认证时，请求需要携带cookies参数。四、请求、基础路径封装SendUtil：class SendUtil: session = requests.Session() # 初始化时，就获得项目名称，和环境名称 def __init__(self, team, workspace): self.url = YamlUtil.read_yaml(team, workspace) # 根据数据文件的绝对路径，在调用时，拼接上具体的模块名，即可完成接口拼接 def send(self, method, url, **kwargs): url = self.url + url # 将请求大小写统一设置为小写 method = str(method).lower() # 多参数可以传入data，json，cookie等 res = self.session.request(method=method, url=url, **kwargs) print(f"当前环境是：{YamlUtil.now_workspace}:{url}") return res1、将请求方法method、请求url，以及**kwargs封装成形参，在外部调用请求时，必须传入参数，内部使用session管理请求，达到cookie管理效果2、session为类属性，方便不同的方法去调用该session，防止产生资源浪费3、在SendUtil类初始化时传入参数，传入的team为项目名称，workspace为环境名称，通过封装read_yaml去读取Yaml文件，随后将读取的数据传递给send请求方法的url，完成基础路径的拼接，这里这样做的意义是每个项目都有固定的基础路径，后面拼接的为具体的模块名，通过封装基础路径在调用时再拼接。YamlUtil：class YamlUtil: # 获得数据文件的绝对路径 now_workspace = None @classmethod def get_path(cls): return os.path.dirname(os.path.dirname(__file__)) # 根据数据文件的绝对路径获取数据，第一个参数表示是哪个项目，第二个表示是什么环境 @classmethod def read_yaml(cls, team, workspace): path = cls.get_path()+"/testcases/API/config.yaml" with open(path, mode="r", encoding="utf-8") as file: data = yaml.load(file, Loader=yaml.FullLoader) cls.now_workspace = workspace return data["BASE"][team][workspace]1、get_path为获取数据文件绝对路径方法，在实际项目中，尽量使用绝对路径去拼接，避免资源找不到错误(FileNotFoundError)，read_yaml方法需要传入两个参数，第一个是项目名，第二个是环境，通过绝对路径去打开yaml文件，然后返回数据的时候根据我们的项目名和环境名去匹配对应的基础路径config.yaml:BASE: RuoYi: DEV: http://8.129.162.221:login TEST: http://8.129.162.221:getInfo Shop: DEV: http://8.129.162.220:upload TEST: http://8.129.162.220:download使用yaml格式去定义项目的基础路径，在read_yaml读取到项目路径后，返回项目和操作环境即可在跑自动化时一目了然。五、数据读取封装ReadYamlUtil：def read_yaml(path): with open(path, mode="r", encoding="utf-8") as file: data = yaml.load(file, Loader=yaml.FullLoader) return data通过传入path读取Yaml文件内容，随后返回内容，注意要使用encodingdata.yaml:- name: 登录接口 description: 验证登录模块 request: method: POST url: http://8.129.162.221:xxx/login data: code: 1234 password: **** username: cola uuid: 63b2234b8*******3cded6dbedd739 validate: None -test_login:@allure.epic("项目名称：若依管理系统") @allure.feature("模块名称：登录模块") class Test: @allure.story("登录模块") @allure.severity(allure.severity_level.BLOCKER) @pytest.mark.run(order=2) @pytest.mark.smoke @pytest.mark.parametrize("data", read_yaml("data.yaml")) def test_baidu01(self, data): allure.dynamic.title(data["name"]) allure.dynamic.description(data["description"]) # 未封装基础路径之前，使用我们yaml读取url # res = SendUtil.send(method=data["request"]["method"], # url=data["request"]["url"], json=data["request"]["data"]) # 封装了基础路径之后的用法，通过具体模块名拼接基础路径 res = SendUtil("RuoYi", "DEV").send(method=data["request"]["method"], url="/login", json=data["request"]["data"]) print(res.json()["msg"]) assert res.json()["msg"] == "操作成功"六、接口关联参数封装ReadYaml：接口关联的参数，如果每一个都放到全局变量中代码是非常冗余的，于是我们将其封装起来，常见办法有两种，一种是通过封装方法存入数据库，另一种方法是通过封装方法写入Yaml文件。 # 读取接口关联数据 @classmethod def read_extract(cls, param="Authorization"): path = cls.get_path()+"/testcases/API/extract.yaml" with open(path, encoding="utf-8") as file: data = yaml.load(stream=file, Loader=yaml.FullLoader) return data[param] # 写入接口关联数据 @classmethod def write_extract(cls, data): path = cls.get_path()+"/testcases/API/extract.yaml" with open(path, mode="a", encoding="utf-8") as file: yaml.dump(data=data, stream=file, allow_unicode=True) # 清空接口关联数据 @classmethod def clear_extract(cls): path = cls.get_path() + "/testcases/API/extract.yaml" with open(path, mode="w", encoding="utf-8") as file: file.truncate()test_login:在登录模块成功登录之后，通过write_extract方法以字典的格式写入Yaml文件保存，注意token格式，例如我的项目token需要在前置加上"Bearer "@allure.story("登录模块") @allure.severity(allure.severity_level.BLOCKER) @pytest.mark.run(order=1) @pytest.mark.smoke @pytest.mark.parametrize("data", YamlUtil.read_yaml("./testcases/API/data.yaml")) def test_login(self, data): allure.dynamic.title(data["name"]) allure.dynamic.description(data["description"]) # 封装了基础路径之后的用法，通过具体模块名拼接基础路径 res = SendUtil("RuoYi", "DEV").send(method=data["request"]["method"], url=data["request"]["url"], json=data["request"]["data"]) print(res.json()) # 登录成功后，写入关联数据token YamlUtil.write_extract({"Authorization": "Bearer "+res.json()["token"]}) assert res.json()["msg"] == "操作成功"在写入Yaml文件后，我们的token得到了保存，在其他接口调用时，即可通过读取yaml方法，获得token的值@allure.story("获取个人信息模块") @allure.severity(allure.severity_level.BLOCKER) @pytest.mark.run(order=2) @pytest.mark.smoke @pytest.mark.parametrize("data", YamlUtil.read_yaml("./testcases/API/getInfo.yaml")) def test_getinfo(self, data): allure.dynamic.title(data["name"]) allure.dynamic.description(data["description"]) # 封装了基础路径之后的用法，通过具体模块名拼接基础路径 res = SendUtil("RuoYi", "DEV").send(method=data["request"]["method"], url=data["request"]["url"], headers=data["request"]["headers"]) print(res.json()["msg"]) assert res.json()["msg"] == "操作成功"问题来了，当我们在进行参数化的时候，Yaml文件会产生多条Token决此办法需要通过conftest.py文件，每次调用前清空内容即可@pytest.fixture(scope="session", autouse=True, name="fixture") def execute_sql(): # 每次运行之前都清空接口关联的数据，否则每次执行都会产生相同的数据，久而久之数据会变得非常大 YamlUtil.clear_extract()由于我们项目中不止一个接口会需要用到接口参数关联，可能还有需要参数需要关联，因此我对read_yaml方法进行了优化，可以根据关联参数的键进行配对，找到需要关联的参数ReadYamlUtil:param参数默认是token登录鉴权，如果添加了其他关联参数，传递的参数会覆盖此参数，如果不传参数会报错，因此选择了默认参数。 # 读取接口关联数据 @classmethod def read_extract(cls, param="Authorization"): path = cls.get_path()+"/testcases/API/extract.yaml" with open(path, mode="r", encoding="utf-8") as file: data = yaml.load(file, Loader=yaml.FullLoader) data_format = {param: data[param]} return data_format为了实现方便管理，将来会把用例全部写入Yaml文件中，让不懂代码的人也可以跑接口自动化，因此需要将接口关联参数读取进行优化，通过{{params}} 对关联参数进行修饰，在读取时，通过正则表达式去除两边括弧，然后根据中间关键词去读取接口关联参数。getInfo.yaml- name: 获取个人信息接口 description: 个人信息模块 request: method: GET url: /getInfo headers: '{{Authorization}}' validate: NoneSendUtil.py(重点)class SendUtil: session = requests.Session() # 初始化时，就获得项目名称，和环境名称 def __init__(self, team, workspace): self.base_url = YamlUtil.read_configyaml(team, workspace) self.headers_dict = {} # 先生成字符串格式，替换URL中的{{}}，然后返回原有格式的URL @classmethod def replace_value(cls, data): if data and isinstance(data, dict): value = json.dumps(data) else: value = data for item in range(0, value.count("{{")): if "{{" in value and "}}" in value: start_index = value.index("{{") end_index = value.index("}}") old_value = value[start_index:end_index+2] new_value = YamlUtil.read_extract(old_value[2:-2]) # replace方法只能传字符串，如果是数值，需要转换 if type(new_value) == int: new_value = str(new_value) value = value.replace(old_value, new_value) # 如果不先生成字符串格式，无法进行替换，替换了之后，需要把数据还原成字典格式 if value and isinstance(data, dict): new_data = json.loads(value) else: new_data = value return new_data # 根据数据文件的绝对路径，在调用时，拼接上具体的模块名，即可完成接口拼接 def send(self, method, url, headers=None, **kwargs): # 获取{{param}}参数，替换为关联参数 url = self.base_url + SendUtil.replace_value(url) # 替换请求头 if headers: # 取token的value headers_value = SendUtil.replace_value(headers) # 取key，拼接成字典格式 headers_key = headers[2: -2] self.headers_dict = {headers_key: headers_value} # 替换请求数据 for key, value in kwargs.items(): if key in ['params', 'data', 'json']: kwargs[key] = self.replace_value(value) method = str(method).lower() # 多参数可以传入data，json，cookie等 res = self.session.request(method=method, url=url, headers=self.headers_dict, **kwargs) print(f"当前环境是：{YamlUtil.now_workspace}:{url}") return res七、Yaml用例封装1.通过自定义Yaml必填规则，让业务人员填写时遵守Yaml编写规则2.判断用例是否需要请求头，有的情况下，需要将请求头读取后添加3.判断用例是否需要断言analysis_yaml(分析Yaml):# yaml测试用例规则约束 def analysis_yaml(self, case): # 获取yaml用例的所有键 resp = None case_key = dict(case).keys() # 判断必填的键是否存在 if 'name' in case_key and 'base_url' in case_key and 'request' in case_key and 'validate' in case_key: request_key = dict(case['request']).keys() # 判断request中的method和url是否存在 if 'method' in request_key and 'url' in request_key: # 获取method和url method = case['request']['method'] url = case['request']['url'] # 从列表中移除method和url和headers，因为要把可变长度的参数传给send方法的**kwargs del case['request']['method'] del case['request']['url'] headers = None # 通过jsonpath判断是否存在请求头 if jsonpath.jsonpath(case, '$.request.headers'): headers_value = case['request']['headers'] headers = self.replace_load(headers_value) # 从列表中移除method和url和headers，因为要把可变长度的参数传给send方法的**kwargs del case['request']['headers'] print("发送请求头为：", headers) resp = self.send(method=method, url=url, headers=headers, **case['request']) res_data = resp.json() res_text = resp.text if not case['validate'] is None: self.validate_result(res_data, case['validate']) elif case['validate'] is None: print("无需断言") if jsonpath.jsonpath(case, '$.extract'): for key, value in dict(case['extract']).items(): # 通过正则表达式提取token if '(.+?)' in value or '(*.?)' in value: re_value = re.search(value, res_text) if re_value: extract_data = {key: "Bearer "+re_value.group(1)} YamlUtil.write_extract(extract_data) # 通过json表达式提取token else: extract_data = {key: "Bearer "+res_data[value]} YamlUtil.write_extract(extract_data) else: print("request必填项不能为空") else: print("yaml用例必填项不能为空") return respYaml用例：- name: 岗位管理新增接口 description: 系统管理模块 base_url: http://8.129.162.225:8080 request: method: POST url: /system/post json: postCode: ${get_random_number(50,10000)} postName: ${get_random_name(1,1000)} postSort: 0 status: 0 headers: ${get_extract_data(Authorization)} validate: code: 200 equals: 操作成功测试用例(先进行yaml规则校验，然后再发送请求)： @allure.story("岗位关联模块") @allure.severity(allure.severity_level.BLOCKER) @pytest.mark.run(order=3) @pytest.mark.smoke @pytest.mark.parametrize("data", YamlUtil.read_yaml("setPost.yaml")) def test_set_post(self, data): allure.dynamic.title(data["name"]) allure.dynamic.description(data["description"]) # 封装了基础路径之后的用法，通过具体模块名拼接基础路径 res = SendUtil("RuoYi", "DEV").analysis_yaml(data) print(res.json()) 八、Yaml优化—热加载通过反射方法，将yaml用例中的方法映射到Debug_talk.py文件的方法中，形成参数替换replace_load：# 热加载替换方式 @classmethod def replace_load(cls, data): if data and isinstance(data, dict): value = json.dumps(data, ensure_ascii=False) else: value = data for item in range(0, value.count("${")): if "${" in value and "}" in value: start_index = value.index("${") end_index = value.index("}") old_value = value[start_index:end_index + 1] # 获取yaml文件中的方法名 function_name = old_value[2: old_value.index('(')] # 获取yaml文件中的参数 args_value = old_value[old_value.index('(')+1: old_value.index(')')] # 将参数分割，变成单个个体 args_value_list = args_value.split(',') # 通过反射方法，去获取新的值 new_value = getattr(DebugTalk(), function_name)(*args_value_list) # 得到新的值，replace只能传字符串，需要强转 value = value.replace(old_value, str(new_value)) # 如果不先生成字符串格式，无法进行替换，替换了之后，需要把数据还原成字典格式 if data and isinstance(data, dict): data = json.loads(value) else: data = value return dataYaml用例：- name: 岗位管理新增接口 description: 系统管理模块 base_url: http://8.129.162.225:8080 request: method: POST url: /system/post json: postCode: ${get_random_number(50,10000)} postName: ${get_random_name(1,1000)} postSort: 0 status: 0 headers: ${get_extract_data(Authorization)} validate: code: 200 equals: 操作成功DebugTalk.py：import random from common.yaml_util import YamlUtil class DebugTalk: # 热加载获取随机数方法 @classmethod def get_random_number(cls, min_num, max_num): number = random.randint(int(min_num), int(max_num)) return number # 热加载获取随机名称 @classmethod def get_random_name(cls, min_num, max_num): num = random.randint(int(in_num), int(max_num)) name = str(num) + "测试岗位" return name # 热加载获取token或者其他关联参数 @classmethod def get_extract_data(cls, param): return YamlUtil.read_extract(param=param) 九、断言封装 # 断言封装 def validate_result(self, result, expect): if expect and isinstance(expect, dict): for key, value in dict(expect).items(): if key == "code" and type(value) == int: assert value == result[key] if type(key) == str and key == "equals": result_str = str(result) assert value in result_str十、其他的一些配置文件pytest.ini（添加运行参数）：[pytest] addopts = -vs -m 'smoke or newModel' --alluredir=reports/temps --clean-alluredir testpaths = testcases/ python_files = "test_*.py" python_classes = "TestApi*" python_functions = "test_*" markers = smoke: All_test newModel: some_testconftest.py（全局夹具）：import pytest from common.yaml_util import YamlUtil @pytest.fixture(scope="session", autouse=True, name="fixture") def execute_sql(): print("········夹具前置") # 每次运行之前都清空接口关联的数据，否则每次执行都会产生相同的数据，久而久之数据会变得非常大 YamlUtil.clear_extract() yield print("夹具后置········") run.py（用例执行）：import os import pytest if __name__ == '__main__': # # 运行所有 # pytest.main() # # 指定模块 # pytest.main(['-vs', 'testcases/test_api.py']) # # 指定目录 # pytest.main(['-vs', 'testcases']) # # 通过node id指定用例运行 # pytest.main(['-vs', 'testcases/test_api.py::TestApi::test_baidu']) # # 失败重跑 # pytest.main(['-vs', '--reruns=2', 'testcases']) # # 发现失败即可停止运行 # pytest.main(['-vs', '-x', 'testcases/test_api.py']) # # 发现N个失败即可停止运行 # pytest.main(['-vs', '--maxfail=2', 'testcases/test_api.py']) # # 生成测试报告 # pytest.main(['-vs', '--maxfail=2', '--html=report/report.html', 'testcases/test_api.py']) # # 多线程运行 # pytest.main(['-vs', '-n 3', 'testcases/test_api.py']) # 根据测试用例的部分字符串指定测试用例 # pytest.main(['-vs', '-k', 'test_baidu03 or test_baidu04', 'testcases/test_api.py']) pytest.main() os.system("allure generate reports/temps -o reports/allures --clean")requirements.txt（项目依赖自动安装, pip install -r requirements）：pytest~=7.1.2 pytest-html pytest-xdist pytest-ordering pytest-rerunfailures allure-pytest requests~=2.27.1 PyYAML~=6.0 jsonpath~=0.82总结：只是一个基础框架，归根结底很多代码需要根据公司实际业务去进行优化，代码只是编程的实现方式，更重要的是思维方式，ok，以下一张图结束本节。

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

Selenium教程一、安装SeleniumWebdrive1、下载selenium webdrive2、下载地址：chromedrive3、找到与谷歌浏览器版本号一致的包,下载chromedriver_win32.zip可以通过浏览器右上角,点击设置,找到关于谷歌,即可查看本地谷歌浏览器的版本号随后在淘宝镜像网中,找到与浏览器版本号开头一致的数字包即可.4、配置环境变量，将chromedriver_win32.zip文件解压地址添加到Path变量Selenium驱动程序需要环境变量配置二、Pycharm安装selenium控制台Terminal输入安装命令pip install selenium三、测试Demofrom selenium import webdriver driver = webdriver.Chrome(port=8800) url = "https://www.colablog.top" driver.get(url)配置port端口可以用于多浏览器运行自动化，例如A电脑谷歌浏览器端口为8800B电脑谷歌浏览器端口为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() 该元素指定属性的值（一）、xpathinput_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"的元素**选择所有元素elementp选择所有元素element,elementdiv,p选择所有元素和元素element elementdiv p选择元素内的所有元素element>elementdiv>p选择所有父级是元素的元素element+elementdiv+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.alertaccetp()1.先用switch_to_alert方法切换到alert弹出框上2.可以用text方法获取弹出的文本信息3.accept()点击确认按钮dismiss()1.先用switch_to_alert方法切换到alert弹出框上2.可以用text方法获取弹出的文本信息3.dismiss()相当于点右上角x，取消弹出框send_keys()— 仅限于prompt1.先用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)十、键盘操作指定元素键盘操作—Keysfrom selenium.webdriver import Keys baidu_element.send_keys(Keys.ENTER)全局键盘操作—ActionChainsfrom 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二次封装，即基础层，BasePagesConfig：项目配置层，存放项目配置文件，如conf.yaml，db.iniData：数据层，存放测试数据，或者数据驱动文件，关键字驱动等等Logs：日志层，存放项目运行日志，按照日期区分Reports：测试报告层，存放测试用例执行的HTML报告文件Pages：页面层，一个网页即为一个页面.py文件，封装页面的元素及方法TestCases：测试用例层，存放测试用例，按照pytest命名规则，以test_开头Utils：工具层，封装工具类方法，如读取yaml，获取绝对路径，日志类封装等conftest.py：夹具层，存放测试类或者测试方法的全局测试前置步骤和后置步骤run.py：执行测试用例，生成测试报告(2)、编写BasePagefrom 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()