背景

我们把接口的信息按照规定的格式都维护在excel文件中，通过代码实现调用excel，完成接口的自动化测试。这样，只需要负责人将主要逻辑写好之后，公司其他不会写代码的员工，也可以通过维护excel中的接口数据，完成整体项目的接口自动化。

本篇文章中可能代码会偏多，原谅我文笔不是很好，不知道怎么优化文字描述。。。直接上代码，哈哈哈。。。在写的过程中部分逻辑判断不是很完整，但是主要流程是可以实现的，大家就将就着看吧。

excel数据

excel文件中的数据为下图所示：

简单说明一下：

（1）id : 测试用例的编号，格式尽量为：case_01；

（2）请求名称：自己写，能看明白就行；

（3）url：接口的路径，也可以加上域名，我没写域名，因为域名在代码中配置了，这样可以在不同环境上运行同一套代码；

（4）是否运行：当前用例是否运行；

（5）请求类型：接口的请求方式；

（6）header：当前接口是否需要header；

（7）依赖id：当前接口需要依赖哪个接口，也就是依赖的这个接口的响应结果中的某个字段是当前接口的请求参数；

（8）依赖接口的返回数据：这个后面没有用到，大家自己看情况；

（9）数据依赖字段：依赖的数据字段名；

（10）请求数据：当前接口的请求数据，页面操作之后可在F12中复制即可；

（11）预期结果：可用来做断言

（12）实际结果：写入接口的响应结果，目前也没用，大家自行写入吧

业务流程

业务名称叫散件入库（这是我自己当时公司项目中的）

该业务流程接口有4个：先新增一个散件入库单（接口1），给这个散件入库单添加需要入库的产品（接口2），此时为待提交的状态，然后提交该散件入库单（接口3），提交之后为待审核的状态，再将该散件入库单审核通过（接口4）。其中每个接口都需要token验证，token在代码中使用登录接口单独提取，全局传入。

代码实现

下面是项目下的目录，方便大家看导入的包都在哪找，目录接口其实也不是特别的合理，大家按照自己项目中的习惯排列就好。

封装的请求函数send_requests.py

1. import requests

3. '''封装一个接口请求方法'''

5. def send_requests(method, url, data=None, header=None):

6. result = ''

7. if method == "get":

8. res = requests.get(url=url, json=data, headers=header)

9. result = res.json()

10. elif method == "post":

11. res = requests.post(url=url, json=data, headers=header)

12. result = res.json()

13. elif method == "delete":

14. res = requests.delete(url=url, json=data, headers=header)

15. result = res.json()

16. else:

17. print("没有包含当前的请求方式！！！")

18. return result

封装的日志函数logger.py

在测试用例的case上面加上装饰器（@decorate_log）实现就行

1. import logging, time, os

2. from functools import wraps

3. import traceback

5. """handlers是什么？"""

6. # logging模块中包含的类

7. # 用来自定义日志对象的规则（比如：设置日志输出格式、等级等）

8. # 常用子类：StreamHandler、FileHandler

9. # StreamHandler 控制台输出日志

10. # FileHandler 日志输出到文件

12. BASE_PATH = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

13. print(BASE_PATH)

14. # 日志文件路径

15. LOG_PATH = os.path.join(BASE_PATH, "log")

16. if not os.path.exists(LOG_PATH):

17. os.mkdir(LOG_PATH)

20. class Logger():

22. def __init__(self):

23. # 创建日志路径和时间

24. """ 知识点解析 #time strftime() 函数接收以时间元组，并返回以可读字符串表示的当地时间，格式由参数 format 决定。"""

25. self.logname = os.path.join(LOG_PATH, "{}.log".format(time.strftime("%Y%m%d")))

26. # 创建一个logger日志对象

27. self.logger = logging.getLogger("log")

28. # 设置默认的日志级别

29. self.logger.setLevel(logging.DEBUG)

30. # 创建日志格式对象

31. self.formater = logging.Formatter(

32. '[%(asctime)s][%(filename)s %(lineno)d][%(levelname)s]: %(message)s')

34. # 创建FileHandler对象

35. """mode = 'a'"""

36. # a=append=追加，即 给文件保存写入内容，不是覆盖之前已有文件中内容，而是放在最后，追加到最后。

37. # 一般append追加，适用于 log日志的处理：保留之前log，追加写入新log。

38. self.filelogger = logging.FileHandler(self.logname, mode='a', encoding="UTF-8")

39. # 创建StreamHandler对象

40. self.console = logging.StreamHandler()

42. # FileHandler对象自定义日志级别

43. self.console.setLevel(logging.DEBUG)

44. self.filelogger.setLevel(logging.DEBUG)

46. # 设置两个地方的格式

47. self.filelogger.setFormatter(self.formater)

48. self.console.setFormatter(self.formater)

50. # logger日志对象加载FileHandler对象

51. self.logger.addHandler(self.filelogger)

52. # logger日志对象加载StreamHandler对象

53. self.logger.addHandler(self.console)

56. Logger = Logger().logger

59. def decorate_log(func):

60. @wraps(func)

61. def log(*args, **kwargs):

62. Logger.info(f'------开始执行{func.__name__}用例------')

63. try:

64. func(*args, **kwargs)

65. except Exception as e:

66. Logger.error(f'------{func.__name__}用例执行失败，失败原因：{e}------')

67. Logger.error(f"{func.__name__} 用例 is error,here are details:{traceback.format_exc()}")

68. raise e

69. else:

70. Logger.info(f'------{func.__name__}执行成功------')

72. return log

75. @decorate_log

76. def funmane_wangxiaoyu():

77. print("************")

78. assert 2 == 2

81. if __name__ == '__main__':

82. funmane_wangxiaoyu()

84. # Logger.info("---测试开始---")

85. # Logger.error("---测试结束---")

86. # Logger.debug("---测试结束---")

'

运行

运行

封装的工具函数operation_json.py

1. # include json library

2. import json

5. class OperationJson:

6. def __init__(self, data_str):

7. self.data_str = data_str

9. # 将传入的str类型转化为json格式

10. def get_data_json(self):

11. json_object = json.loads(self.data_str)

12. return json_object

14. def dict_to_str(self):

15. # json.dumps()函数将字典转化为字符串

16. json_info = json.dumps(self.data_str)

18. return json_info

21. if __name__ == '__main__':

22. b = '{"supplierSn": "1", "sparePartsType": "451776602776477696", "remarks": ""}'

23. a = OperationJson(b).get_data_json()

24. print(type(a))

25. print(a)

27. dict1 = {"age": "12"}

28. c = OperationJson(dict1).dict_to_str()

29. print(c)

封装的工具函数read_yaml.py

1. import os

2. import yaml

5. class HandleYaml:

6. """读取yaml"""

8. def read_yaml(self, filename):

9. path = os.path.dirname(os.path.dirname(__file__))

10. datapath = path + filename

11. with open(datapath, encoding='utf-8') as f:

12. result = yaml.load(f, Loader=yaml.SafeLoader)

13. return result

16. do_yaml = HandleYaml()

'

运行

运行

封装获取常量data_config.py

1. # 封装获取常量

2. from common.send_requests import send_requests

3. from util.read_yaml import do_yaml

6. class global_var:

7. # case_id

8. Id = '0'

9. request_name = '1'

10. url = '2'

11. run = '3'

12. request_way = '4'

13. header = '5'

14. case_dependid = '6'

15. data_depend = '7'

16. field_depend = '8'

17. data = '9'

18. expect = '10'

19. result = '11'

22. # 获取caseid

23. def get_id():

24. return global_var.Id

27. def get_request_name():

28. return global_var.request_name

31. def get_url():

32. return global_var.url

35. def get_run():

36. return global_var.run

39. def get_request_way():

40. return global_var.request_way

43. def get_header():

44. return global_var.header

47. def get_case_dependid():

48. return global_var.case_dependid

51. def get_data_depend():

52. return global_var.data_depend

55. def get_field_depend():

56. return global_var.field_depend

59. def get_data():

60. return global_var.data

63. def get_expect():

64. return global_var.expect

67. def get_result():

68. return global_var.result

71. def get_header_value():

72. # 获取header，主要是需要包含变化的token

73. """登录接口"""

74. url_data = '\configs\url_data.yaml'

75. url = do_yaml.read_yaml(url_data)["baseurl"] + '/auth/login'

76. case_data_file = '\configs\login_data.yaml'

77. username = do_yaml.read_yaml(case_data_file)['test_login']['login_data']['username']

78. password = do_yaml.read_yaml(case_data_file)['test_login']['login_data']['password']

79. data = {

80. "username": username,

81. "password": password

82. }

83. header1 = {"Content-Type": "application/json;charset=UTF-8"}

84. result = send_requests("post", url, data, header=header1)

85. access_token = result["data"]["access_token"]

86. header = {

87. "Content-Type": "application/json;charset=UTF-8",

88. "access-token": access_token

89. }

91. return header

94. if __name__ == '__main__':

95. a = get_header_value()

96. print(type(a))

97. print(a)

操作excel函数:operation_excel.py

1. import os

3. import xlrd

6. class OperationExcel:

7. def __init__(self, file_name=None, sheet_id=None):

8. if file_name:

9. self.file_name = file_name

10. self.sheet_id = sheet_id

11. self.data = self.get_data()

12. else:

13. self.file_name = os.path.abspath(os.path.join(os.getcwd(), "..")) + "\data\PartsPurchase.xls"

14. self.sheet_id = 0

15. self.data = self.get_data()

16. # 获取sheets的内容

17. def get_data(self):

18. data = xlrd.open_workbook(self.file_name)

19. tables = data.sheets()[self.sheet_id]

20. return tables

22. # 获取单元格的行数

23. def get_lines(self):

24. tables = self.data

25. return tables.nrows

27. # 获取某一个单元格的内容

28. def get_cell_value(self, row, col):

29. return self.data.cell_value(row, col)

31. # 写入excel数据

32. def write_value(self, row, col, value):

33. read_data = xlrd.open_workbook(self.file_name)

34. write_data = copy(read_data)

35. sheet_data = write_data.get_sheet(0)

36. sheet_data.write(row, col, value)

37. write_data.save(self.file_name)

39. # 根据对应的caseid 找到对应行的内容

40. def get_rows_data(self, case_id):

41. row_num = self.get_row_num(case_id)

42. rows_data = self.get_row_values(row_num)

43. return rows_data

45. # 根据对应的caseid 找到对应的行号``````````````````

46. def get_row_num(self, case_id):

47. num = 0

48. clols_data = self.get_cols_data()

49. for col_data in clols_data:

50. if case_id in col_data:

51. return num

52. num = num + 1

54. # 根据对应行号，找到该行的内容

55. def get_row_values(self, row):

56. tables = self.data

57. row_data = tables.row_values(row)

58. return row_data

60. # 根据某一个获取某一列的内容

61. def get_cols_data(self, col_id=None):

62. if col_id != None:

63. cols = self.data.col_values(col_id)

64. else:

65. cols = self.data.col_values(0)

66. return cols

69. if __name__ == '__main__':

70. filename = os.path.abspath(os.path.join(os.getcwd(), "..")) + "\data\PartsPurchase.xls"

71. opers = OperationExcel(file_name=filename, sheet_id=0)

72. print(opers.get_cell_value(1, 1))

封装获取数据函数get_data.py

1. from handle_data import data_config

2. from handle_data.operation_excel import OperationExcel

3. from util.operation_json import OperationJson

6. class GetData:

7. opera_excel = None

9. def __init__(self, filename, sheetid):

10. self.opera_excel = OperationExcel(

11. file_name=filename, sheet_id=sheetid)

13. # def __init__(self):

14. # self.opera_excel = OperationExcel(

15. # file_name=os.path.abspath(os.path.join(os.getcwd(), "..")) + "\data\PartsPurchase.xls", sheet_id=0)

17. # 获取excel行数，就是case的个数

18. def get_case_lines(self):

19. return self.opera_excel.get_lines()

21. # 是否执行

22. def get_is_run(self, row):

23. flag = None

24. col = int(data_config.get_run())

25. run_model = self.opera_excel.get_cell_value(row, col)

26. if run_model == 'yes':

27. flag = True

28. else:

29. flag = False

30. return flag

32. # 是否携带header

33. def is_header(self, row):

34. col = int(data_config.get_header())

35. header = self.opera_excel.get_cell_value(row, col)

36. return header

38. # def header1(self, row):

39. # col = int(data_config.get_header())

40. # header = self.opera_excel.get_cell_value(row, col)

41. # header = data_config.get_header_value()

42. # return header

44. # def headervalue(self, row):

45. # col = int(data_config.get_header())

46. # header = self.opera_excel.get_cell_value(row, col)

47. # header = data_config.get_aut_value()

48. # return header

50. # return header, data_config.get_header_value()

52. # def is_header(self,row):

53. # header = data_config.get_header_value()

54. # return header

55. # if header != '':

56. # return header

57. # else:

58. # return None

60. # 获取请求方式

61. def get_request_method(self, row):

62. col = int(data_config.get_request_way())

63. request_method = self.opera_excel.get_cell_value(row, col)

64. return request_method

66. # 获取url

67. def get_request_url(self, row):

68. col = int(data_config.get_url())

69. url = self.opera_excel.get_cell_value(row, col)

70. return url

72. # 获取请求数据

73. def get_request_data(self, row):

74. col = int(data_config.get_data())

75. data = self.opera_excel.get_cell_value(row, col)

76. if data == '':

77. return None

78. return data

80. # 通过获取关键字拿到 searchjson data数据

81. def get_data_for_json(self, row):

82. # opera_json = OperationJson() # 源代码

83. # request_data = opera_json.get_data(self.get_request_data(row))

84. opera_json = OperationJson(self.get_request_data(row))

85. request_data = opera_json.get_data_json()

86. if request_data == '':

87. return None

88. return request_data

90. # 获取预期结果

91. def get_expect_data(self, row):

92. col = int(data_config.get_expect())

93. expect = self.opera_excel.get_cell_value(row, col)

94. if expect == '':

95. return None

96. return expect

98. def write_result(self, row, value):

99. col = int(data_config.get_result())

100. self.opera_excel.write_value(row, col, value)

102. # 判断是否有case依赖

103. def is_depend(self, row):

104. col = int(data_config.get_case_dependid())

105. depend_case_id = self.opera_excel.get_cell_value(row, col)

106. if depend_case_id == "":

107. return None

108. else:

109. return depend_case_id

111. # 获取依赖数据的key

112. def get_depend_key(self, row):

113. col = int(data_config.get_data_depend())

114. depend_key = self.opera_excel.get_cell_value(row, col)

115. if depend_key == "":

116. return None

117. else:

118. return depend_key

120. # 获取数据依赖字段

121. def get_depend_field(self, row):

122. col = int(data_config.get_field_depend())

123. data = self.opera_excel.get_cell_value(row, col)

124. if data == "":

125. return None

126. else:

127. return data

有依赖case的处理逻辑：dependent_data.py

1. from common.send_requests import send_requests

2. from util.read_yaml import do_yaml

5. class DependentDataclass:

6. # 通过依赖的caseid找到所在行row, 把行传进去之后可以获取依赖接口的响应结果

7. def __init__(self, data):

8. self.data = data

9. self.opera_excel = data.opera_excel

11. def DependentData(self, depend_case, header_token):

12. print("此接口依赖:" + depend_case)

13. # 通过caseid获取所在的行号，找到该行所对应的值

14. depend_row = self.opera_excel.get_row_num(depend_case)

15. url_data = '\configs\url_data.yaml'

16. url1 = self.data.get_request_url(depend_row)

17. url = do_yaml.read_yaml(url_data)["baseurl"] + url1

18. # print(url)

19. method = self.data.get_request_method(depend_row)

20. request_data = self.data.get_data_for_json(depend_row)

21. header = self.data.is_header(depend_row)

22. # 获取该行是否依赖

23. depend_case = self.data.is_depend(depend_row)

24. # 判断依赖行的case中是否也依赖另外的caseID

25. if depend_case != None:

26. print("依赖的caseid也依赖其他的接口！暂未写")

27. else:

28. print("该case不依赖其他接口！独立执行！")

29. # 判断依赖行的case中header的取值

30. if header == "yes":

31. header = header_token

32. # print("1header:" + str(header))

33. depend_response_data = send_requests(method=method, url=url, data=request_data, header=header)

34. else:

35. depend_response_data = send_requests(method=method, url=url, data=request_data)

36. return depend_response_data

域名配置url_data.yaml

下面的地址是项目中的地址，外网可以访问，所以我不能透露，抱歉哦，嘻嘻嘻

1. #预发布环境

2. #预发布环境测试地址

3. baseurl: http://yufabu****************

4. subject: "这是系统预发布环境的接口测试报告"

7. ##练习环境

8. ##练习环境地址

9. #baseurl: http://lianxi****************

10. #subject: "这是系统练习环境的接口测试报告"

登录参数：login_data.yaml

1. # 登录参数

2. test_login:

3. header:

4. "Content-Type": "application/json"

5. login_data:

6. "username": "admin"

7. "password": "123456"

8. "expected": "登录成功"

单例对象：MyClass.py

1. # 单例对象

2. import time

4. from configs.Singleton import Singleton

7. @Singleton

8. class MyClass(object):

9. # 请求头

10. header_token = None

11. # 创建字典，用于存储每个已执行接口的返回对象

12. dict = {}

14. def __init__(self):

15. time.sleep(1)

18. if __name__ == "__main__":

19. cls1 = MyClass()

20. cls2 = MyClass()

21. print(id(cls1) == id(cls2)) # True

22. print(id(cls1))

23. print(id(cls2))

单例类装饰器：Singleton.py

1. import threading

3. # 双重检查加锁单例类装饰器

4. class Singleton(object):

5. _instance_lock = threading.Lock()

7. def __init__(self, cls):

8. self._cls = cls

9. self.uniqueInstance = None

11. def __call__(self):

12. if self.uniqueInstance is None:

13. with self._instance_lock:

14. if self.uniqueInstance is None:

15. self.uniqueInstance = self._cls()

16. return self.uniqueInstance

'

运行

运行

报告的配置conftest.py

1. from datetime import datetime

2. from py.xml import html

3. import pytest

4. from util.read_yaml import do_yaml

7. @pytest.mark.optionalhook

8. def pytest_html_results_summary(prefix, summary, postfix):

9. prefix.extend([html.p("测试人: wangxiaoyu")])

12. @pytest.mark.parametrize

13. def pytest_configure(config):

14. url_data = '\configs\url_data.yaml'

15. report_url = do_yaml.read_yaml(url_data)["baseurl"]

16. report_subject = do_yaml.read_yaml(url_data)["subject"]

17. # config._metadata.pop("JAVA_HOME") # 删除java_home

18. config._metadata["项目名称"] = report_subject # 添加项目名称

19. config._metadata["接口地址"] = report_url # 添加接口地址

22. @pytest.mark.optionalhook

23. def pytest_html_results_table_header(cells):

24. cells.insert(2, html.th("Description")) # 表头添加Description

25. cells.insert(3, html.th("Time", class_="sortable time", col="time"))

26. cells.pop(-1) # 删除link

29. @pytest.mark.optionalhook

30. def pytest_html_results_table_row(report, cells):

31. cells.insert(2, html.td(report.description)) # 表头对应的内容

32. cells.insert(3, html.td(datetime.now(), class_="col-time"))

33. cells.pop(-1) # 删除link

36. @pytest.mark.hookwrapper

37. def pytest_runtest_makereport(item, call): # Description取值为用例说明__doc__

38. outcome = yield

39. report = outcome.get_result()

40. report.description = str(item.function.__doc__)

41. # report.nodeid = report.nodeid.encode("utf-8").decode("unicode_escape")

42. report.nodeid = report.nodeid.encode("unicode_escape").decode("utf-8")

发送电子邮件的配置send_email.py

1. import smtplib,os

2. from email.mime.text import MIMEText

4. from util.read_yaml import do_yaml

6. cwd_path = os.getcwd()

7. result_path = os.path.join(cwd_path, "report")

8. report_path = os.path.join(result_path, "report.html")

9. # print(report_path)

12. def send_mail():

13. '''发送测试报告邮件'''

14. smtps_server = "smtp.qq.com"

15. port = 465

16. sender = "*******@qq.com" # 涉及隐私

17. psw = "**w********beaa" # 涉及隐私

18. receiver = ["*******@qq.com"] # 涉及隐私

20. f = open(report_path, 'rb')

21. mail_body = f.read().decode('gbk')

22. f.close()

24. url_data = '\configs\url_data.yaml'

25. report_subject = do_yaml.read_yaml(url_data)["subject"]

26. subject = report_subject

27. msg = MIMEText(mail_body, 'html', 'utf8')

28. msg['from'] = sender

29. msg['to'] = ",".join(receiver)

30. msg['subject'] = subject

32. server = smtplib.SMTP_SSL(smtps_server, port)

33. server.connect(smtps_server, port)

34. server.login(sender, psw)

35. server.sendmail(sender, receiver, msg.as_string())

36. server.quit()

37. print("测试邮件发送成功")

40. if __name__ == '__main__':

41. send_mail()

测试用例test_PartsPurchaseByexcel.py

1. import ast

2. import json

3. import os

4. import pytest

5. import pytest_html

6. from common.logger import decorate_log

7. from common.send_requests import send_requests

8. from configs.MyClass import MyClass

9. from handle_data.data_config import get_header_value

10. from handle_data.dependent_data import DependentDataclass

11. from handle_data.get_data import GetData

12. from util.read_yaml import do_yaml

14. '''通过调用excel中的数据测试散件入库'''

17. class test_PartsPurchaseByexcel:

19. def __init__(self, header_token, file_name, sheet_id):

20. self.header_token = header_token

21. self.data = GetData(file_name, sheet_id)

22. self.DependentDataclass = DependentDataclass(self.data)

24. def sparePartsPurchaseByexcel(self):

25. # data = GetData()

26. rows_count = self.data.get_case_lines()

27. for i in range(1, rows_count):

28. is_run = self.data.get_is_run(i)

29. if is_run:

30. # print("用例执行！")

31. # 获取该行的URL

32. # url = self.data.get_request_url(i)

33. url_data = '\configs\url_data.yaml'

34. url1 = self.data.get_request_url(i)

35. url = do_yaml.read_yaml(url_data)["baseurl"] + url1

36. # 获取该行的请求方式

37. method = self.data.get_request_method(i)

38. # 获取该行的请求数据，json格式

39. request_data = self.data.get_data_for_json(i)

40. # 获取该行预期结果

41. expect = self.data.get_expect_data(i)

42. # 获取该行header

43. header = self.data.is_header(i)

44. # 获取该行是否依赖

45. depend_case = self.data.is_depend(i)

46. # 当前执行接口行的caseid

47. caseid = self.data.opera_excel.get_cell_value(i, 0)

48. # 判断依赖的id是否为空

49. if depend_case != None:

50. print("依赖caseid不为空，继续！")

51. request_data_dict = None

52. # self.depend_data = DependentData(depend_case)

53. # 判断id对应的返回值字典是否存在，存在则表示之前执行过该接口，不再重复执行

54. if depend_case in MyClass().dict:

55. depend_response_data = MyClass().dict[depend_case]

56. else:

57. # 通过依赖的caseid找到所在行row,把行传进去之后可以获取依赖接口的响应结果

58. depend_response_data = self.DependentDataclass.DependentData(depend_case, self.header_token)

59. MyClass().dict[depend_case] = depend_response_data

61. # 获取依赖字段

62. depend_key = self.data.get_depend_field(i) # 假如依赖的是id

63. depend_keys = depend_key.split(',')

64. for key in depend_keys:

65. print("当前依赖的字段:", key)

66. depend_value = depend_response_data["data"][key] # 得到所依赖接口的id对应的值

67. request_data_dict = request_data

68. if depend_value != None and key in request_data_dict:

69. # 用所依赖接口响应结果中取到的值替换当前接口请求中的依赖字段的值

70. request_data_dict[key] = depend_value

72. request_data_str = json.dumps(request_data_dict)

73. request_data = ast.literal_eval(request_data_str)

74. # request_data2 = json.dumps({depend_key: depend_value}) # 请求数据=依赖的返回数据

75. # request_data = json.dumps(request_data2)

76. if header == "yes":

78. header = self.header_token

79. # print("2header:" + str(header))

80. depend_response_data = send_requests(method=method, url=url, data=request_data, header=header)

81. MyClass().dict[caseid] = depend_response_data

82. # return depend_response_data

83. else:

84. print("没有header，这是没有header的执行请求，没写没写没写没写！！！！！！")

85. # return depend_response_data

87. else:

88. print("该case不依赖其他接口！独立执行！没写没写没写")

90. else:

91. print("用例不执行！")

94. @decorate_log

95. def test_sparePartsPurchaseByexcel():

96. ''' 测试散件入库 '''

97. cls1: MyClass = MyClass() # 全局参数单例对象初始化

98. cls1.header_token = get_header_value()

99. header_token = MyClass().header_token

100. file_name = os.path.abspath(os.path.join(os.getcwd(), "..")) + "\wxy_test_chelingzhuByExcel\data\PartsPurchase.xls"

101. print(file_name)

102. sheet_id = 0

103. runn = test_PartsPurchaseByexcel(header_token, file_name, sheet_id)

104. runn.sparePartsPurchaseByexcel()

运行入口run.py

1. import pytest

3. import send_email

5. if __name__ == '__main__':

6. pytest.main(["-sv", "--html=./report/report.html", "--self-contained-html"])

7. # pytest.main()

8. send_email.send_mail()

大功告成

运行之后会给你的QQ邮箱发送测试报告，如下图，虽然丑点但是能看明白！！！

 

总结：

感谢每一个认真阅读我文章的人！！！

作为一位过来人也是希望大家少走一些弯路，如果你不想再体验一次学习时找不到资料，没人解答问题，坚持几天便放弃的感受的话，在这里我给大家分享一些自动化测试的学习资源，希望能给你前进的路上带来帮助。

软件测试面试文档

我们学习必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有字节大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

 

          视频文档获取方式：
这份文档和视频资料，对于想从事【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！以上均可以分享，点下方小卡片即可自行领取。