Selenium+Unittest自动化测试框架实战

前言

之前介绍过pytest+selenium的自动化测试框架实战，但是可能有些人还没用过pytest，使用的是unittest，对pytest怎么使用的不熟悉。因此专门写一篇unittest框架的吧，内容大致和pytest+selenium实战是一样的。

区别就在于把pytest替换成了unittest。

---

项目框架

开始之前先简单介绍一下框架体系吧：

目录/文件	说明
common	常见的通用类，比如读取config文件，元素文件
logs	日志文件
Page	selenium基类
PageElements	页面元素
PageObject	页面对象POM设计模式，本人对这个的理解来自于苦叶子的博客
report	报告目录
TestCase	测试用例
tools	工具类
conf.py	设置文件
config.ini	配置文件
run_case.py	总运行文件

• 框架有什么优点呢？
  • 代码复用率高，如果不使用框架的话，代码会很冗余
  • 可以组装日志、报告、邮件等一些高级功能
  • 提高元素等数据的可维护性，元素发生变化时，只需要更新一下配置文件
  • 使用更灵活的PageObject设计模式

知道了以上这些我们就开始吧！

---

设置文件

项目中都应该有一个文件对整体的目录进行管理，我也在这个python项目中设置了此文件。

在项目根目录创建conf.py文件，所有的目录配置或者基本不变的配置信息写在这个文件里面。

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
__author__ = '[email protected]'

import sys

sys.path.append('.')
import os
from selenium.webdriver.common.by import By

# 项目目录
BASE_DIR = os.path.dirname(os.path.abspath(__file__))

# 配置文件
INI_PATH = os.path.join(BASE_DIR, 'config.ini')

# 页面元素目录
ELEMENT_PATH = os.path.join(BASE_DIR, 'PageElements')

# 日志目录
LOG_PATH = os.path.join(BASE_DIR, 'logs')

# 报告目录
REPORT_PATH = os.path.join(BASE_DIR, 'report')

# 测试用例
TEST_SUITES = os.path.join(BASE_DIR, "TestCase")

# 元素定位的类型
LOCATE_MODE = {
    'css': By.CSS_SELECTOR,
    'xpath': By.XPATH,
    'name': By.NAME,
    'id': By.ID,
    'class': By.CLASS_NAME
}

# 邮件信息
EMAIL_INFO = {
    'username': '[email protected]',  # 切换成你自己的地址
    'password': 'QQ邮箱授权码',
    'smtp_host': 'smtp.qq.com',
    'smtp_port': 465
}

# 收件人
ADDRESSEE = ['[email protected]', ]

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

注意：QQ邮箱授权码：点击查看生成教程

这个conf文件我模仿了Django的settings.py文件风格。

在这个文件中我们可以设置自己的各个目录，也可以查看自己当前的目录。

遵循了约定：不变的常量名全部大写，变量名称小写的规范。看起来整体美观。

---

配置文件

所谓的配置文件就将固定不变的信息集中在一个文件中

在项目根目录新建一个config.ini文件，里面暂时先放入我们的需要测试的URL

[HOST]
HOST = https://www.baidu.com

配置文件创建好了，接下来我们需要读取这个配置文件以使用里面的信息。

我们在common目录中新建一个readconfig.py文件

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
__author__ = '[email protected]'

import os
import conf
import configparser

HOST = 'HOST'


class ReadConfig:
    """配置文件"""

    def __init__(self):
        self.config_path = conf.INI_PATH
        if not os.path.exists(self.config_path):
            raise FileNotFoundError("配置文件%s不存在！" % self.config_path)
        self.config = configparser.RawConfigParser()  # 当有%的符号时请使用Raw读取
        self.config.read(self.config_path, encoding='utf-8')

    def _get(self, section, option):
        """获取"""
        return self.config.get(section, option)

    def _set(self, section, option, value):
        """更新"""
        self.config.set(section, option, value)
        with open(self.config_path, 'w') as f:
            self.config.write(f)

    @property
    def url(self):
        return self._get(HOST, HOST)


ini = ReadConfig()

if __name__ == '__main__':
    print(ini.url)

可以看到我们用python内置的configparser模块对config.ini文件进行了读取。

对于url值的提取，我使用了高阶语法@property属性值，写法更简单。

---

POM模型

由于下面要讲元素相关的，所以首先理解一下POM模型

Page Object模式具有以下几个优点。

该观点来自 《Selenium自动化测试——基于Python语言》

• 抽象出对象可以最大程度地降低开发人员修改页面代码对测试的影响， 所以， 你仅需要对页
  面对象进行调整， 而对测试没有影响；
• 可以在多个测试用例中复用一部分测试代码；
• 测试代码变得更易读、 灵活、 可维护

Page Object模式图

• basepage ——selenium的基类，对selenium的方法进行封装
• pageelements——页面元素，把页面元素单独提取出来，放入一个文件中
• searchpage ——页面对象类，把selenium方法和页面元素进行整合
• testcase ——使用pytest对整合的searchpage进行测试用例编写

通过上图我们可以看出，通过POM模型思想，我们把：

• selenium方法

• 页面元素

• 页面对象

• 测试用例

以上四种代码主体进行了拆分，虽然在用例很少的情况下做会增加代码，但是当用例多的时候意义很大，代码量会在用例增加的时候显著减少。我们维护代码变得更加直观明显，代码可读性也变得比工厂模式强很多，代码复用率也极大的得到了提高。

---

页面元素

本教程选择的测试地址是百度首页，所以对应的元素也是百度首页的。

项目框架设计中有一个目录PageElements就是专门来存放定位元素的文件的。

通过对各种配置文件的对比，我在这里选择的是YAML文件格式。其易读，交互性好。

我们在配置文件中新建一个search.yaml文件。

搜索框: "id==kw"
候选: "css==.bdsug-overflow"
搜索候选: "css==#form div li"
搜索按钮: "id==su"

元素定位文件创建好了，下来我们需要读取这个文件。

在common中创建readelement.py文件。

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
__author__ = '[email protected]'

import os
import yaml
import conf


class Element:
    """获取元素"""

    def __init__(self, name):
        self.file_name = '%s.yaml' % name
        self.element_path = os.path.join(conf.ELEMENT_PATH, self.file_name)
        if not os.path.exists(self.element_path):
            raise FileNotFoundError("%s 文件不存在！" % self.element_path)
        with open(self.element_path, encoding='utf-8') as f:
            self.data = yaml.safe_load(f)

    def __getitem__(self, item):
        """获取属性"""
        data = self.data.get(item)
        if data:
            name, value = data.split('==')
            return name, value
        raise ArithmeticError("{}中不存在关键字：{}".format(self.file_name, item))


if __name__ == '__main__':
    search = Element('search')
    print(search['搜索框'])

通过特殊方法__getitem__实现调用任意属性，读取yaml中的值。

这样我们就实现了定位元素的存储和调用。

但是还有一个问题，我们怎么样才能确保我们写的每一项元素不出错，人为的错误是不可避免的，但是我们可以通过代码来运行对文件的审查。

所以我们编写一个文件，在common目录中创建inspect.py文件，对所有的元素yaml文件进行审查。

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
__author__ = '[email protected]'

import os
import yaml
import time
import conf


def inspect_element():
    """审查所有的元素是否正确"""
    start_time = time.time()
    for i in os.listdir(conf.ELEMENT_PATH):
        _path = os.path.join(conf.ELEMENT_PATH, i)
        if os.path.isfile(_path):
            with open(_path, encoding='utf-8') as f:
                data = yaml.safe_load(f)
                for k in data.values():
                    pattern, value = k.split('==')
                    if pattern not in conf.LOCATE_MODE:
                        raise AttributeError('【%s】路径中【%s]元素没有指定类型' % (i, k))
                    if pattern == 'xpath':
                        assert '//' in value, '【%s】路径中【%s]元素xpath类型与值不配' % (i, k)
                    if pattern == 'css':
                        assert '//' not in value, '【%s】路径中【%s]元素css类型与值不配' % (i, k)
                    if pattern in ('id', 'name', 'class'):
                        assert value, '【%s】路径中【%s]元素类型与值不匹配' % (i, k)
    end_time = time.time()
    print("校验元素done！用时%.3f秒！" % (end_time - start_time))


if __name__ == '__main__':
    inspect_element()

执行该文件：

/Users/hoou/PycharmProjects/web-demotest/venv/bin/python /Users/hoou/PycharmProjects/web-demotest/common/inspect.py
校验元素done！用时0.002秒！

Process finished with exit code 0

可以看到，很短的时间内，我们就对所填写的YAML文件进行了审查。

---

日志模块

日志，大家应该都很熟悉这个名词，就是记录代码中的动作。在自动化测试过程中，我们也需要记录一下自动化测试过程中的一些操作。

首先在tools目录中创建log.py。

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
__author__ = '[email protected]'

import os
import logging
import conf
from common.times import datetime_strftime


class Log:
    def __init__(self):
        log_path = self.log_path[:self.log_path.rfind('/')]
        if not os.path.exists(log_path):
            os.makedirs(log_path)
        self.logger = logging.getLogger()
        if not self.logger.handlers:
            self.logger.setLevel(logging.DEBUG)

            # 创建一个handle写入文件
            fh = logging.FileHandler(self.log_path, encoding='utf-8')
            fh.setLevel(logging.INFO)

            # 创建一个handle输出到控制台
            ch = logging.StreamHandler()
            ch.setLevel(logging.INFO)

            # 定义输出的格式
            formatter = logging.Formatter(self.fmt)
            fh.setFormatter(formatter)
            ch.setFormatter(formatter)

            # 添加到handle
            self.logger.addHandler(fh)
            self.logger.addHandler(ch)

    @property
    def log_path(self):
        return os.path.join(conf.LOG_PATH, '{}.log'.format(datetime_strftime()))

    @property
    def fmt(self):
        return '%(levelname)s\t%(asctime)s\t[%(filename)s:%(lineno)d]\t%(message)s'


log = Log().logger

if __name__ == '__main__':
    log.info('你好')

在终端中运行该文件，就看到命令行打印出了：

INFO    2020-01-16 17:07:17,655 [log.py:57]     你好

然后在项目logs目录下生成了当月的日志文件。

现在我们基本所需要的组件已经大致完成了。

接下来我们将进行最重要的一环，封装selenium。

---

Selenium基类

在工厂模式种我们是这样写的：

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
__author__ = '[email protected]'

import time
from selenium import webdriver


driver = webdriver.Chrome()
driver.get('https://www.baidu.com')
driver.find_element_by_xpath("//input[@id='kw']").send_keys('selenium')
driver.find_element_by_xpath("//input[@id='su']").click()
time.sleep(5)
driver.quit()

很直白，简单，又明了。

创建driver对象，打开百度网页，搜索selenium，点击搜索，然后停留5秒，查看结果，最后关闭浏览器。

那我们为什么要封装selenium的方法呢。首先我们上述这种较为原始的方法，基本不适用于平时做UI自动化测试的，因为在UI界面实际运行情况远远比较复杂，可能因为网络原因，或者控件原因，我们元素还没有显示出来，就进行点击或者输入。所以我们需要封装selenium方法，通过内置的显式等待或一定的条件语句，才能构建一个稳定的方法。而且把selenium方法封装起来，有利于平时的代码维护。

我们在Page目录创建webpage.py文件。

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
__author__ = '[email protected]'

from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import TimeoutException
from tools.times import sleep
from tools.log import log
import conf

"""
selenium基类
本文件存放了selenium基类的封装方法
"""


class WebPage(object):
    """selenium基类"""

    def __init__(self, driver):
        # self.driver = webdriver.Chrome()
        self.driver = driver
        self.timeout = 20  # 查找元素的超时时间
        self.wait = WebDriverWait(self.driver, self.timeout)

    def get_url(self, url):
        """打开网址并验证"""
        self.driver.maximize_window()
        self.driver.set_page_load_timeout(60)
        try:
            self.driver.get(url)
            self.driver.implicitly_wait(10)
            log.info("打开网页：%s" % url)
        except TimeoutException:
            raise TimeoutException("打开%s超时请检查网络或网址服务器" % url)

    @staticmethod
    def element_locator(func, locator):
        """元素定位器"""
        name, value = locator
        return func(conf.LOCATE_MODE[name], value)

    def find_one_element(self, locator):
        """寻找单个元素"""
        return WebPage.element_locator(lambda *args: self.wait.until(lambda x: x.find_element(*args)), locator)

    def find_all_element(self, locator):
        """查找多个相同的元素"""
        return WebPage.element_locator(lambda *args: self.wait.until(lambda x: x.find_elements(*args)), locator)

    def elements_num(self, locator):  # 获取相同元素的个数
        """获取相同元素的个数"""
        number = len(self.find_one_element(locator))
        log.info("相同元素：{}".format((locator, number)))
        return number

    def is_clear(self, locator):
        """清空输入框"""
        self.find_one_element(locator).clear()
        self.driver.implicitly_wait(0.5)
        log.info("清空输入框！")

    def input_text(self, locator, txt):
        """输入(输入前先清空)"""
        sleep(0.5)
        self.is_clear(locator)
        self.find_one_element(locator).send_keys(txt)
        log.info("输入文本：{}".format(txt))

    def is_click(self, locator):
        """点击"""
        self.find_one_element(locator).click()
        sleep()
        log.info("点击元素：{}".format(locator))

    def get_element_text(self, locator):
        """获取当前的text"""
        ele_text = self.find_one_element(locator).text
        log.info("获取文本：{}".format(ele_text))
        return ele_text

    @property
    def getSource(self):
        """获取页面源代码"""
        return self.driver.page_source

    def shot_file(self, path):
        """文件截图"""
        return self.driver.save_screenshot(path)

    def refresh(self):
        """刷新页面F5"""
        self.driver.refresh()
        self.driver.implicitly_wait(30)


if __name__ == "__main__":
    pass

在文件中我们对主要用了显示等待对selenium的click，send_keys等方法，做了二次封装。提高了运行的成功率。

好了我们完成了POM模型的前奏。接下来我们们进入页面对象。

---

在进入之前，我们注意到导入的第四行里面有一个times模块还未创建。

所以我们在在tools包中创建times.py模块。

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
__author__ = '[email protected]'

import time
import datetime


def datetime_strftime(fmt="%Y%m"):
    """datetime格式化时间"""
    return datetime.datetime.now().strftime(fmt)


def sleep(seconds=1.0):
    """
    睡眠时间
    """
    time.sleep(seconds)


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

---

页面对象

在创建了PageElements和basepage之后，我们开始创建searchpage页面对象类。

在PageObject目录下创建一个searchpage.py文件。

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
__author__ = '[email protected]'

from Page.webpage import WebPage, sleep
from common.readelement import Element

search = Element('search')


class SearchPage(WebPage):
    """搜索类"""

    def input_search(self, content):
        """输入搜索"""
        self.input_text(search['搜索框'], txt=content)
        sleep()

    @property
    def imagine(self):
        """搜索联想"""
        return [x.text for x in self.find_all_element(search['候选'])]

    def click_search(self):
        """点击搜索"""
        self.is_click(search['搜索按钮'])


if __name__ == '__main__':
    pass

在该文件中我们对，输入搜索关键词，点击搜索，搜索联想，进行了封装。

并配置了注释。

在平时中我们应该养成写注释的习惯，因为过一段时间后，没有注释，代码读起来很费劲。

好了我们的页面对象此时业已完成了。

下面我们开始编写测试用例。

---

unittest测试框架

unittest是python标准库中自带的测试框架。

学习unittest最好的教程应该是python官方文档了。

官方文档：https://docs.python.org/zh-cn/3.7/library/unittest.html

就不细说了，自己去看吧。

---

测试用例

我们将使用pytest编写测试用例。

在TestCase目录中创建test_search.py文件。

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
__author__ = '[email protected]'

import re
import unittest
from tools.log import log
from common.readconfig import ini
from selenium import webdriver
from PageObject.searchpage import SearchPage

driver = None


def setUpModule():
    global driver
    if driver is None:
        driver = webdriver.Chrome()


def tearDownModule():
    driver.quit()


class TestSearch(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        cls.search = SearchPage(driver)
        cls.search.get_url(ini.url)

    @classmethod
    def tearDownClass(cls) -> None:
        pass

    def test_001(self):
        """搜索"""
        self.search.input_search("selenium")
        self.search.click_search()
        result = re.search(r'selenium', self.search.getSource)
        log.info(result)
        assert result

    def test_002(self):
        """测试搜索候选"""
        self.search.input_search("selenium")
        log.info(list(self.search.imagine))
        assert all(["selenium" in i for i in self.search.imagine])


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

我们测试用了就编写好了。

• setUpModule和tearDownModule实现了和模块级别的前置启动，后置清理的装饰器。应该是最大的级别了。unittest没有像pytest一样有session级别的。

• 第一个测试用例：

  • 我们实现了在百度selenium关键字，并点击搜索按钮，并在搜索结果中，用正则查找结果页源代码，返回数量大于10我们就认为通过。

• 第二个测试用例：

  • 我们实现了，搜索selenium，然后断言搜索候选中的所有结果有没有selenium关键字。

---

执行用例

以上我们已经编写完成了整个框架和测试用例。

我们进入到当前项目的主目录执行命令：

Testing started at 11:12 上午 ...
/Users/hoou/PycharmProjects/web-unittest/venv/bin/python "/Applications/PyCharm CE.app/Contents/plugins/python-ce/helpers/pycharm/_jb_unittest_runner.py" --path /Users/hoou/PycharmProjects/web-unittest/TestCase/test_search.py
Launching unittests with arguments python -m unittest /Users/hoou/PycharmProjects/web-unittest/TestCase/test_search.py in /Users/hoou/PycharmProjects/web-unittest/TestCase

INFO	2020-04-29 11:12:38,263	[webpage.py:36]	打开网页：https://www.baidu.com


Ran 2 tests in 13.418s

OK

Process finished with exit code 0
INFO	2020-04-29 11:12:38,864	[webpage.py:64]	清空输入框！
INFO	2020-04-29 11:12:39,249	[webpage.py:71]	输入文本：selenium
INFO	2020-04-29 11:12:41,385	[webpage.py:77]	点击元素：('id', 'su')
INFO	2020-04-29 11:12:41,452	[test_search.py:43]	<re.Match object; span=(958, 966), match='selenium'>
INFO	2020-04-29 11:12:42,064	[webpage.py:64]	清空输入框！
INFO	2020-04-29 11:12:42,268	[webpage.py:71]	输入文本：selenium
INFO	2020-04-29 11:12:43,359	[test_search.py:49]	['selenium', 'selenium是什么意思药', 'selenium python', 'selenium面试题']

可以看到两条用例已经执行成功了。

---

生成报告

unittest无法像pytest一样直接添加命令行参数就可以生成报告。

但是可以通过第三方模块HTMLTestRunner_cn去生成报告。我们需要下载该模块去生成报告。

生成的报告结果图：

下载这个模块请加QQ群，在群文件中存储着。

群号在博客下方。

然后将下载的HTMLTestRunner_cn.py文件放在项目的tools目录。

---

发送邮件

当项目执行完成之后，需要发送到自己或者其他人邮箱里查看结果。

我们编写发送邮件的模块。

在tools目录中新建send_mail.py文件

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys

sys.path.append('.')
import os
import conf
import smtplib
from email.header import Header
from email.mime.text import MIMEText
from email.utils import parseaddr, formataddr
from email.mime.multipart import MIMEMultipart


def get_new_report():
    """获取最新的报告"""
    report_path = os.listdir(conf.REPORT_PATH)
    report_new_path = sorted(report_path, key=lambda x: os.path.getmtime(os.path.join(conf.REPORT_PATH, x)))
    report_new_file = os.path.join(conf.REPORT_PATH, report_new_path[-1])
    with open(report_new_file, encoding='utf-8') as f:
        return f.read()


def _format_addr(s):
    """格式化邮件地址"""
    name, addr = parseaddr(s)
    return formataddr((Header(name, 'utf-8').encode(), addr))


def send_report_mail():
    """发送最新的测试报告"""
    # email地址和口令：
    user = conf.EMAIL_INFO['username']
    pwd = conf.EMAIL_INFO['password']
    # 收件人地址
    to_addr = conf.ADDRESSEE
    # SMTP服务器地址
    smtp_server = conf.EMAIL_INFO['smtp_host']
    smtp_port = conf.EMAIL_INFO['smtp_port']
    try:
        # 初始化邮件对象
        msg = MIMEMultipart()
        msg['From'] = _format_addr("selenium爱好者<%s>" % user)
        msg['To'] = _format_addr('管理员 <%s>' % ','.join(to_addr))
        msg['Subject'] = Header("unittest演示测试最新的测试报告", 'utf-8').encode()

        # 发送HTML文件
        msg.attach(MIMEText(get_new_report(), 'html', 'utf-8'))

        # 发件人邮箱中的SMTP服务器，端口
        with smtplib.SMTP_SSL(smtp_server, smtp_port) as server:
            # 括号中对应的是发件人邮箱账号、邮箱密码
            server.login(user, pwd)
            # 括号中对应的是发件人邮箱账号、收件人邮箱账号、发送邮件
            server.sendmail(user, to_addr, msg.as_string())
        print("测试结果邮件发送成功！")
    except smtplib.SMTPException as e:
        print(u"Error: 无法发送邮件", format(e))


if __name__ == '__main__':
    print(get_new_report())
    send_report_mail()

执行该文件：

/Users/hoou/PycharmProjects/web-unittest/venv/bin/python /Users/hoou/PycharmProjects/web-unittest/tools/send_mail.py
/Users/hoou/PycharmProjects/web-unittest/report/20200429_105803.html
测试邮件发送成功！

Process finished with exit code 0

可以看到测试报告邮件已经发送成功了。

---

整合执行

最后我们需要对元素审查和发送邮件进行整合运行。

我们在项目目录下创建run_case.py文件作为项目的运行文件。

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import sys

sys.path.append('.')
import os
import conf
import unittest
from tools.send_mail import send_report_mail
from tools.times import datetime_strftime
from tools.HTMLTestRunner_cn import HTMLTestRunner

discover = unittest.defaultTestLoader.discover(conf.TEST_SUITES, pattern="test*.py")


def report_path():
    """报告文件"""
    if not os.path.exists(conf.REPORT_PATH):
        os.makedirs(conf.REPORT_PATH)
    return os.path.join(conf.REPORT_PATH, '{}.html'.format(datetime_strftime("%Y%m%d_%H%M%S")))


if __name__ == "__main__":
    try:
        with open(report_path(), 'wb+') as fp:
            runner = HTMLTestRunner(stream=fp,
                                    title="测试结果",
                                    description="用例执行情况",
                                    verbosity=2,
                                    retry=1,
                                    save_last_try=True)
            runner.run(discover)
    except Exception as e:
        print("用例执行失败:{}".format(e))
    else:
        send_report_mail()

创建完成后执行该文件，在控制台可以看到成功运行了，打开邮箱。

成功收到了邮件，只是样式丢失了。

这个unittest框架的selenium—demo项目就算是整体完工了。

---

开源地址

为了方便学习交流，本次的示例项目已经开源在coding.net ：

https://sesshomaruling.coding.net/p/web-unittest/d/web-unittest/git

---

参考文献

• 《Selenium自动化测试 基于 Python 语言》

• 《Selenium WebDriver 3.0 自动化测试框架实战指南》

喜欢python自动化测试或正在学习自动化测试的同学 欢迎加入我的QQ群:299524235(python自动化测试学习)