Selenium学习笔记

Selenium概述

官方网址：http://www.seleniumhq.org
官方文档：https://www.selenium.dev/selenium/docs/api/py/index.html
官方文档：http://selenium-python.readthedocs.io
中文文档：http://selenium-python-zh.readthedocs.io

环境准备

1.下载python并配置解释器，下载第三方库selenium

pip install selenium 

2.下载驱动
https://chromedriver.chromium.org/downloads

3.将.exe文件放到运行的python文件的Scripts中,或者Scripts同级目录都可以

4.验证

linux无桌面运行web自动化

1. 在服务器中安装谷歌

$ wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb(我是先下载后再上传到linux中去的)
$ sudo dpkg -i google-chrome*.deb # 如果出错，执行下一个命令
$ sudo apt-get install -f

1. 安装Google-chrome驱动
   地址：http://chromedriver.storage.googleapis.com/index.html

# 查看谷歌版本号
$ google-chrome --version
# 安装对应的驱动
$ wget http://chromedriver.storage.googleapis.com/103.0.5060.134/chromedriver_linux64.zip

解压（unzip）chromedriver_linux64.zip并移动到相应的python环境的bin路径下，可以是所用虚拟环境。

3. jenkins创建任务，导入项目代码

4. 配置设置，测试报告插件，html为例。

   • 安装 HTML Publisher 插件，下载groovy插件
   • 添加shell脚本 cd run
     python3 run.py
   • 在项目配置中的build下，点击Add build step，选择groovy选项Execute system Groovy script
     System.setProperty(“hudson.model.DirectoryBrowserSupport.CSP”, “”)
   • 构建后的步骤添加html，配置测试报告目录文件
     
   • 立即构建
   • 在服务器中安装字体（非必须）
     执行自动化测试脚本，带截图时，截图中的中文是方框或乱码，可能是因为服务器没有相应字体。

   $ sudo apt-get install ttf-wqy-microhei ttf-wqy-zenhei xfonts-wqy
   

   • 注意:在linux中python导入其他模块，在run.py中加入

   import sys, os
   demo1_path = os.getcwd()
   sys.path.append(demo1_path)
   

自动化测试技能工具篇

• 单元自动化测试：unitest、pytest、junit、testng
• 功能自动化测试：
  • 接口测试：soupui、postman
  • 接口自动化测试：newman、httprunner、requests、httpclient
  • UI自动化测试：
    • web自动化测试：selenium、selenide
    • app自动化测试：appnium、uiautomator2
    • 其他自动化测试：minium、Robot Framework
• 性能测试：
  • 接口性能测试：jmeter、loadrunner、locust、webbench、abbench
  • web性能测试：jmeter、loadrunner、locust
  • 桌面性能测试：loadrunner
  • 数据库性能测试：sysbench、jmeter
  • 系统性能测试：sysbench
• 其他测试：安全测试、运维测试

操作

结合js修改元素的属性

path = driver.find_element_by_xpath('//*[@id="su"]')
js= 'arguments[0].value="test"'
driver.execute_script(js,path)

unittest

1.python中直接加载了Unittest框架，无须额外安装
2.四大组件：
a. test fixture:setUp、tearDown，用于初始化测试用例测试用例及清理和释放资源
b. test case:通过集成unittest.TestCase实现用例的继承
c. test suite：测试套件，测试用例集
d. test runner： 运行器

用例编写—testcase

1.用例文件夹创建
2.用例类定义
必须继承unittest.TestCase
3.用例方法定义
使用test开头

用例编写—前置后置方法

def setUp(self):用例级别的前置（每条用例执行之前都会执行）

def teatDown(self):用例级别的后置方法（每条用例执行之后都会执行）

@classmethod
def setUpClass(cls):测试类级别的前置方法（整个测试类中的用例执行之前都会执行一次）

@classmethod
def teatDownClass(cls):测试类级别的后置方法（整个测试类中的用例执行之后都会执行一次）

测试套件—TestSuite

创建一个用例套件：suite = unittest.TestSuite()

创建一个用例加载器：loader = unittest.TestLoader()

- 方式一：通过类名进行加载
suite.addTest(loader.loadTestsFromTestCase(类名1))
suite.addTest(loader.loadTestsFromTestCase(类名2))

- 方式二：通过用例模块进行加载
suite.addTest(loader.loadTestsFromModule(模块文件名))

- 方式三：通过用例文件所在路径进行加载
suite.addTest(loader.discover(文件路径,'*',pattern="匹配规则"))
# 默认的匹配规则是test开头

suite = unittest.defaultTestLoader.discover('../case', '*')

获取套件中的用例数量
suite,countTestCases()

用例运行—TestRunner

file = open('../report/hjweb_test_result.html', mode='wb')
runner = HTMLTestReport(file, title="自动化测试报告", description="汇健官网自动化测试，涵盖前后端及交互", tester='IDC毛辉')
runner.run(suite)
file.close()
unittest.main()

# # 将测试用例加载到测试套件中
# runner = BeautifulReport.BeautifulReport(suite)
# runner.report(filename='hjweb_test_result.html',description='汇健官网自动化测试，涵盖前后端及交互',log_path='.',report_dir='../report')

第三方库—unittestreport

• 测试报告

1.安装：https://pypi.org/project/unittestreport/
pip install unittestreport
runner=TestRunner(suite)
runner.run()

• 数据驱动
  https://unittestreport.readthedocs.io/en/latest/doc5_ddt/

• 用例失败重执行
  https://unittestreport.readthedocs.io/en/latest/doc3_rerun/

DDT数据驱动

from ddt import ddt, data, unpack
@ddt  #表示使用ddt进行多数据驱动
class CmsFaultLogin(unittest.TestCase):
    @data(['admin0', '123456'], ['text', '123456'])
    @unpack  #表示解包
    def test019(self, name, pwd):
        pass

断言

常用:
self.assertEqual(实际值,期望值,msg="断言错误时返回的信息")

skip()用法

# 无条件跳过执行该条用例
@unittest.skip('理由是什么')
def test_1():
    pass

# 有条件执行跳过操作
@unittest.skipIf(1<2,'为True时跳过')
def test_2()；
    pass

# 有条件执行跳过操作
@ unittest.skipUnless(1>2,"为false时跳过")
def test_3():
    pass

# 如果用例执行失败，不计入失败的case数中
@ unittest.expectedFailure
def test_3():
    pass

pytest

pip install pytest

用例编写规范

1.模块名必须以test_开头或者以_test结尾，建议test_+业务名称
2.class类名必须以Test开头，建议驼峰命名规则TestXxxx
3.函数方法以test_开头，建议test_+固定位数字+_+业务

运行测试用例

• 命令行运行用例
  1.pytest ./ 运行当前目录及子目录下所有用例
  2.pytest part14 运行指定目录及子目录下所有用例
  3.pytest part14/test_hello.py 指定模块运行
  4.pytest -k ‘answer’ ./ 按关键字匹配运行
  5.pytest part14/test_hello.py::test_answer1 指定函数运行
  6.pytest part14/test_hello.py::TestHello 指定类运行
  7.pytest part14/test_hello.py::TestHello::test_answer3 指定类方法运行
  8.pytest --pyargs part14.test_hello 通过包运行
  pytest命令等价于python -m pytest

• 运行命令参数
  -v 详细输出
  -s 调试输出，等价于–capture==no
  -k ‘method1 or method2’ 执行名称中包含指定的键字（支持and or not）
  -x 在第一次失败后停止，等价于pytest --exitfirst
  –maxfail=n 在第n次失败后停止
  -m 通过标志表达式运行
  –capture=no 支持’fd’,‘sys’,‘tee-sys’,–capture=no等价于-S
  –cache-show 显示当前缓存
  –cache-clear 清空当前缓存
  –if 重跑上次失败用例，等价于–last-failed
  –collect-only 收集测试用例（不执行）
  –durations=10 --durations-min=1.0 收集时间大于1秒的top10用例
  -n=2 多线程运行（依赖于插件）

• 通过主函数与运行
  pytest.main()
  pytest.main 同样支持添加参数
  pytest.main([“-vs”]) == pycharm中pytest.main([“-vs”,“./”])
  pytest.main([“-vs”,“-n=2”])
  不同的编辑器，默认的相对路径不同，所以导致找到的路径不同，所以如果需要运行某一文件,os.getCwd()在vscode和pycharm中不同

if __name__=="__main__"
    # 采用动态路径加载为最佳
    pytest.main(["-vs",___file___])

- 用例执行顺序
与是函数还是类无关，用例按代码顺序从上到下执行

固件运行顺序

**fixture

概述

1.与setup、teardown类似，提供了测试执行前和执行后的动作处理。
2.fixture通过yield来区分前后置，前后置可以单独存在；fixture如果有后置，都会执行后置（除了前置报错）
3.fixture可用于封装数据，也可用于封装逻辑动作，使用范围广
4.fixture可用于代码模块化、数据处理、流程设计等

fixture执行方式

1.函数引用/显示引用

def test_data(init_data):
    pass

2.自动适配（影响所有用例）

@pytest.fixture(autouse=True)
def init_data():
    print("before")
    yield 10
    Print("after")

3.usefixture手动调用（可以多个调用）

@pytest.mark.usefixture("init_data","init+data1")
def test_01_data():
    pass

fixture作用域

function:每一个测试用例（包括函数和方法）都会执行一次，默认作用域
class: 每一个测试类都会执行一次
module： 每一个py文件都会执行一次
package：每一个python包都会执行一次
session：整个测试都会执行一次
1.执行顺序遵循session->package->module->class->function
2.每一类的fixture可以是多个，同类按书写先后执行
3.模块中的fixture对函数、方法均有效，class中的fixture只对方法有效
4.每一个函数前后均会执行模块中的class
5.在模块和类中有同名的fixture存在时：如果时function，类中会覆盖模块中，其他的不会覆盖

1.在类中我们通常不写session、package、module级别的fixture
2.测试用例我们建议放在类中，但是不绝对
3.实践使用中，建议重点使用session、module、function级，越简单越好

跨模块共享fixture

如果多个模块使用的fixture相同，我们可以将fixture写在一个固定的conftest.py中，这样达到跨模块和文件的效果。
1.文件名称默认为conftest.py
2.conftest.py可以有多个，搜索优先级自低而上，下层会覆盖上层（越靠近执行文件得会覆盖最外层得）
3.conftest.py中得fixture支持函数直接引用、手动调用，也可以自动适配

fixture销毁方式

fixture在场景中，实际代表了数据/动作得前后置处理，比如我们测试用户查询用例中，他们前置动作是往数据库插入用户，那么它必然有删除用户得后置动作（尽可能遵循用例得幂等性）
1.yield方式

@pytest.fixture()
def init_data():
    print("初始化数据")
    yield 10
    print("清空数据")

2.request.addfinalizer方式

@pytest.fixture()
def init_data():
    print("初始化数据")
    def clear():
        print("清空数据")
    request.addfinalizer(clear)
    return 10

均遵循以下规则：
用例如果发生异常，不影响前后置动作得执行；如果前置动作失败，那么后置动作不会执行。
3.fixture的安全销毁
通常我们在设计fixture时，尽量不要把多个改变状态的逻辑设计在同一个fixture中，否则在发生异常时，有可能影响用例的幂等性，同时会生成垃圾数据（前置动作第一个改变成功，第二个改变不成功，那么如果是一个fixture的话，那么后置动作都不会执行。）

fixture标志传参

1.采用pytest.mark.xxx(参数)标志所需要的参数
2.传参的个数可以是多个，类型可以为复杂对象
3.采用request获取参数

@pytest.fixture
def init_data(request):
    marker = request.node.get_closest_marker("data_type")
    if marker is None:
        data=None
    else:
        data = marker.args[0]
    return data
@pytest.mark.data_type(36)
def test_data(init_data):
    assert init ==36

if __name__=="__main__":
    pytes.main(["-vs",__file__])

fixture参数化

datas = {"参数1","参数2","参数3"}
@pytest.fixture(params=datas,ids=[客户1,客户2,客户3])
def init_data(request):
    return request.param

def test_data(init_data):
    print(init_data)

1.fixtur可以通过设计params，将依赖该fixture的用例迭代执行
2.fixture可以互相引用，一个用例也可以引用多个fixture，会出现笛卡尔积现象的引用。

fixture工厂模式

import pytest
@pytest.fixture()
def register():
    def _register(user):
        # 这里书写真实逻辑，调用注册接口，返回结果 
        pass
    return _register

def test_case_01(register):
    """测试多次注册接口案例"""
    # 第一次注册成功
    result1 = register("sober")
    # 第二次注册失败
    result2 = register("sober")

fixture参数总结

scope：fixture作用域级别，function < class < module < package < session
params:用于给fixture传参，可实现数据基于fixture的数据驱动
autouse：是否自动适配
ids：取别名
name：引用名称

主要配置介绍

命令分类

pytest -h
1.命令行参数
2.个性化参数
3.配置参数
可在pytest.ini中配置的参数
4.环境参数

pytest.ini

[pytest]
addopts = -vs -- strict-markers # 运行的参数
norecursedirs = ..              # 表示不访问哪些目录
testpaths = ...                 # 表示访问哪些目录，优先级：默认命令路径>testpaths > norecursedirs

#执行规则的更改（一般默认）
python_classes = Test
python-files = test_*  *_test
python_functions = test_*  check_*


# 注册自定义标志，例如：
markers = 
    login:（）
    order：
    data_type:
    module1：
    module2：
# 1.pytest.ini中最好不要用中文，如果使用的话，大家要将文件编码改成gbk
# 2.所有的自定义标志，最好通过-strict-marker进行授权
# 3.可以对模块、函数、类、方法进行业务标志，一个或多个
# pytestmark = pytest.mark.module1(模块标记)
# @pytest.mark.module 函数、class、方法标志 
# 运行 pytest.main(["-vs","-m not mudule",__file__])

fixture参数化

1.@pytest.fixture():允许对fixture函数进行参数化
2.@pytest.mark.parametrize:允许在测试函数、方法进行参数化
3.Pytes_generate_tests:允许定义自定义参数化方案和拓展

parametrize参数化

• 单个参数
  @pytest.mark.parametrize(“param1”,[1,2,3])
  1.第一个参数为名称，在后面会用到，入param1
  2.第二个参数为值，通常为列表，运行时以列表的长度，对用例进行运行迭代

• 多个参数
  1.@pytest.mark.parametrize(“param1，param2”,[（1+2，3）,（24，6）,（13+1，4）])
  2.@pytest.mark.parametrize((“param1”，“param2”),[（1+2，3）,（24，6）,（13+1，4）])

• parametrize可以双重迭代，嵌套
  两个parametrize装饰器

parametrize参数化与fixture混合

可以做嵌套，双重循环，笛卡尔积

ids别名的使用

@pytest.fixture(params=[1,2,3],ids=["角色1"，"角色2"，"角色3"])
def fixtest(request):
    return request.param

@pytest.mark.parametrize(("param1"，"param2"),[（1+2，3）,（2*4，6）,（13+1，4）]，,ids=["用户1"，"用户2"，"用户3"])
def test_eval(fixtest,param1,param2):
    assert eval(param1)==param2

1.fixture与parametrize均可以使用别名，用法基本一致，均使用ids=
2.如果使用中文，在控制台可能会乱码，在pytest.ini中添加如下代码：disable_test_id_escaping_and_forfeit_all_rights_to_community_support=True

间接参数

@pytest.mark.parametrize("fixt",params)
@pytest.mark.parametrize("fixt",params,indirect=Ture)
第一种使用，fixt就是一个普通的变量
第二种使用，fixt相当于是一个fixture函数，会执行这个函数

# 指定间接参数
@pytest.mark.parametrize("x，y",params,indirect=["x"])
x代表一个函数
y代表普通的变量

mark参数

pytest.param(“1+7”,8,marks=pytest.mark.basic)
执行用例时可以用-m basic执行执行

yaml读取参数

import yaml
def read_yaml()
    with open('./login.yaml','r',encoding="utf-8") as file:
    value=yaml.load(stream=file,Loader=yaml.FullLoader)
    return value

@pytest.mark.parametrize('param',read_yaml)
def test_yaml(param):
    pass

json读取参数

import json
def read_json():
    dict_data={}
    with open('./login.yaml','r',encoding="utf-8") as file
    value=json.load(file)
    return dict_data

csv读取参数

import csv 
def read_csv(filepath):
    item=[]
    a = csv.reader(open(work,"r",encoding="utf-8"))
    for i in a:
        item.append(i)
    return item

POM模式

1.base层，主要封装selenium基础的原生方法、框架方法
2.page层，主要用于存放页面的元素和动作
3.testcase层，测试用例场景
新增：
data层：存放测试数据
场景层：

优点

1.冗余代码少，页面元素定位和业务操作方法分离，使得代码更加清晰，减少冗余代码
2.高可读性，测试方法单独剥离，提高用例的可读性
3.高维护性，针对ui变化频繁的项目和测试步骤的变化，提高用例的可维护。

三种模式

1.pom设计思想是一种顶层设计，决定整个工程代码架构
2.数据驱动是一种面向用例设计，将数据与用例进行剥离
3.关键字驱动一种面向过程设计，将业务逻辑进行解耦

allure

官网文档：https://docs.qameta.io/allure/#_pytest

安装

• 方法一：
  1.进入https://github.com/allure-framework/allure2/releases下载对应的版本
  2.下载解压后，将bin目录添加到path环境变量中
  3.cmd–>allure --version检查是否安装成功
• 方法二：
  1.按照官网进行安装，https://docs.qameta.io/allure/#_get_started

结合allure-pytest

pip install allure-pytest

if __name__ == '__main__':
    # path = os.path.dirname(__file__)
    path = os.path.pardir
    pytest.main(["-vs", "--alluredir="+path+"/my_allure_results","--clean-alluredir", __file__])
    os.system('allure serve ' + path+"/my_allure_results")

Jenkins

持续化集成

持续集成，CI（continuous integration）

持续集成，简单的说就是时刻监控变动，只要出现变动或者或者问题，第一时间通知相关人员

jenkins

jenkins是一个开源软件项目，是基于java开发的一种持续集成工具，用户监控持续重复的工作，旨在提供一个开放易用的软件平台，使软件的持续集成变成可能

jenkins安装

依赖java环境:查看jenkins官网 对jdk版本有相应的要求

1.下载jenkins.war

2.进入jenkins.war所在目录，执行;java –jar Jenkins.war --httpPort=8080（可写可不写）

3.浏览器进入：localhost：8080

4.输入初始的密码

5.下载插件

6.设置初始化的用户信息

7.公司环境一般都是装在服务器的

windows下载jenkins

1.下载jdk：
配置环境变量JAVA_HOME:jdk安装目录；修改path:%JAVA_HOME%\bin,%JAVA_HOME%\jre\bin。
cmd验证：java -version

2.下载tomcat（可以不用）
下载解压。startup.bat
3.下载jenkins

linux下载jenkins

更改jenkins的工作路径

可以在启动之前配置新的环境变量path：JENKINS_HOME；

jenkins中3大重要概念

1.job（任务/工程）
在jenkins平台中，都是以job为单位去完成一件事的。在使用jenkins时，都是会在Jenkins管理界面当中创建一个job/item，在job/item中组织任务

2.plugin（插件）
jenkins提供平台，集成各种插件来完成一个job。想用jenkins来做什么，先找找有没有相应的插件

3.workspace（工作空间）
jenkins是通过文件形式来存储和管理数据的。所以，在安装jenkins，要指定一个jenkins_home目录。所有Jenkins相关的数据都存放在此目录下。

创建使用job应用

1.新建job

2.自定义工作空间

3.输入执行命令：python all.py

4.执行grovy脚本: System.setProperty(“hudson.model.DirectoryBrowserSupport.CSP”, “”)
（不会丢失html样式，但是jenkins重启就没有了）

配置git

Failed to connect to repository : Command “git.exe ls-remote -h – https://github.com/sobermh/database_request_pytest.git HEAD” returned status code 128:
stdout:
stderr: fatal: unable to access ‘https://github.com/sobermh/database_request_pytest.git/’: OpenSSL SSL_read: Connection was reset, errno 10054

可能是：用户凭证不对，注意分支要一致。有的可能是main，有的是master。

集成Allure报告

1.安装allure插件 Allure Jenkins Plugin

2.在【全局工具配置】，配置allure

3.在job配置allure报告:注意！！！！json等文件生成的路径和最后报告查看的路径，不能一样。report路径最好不要变allure-report；result路径是生成json文件的路径。

展示html测试报告

1.安装插件 HTML Publisher

2.下载groovy插件，在项目配置中的build下，点击Add build step，选择groovy选项Execute system Groovy script
System.setProperty(“hudson.model.DirectoryBrowserSupport.CSP”, “”)
3.脚本输入：System.setProperty(“hudson.model.DirectoryBrowserSupport.CSP”, “”)

企业微信实战

1.创建企业微信群管理机器人，获得webhook

2.安装插件：Qy Wechat…

3.在【系统配置】添加webhook地址

4.进入job，添加构建后的操作，配置企业微信通知

集成电子邮件通知

1.安装插件： Email extension…

2.新建一个邮箱：如163，打开POP3和smtp，获得客户端密码

3.在【系统配置】配置邮件的发件人（系统管理员）（只有一个发件人），SMTP服务器，收件人信息。（多个收件人用逗号隔开）

4.进入job，添加构建后操作，配置邮件通知

构建定时任务

构建触发器
Build periodically
日程表
* * * * * MINUTE HOUR DOM MONTH DOW
0-59 0-23 1-31 1-12 0-7（0和7表示周天）
每天晚上20点
0 20 * * *

一周1，3，5晚上20点执行
0 20 * * 1,3,5

每周周一到周五晚上20点执行
0 20 * * 1-5

一周内每2天执行，20点执行一次
0 20 * * * /2

运行python脚本

Build-add构建步骤：

默认的路径在工作路径下。

搭建持续集成的环境

Ubuntu安装Docker

参照官网文档进行下载：https://docs.docker.com/
测试docker是否下载成功：

root@aliyun:/usr/local/bin# docker version

或者运行第一个docker：

root@aliyun:/usr/local/bin# docker run hello-world

出现Hello from Docker!代表成功

Docker镜像加速

阿里云镜像获取地址：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors
，登陆后，左侧菜单选中镜像加速器就可以看到你的专属地址了：

检测是否配置成功：

$ docker info
Registry Mirrors:
    https://reg-mirror.qiniu.com

小白配置jenkins镜像环境

创建jenkins镜像

1.按照jenkins官网文档，安装jenkins镜像
https://www.jenkins.io/zh/download/
2.启动镜像

docker run -it -p 3344:8080 jenkins/jenkins:lts-jdk11

3.访问配置

docker exec -it 4738f0a62349 /bin/bash
# 查看密码
cat /var/jenkins_home/secrets/initialAdminPassword

在jenkins镜像中配置python环境

1. 以root权限进入jenkins容器：

root@aliyun:~# docker exec -it -uroot 4738f0a62349 /bin/bash

2. 前置安装一些软件包

apt-get update # 获取最新的软件包
apt-get upgrade # 升级已安装的软件包
 
# 提前安装，以便接下来的配置操作
 
apt-get -y install gcc automake autoconf libtool make
 
apt-get -y install make*
 
apt-get -y install zlib*
 
apt-get -y install openssl libssl-dev
 
apt-get install sudo

注意:
如果在安装make* 报错的话,不需要管他,继续往下安装

3. 安装python3.10.2

cd /var# 进入jenkins的安装目录（不能进入jenkins_home）
``*(不用进入到jenkins_home下面去创建python3，不然的话，下次重启这个镜像的时候，由于根是jenkins的镜像，所有java_home会发生重置，里面的东西都会消失的。)*``！！！！！！！！！！！！！！！！！！！！！！！！！！
mkdir python3   # 新建一个python3目录
cd python3
apt-get -y install wget
wget https://www.python.org/ftp/python/3.10.2/Python-3.10.2.tgz
tar -zxvf Python-3.10.2.tgz
mv Python-3.10.2 py3.10
cd py3.10

配置环境变量

apt-get -y install vim
vim /etc/profile
#写入以下内容
#Python3.8
export PYTHON_HOME=/var/python3
export PATH=$PATH:$PYTHON_HOME/bin
------------------------------------------
source /etc/profile
echo $PATH  查看环境是否配置成功

./configure --prefix=/var/python3  --with-ssl # 指定安装的目录
make   # 编译
make install  # 安装

4. 添加一些软链接：python3 和pip3

　ln -s /var/python3/bin/python3.10  /usr/bin/python3
　ln -s /var/python3/bin/pip3 /usr/bin/pip3

5. 检查配合的环境

 python3 -V 和 pip3 -V

Jenkins配置

1.创建一个新的任务

• 源码管理，配置gitee的仓库地址，添加Credentials认证信息（注意分支是master还是main）
• 可以配置触发器，定时触发，0 20 * * 3,每个礼拜，礼拜三8点
• linux构建shell脚本：
  cd case
  python3 run.py
• 生成allure，
  需要先下载allure插件，第一个Path为python中写的报告生成的临时文件夹:report/tmp。注意生成allure报告，需要先下载allure压缩工具包，

apt-get install -y lrzsz
rz **/allure-commandline-2.17.2.zip

unzip allure-commandline-2.17.2.zip
vim /etc/profile

# 使环境变量生效
source /etc/profile

# allure_pytest是对allure需要的json文件的生成做的一个插件
pip install  allure_pytest

然后在系统的全局变量中，添加解压的allure的地址

jenkisn的插件

由于是jenkins的镜像，所以在镜像重新构建容器的时候，jenkins_home里面的内容会重置，所以我们把plugins文件用cpoy的方式（硬链接只支持文件）导出在/var 目录下，来保存其在下一次构建时不会消失，我们在启动jenkins时将plugins文件导入到/var/jenkins_home中，实现插件的转移。为什么不做一个数据卷映射到本机呢，因为没必要。关于如何保存jenkins的job构建数据，暂时不知道。

cp -r plugins/ /var/jenkins_plugins

导出配置过的镜像

1. 退出容器 ctrl+p+q
2. 新建一个镜像：docker commit -m=“jenkins and python” -a=“maowansen” 4738f0a62349 jenkins/python:1.0
3. 上传到aliyun

docker login --username=maohui registry.cn-hangzhou.aliyuncs.com

docker tag 23554f052b7f registry.cn-hangzhou.aliyuncs.com/maowansen/maowanseng-jenkins-python:1.0

docker push registry.cn-hangzhou.aliyuncs.com/maowansen/maowanseng-jenkins-python:1.0

编写dockerfile