用Pytest+Allure+Jenkins实现Web自动化集成测试

前言

今天我们来讲讲Pytest Allure Jenkins实现Web自动化集成测试，喜欢的小伙伴记得点赞哟。

Pytest介绍

pytest是一个非常成熟的全功能的Python测试框架，主要有以下几个特点：简单灵活、容易上手、文档丰富；支持参数化，可以细粒度地控制被测用例；能够支持简单的单元测试和复杂的功能测试，还可以用来做Web自动化(selenium)、APP自动化(appium)以及接口自动化(pytest requests)；pytest具有很多第三方插件，并且可以自动以扩展，比较好用的如pytest-html(完美html测试报告生成)、pytest-rerunfailures(失败用例重复执行)、pytest-xdist(多CPU分发)等；测试用例的skip和xfail处理；可以很好的和CI工具结合，如：Jenkins。

Pytest安装

直接在命令窗口执行以下命令即可，更多信息可查阅官方文档

1.  
   pip install pytest # 安装pytest
2.  
   pytest --version # 查看pytest版本

直接在PyCharm中安装，下面提到的使用pip安装方式都可以直接在PyCharm中安装，安装成功后点击【OK】

PyCharm中设置使用pytest

由于PyCharm默认使用Unitest，所以安装pytest后需要更改默认值，配置路径如下

配置路径：依次点击【File】→【Settings】→【Tools】→【Python Integrated Tools】，【Default test runner】选择“pytest”，然后点击【Apply】→【OK】，就可以使用Pytest啦
 

Pytest使用方法

Pytest规则

编写pytest测试用例默认使用以下规则，当然，规则是可以修改的

• 测试文件以test_开头或者以_test结尾
• 测试类以Test开头，且类中不能包含__init__方法
• 测试函数/方法以test_开头
• 断言使用基本的assert即可

修改规则需添加配置文件pytest.ini，它是pytest的主配置文件，可以修改pytest的默认行为，此文件放在项目的根目录下才会生效（除非指定目录查找配置文件），如下配置，注意：实际配置文件中不可出现中文、冒号、引号等

1.  
   [pytest]
2.  
   python_files = test_*.py *_test.py case_* # 添加以case_*开头的测试模块
3.  
   python_classes = Test* *_case* # 添加以*_case结尾的测试类
4.  
   python_functions = test_* case_* # 添加以case_*开头的测试函数
5.  
   testpaths = testcases # 指定测试目录，是指以testpaths所在目录为基准的相对路径
6.  
   addopts = -vs -l # 将常用命令参数设为默认，省去重复输入的工作
7.  
   norecursedirs = .* build dist CVS _darcs {arch} *.egg src # 指定pytest忽略查找某些目录，多个目录之间空格隔开
8.  
   log_cli = True # 控制台实时输出日志
9.  
    
10.  
    # 注册mark标记
11.  
    markers =
12.  
    smoke : smoke tests as smoke
13.  
    output : print

Pytest标记

上面的配置文件中提到了标记，又如何使用呢？

• 默认情况下，pytest会递归查找当前目录下所有以test开头或结尾的Python脚本，并执行文件内所有以test开头的函数和方法。工作中由于功能尚未实现、挑选用例执行冒烟测试等原因，只想测试指定用例，在pytest中有几种方法可解决
• 显式指定函数名，通过::标记，例如：某文件内存在两个类，但一个类尚未完成，只想执行第二个类中的用例，就可指定类执行
• pytest -vs test_learn.py::Testpy2 # 只执行文件中的Testpy2类 pytest -vs test_learn.py::Testpy2::test_method # 只执行文件中Testpy2类下的test_method方法
• 使用模糊匹配，通过-k参数识别关键字，例如：
• pytest -k login test_learn.py # 只执行文件中包含关键字login的用例
• 使用pytest.mark在用例上进行标记，标记需要在pytest.ini文件中配置，配置方法见上文，格式一定要写对，若未配置也可执行，但是会出现警告，配置中冒号前是标记名，冒号后可以理解为标记解释，当然也可以前后一样
• @pytest.mark.check # 在函数上设置标记 def test_func1(self): assert 1 == 1 @pytest.mark.output # 在类上面设置标记，对类中所有方法都有效 class caseCls(object): def dyd_case(self): @pytest.mark.smoke def test_func1(self): # 在类中的方法上设置标记 print("这是Pytest")
• 执行带有标记的函数，使用-m参数
• pytest -m check test_learn.py # 执行带有check标记的用例，此标记在一个函数上标记了一次，所有只会执行一条用例 pytest -m smoke test_learn.py # 执行带有smoke标记的用例，此标记在一个方法上标记了一次，同样只会执行一条用例 pytest -m output test_learn.py # 执行带有output标记的用例，因为用例在类上，故类中所有的用例都会被执行
   

Pytest运行

1. 通过命令行运行
2. pytest -vs /package_name # 执行包中所有模块的用例 pytest -vs file_name.py # 执行单独的pytest模块，file_name.py文件 pytest -vs file_name.py::class_name # 只执行文件中的class_name类 pytest -vs file_name.py::class_name::method_name # 只执行文件中class_name类下的method_name方法 pytest -vs file_name.py::function_name # 只执行文件中function_name函数
3. pytest命令参数
    

• -v 展示每个测试函数的执行结果（详细信息）
• -q 只显示整体测试结果（简要信息）
• -s 展示测试函数中print()函数输出信息
• -k 只执行包含关键字的用例
• -m 只执行指定标记的用例
• -x 出现失败用例则立即停止执行
• -l 用例失败时打印相关局部变量
• -c 从指定目录加载配置文件，而非自动查找配置文件
• -lf 只执行上次失败的用例，若没有则执行全部用例
• -ff 先执行完上次失败的再执行剩余的用例
• -tb=style 用例失败时错误的详细程度（auto/long/short/line/native/no）
• --maxfail=num 用例允许失败的最大次数，超出则立即停止执行
• --collect-only 收集但不执行用例
• --durations=num -vv 显示设定数值内，按照耗时时长降序打印结果，通常用于调优
• -h，--help 帮助
• 通过main方法
• if __name__ == '__main__': pytest.main(["-sv", "file_name.py"]) # 通过main函数执行

示例：

1.  
   # 文件名称命名规则，以test_开头或_test结尾
2.  
   import pytest
3.  
   def test_func(): # 通常在类外面称为函数，函数命名规则，以test_开头
4.  
   assert 1 == 1
5.  
   class Testpy(object): # 类命名规则，以Test开头
6.  
   def test_method(self): # 通常在类中称为方法，方法命名规则与函数一样，以test_开头
7.  
   assert 1 2 == 3
8.  
   @pytest.mark.smoke
9.  
   def test_func1(self):
10.  
    print("这是Pytest")
11.  
    @pytest.mark.smoke
12.  
    class caseCls(object):
13.  
    def dyd_case(self):
14.  
    print("修改函数后的规则后")
15.  
    if __name__ == '__main__':
16.  
    pytest.main(["test_learn.py"]) # 通过main函数执行命令

使用命令执行示例中的用例

1.  
   pytest ../Pytest # 执行包中所有模块的用例
2.  
   pytest -vs test_learn.py # 执行单独的pytest模块，test_learn.py文件
3.  
   pytest -vs test_learn.py::Testpy # 只执行文件中的Testpy类
4.  
   pytest -vs test_learn.py::Testpy::test_method # 只执行文件中Testpy类下的test_method方法
5.  
   pytest -vs test_learn.py::test_function # 只执行文件中test_function函数
6.  
   pytest -m smoke test_learn.py # 执行带有smoke标记的用例
7.  
   pytest -k dyd test_learn.py # 只执行包含关键字dyd的用例
8.  
   pytest --maxfail=2 test_learn.py # 执行指定文件中的用例，失败用例超出2条则停止执行
9.  
   pytest --collect-only test_learn.py # 收集指定文件中的用例，不加文件名则直接搜索当前目录下所有用例

Pytest参数化

在pytest中，可以使用参数化测试，即每组参数都独立执行一次

使用参数化装饰器pytest.mark.parametrize(argnames,argvalues)，参数化的名字要与方法中的参数名一个一个地对应，传递多个参数时可使用列表、元组、字典或列表嵌套等，实际工作中还是以json、yaml、excel等文件形式做参数化的较多，后续再介绍，示例如下：

1.  
   import pytest # 导入pytest包
2.  
    
3.  
   list = [1,"1 1","1 2"] # 列表
4.  
   # ↓参数必须与值的个数相等，可使用ids参数重命名，名字方便理解其意思即可，ids的个数要等于传递的数据个数
5.  
   @pytest.mark.parametrize("value",list,ids=["value=1","value=2","value=3"])
6.  
   def test_list(value):
7.  
   print(value) # 打印三个结果
8.  
    
9.  
   tuple = [("abc"),("def"),["g","h","i"],[1,2,3]] # 元组
10.  
    @pytest.mark.parametrize("x,y,z",tuple) # 参数必须与值的个数相等
11.  
    def test_xzy(x,y,z):
12.  
    print(x,y,z) # 打印四个结果
13.  
     
14.  
    @pytest.mark.parametrize("input,expect",[("1 1",2),("2 2",4)])
15.  
    def test_count(input,expect):
16.  
    assert eval(input) ==expect # 估算实际结果是否与期望结果一致，打印两个结果
17.  
     
18.  
    dict = ({"username":"dyd","passwd":123456},{"phone":18888888888,"age":18}) # 字典
19.  
    @pytest.mark.parametrize("dic",dict)
20.  
    def test_dict(dic):
21.  
    print(dic) # 打印两个结果
22.  
     
23.  
    data = [ # ↓通过pytest中的param定义参数，id是对参数的一个说明，可自定义，方便理解各用例的含义即可
24.  
    pytest.param(100,100,200,id="a b:pass"),
25.  
    pytest.param("a","b","ab",id="a b:pass"),
26.  
    pytest.param(1,1,6,id="a b:fail")]
27.  
    def add(a,b): # 定义一个add相加的函数
28.  
    return a b
29.  
    class TestParam(object):
30.  
    @pytest.mark.parametrize("a,b,expect",data)
31.  
    def test_param(self,a,b,expect):
32.  
    assert add(a,b) == expect # 调用a b，判断实际结果是否与期望结果一致，出现三个结果
33.  
     
34.  
    @pytest.mark.parametrize("x",(1,2,3))
35.  
    @pytest.mark.parametrize("y",(4,5,6))
36.  
    def test_dkej(x,y):
37.  
    print(f"打印组合方式：({x},{y})") # 通过参数化实现笛卡尔积

Setup与teardown

在执行用例时，可能某些操作只需要进行一次，比如打开浏览器，或者每次操作前都需要先执行其它操作，比如查看数据前需要连接数据库，查看后需要断开数据库等，类似的操作可以使用以下几种setup/teardown进行配置与销毁

• 模块级 setup_module/teardowm_module 开始于模块始末，全局的
• 函数级 setup_function/teardown_function 只对函数用例生效（在类外）
• 类级 setup_class/teardown_class 只在类中前后运行一次（在类中）
• 方法级 setup_method/teardown_method 类中的每个方法执行前后（在类中）
• 类中的 setup/teardown 运行在调用方法前后（常用）

下面是使用方法简单示例，setup/teardown并非必须成对使用，比如连接数据库后不想断开，就可以只使用setup

1.  
   def setup_module():
2.  
   print("setup_模块级")
3.  
   def teardown_module():
4.  
   print("teardown_模块级")
5.  
   …… setup_function/teardown_function
6.  
   def test_01():
7.  
   print("测试01")
8.  
   def test_02():
9.  
   print("测试02")
10.  
     
11.  
    class Testcase01(object):
12.  
    @classmethod
13.  
    def setup_class(cls):
14.  
    print("setup_类")
15.  
    def teardown_class(cls):
16.  
    print("teardown_类")
17.  
    …… setup_method/teardown_method
18.  
    …… setup/teardown
19.  
    def test_03(self):
20.  
    print("测试03")
21.  
    def test_04(self):
22.  
    print("测试04")

下面是两个函数test_01、02和两个方法test_03、04，在配置setup和teardown后运行的结果，从结果中可以看出它们的层级关系

1.  
   setear_test.py::test_01
2.  
   setup_模块级
3.  
   setup_函数
4.  
   测试用例01 PASSED
5.  
   teardown_函数
6.  
    
7.  
   setear_test.py::test_02
8.  
   setup_函数
9.  
   测试用例02 PASSED
10.  
    teardown_函数
11.  
     
12.  
    setear_test.py::Testcase01::test_03
13.  
    setup_类
14.  
    setup_方法
15.  
    setup
16.  
    测试用例03 PASSED
17.  
    teardown
18.  
    teardown_方法
19.  
     
20.  
    setear_test.py::Testcase01::test_04
21.  
    setup_方法
22.  
    setup
23.  
    测试用例04 PASSED
24.  
    teardown
25.  
    teardown_方法
26.  
    teardown_类
27.  
    teardown_模块级

Pytest fixture

上面setup/teardown可实现的功能，fixture可以更灵活的实现

定义fixture和定义普通函数差不多，唯一区别是在函数上加上个装饰器@pytest.fixture()

为了跟用例有所区分，fixture命名时不要以test开头，fixture是有返回值的，若没有返回值则默认为None

用例调用fixture的返回值，直接把fixture的函数名当作变量名

1.  
   import pytest
2.  
   @pytest.fixture() # 默认范围为函数级(function)
3.  
   def login():
4.  
   print("请先登录")
5.  
   return
6.  
   def test_Search(): # 不需要登录，所以不调用fixture
7.  
   print("搜索商品，无需登录")
8.  
   def test_Cart(login): # 需要登录，调用fixture
9.  
   print("加购商品，需登录")
10.  
     
11.  
    @pytest.fixture(scope="class") # 设置范围为类级(class)
12.  
    def login():
13.  
    print("请登录后再购买")
14.  
    return
15.  
    class Testfix(object):
16.  
    def test_Look(self):
17.  
    print("查看商品，无需登录") # 不需要登录，所以不调用fixture
18.  
    def test_Pay(self,login):
19.  
    print("购买商品，需登录") # 需要登录，调用fixture

输出结果如下，控制范围(scope)还有module，package，session，以及其它参数如：param、ids、name等

1.  
   test_fix.py::test_Search
2.  
   搜索商品，无需登录 PASSED
3.  
   test_fix.py::test_Cart
4.  
   请登录后再购买
5.  
   加购商品，需登录 PASSED
6.  
    
7.  
   test_fix.py::Testfix::test_Look
8.  
   查看商品，无需登录 PASSED
9.  
   test_fix.py::Testfix::test_Pay
10.  
    请登录后再购买
11.  
    购买商品，需登录 PASSED

再介绍一下session级别，它是可以跨.py模块调用的，也就是说有多个.py文件的测试用例时，只需调用一次fixture，设置scope="session"，并写在conftest.py文件中，conftest.py文件是固定名称，pytest会自动识别此文件，所以不可改名称，此文件放在项目根目录，则可全局调用，放在某个包中，则只对包内的有效

比如使用钩子函数实现失败用例截图，将以下代码写在conftest.py中，其它模块就可以直接调用

1.  
   import allure
2.  
   import pytest
3.  
   from selenium import webdriver
4.  
    
5.  
   driver = None # 自定义一个driver=None
6.  
   @pytest.hookimpl(tryfirst=1,hookwrapper=1)
7.  
   def pytest_runtest_makereport(item,call): # 钩子函数
8.  
   # 用例执行完成后再执行此操作，（后置处理用yield）
9.  
   outcome = yield # 测试用例执行完后接下来要做什么事情
10.  
    rep = outcome.get_result() # 获取用例执行完成之后的结果
11.  
    if rep.when == "call" and rep.failed: # 若结果正在被调用而且是失败的则进行截图
12.  
    img = driver.get_screenshot_as_png() # 若出现异常，则进行截图操作
13.  
    allure.attach(img, "失败截图", allure.attachment_type.PNG) # 将图片展现在Allure报告上
14.  
     
15.  
    # 自定义一个Fixture，初始化driver对象
16.  
    @pytest.fixture(scope="session",autouse=True)
17.  
    def init_driver():
18.  
    global driver
19.  
    driver = webdriver.Chrome()
20.  
    return driver # 返回初始化后的driver，就可以直接被调用啦

调用conftest.py中的函数

1.  
   def test_百度(init_driver):
2.  
   init_driver.get("http://百度.com")
3.  
   init_driver.find_element(By.CLASS_NAME, "123").click()
4.  
   ……

Pytest Allure

Allure安装

Allure运行需要Java环境，Java安装并配置环境变量后，在命令窗口执行以下命令，更多信息可查阅官方文档

pip install allure-pytest

安装完成后，下载一个allure可执行文件，点击此次进入下载列表页，下载所需版本，下载后解压文件，然后将bin目录加到PATH环境变量中，最后在命令行窗口输入allure或者allure --version验证是否配置成功

Allure用例描述

Allure报告生成

生成测试报告必须在命令行执行

• 生成中间结果，使用下面的命令指定结果生成到的目录，生成结果中包含两个格式文件(text、json)
• pytest --alluredir=./result --clean-alluredir # 将包中所有模块的用例生成报告并清除之前的报告 pytest --alluredir=./result test_Jpress.py # 将指定的文件生成报告 pytest --alluredir=./result test_Jpress.py::TestUser# 将指定文件中的类生成报告 …… # 可以指定方法或使用标记等生成报告
• 中间结果无法直接查看，执行下面命令启动Allure查看HTML报告
• allure serve ./result
• 也可以直接生成可在线访问的HTML结果
• allure generate ./result -o ./report --clean-alluredir # 可以加上--clean-alluredir参数，表示若指定目录已存在则先清空此目录 # 也可以加上--allure-no-capture，表示无需将pytest捕获的日志记录(logging)、标准输出(stdout)、标准错误(stderr)附加到报告中
   

示例如下：

1.  
   from selenium import webdriver
2.  
   from selenium.webdriver.common.by import By
3.  
   from selenium.webdriver.support import expected_conditions as EC
4.  
   from selenium.webdriver.support.wait import WebDriverWait
5.  
   import pytest
6.  
   import allure
7.  
   from util import util # 导入自己封装的日志模块
8.  
    
9.  
   loginError = [["","654321","账号不能为空"],["test","123456","用户名不正确。"],
10.  
    ["admin","","密码不能为空"],["admin","654321","用户名或密码不正确"]]
11.  
    loginOK = [["admin","123456","用户中心"]]
12.  
     
13.  
    @allure.feature("Jpress后端测试")
14.  
    class TestUser(object):
15.  
    def setup_class(self):
16.  
    self.driver = webdriver.Chrome()
17.  
    self.driver.maximize_window()
18.  
    self.driver.get("http://192.166.66.22:8080/user/login")
19.  
    self.logger = util.get_logger()
20.  
    self.logger.info("登录测试")
21.  
     
22.  
    @allure.story("这是登录失败的测试用例")
23.  
    @allure.description("登录平台-错误场景")
24.  
    @pytest.mark.parametrize("username,pwd,expected",loginError)
25.  
    def test_user_login_Error(self,username,pwd,expected):
26.  
    user = username
27.  
    pwd = pwd
28.  
    expected = expected
29.  
     
30.  
    # 清空输入框后输入用户名
31.  
    self.driver.find_element(By.NAME, "user").clear()
32.  
    self.driver.find_element(By.NAME, "user").send_keys(user)
33.  
    # 清空输入框后输入密码
34.  
    self.driver.find_element(By.NAME, "pwd").clear()
35.  
    self.driver.find_element(By.NAME, "pwd").send_keys(pwd)
36.  
    # 点击【登录】
37.  
    self.driver.find_element(By.CLASS_NAME, "btn").click()
38.  
    WebDriverWait(self.driver, 3).until(EC.alert_is_present())
39.  
    alert = self.driver.switch_to.alert
40.  
    # 验证报错信息是否正确
41.  
    assert alert.text == expected
42.  
    self.logger.debug("登录失败，用户名或密码输出有误！")
43.  
    alert.accept()
44.  
     
45.  
    @allure.story("后台管理平台登录失败")
46.  
    @allure.description("记录失败时的截图和日志")
47.  
    def test_failcase(self):
48.  
    self.driver = webdriver.Chrome()
49.  
    self.driver.get("http://192.166.66.22:8080/admin/login")
50.  
    self.driver.find_element(By.NAME, "user").send_keys("admin")
51.  
    self.driver.find_element(By.NAME, "pwd").send_keys("123456")
52.  
    self.driver.find_element(By.NAME, "captcha").send_keys(8888)
53.  
    try:
54.  
    self.driver.find_element(By.CLASS_NAME, "btn错误的登录按钮元素").click()
55.  
    except Exception as e:
56.  
    img = self.driver.get_screenshot_as_png() # 若出现异常，则进行截图操作
57.  
    allure.attach(img, "失败截图", allure.attachment_type.PNG) # 将图片展示在Allure报告上
58.  
    log = self.logger.error("报错信息:%s", "无法登录，找不到登录按钮", exc_info=1) # 记录报错日志
59.  
    # 获取报错日志，并将日志展示在Allure报告上
60.  
    allure.attach.file(self.driver.get_log(log), "失败日志", allure.attachment_type.TEXT)
61.  
    WebDriverWait(self.driver, 3).until(EC.alert_is_present())
62.  
    alert = self.driver.switch_to.alert
63.  
    assert alert.text == "登录失败"
64.  
     
65.  
    @allure.story("这是登录成功用例")
66.  
    @allure.description("成功登录至平台")
67.  
    @allure.severity(severity_level="Blocker")
68.  
    @pytest.mark.parametrize("username,pwd,expected",loginOK)
69.  
    def test_user_login_OK(self,username,pwd,expected):
70.  
    user = username
71.  
    pwd = pwd
72.  
    expected = expected
73.  
     
74.  
    self.driver.find_element(By.NAME, "user").clear()
75.  
    self.driver.find_element(By.NAME, "user").send_keys(user)
76.  
    self.driver.find_element(By.NAME, "pwd").clear()
77.  
    self.driver.find_element(By.NAME, "pwd").send_keys(pwd)
78.  
    self.driver.find_element(By.CLASS_NAME, "btn").click()
79.  
    WebDriverWait(self.driver, 3).until(EC.title_is(expected))
80.  
    assert self.driver.title == expected
81.  
     
82.  
    @allure.story("文章管理测试用例")
83.  
    @allure.title("查看文章列表")
84.  
    @allure.step("步骤1：进入文章列表")
85.  
    def test_article_list(self):
86.  
    expected = "http://192.166.66.22:8080/ucenter/article"
87.  
    self.driver.find_element(By.XPATH,'//span[contains(text(),"我的文章")]').click()
88.  
    self.driver.find_element(By.LINK_TEXT,"文章列表").click()
89.  
    WebDriverWait(self.driver, 2).until(EC.url_contains("/ucenter/article"))
90.  
    assert self.driver.current_url == expected
91.  
     
92.  
    @allure.story("文章管理测试用例")
93.  
    @allure.title("查看文章详情")
94.  
    @allure.step("步骤2：查看文章详情")
95.  
    @allure.severity(severity_level="critical")
96.  
    def test_Look_article(self):
97.  
    expected = "一个小测试"
98.  
    handle = self.driver.current_window_handle # 获取当前窗口句柄
99.  
    self.driver.find_element(By.LINK_TEXT, "一个小测试").click()
100.  
     handles = self.driver.window_handles # 获取所有窗口句柄
101.  
     for newhandle in handles: # 对窗口进行遍历
102.  
     if newhandle != handle: # 判断当前窗口是否为新窗口
103.  
     self.driver.switch_to.window(newhandle) # 切换到新打开的窗口
104.  
     WebDriverWait(self.driver, 2).until(EC.title_is(expected))
105.  
     assert self.driver.title == expected
106.  
     # 关闭浏览器
107.  
     self.driver.quit()
108.  
      
109.  
     @allure.feature("Jpress前端测试")
110.  
     class TestBlog(object):
111.  
     def setup_class(self):
112.  
     self.driver = webdriver.Chrome()
113.  
     self.driver.maximize_window()
114.  
     self.driver.get("http://192.166.66.22:8080/")
115.  
     self.logger = util.get_logger()
116.  
     self.logger.info("博客访问测试")
117.  
      
118.  
     @allure.title("查看博客详情")
119.  
     @pytest.mark.skipif(reason="刻意跳过此用例")
120.  
     def test_details(self):
121.  
     expected = "一个小测试"
122.  
     self.driver.find_element(By.CLASS_NAME,"bh-card-main-title").click()
123.  
     WebDriverWait(self.driver, 2).until(EC.url_contains("/article/2"))
124.  
     assert self.driver.title == expected
125.  
     # 关闭浏览器
126.  
     self.driver.quit()

下图是生成的Allure报告用例执行结果

数据驱动测试(DDT)

读取excel文件

需要安装xlrd模块，使用xlrd模块处理excel文件，新版xlrd不支持xlsx格式的excel，会报错xlrd.biffh.XLRDError: Excel xlsx file; not supported，可以使用xls格式的excel，或者可以安装老版本的xlrd
 

pip install xlrd==1.2.0    # 此版本支持xlx格式的excel

结合pytest的参数化的方式，实现excel文件数据驱动，示例如下：

1.  
   import pytest
2.  
   import xlrd
3.  
    
4.  
   def get_data(): # 定义一个获取数据的函数
5.  
   filename = "my_data.xlsx" # 定义数据文件
6.  
   wb = xlrd.open_workbook(filename) # 打开文件
7.  
   sheet = wb.sheet_by_index(0) # 使用索引方式获得文件中的第一个sheet
8.  
   rows = sheet.nrows # 获取行
9.  
   cols = sheet.ncols # 获取列
10.  
    lst = []
11.  
    for row in range(rows): # 遍历行
12.  
    for col in range(cols): # 遍历列
13.  
    cell_data = sheet.cell_value(row,col) # 获取单元格中的数据
14.  
    lst.append([cell_data]) # 将单元格中的数添加到列表中
15.  
    return lst # 返回list列表
16.  
     
17.  
    @pytest.mark.parametrize("value",get_data()) # 调用excel数据
18.  
    def test_read(value):
19.  
    print(value)
20.  
    # 输出结果，2*2的表格，打印每个单元格中的数据
21.  
    test_excel.py::test_read[value0] PASSED [ 25%]['xlsx']
22.  
    test_excel.py::test_read[value1] PASSED [ 50%]['格式']
23.  
    test_excel.py::test_read[value2] PASSED [ 75%]['读取文件']
24.  
    test_excel.py::test_read[value3] PASSED [100%]['666']

读取csv文件

csv文件是使用逗号分隔的文本文件，直接使用python的csv模块处理csv文件，然后结合pytest的参数化的方式，实现csv文件数据驱动，

示例如下：

1.  
   # 测,试
2.  
   # ceshi,testing
3.  
   import csv
4.  
   import pytest
5.  
    
6.  
   def get_data():
7.  
   with open("my_data.csv","r",encoding='UTF-8') as j: # 只读模式打开csv文件
8.  
   data = csv.reader(j) # csv.reader(f)返回一个csv_reader对象
9.  
   lst = []
10.  
    for row in data: # 遍历对象，每次返回一行
11.  
    lst.extend(row) # 将数据一次性追加到lst中，将结果写到一个列表中
12.  
    return lst # 返回lst
13.  
     
14.  
    @pytest.mark.parametrize("csv_value",get_data()) # 调用csv数据
15.  
    def test_read(csv_value):
16.  
    print(csv_value) # 将写在列表中的数据一个一个的输出
17.  
    # 输出结果
18.  
    test_csv.py::test_read[\u6d4b] PASSED [ 25%]测
19.  
    test_csv.py::test_read[\u8bd5] PASSED [ 50%]试
20.  
    test_csv.py::test_read[ceshi] PASSED [ 75%]ceshi
21.  
    test_csv.py::test_read[testing] PASSED [100%]testing

读取json文件

直接使用python中的json模块处理json文件，然后结合pytest的参数化方式，实现json文件数据驱动

json文件内容

1.  
   [
2.  
   {
3.  
   "name":"",
4.  
   "pwd":"654321",
5.  
   "expected":"账号不能为空"
6.  
   },
7.  
   {
8.  
   "name":"admin",
9.  
   "pwd":"",
10.  
    "expected":"密码不能为空"
11.  
    },
12.  
    {
13.  
    "name":"admin",
14.  
    "pwd":"654321",
15.  
    "expected":"用户名或密码不正确"
16.  
    }
17.  
    ]

示例如下：

1.  
   import pytest
2.  
   import json
3.  
   from selenium import webdriver
4.  
   from selenium.webdriver.common.by import By
5.  
   from selenium.webdriver.support.wait import WebDriverWait
6.  
   from selenium.webdriver.support import expected_conditions as EC
7.  
    
8.  
   def get_data():
9.  
   lst = []
10.  
    with open("my_data.json","r",encoding='UTF-8') as j: # 只读模式打开json文件
11.  
    dict_data = json.loads(j.read()) # 将json转换为字典
12.  
    for i in dict_data: # 遍历字典
13.  
    lst.append(tuple(i.values())) #将数据以元组形式添加到lst中
14.  
    return lst # 返回lst
15.  
     
16.  
    # 此时输出get_data()值，会得到的下面结果
17.  
    [('', '654321', '账号不能为空'), ('admin', '', '密码不能为空'), ('admin', '654321', '用户名或密码不正确')]
18.  
     
19.  
    class TestUser(object):
20.  
    def setup_class(self):
21.  
    self.driver = webdriver.Chrome()
22.  
    self.driver.maximize_window()
23.  
    self.driver.get("http://192.166.66.22:8080/user/login")
24.  
     
25.  
    @pytest.mark.parametrize("username,pwd,expected",get_data()) # 调用json数据
26.  
    def test_user_login_Error(self,username,pwd,expected):
27.  
    user = username
28.  
    pwd = pwd
29.  
    expected = expected
30.  
     
31.  
    # 清空输入框后输入用户名
32.  
    self.driver.find_element(By.NAME, "user").clear()
33.  
    self.driver.find_element(By.NAME, "user").send_keys(user)
34.  
    # 清空输入框后输入密码
35.  
    self.driver.find_element(By.NAME, "pwd").clear()
36.  
    self.driver.find_element(By.NAME, "pwd").send_keys(pwd)
37.  
    # 点击【登录】
38.  
    self.driver.find_element(By.CLASS_NAME, "btn").click()
39.  
    # 等待页面加载
40.  
    WebDriverWait(self.driver, 3).until(EC.alert_is_present())
41.  
    alert = self.driver.switch_to.alert
42.  
    # 验证报错信息是否正确
43.  
    assert alert.text == expected
44.  
    alert.accept()

读取yaml文件

先安装yaml模块，然后结合pytest的参数化方式，实现yaml文件数据驱动，和json差不多

pip install pyyaml

yaml文件内容

1.  
   ---
2.  
   name: ""
3.  
   pwd: "123456"
4.  
   expected: "账号不能为空"
5.  
   ---
6.  
   name: "admin"
7.  
   pwd: ""
8.  
   expected: "密码不能为空"
9.  
   ---
10.  
    name: "admin"
11.  
    pwd: "654321"
12.  
    expected: "用户名或密码不正确"

使用yaml验证登录，示例如下：

1.  
   import pytest
2.  
   import yaml
3.  
   from selenium import webdriver
4.  
   from selenium.webdriver.common.by import By
5.  
   from selenium.webdriver.support.wait import WebDriverWait
6.  
   from selenium.webdriver.support import expected_conditions as EC
7.  
    
8.  
   def get_data():
9.  
   lst = []
10.  
    with open("my_data.yaml","r",encoding='UTF-8') as j: # 只读模式打开yaml文件
11.  
    ym = yaml.load_all(j.read()) # 使用load_all生成迭代器
12.  
    for i in ym: # 遍历ym中的数据
13.  
    lst.append(tuple(i.values())) #将数据以元组形式添加到lst中
14.  
    return lst # 返回lst
15.  
     
16.  
    # 此时输出get_data()值，会得到和读取json文件一样的结果
17.  
    [('', '123456', '账号不能为空'), ('admin', '', '密码不能为空'), ('admin', '654321', '用户名或密码不正确')]
18.  
     
19.  
    class TestUser(object):
20.  
    def setup_class(self):
21.  
    self.driver = webdriver.Chrome()
22.  
    self.driver.maximize_window()
23.  
    self.driver.get("http://192.166.66.22:8080/user/login")
24.  
     
25.  
    @pytest.mark.parametrize("username,pwd,expected",get_data()) # 调用yaml数据
26.  
    def test_user_login_Error(self,username,pwd,expected):
27.  
    user = username
28.  
    pwd = pwd
29.  
    expected = expected
30.  
     
31.  
    # 清空输入框后输入用户名
32.  
    self.driver.find_element(By.NAME, "user").clear()
33.  
    self.driver.find_element(By.NAME, "user").send_keys(user)
34.  
    # 清空输入框后输入密码
35.  
    self.driver.find_element(By.NAME, "pwd").clear()
36.  
    self.driver.find_element(By.NAME, "pwd").send_keys(pwd)
37.  
    # 点击【登录】
38.  
    self.driver.find_element(By.CLASS_NAME, "btn").click()
39.  
    # 等待页面加载
40.  
    WebDriverWait(self.driver, 3).until(EC.alert_is_present())
41.  
    alert = self.driver.switch_to.alert
42.  
    # 验证报错信息是否正确
43.  
    assert alert.text == expected
44.  
    alert.accept()

Jenkins集成Allure报告

本次Jenkins是安装在Windows上的，直接Jenkins官网下载安装包进行安装就行啦，不多做介绍

1. Jenkins安装完成后，进入插件管理，安装Allure插件

  2.进入全局配置，配置Allure Commandline，填写本地Allure安装路径，别名自定义，完成后点击【应用】→【保存】

 3.新建一个自由风格的项目

  4.配置项目，在常规配置里点击【高级】，勾选“使用自定义的工作空间”，填写工作空间目录(通常填写项目的主目录)，显示名称自定义

 然后增加构建步骤，选择“执行windows批处理命令”，填写要执行的命令，命令可以指定文件或类等，具体上文有介绍

pytest -vs --alluredir=./pytest_result test_Jpress.py --clean-alluredir

 最后增加构建后操作步骤，选择“Allure Report”，填写结果路径，一定要与构建时的路径相同，然后【应用】→【保存】

 8.在Jenkins页面上会出现Allure报告标识，点击可查看具体构建报告

  报告结果如下图所示

 好了今天的分享就到这了，喜欢的记得关注点赞哟

这些资料，对于想转行做【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！凡事要趁早，特别是技术行业，一定要提升技术功底。希望对大家有所帮助……

这篇好文章是转载于：学新通技术网