Python+Selenium+Pytest+Allure PO模式UI自动化框架

一、框架结构

• allure-report：测试报告
• base：定位元素封装
• data：数据
• log：日志文件
• page：页面封装文件夹
• report：缓存报告
• testcases：测试用例层
• utils：工具类
• run.py：执行文件

二、封装类

base.py

import datetime
import time

from selenium.webdriver import Keys, ActionChains
from selenium.webdriver.support.select import Select
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from utils.log_util import logger


class BasePage:
    def __init__(self, driver):
        self.driver = driver
        self.driver.maximize_window()
        self.driver.implicitly_wait(10)  # 隐式等待
        self.wait = WebDriverWait(self.driver, 10)  # 显示等待
        self.actions = ActionChains(self.driver)  # 鼠标动作链初始化

    # 这是基础的find_element封装
    # def find_element(self, locator):
    #     logger.info(f"当前定位{locator}")
    #     return self.driver.find_element(*locator)

    def find_element(self, locator, condition='visibility', retry=1):
        """

        :param locator: 元素定位信息
        :param condition: 默认是visibility
        :param retry: 重试次数，默认是1，重试一次
        :return:
        """
        for time in range(retry + 1):
            try:
                logger.info(f"定位元素{locator}")
                if condition == 'visibility':
                    node = self.wait.until(EC.visibility_of_element_located(locator))
                else:
                    node = self.wait.until(EC.presence_of_element_located(locator))
                return node
            except Exception as e:
                error_info = f"{locator}定位失败，错误信息{e}"
                logger.error(error_info)
                if time < retry:
                    logger.info(f"正在重新定位，当前重试次数:{time + 1}")
                else:
                    raise Exception(error_info)

    def find_elements(self, locator, retry=1):
        """
        返回列表节点
        :param locator: 元素定位信息
        :param retry: 重试次数，默认是1，重试一次
        :return:
        """
        for time in range(retry + 1):
            try:
                logger.info(f"定位元素{locator}")
                node = self.wait.until(lambda x: x.find_elements(*locator))
                return node
            except Exception as e:
                error_info = f"{locator}定位失败，错误信息{e}"
                logger.error(error_info)
                if time < retry:
                    logger.info(f"正在重新定位，当前重试次数:{time + 1}")
                else:
                    raise Exception(error_info)

    def send_keys(self, locator, value, enter=False):
        """
        封装输入内容函数
        :param locator: 元素定位信息
        :param value: 输入项的内容
        :return:
        """
        # 1. 先定位元素
        node = self.find_element(locator)
        # 2. 清空输入框
        node.clear()
        # 3. 输入内容
        node.send_keys(value)
        logger.info(f"输入内容为：{value}")
        if enter:
            # 调用键盘的回车键
            node.send_keys(Keys.ENTER)
            logger.info("点击回车键")

    def click(self, locator):
        """
        定位元素并点击
        :param locator: 元素定位信息
        :return:
        """
        # 1. 先定位元素
        node = self.find_element(locator)
        # 2. 点击
        node.click()
        logger.info("点击按钮")

    def get_url(self, url=''):
        """
        请求url
        :param url: 网址
        :return:
        """
        self.driver.get(url)
        logger.info(f"打开网址{url}")

    def close_driver(self):
        """
        关闭浏览器
        :return:
        """
        logger.info("关闭浏览器")
        self.driver.close()

    def quit_driver(self):
        """
        退出浏览器
        :return:
        """
        logger.info("退出浏览器")
        self.driver.quit()

    def refresh(self):
        """
        刷新浏览器
        :return:
        """
        self.driver.refresh()
        logger.info("刷新浏览器")

    def switch_to_window(self, to_parent_window=False):
        """
        切换窗口
        :param to_parent_window: 是否回到主窗口
        :return:
        """
        total = self.driver.window_handles
        if to_parent_window:
            # 切换到主窗口
            self.driver.switch_to.window(total[0])
        else:
            # 获取当前窗口
            current_window = self.driver.current_window_handle
            for window in total:
                if window != current_window:
                    logger.info("切换窗口")
                    self.driver.switch_to.window(window)

    def get_title(self):
        """
        获取网页title
        :return:
        """
        return self.driver.title

    def get_current_url(self):
        """
        获取当前的URL
        :return:
        """
        return self.driver.current_url

    def get_page_source(self):
        """
        获取网页源代码
        :return:
        """
        return self.driver.page_source

    def get_text(self, locator):
        """
        获取元素的文本内容
        :param locator: 元素定位信息
        :return:
        """
        ele = self.find_element(locator)
        text = ele.text
        if text == "":
            text = ele.accessible_name
        logger.info(f"元素{locator}的text为{text}")
        return text

    def move_to_element(self, locator):
        """
        鼠标移动到指定位置
        :param locator: 指定位置
        :return:
        """
        ele = self.find_element(locator)
        self.actions.move_to_element(ele).perform()
        logger.info(f"鼠标移动到{locator}位置")

    def drag_and_drop(self, locator_start, locator_end):
        """
        鼠标拖动元素到另一个元素
        :param locator_start: 元素开始位置
        :param locator_end: 元素结束位置
        :return:
        """
        start = self.find_element(locator_start)
        end = self.find_element(locator_end)
        self.actions.drag_and_drop(start, end).perform()
        logger.info(f"鼠标从{locator_start}拖动到{locator_end}")

    def drag_and_drop_by_offset(self, locator, x, y):
        """
        拖动一段距离
        :param locator: 拖动的元素
        :param x: x距离
        :param y: y距离
        :return:
        """
        ele = self.find_element(locator)
        self.actions.drag_and_drop_by_offset(ele, x, y)
        logger.info("鼠标拖动一段距离")

    def select_by_index(self, locator, index):
        """
        根据下标获取select
        :param locator: 元素定位信息
        :param index: 下标，从0开始
        :return:
        """
        ele = self.find_element(locator)
        select = Select(ele)
        select.select_by_index(index)
        logger.info(f"根据下表{index}获取select")

    def select_by_value(self, locator, value):
        """
        根据value值获取select
        :param locator: 元素定位信息
        :param value: value值
        :return:
        """
        ele = self.find_element(locator)
        select = Select(ele)
        select.select_by_value(value)
        logger.info(f"根据下表{value}获取select")

    def select_by_visible_text(self, locator, visible_text):
        """
        根据visible_text值获取select
        :param locator: 元素定位信息
        :param visible_text: visible_text值
        :return:
        """
        ele = self.find_element(locator)
        select = Select(ele)
        select.select_by_visible_text(visible_text)
        logger.info(f"根据下表{visible_text}获取select")

    # 等待元素存在
    def wait_ele_presence(self, locator, center=True):
        """     知识点解析：
        #scrollIntoView:
                # 如果为true，元素的顶端将和其所在滚动区的可视区域的顶端对齐。
                # 如果为false，元素的底端将和其所在滚动区的可视区域的底端对齐。
        #scrollIntoViewIfNeeded:
                #如果为true，则元素将在其所在滚动区的可视区域中居中对其。
                # 如果为false，则元素将与其所在滚动区的可视区域最近的边缘对齐。 根据可见区域最靠近元素的哪个边缘，
                # 元素的顶部将与可见区域的顶部边缘对准，或者元素的底部边缘将与可见区域的底部边缘对准。"""
        try:
            start = datetime.datetime.now()
            ele = self.wait.until(EC.presence_of_element_located(locator))
            end = datetime.datetime.now()
            logger.info("元素{}已存在，等待{}秒".format(locator, (end - start).seconds))
            self.driver.execute_script("arguments[0].scrollIntoViewIfNeeded(arguments[1]);", ele, center)
            return ele
        except Exception:
            logger.error("元素不存在-{}".format(locator))
            raise

    def execute_js(self, element):
        self.driver.execute_script("arguments[0].click();", element)

    def switch_to_frame(self, index=0, to_parent_frame=False, to_default_frame=False):
        """
        切换到不同的frame框架
        :param index: expect by frame index value or id or name or element
        :param to_parent_frame: 是否切换到上一个frame，默认False
        :param to_default_frame: 是否切换到最上层的frame，默认False
        :return:
        """
        if to_parent_frame:
            self.driver.switch_to.parent_frame()
        elif to_default_frame:
            self.driver.switch_to.default_content()
        else:
            self.driver.switch_to.frame(index)
        logger.info(f'切换frame，to：{index}')

    def popup_window_operation(self, action='yes', send_info='', get_window_info=False):
        """
        弹窗操作
        :param action: 要执行的动作，yes or no
        :param send_info: 在弹窗的文本框内输入信息
        :param get_window_info: 获取弹窗的文本信息
        :return:
        """
        if self.wait.until(EC.alert_is_present()):
            if send_info:
                logger.info(f'在弹窗上输入信息：{send_info}')
                self.driver.switch_to.alert.send_keys(send_info)

            if get_window_info:
                popup_info = self.driver.switch_to.alert.text
                logger.info(f'获取弹窗的文本信息：{popup_info}')
                return popup_info

            if action == 'yes':
                logger.info('在弹窗上点击确认')
                self.driver.switch_to.alert.accept()  # 点击确认
            else:
                logger.info('在弹窗上点击取消')
                self.driver.switch_to.alert.dismiss()  # 点击取消

    def page_scrolling(self, go_to_bottom=False, rolling_distance=(0, 1000)):
        """
        页面滚动，如果没有滚动效果，添加延时（页面需要全部加载完毕才能滚动）
        :param bool go_to_bottom: 是否直接滚动到当前页面的最底部，默认False
        :param tuple rolling_distance: 滚动距离，默认是向下滚动1000像素
        :return:
        """
        if go_to_bottom:
            js = "window.scrollTo(0, document.body.scrollHeight)"
        else:
            js = "window.scrollBy({}, {})".format(rolling_distance[0], rolling_distance[1])
        self.driver.execute_script(js)
        logger.debug(f'页面滚动完毕')

    def back(self):
        """网页后退"""
        self.driver.back()
        logger.debug('网页后退')

    def forward(self):
        """网页前进"""
        self.driver.forward()
        logger.debug('网页前进')

    # 获取元素的属性
    def get_ele_attribute(self, locator, name, center=True):
        ele = self.wait_ele_presence(locator, center)
        try:
            value = ele.get_attribute(name)
            logger.info("元素{}的{}属性-{}".format(locator, name, value))
            return value
        except:
            logger.error("元素获取属性{}失败-{}".format(name, locator))
            raise

page 文件

user_page.py示例

import allure
from selenium.webdriver.common.by import By
from base.base_page import BasePage
from testcases.user_center.conftest import delete_user, delete_code
from utils.assert_util import assert_compare


"""
后台登录商户余额审核
"""
class UserPage(BasePage):
    # 选择城市
    login_city = (By.XPATH, '//*[@id="app"]/div/div[2]/div/div/div[2]/button/span')
    # 选择全部取消
    click_all = (By.XPATH, '//*[@id="app"]/div/div[2]/div/div/div[6]/div/div[2]/form/div/div/div[2]/label/span[1]/span')
    # 选择自营深圳
    click_sz = (By.XPATH, '//*[@id="app"]/div/div[2]/div/div/div[6]/div/div[2]/form/div/div/div[3]/div[1]/div/div/div/label[7]/span[1]/span')
    # 点击确认
    click_confir= (By.XPATH, '//*[@id="app"]/div/div[2]/div/div/div[6]/div/div[3]/div/button[2]/span')
    # 用户列表-手机号搜索
    phone_serch = (By.XPATH, '//*[@id="app"]/div/div[2]/section/div/div[1]/div/div[1]/form/div[2]/div/div/input')
    
     def login(self):
        self.get_url("https://XXXX/?#/login")
        self.send_keys(self.login_account, "admin")
        self.send_keys(self.login_password, "123456")
        self.send_keys(self.login_code, 1)
        self.click(self.login_btn)

testcese 文件

test_user.py示例

import time
import allure
import pytest
from page.user_page import UserPage
# from testcases.user_center.conftest import delete_user, delete_code
from utils.assert_util import assert_compare
# from utils.mysql_util import db
from utils.read import read_yaml

@allure.epic("财务余额调控")
@allure.feature("余额调控")
@pytest.mark.run(order=1)
class TestUser:
    @allure.title("用户登录")
    @pytest.mark.parametrize('data', read_yaml()['user_login'])
    def test_user_login(self, driver_project, data):
        username, password,code = str(data['username']), str(data['password']),str(data['code'])
        page = UserPage(driver_project)
        page.get_url('https://XXXXX/?#/login')
        # page.refresh()
        page.send_keys(page.login_account, username)
        page.send_keys(page.login_password, password)
        page.send_keys(page.login_code, code)
        page.click(page.login_btn)
        time.sleep(3)

• conftest.py文件

import allure
import pytest
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from utils.get_filepath import get_screen_shot_path
from selenium.webdriver.chrome.options import Options
from selenium.common.exceptions import WebDriverException
options = Options()
options.binary_location = r"C:\Program Files\Google\Chrome\Application\chrome.exe"
service = Service(r'C:\Program Files\Google\Chrome\Application\chromedriver.exe')
options.add_argument("--headless")
options.add_argument("--disable-dev-shm-usage")

try:
    driver = webdriver.Chrome(options=options)
except WebDriverException as e:
    print("完整错误信息:", e.msg)
    with open("error.log", "w") as f:
        f.write(str(e))


@pytest.fixture(scope="session")
def driver_project():
    global driver
    driver = webdriver.Chrome()
    driver.maximize_window()
    driver.get("https://XXXXX/?#/login")
    # print(driver.page_source)
    print("打开浏览器")
    yield driver
    print("关闭浏览器")
    driver.close()
    driver.quit()


# 钩子函数，结果
@pytest.hookimpl(hookwrapper=True, tryfirst=True)
def pytest_runtest_makereport(item, call):
    """

    :param item: 代表测试函数或方法，包含测试相关的信心，比如名称，位置，标记
    :param call: 包含测试函数执行的详细信息，比如结果，执行时间
    :return:
    when = setup:前置
    when = call:执行测试用例
    when = teardown:后置
    """
    print("=========================")
    # 获取钩子函数的结果
    out = yield
    # 获取测试报告
    report = out.get_result()

    print(f"测试报告：{report}")
    print(f"步骤：{report.when}")
    print(f"nodeid：{report.nodeid}")
    print(f"运行结果：{report.outcome}")
    # 失败测试用例截图
    if report.when == 'call' and report.failed:
        # 保存到本地
        driver.save_screenshot(get_screen_shot_path())
        # 截图,get_screenshot_as_png二进制数据
        # 使用allure.attach将二进制数据附加到allure报告中
        allure.attach(driver.get_screenshot_as_png(), "用例执行失败截图", allure.attachment_type.PNG)

utils 文件夹

• assert_util.py

from utils.log_util import logger


def assert_compare(expect, compare, actual):
    """

    :param expect: 预期结果
    :param compare: 断言方式
    :param actual: 实际结果
    :return:
    """
    logger.info(f"预期结果:{expect} {compare} {actual}")
    try:
        if compare == "==":
            assert expect == actual
        elif compare == "!=":
            assert expect != actual
        elif compare == ">":
            assert expect > actual
        elif compare == "<":
            assert expect < actual
        elif compare == "in":
            assert expect in actual
        else:
            try:
                raise NameError(f"{compare} 断言方式错误，请填写正确")
            except Exception as e:
                logger.error(e)
                raise
        logger.info("断言成功")
    except AssertionError as e:
        logger.error(f"断言失败{e}")
        raise

• get_filepath.py

import os
import time


def get_report_path():
    path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "allure-report/export",
                        'prometheusData.txt')
    return path


def get_screen_shot_path():
    file_name = "截图{}.png".format(time.strftime("%Y-%m-%d_%H-%M-%S"))
    path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "file", file_name)
    return path


def get_logo_path():
    path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "file", "logo.jpg")
    return path


def download_file_path():
    path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "file")
    return path


def get_yaml_path():
    path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "data", "data.yaml")
    return path


def get_ini_path():
    path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "config", "settings.ini")
    return path


def get_log_path():
    path = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), "log")
    return path


if __name__ == '__main__':
    print(get_report_path())

• log_util.py

import logging
import os
import time

from utils.get_filepath import get_log_path

log_path = get_log_path()

if not os.path.exists(log_path):
    os.mkdir(log_path)


class Logger:

    def __init__(self):
        # 定义日志位置和文件名
        self.logname = os.path.join(log_path, "{}.log".format(time.strftime("%Y-%m-%d")))
        # 定义一个日志容器
        self.logger = logging.getLogger("log")
        # 设置日志打印的级别
        self.logger.setLevel(logging.DEBUG)
        # 创建日志输入的格式
        self.formater = logging.Formatter(
            '[%(asctime)s][%(filename)s %(lineno)d][%(levelname)s]: %(message)s')
        # 创建日志处理器，用来存放日志文件
        self.filelogger = logging.FileHandler(self.logname, mode='a', encoding="UTF-8")
        # 文件存放日志级别
        self.filelogger.setLevel(logging.DEBUG)
        # 文件存放日志格式
        self.filelogger.setFormatter(self.formater)
        # 创建日志处理器，在控制台打印
        self.console = logging.StreamHandler()
        # 设置控制台打印日志界别
        self.console.setLevel(logging.DEBUG)
        # 控制台打印日志格式
        self.console.setFormatter(self.formater)
        # 将日志输出渠道添加到日志收集器中
        self.logger.addHandler(self.filelogger)
        self.logger.addHandler(self.console)


logger = Logger().logger

if __name__ == '__main__':
    logger.debug("我打印DEBUG日志")
    logger.info("我打印INFO日志")
    logger.warning("我打印WARNING日志")
    logger.error("我打印ERROR日志")

• read.py

import configparser

import yaml

from utils.get_filepath import get_yaml_path, get_ini_path

path = get_yaml_path()
ini_path = get_ini_path()


def read_yaml():
    with open(path, encoding="utf8") as f:
        data = yaml.safe_load(f)
        return data


def read_ini():
    config = configparser.ConfigParser()
    config.read(ini_path, encoding='utf8')
    return config


if __name__ == '__main__':
    print(read_yaml())
    # print(read_ini()['mysql']['HOST'])

• pytest.ini

[pytest]
;使用testpaths指定测试用例运行目录或者运行文件
testpaths = testcases/official_website testcases/user_center testcases/reward_punish testcases/order_center
;mark标记
markers=
    pro:pro
    test:test
    p1:p1

addopts: -vs --alluredir ./report --clean-alluredir

• run.py

 import pytest
 import os

 if __name__ == '__main__':
     # 1.执行测试用例
     pytest.main()
     os.system("copy environment.properties  .\\report")
     # 2.生成报告
     os.system("allure generate report -o allure-report --clean")
     # 3.打开报告
     os.system("allure open allure-report")

三、测试报告

• 测试报告展示如图
  
• 报告详情展示