• Appium自动化测试框架：关键字驱动+数据驱动

    1. 关键字驱动框架简介

    原理及特点

    1. 关键字驱动测试是数据驱动测试的一种改进类型，它也被称为表格驱动测试或者基于动作字的测试。
    2. 主要关键字包括三类：被操作对象（Item）、操作行为（Operation）和操作值（Value），用面向对象形式可将其表现为 Item.Operation(Value)。
    3. 将测试逻辑按照这些关键字进行分解，形成数据文件。
    4. 用关键字的形式将测试逻辑封装在数据文件中，测试工具只要能够解释这些关键字即可对其应用自动化。

    优势

    1. 执行人员可以不需要太多的技术：一旦框架建立，手工测试人员和非技术人员都可以很容易的编写自动化测试脚本。
    2. 简单易懂：它存在 Excel 表格中，没有编码，测试脚本容易阅读和理解。关键字和操作行为这样的手工测试用例，使它变得更容易编写和维护。
    3. 早期介入：可以在应用未提交测试之前，就可以建立关键字驱动测试用例对象库，从而减少后期工作。使用需求和其它相关文档进行收集信息，关键字数据表可以建立手工测试程序。
    4. 代码的重用性：用关键字的形式将测试用例及数据进行组装并解释执行，提高代码的可重用性。

     

    2. 框架结构说明

    框架结构

    整个测试框架分为四层，通过分层的方式，测试代码更容易理解，维护起来较为方便。

    第一层是“测试工具层”：

    • util 包：用于实现测试过程中调用的工具类方法，例如读取配置文件、页面元素的操作方法、操作 Excel 文件、生成测试报告、发送邮件等。
    • conf 包：配置文件及全局变量。
    • log 目录：日志输出文件。
    • exception_pic 目录：失败用例的截图保存目录。

    第二层是“服务层”：相当于对测试对象的一个业务封装。对于接口测试，是对远程方法的一个实现；对于 UI 测试，是对页面元素或操作的一个封装。

    • action 包：封装具体的页面动作，如点击、输入文本等。

    第三层是“测试用例逻辑层”：该层主要是将服务层封装好的各个业务对象，组织成测试逻辑，进行校验。

    • bussiness_process 包：基于关键字的形式，实现单条、多条用例的测试脚本逻辑。
    • test_data 目录：Excel 数据文件，包含用例步骤、被操作对象、操作动作、操作值、测试结果等。

    第四层是“测试场景层”：将测试用例组织成测试场景，实现各种级别 cases 的管理，如冒烟，回归等测试场景。

    • main.py：本框架工程的运行主入口。

    框架特点

    1. 基于关键字测试框架，即使不懂开发技术的测试人员也可以实施自动化测试，便于在整个测试团队中推广和使用自动化测试技术，降低自动化测试实施的技术门槛。
    2. 使用外部测试数据文件，使用Excel管理测试用例的集合和每个测试用例的所有执行步骤，实现在一个文件中完成测试用例的维护工作。
    3. 通过定义关键字、操作元素的定位方式和定位表达式和操作值，就可以实现每个测试步骤的执行，可以更加灵活地实现自动化测试的需求。
    4. 基于关键字的方式，可以进行任意关键字的扩展，以满足更加复杂的自动化测试需求。
    5. 实现定位表达式和测试代码的分离，实现定位表达式直接在数据文件中进行维护。
    6. 框架提供日志功能，方便调试和监控自动化测试程序的执行。

     

    3. 框架代码实现

    action 包

    action 包为框架第二层“服务层”，相当于对测试对象的一个业务封装。对于接口测试，是对远程方法的一个实现；对于 UI 测试，是对页面元素或操作的一个封装。

    page_action.py

    本模块基于关键字格式，封装了页面操作的常用函数，如打开 APP、点击、输入文本等。

    1. 1 import traceback
    2.  2 import os
    3.  3 import time
    4.  4 from appium import webdriver
    5.  5 from util.get_desired_caps import get_desired_caps
    6.  6 from util.datetime_util import *
    7.  7 from util.find_element_util import *
    8.  8 from util.global_var import *
    9.  9 from util.log_util import *
    10. 10 
    11. 11 
    12. 12 DRIVER = ""
    13. 13 
    14. 14 
    15. 15 # 打开APP，获取webdriver对象
    16. 16 def open_app():
    17. 17     global DRIVER
    18. 18     desired_caps = get_desired_caps()
    19. 19     DRIVER = webdriver.Remote(APPIUM_SERVER, desired_caps)
    20. 20 
    21. 21 
    22. 22 # 设定开始活动页
    23. 23 def open_start_activity(app_name, start_activity_name):
    24. 24     global DRIVER
    25. 25     DRIVER.start_activity(app_name, start_activity_name)
    26. 26 
    27. 27 
    28. 28 # 退出APP
    29. 29 def quit_app():
    30. 30     global DRIVER
    31. 31     DRIVER.quit()
    32. 32 
    33. 33 
    34. 34 # 在页面输入框中输入数据
    35. 35 def input_string(location_type, locator_expression, input_content):
    36. 36     global DRIVER
    37. 37     find_element(DRIVER, location_type, locator_expression).send_keys(input_content)
    38. 38 
    39. 39 
    40. 40 # 清除输入框默认内容
    41. 41 def clear(location_type, locator_expression):
    42. 42     global DRIVER
    43. 43     find_element(DRIVER, location_type, locator_expression).clear()
    44. 44 
    45. 45 
    46. 46 # 点击页面元素
    47. 47 def click(location_type, locator_expression):
    48. 48     global DRIVER
    49. 49     find_element(DRIVER, location_type, locator_expression).click()
    50. 50 
    51. 51 
    52. 52 # 断言界面源码是否存在某关键字或关键字符串
    53. 53 def assert_string_in_pagesource(assert_string):
    54. 54     global DRIVER
    55. 55     try:
    56. 56         assert assert_string in DRIVER.page_source, "%s not found in page source!" % assert_string
    57. 57         info("断言成功【关键字：{}】".format(assert_string))
    58. 58     except:
    59. 59         error("断言失败【关键字：{}】".format(assert_string))
    60. 60         raise
    61. 61 
    62. 62 
    63. 63 # 强制等待
    64. 64 def sleep(sleep_seconds):
    65. 65     time.sleep(int(sleep_seconds))
    66. 66 
    67. 67 
    68. 68 # 批量断言
    69. 69 def assert_app_list(location_type, locator_expression, assert_string):
    70. 70     global DRIVER
    71. 71     assert_string_list = assert_string.split(",")
    72. 72     elements = find_element(DRIVER, location_type, locator_expression)
    73. 73     for element in elements[:3]:
    74. 74         assert element.text in assert_string_list
    75. 75 
    76. 76 
    77. 77 # 截图函数
    78. 78 def take_screenshot():
    79. 79     global DRIVER
    80. 80     # 创建当前日期目录
    81. 81     dir = os.path.join(EXCEPION_PIC_PATH, get_chinese_date())
    82. 82     if not os.path.exists(dir):
    83. 83         os.makedirs(dir)
    84. 84     # 以当前时间为文件名
    85. 85     file_name = get_chinese_time()
    86. 86     file_path = os.path.join(dir, file_name+".png")
    87. 87     try:
    88. 88         DRIVER.get_screenshot_as_file(file_path)
    89. 89         # 返回截图文件的绝对路径
    90. 90         return file_path
    91. 91     except:
    92. 92         print("截图发生异常【{}】".format(file_path))
    93. 93         traceback.print_exc()
    94. 94         return file_path

     

    business_process 包

    business_process 包是框架第三层“测试用例逻辑层”，该层主要是将服务层封装好的各个业务对象，组织成测试逻辑，进行校验。

    case_process.py

    • 测试用例文件的一行数据，拼接其中的操作动作、操作对象、操作值等关键字，形成与 page_action.py 中的函数相对应的字符串，并通过 eval() 转成表达式以执行用例。
    • 记录该用例的测试结果，如测试执行结果、测试执行时间等。
    • 如需数据驱动的用例集，则获取数据驱动的数据源集合，循环将每组数据传递给用例步骤。
    • 如果遇到需要参数化的值 ${变量名}，则根据数据驱动的数据源，根据变量名进行参数化。

     

    data_source_process.py

    本模块实现了获取数据驱动所需的数据源集合。

    • 根据数据源 sheet 名，获取该 sheet 所有行数据，每行数据作为一组测试数据。
    • 每行数据作为一个字典，存储在一个列表中。如 [{"登录用户名": "xxx", "登录密码": "xxx", ...}, {...}, ...]

     

    1.  
    2.  1 from util.excel_util import Excel
    3.  2 from util.global_var import *
    4.  3 from util.log_util import *
    5.  4 
    6.  5 
    7.  6 # 数据驱动
    8.  7 # 每行数据作为一个字典，存储在一个列表中。如[{"登录用户名": "xxx", "登录密码": "xxx", ...}, {...}, ...]
    9.  8 def get_test_data(excel_file_path, sheet_name):
    10.  9     # excel对象初始化
    11. 10     if isinstance(excel_file_path, Excel):
    12. 11         excel = excel_file_path
    13. 12     else:
    14. 13         excel = Excel(excel_file_path)
    15. 14     # 校验sheet名
    16. 15     if not excel.get_sheet(sheet_name):
    17. 16         error("sheet【】不存在，停止执行！" % sheet_name)
    18. 17         return
    19. 18     result_list = []
    20. 19     all_row_data = excel.get_all_row_data()
    21. 20     if len(all_row_data) <= 1:
    22. 21         error("sheet【】数据不大于1行，停止执行！" % sheet_name)
    23. 22         return
    24. 23     # 将参数化的测试数据存入全局字典
    25. 24     head_line_data = all_row_data[0]
    26. 25     for data in all_row_data[1:]:
    27. 26         if data[-1].lower() == "n":
    28. 27             continue
    29. 28         row_dict = {}
    30. 29         for i in range(len(data[:-1])):
    31. 30             row_dict[head_line_data[i]] = data[i]
    32. 31         result_list.append(row_dict)
    33. 32     return result_list
    34. 33 
    35. 34 
    36. 35 if __name__ == "__main__":
    37. 36     from util.global_var import *
    38. 37     print(get_test_data(TEST_DATA_FILE_PATH, "搜索词"))
    39. 38     # [{'搜索词': 'python', '断言词': 'python'}, {'搜索词': 'mysql', '断言词': 'mysql5.6'}]

    main_process.py

    本模块基于 case_process.py 和 data_source_process.py，实现关键字驱动+数据驱动的测试用例集的执行。

    • suite_process()：执行具体的测试用例步骤 sheet（如“登录” sheet、“搜索” sheet 等）
    • main_suite_process()：执行“测试用例”主 sheet 的用例集。每行用例集对应一个用例步骤 sheet 和数据源 sheet。 
      1.  
      2.   1 from util.excel_util import *
      3.   2 from util.datetime_util import *
      4.   3 from util.log_util import *
      5.   4 from util.global_var import *
      6.   5 from bussiness_process.case_process import execute_case
      7.   6 from bussiness_process.data_source_process import get_test_data
      8.   7 
      9.   8 
      10.   9 # 执行具体的测试用例步骤sheet
      11.  10 def suite_process(excel_file_path, sheet_name, test_data_source=None):
      12.  11     """
      13.  12     :param excel_file_path: excel文件绝对路径或excel对象
      14.  13     :param sheet_name: 测试步骤sheet名
      15.  14     :param test_data_source: 数据驱动的数据源，默认没有
      16.  15     :return:
      17.  16     """
      18.  17     # 记录测试结果统计
      19.  18     global TOTAL_CASE
      20.  19     global PASS_CASE
      21.  20     global FAIL_CASE
      22.  21     # 整个用例sheet的测试结果，默认为全部通过
      23.  22     suite_test_result = True
      24.  23     # excel对象初始化
      25.  24     if isinstance(excel_file_path, Excel):
      26.  25         excel = excel_file_path
      27.  26     else:
      28.  27         excel = Excel(excel_file_path)
      29.  28     if not excel.get_sheet(sheet_name):
      30.  29         error("sheet【】不存在，停止执行！" % sheet_name)
      31.  30         return
      32.  31     # 获取测试用例sheet的全部行数据
      33.  32     all_row_data = excel.get_all_row_data()
      34.  33     if len(all_row_data) <= 1:
      35.  34         error("sheet【】数据不大于1行，停止执行！" % sheet_name)
      36.  35         return
      37.  36     # 标题行数据
      38.  37     head_line_data = all_row_data[0]
      39.  38     # 切换到测试结果明细sheet，准备写入测试结果
      40.  39     if not excel.get_sheet("测试结果明细"):
      41.  40         error("【测试结果明细】sheet不存在，停止执行！")
      42.  41         return
      43.  42     excel.write_row_data(head_line_data, None, True, "green")
      44.  43     # 执行每行的测试用例
      45.  44     for row_data in all_row_data[1:]:
      46.  45         result_data = execute_case(excel, row_data, test_data_source)
      47.  46         # 无需执行的测试步骤，跳过
      48.  47         if result_data is None:
      49.  48             continue
      50.  49         TOTAL_CASE += 1
      51.  50         if result_data[CASESTEP_TEST_RESULT_COL_NO].lower() == "fail":
      52.  51             suite_test_result = False
      53.  52             FAIL_CASE += 1
      54.  53         else:
      55.  54             PASS_CASE += 1
      56.  55         excel.write_row_data(result_data)
      57.  56     # 切换到测试结果统计sheet，写入统计数据
      58.  57     if not excel.get_sheet("测试结果统计"):
      59.  58         error("【测试结果统计】sheet不存在，停止执行！")
      60.  59         return
      61.  60     excel.insert_row_data(1, [TOTAL_CASE, PASS_CASE, FAIL_CASE])
      62.  61     return excel, suite_test_result
      63.  62 
      64.  63 
      65.  64 # 执行【测试用例】主sheet的用例集
      66.  65 def main_suite_process(excel_file_path, sheet_name):
      67.  66     # 初始化excel对象
      68.  67     excel = Excel(excel_file_path)
      69.  68     if not excel:
      70.  69         error("excel数据文件【%s】不存在！" % excel_file_path)
      71.  70         return
      72.  71     if not excel.get_sheet(sheet_name):
      73.  72         error("sheet名称【%s】不存在！" % sheet_name)
      74.  73         return
      75.  74     # 获取所有行数据
      76.  75     all_row_datas = excel.get_all_row_data()
      77.  76     if len(all_row_datas) <= 1:
      78.  77         error("sheet【%s】数据不大于1行，停止执行！" % sheet_name)
      79.  78         return
      80.  79     # 标题行数据
      81.  80     head_line_data = all_row_datas[0]
      82.  81     for row_data in all_row_datas[1:]:
      83.  82         # 跳过不需要执行的测试用例集
      84.  83         if row_data[TESTCASE_IS_EXECUTE_COL_NO].lower() == "n":
      85.  84             info("#" * 50 + " 测试用例集【%s】无需执行！" % row_data[TESTCASE_CASE_NAME_COL_NO] + "#" * 50 + "\n")
      86.  85             continue
      87.  86         # 记录本用例集的测试时间
      88.  87         row_data[TESTCASE_TEST_TIME_COL_NO] = get_english_datetime()
      89.  88         # 校验用例步骤sheet名是否存在
      90.  89         if row_data[TESTCASE_CASE_STEP_SHEET_NAME_COL_NO] not in excel.get_all_sheet():
      91.  90             error("#" * 50 + " 用例步骤集【%s】不存在！ " % row_data[TESTCASE_CASE_STEP_SHEET_NAME_COL_NO] + "#" * 50 + "\n")
      92.  91             row_data[TESTCASE_TEST_RESULT_COL_NO] = "Fail"
      93.  92             excel.write_row_data(head_line_data, None, True, "red")
      94.  93             excel.write_row_data(row_data)
      95.  94             continue
      96.  95         # 判断本测试用例集是否进行数据驱动
      97.  96         if row_data[TESTCASE_DATA_SOURCE_SHEET_NAME_COL_NO]:
      98.  97             # 校验测试数据集sheet名是否存在
      99.  98             if row_data[TESTCASE_DATA_SOURCE_SHEET_NAME_COL_NO] not in excel.get_all_sheet():
      100.  99                 error("#" * 50 + " 测试数据集【%s】不存在！ " % row_data[TESTCASE_DATA_SOURCE_SHEET_NAME_COL_NO] + "#" * 50 + "\n")
      101. 100                 row_data[TESTCASE_TEST_RESULT_COL_NO] = "Fail"
      102. 101                 excel.write_row_data(head_line_data, None, True, "red")
      103. 102                 excel.write_row_data(row_data)
      104. 103                 continue
      105. 104             # 获取测试数据集
      106. 105             test_data_source = get_test_data(excel, row_data[TESTCASE_DATA_SOURCE_SHEET_NAME_COL_NO])
      107. 106             # 每条数据进行一次本用例集的测试
      108. 107             for data_source in test_data_source:
      109. 108                 info("-" * 50 + " 测试用例集【%s】开始执行！" % row_data[TESTCASE_CASE_NAME_COL_NO] + "-" * 50)
      110. 109                 excel, test_result_flag = suite_process(excel, row_data[TESTCASE_CASE_STEP_SHEET_NAME_COL_NO], data_source)
      111. 110                 # 记录本用例集的测试结果
      112. 111                 if test_result_flag:
      113. 112                     info("#" * 50 + " 测试用例集【%s】执行成功！ " % row_data[TESTCASE_CASE_NAME_COL_NO] + "#" * 50 + "\n")
      114. 113                     row_data[TESTCASE_TEST_RESULT_COL_NO] = "Pass"
      115. 114                 else:
      116. 115                     error("#" * 50 + " 测试用例集【%s】执行失败！ " % row_data[TESTCASE_CASE_NAME_COL_NO] + "#" * 50 + "\n")
      117. 116                     row_data[TESTCASE_TEST_RESULT_COL_NO] = "Fail"
      118. 117                 # 全部测试步骤结果写入后，最后写入本用例集的标题行和测试结果行数据
      119. 118                 # 切换到“测试结果明细”sheet，以写入测试执行结果
      120. 119                 excel.get_sheet("测试结果明细")
      121. 120                 excel.write_row_data(head_line_data, None, True, "red")
      122. 121                 excel.write_row_data(row_data)
      123. 122         # 本用例集无需数据驱动
      124. 123         else:
      125. 124             info("-" * 50 + " 测试用例集【%s】开始执行！" % row_data[TESTCASE_CASE_NAME_COL_NO] + "-" * 50)
      126. 125             excel, test_result_flag = suite_process(excel, row_data[TESTCASE_CASE_STEP_SHEET_NAME_COL_NO])
      127. 126             # 记录本用例集的测试结果
      128. 127             if test_result_flag:
      129. 128                 info("#" * 50 + " 测试用例集【%s】执行成功！ " % row_data[TESTCASE_CASE_NAME_COL_NO] + "#" * 50 + "\n")
      130. 129                 row_data[TESTCASE_TEST_RESULT_COL_NO] = "Pass"
      131. 130             else:
      132. 131                 error("#" * 50 + " 测试用例集【%s】执行失败！ " % row_data[TESTCASE_CASE_NAME_COL_NO] + "#" * 50 + "\n")
      133. 132                 row_data[TESTCASE_TEST_RESULT_COL_NO] = "Fail"
      134. 133             # 全部测试步骤结果写入后，最后写入本用例集的标题行和测试结果行数据
      135. 134             # 切换到“测试结果明细”sheet，以写入测试执行结果
      136. 135             excel.get_sheet("测试结果明细")
      137. 136             excel.write_row_data(head_line_data, None, True, "red")
      138. 137             excel.write_row_data(row_data)
      139. 138     return excel
      140. 139 
      141. 140 
      142. 141 if __name__ == "__main__":
      143. 142     from util.report_util import create_excel_report_and_send_email
      144. 143     # excel, _ = suite_process(TEST_DATA_FILE_PATH, "进入主页")
      145. 144     # excel, _ = suite_process(excel, "登录")
      146. 145     excel = main_suite_process(TEST_DATA_FILE_PATH, "测试用例")
      147. 146     create_excel_report_and_send_email(excel, "182230124@qq.com", "app自动化测试", "请查收附件：app自动化测试报告")

    util 包

    util 包属于第一层的测试工具层：用于实现测试过程中调用的工具类方法，例如读取配置文件、页面元素的操作方法、操作 Excel 文件、生成测试报告、发送邮件等。

    global_var.py

    本模块用于定义测试过程中所需的全局变量。

    1.  
    2.  1 import os
    3.  2 
    4.  3 
    5.  4 PROJECT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    6.  5 
    7.  6 # APP配置信息路径
    8.  7 INI_FILE_PATH = os.path.join(PROJECT_DIR, "conf", "desired_caps_config.ini")
    9.  8 
    10.  9 # 异常截图路径
    11. 10 EXCEPION_PIC_PATH = os.path.join(PROJECT_DIR, "exception_pic")
    12. 11 
    13. 12 # 日志配置文件路径
    14. 13 LOG_CONF_FILE_PATH = os.path.join(PROJECT_DIR, "conf", "logger.conf")
    15. 14 
    16. 15 # 测试数据文件路径
    17. 16 TEST_DATA_FILE_PATH = os.path.join(PROJECT_DIR, "test_data", "test_case.xlsx")
    18. 17 
    19. 18 # 测试报告存放路径
    20. 19 TEST_REPORT_FILE_DIR = os.path.join(PROJECT_DIR, "test_report")
    21. 20 
    22. 21 # Appium server地址
    23. 22 APPIUM_SERVER = 'http://localhost:4723/wd/hub'
    24. 23 
    25. 24 # 测试数据文件中，测试用例sheet中部分列对应的数字序号
    26. 25 TESTCASE_CASE_NAME_COL_NO = 0
    27. 26 TESTCASE_FRAMEWORK_TYPE_COL_NO = 1
    28. 27 TESTCASE_CASE_STEP_SHEET_NAME_COL_NO = 2
    29. 28 TESTCASE_DATA_SOURCE_SHEET_NAME_COL_NO = 3
    30. 29 TESTCASE_IS_EXECUTE_COL_NO = 4
    31. 30 TESTCASE_TEST_TIME_COL_NO = 5
    32. 31 TESTCASE_TEST_RESULT_COL_NO = 6
    33. 32 
    34. 33 # 用例步骤sheet中，部分列对应的数字序号
    35. 34 CASESTEP_NAME_COL_NO = 0
    36. 35 CASESTEP_ACTION_COL_NO = 1
    37. 36 CASESTEP_LOCATE_METHOD_COL_NO = 2
    38. 37 CASESTEP_LOCATE_EXPRESSION_COL_NO = 3
    39. 38 CASESTEP_OPERATION_VALUE_COL_NO = 4
    40. 39 CASESTEP_IS_EXECUTE_COL_NO = 5
    41. 40 CASESTEP_TEST_TIME_COL_NO = 6
    42. 41 CASESTEP_TEST_RESULT_COL_NO = 7
    43. 42 CASESTEP_EXCEPTION_INFO_COL_NO = 8
    44. 43 CASESTEP_EXCEPTION_PIC_DIR_COL_NO = 9
    45. 44 
    46. 45 # 数据源sheet中，是否执行列对应的数字编号
    47. 46 DATASOURCE_DATA = 0
    48. 47 DATASOURCE_KEYWORD = 1
    49. 48 DATASOURCE_IS_EXECUTE = 2
    50. 49 DATASOURCE_TEST_TIME = 3
    51. 50 DATASOURCE_TEST_RESULT = 4
    52. 51 
    53. 52 # 测试执行结果统计
    54. 53 TOTAL_CASE = 0
    55. 54 PASS_CASE = 0
    56. 55 FAIL_CASE = 0
    57. 56 
    58. 57 
    59. 58 if __name__ == "__main__":
    60. 59     print(PROJECT_DIR)

     

    find_element_util.py

    本模块封装了基于显式等待的界面元素定位方法。

    1.  
    2.  1 from selenium.webdriver.support.ui import WebDriverWait
    3.  2 
    4.  3 
    5.  4 # 显式等待一个元素
    6.  5 def find_element(driver, locate_method, locate_exp):
    7.  6     # 显式等待对象（最多等10秒，每0.2秒判断一次等待的条件）
    8.  7     return WebDriverWait(driver, 10, 0.2).until(lambda x: x.find_element(locate_method, locate_exp))
    9.  8 
    10.  9 # 显式等待一组元素
    11. 10 def find_elements(driver, locate_method, locate_exp):
    12. 11     # 显式等待对象（最多等10秒，每0.2秒判断一次等待的条件）
    13. 12     return WebDriverWait(driver, 10, 0.2).until(lambda x: x.find_elements(locate_method, locate_exp))

     

    excel_util.py

    本模块封装了对 excel 的读写操作（openpyxl 版本：3.0.4）。

    1.  
    2.   1 import os
    3.   2 from openpyxl import load_workbook
    4.   3 from openpyxl.styles import PatternFill, Font, Side, Border
    5.   4 from util.datetime_util import *
    6.   5 from util.global_var import *
    7.   6 from util.log_util import *
    8.   7 
    9.   8 
    10.   9 # 支持excel读写操作的工具类
    11.  10 class Excel:
    12.  11 
    13.  12     # 初始化读取excel文件
    14.  13     def __init__(self, file_path):
    15.  14         if not os.path.exists(file_path):
    16.  15             return
    17.  16         self.wb = load_workbook(file_path)
    18.  17         # 初始化默认sheet
    19.  18         self.ws = self.wb.active
    20.  19         self.data_file_path = file_path
    21.  20         # 初始化颜色字典，供设置样式用
    22.  21         self.color_dict = {"red": "FFFF3030", "green": "FF008B00"}
    23.  22 
    24.  23     def get_all_sheet(self):
    25.  24         return self.wb.get_sheet_names()
    26.  25 
    27.  26     # 打开指定sheet
    28.  27     def get_sheet(self, sheet_name):
    29.  28         if sheet_name not in self.get_all_sheet():
    30.  29             print("sheet名称【%s】不存在！" % sheet_name)
    31.  30             return
    32.  31         self.ws = self.wb.get_sheet_by_name(sheet_name)
    33.  32         return True
    34.  33 
    35.  34     # 获取最大行号
    36.  35     def get_max_row_no(self):
    37.  36         # openpyxl的API的行、列索引默认都从1开始
    38.  37         return self.ws.max_row
    39.  38 
    40.  39     # 获取最大列号
    41.  40     def get_max_col_no(self):
    42.  41         return self.ws.max_column
    43.  42 
    44.  43     # 获取所有行数据
    45.  44     def get_all_row_data(self, head_line=True):
    46.  45         # 是否需要标题行数据的标识，默认需要
    47.  46         if head_line:
    48.  47             min_row = 1  # 行号从1开始，即1为标题行
    49.  48         else:
    50.  49             min_row = 2
    51.  50         result = []
    52.  51         # min_row=None：默认获取标题行数据
    53.  52         for row in self.ws.iter_rows(min_row=min_row, max_row=self.get_max_row_no(), max_col=self.get_max_col_no()):
    54.  53             result.append([cell.value for cell in row])
    55.  54         return result
    56.  55 
    57.  56     # 获取指定行数据
    58.  57     def get_row_data(self, row_num):
    59.  58         # 0 为标题行
    60.  59         return [cell.value for cell in self.ws[row_num+1]]
    61.  60 
    62.  61     # 获取指定列数据
    63.  62     def get_col_data(self, col_num):
    64.  63         # 索引从0开始
    65.  64         return [cell.value for cell in tuple(self.ws.columns)[col_num]]
    66.  65 
    67.  66     # 追加行数据且可以设置样式
    68.  67     def write_row_data(self, data, font_color=None, border=True, fill_color=None):
    69.  68         if not isinstance(data, (list, tuple)):
    70.  69             print("写入数据失败：数据不为列表或元组类型！【%s】" % data)
    71.  70         self.ws.append(data)
    72.  71         # 设置字体颜色
    73.  72         if font_color:
    74.  73             if font_color.lower() in self.color_dict.keys():
    75.  74                 font_color = self.color_dict[font_color]
    76.  75         # 设置单元格填充颜色
    77.  76         if fill_color:
    78.  77             if fill_color.lower() in self.color_dict.keys():
    79.  78                 fill_color = self.color_dict[fill_color]
    80.  79         # 设置单元格边框
    81.  80         if border:
    82.  81             bd = Side(style="thin", color="000000")
    83.  82         # 记录数据长度（否则会默认与之前行最长数据行的长度相同，导致样式超过了该行实际长度）
    84.  83         count = 0
    85.  84         for cell in self.ws[self.get_max_row_no()]:
    86.  85             # 设置完该行的实际数据长度样式后，则退出
    87.  86             if count > len(data) - 1:
    88.  87                 break
    89.  88             if font_color:
    90.  89                 cell.font = Font(color=font_color)
    91.  90             # 如果没有设置字体颜色，则默认给执行结果添加字体颜色
    92.  91             else:
    93.  92                 if cell.value is not None and isinstance(cell.value, str):
    94.  93                     if cell.value.lower() == "pass" or cell.value == "成功":
    95.  94                         cell.font = Font(color=self.color_dict["green"])
    96.  95                     elif cell.value.lower() == "fail" or cell.value == "失败":
    97.  96                         cell.font = Font(color=self.color_dict["red"])
    98.  97             if border:
    99.  98                 cell.border = Border(left=bd, right=bd, top=bd, bottom=bd)
    100.  99             if fill_color:
    101. 100                 cell.fill = PatternFill(fill_type="solid", fgColor=fill_color)
    102. 101             count += 1
    103. 102 
    104. 103     # 指定行插入数据（行索引从0开始）
    105. 104     def insert_row_data(self, row_no, data, font_color=None, border=True, fill_color=None):
    106. 105         if not isinstance(data, (list, tuple)):
    107. 106             print("写入数据失败：数据不为列表或元组类型！【%s】" % data)
    108. 107         for idx, cell in enumerate(self.ws[row_no+1]):  # 此处行索引从1开始
    109. 108             cell.value = data[idx]
    110. 109 
    111. 110     # 生成写入了测试结果的excel数据文件
    112. 111     def save(self, save_file_name, timestamp):
    113. 112         save_dir = os.path.join(TEST_REPORT_FILE_DIR, get_chinese_date())
    114. 113         if not os.path.exists(save_dir):
    115. 114             os.mkdir(save_dir)
    116. 115         save_file = os.path.join(save_dir, save_file_name + "_" + timestamp + ".xlsx")
    117. 116         self.wb.save(save_file)
    118. 117         info("生成测试结果文件：%s" % save_file)
    119. 118         return save_file
    120. 119 
    121. 120 
    122. 121 if __name__ == "__main__":
    123. 122     from util.global_var import *
    124. 123     from util.datetime_util import *
    125. 124     excel = Excel(TEST_DATA_FILE_PATH)
    126. 125     excel.get_sheet("测试结果统计")
    127. 126     # print(excel.get_all_row_data())
    128. 127     # excel.write_row_data(["4", None, "嘻哈"], "green", True, "red")
    129. 128     excel.insert_row_data(1, [1,2,3])
    130. 129     excel.save(get_timestamp())

     

    ini_reader.py

    本模块封装了对 ini 配置文件的读取操作。

    1.  
    2.  1 import os
    3.  2 import configparser
    4.  3 
    5.  4 
    6.  5 # 读取ini文件的工具类
    7.  6 class IniParser:
    8.  7 
    9.  8     # 初始化打开ini文件
    10.  9     def __init__(self, file_path):
    11. 10         if not os.path.exists(file_path):
    12. 11             print("ini文件【%s】不存在！" % file_path)
    13. 12             return
    14. 13         self.cf = configparser.ConfigParser()
    15. 14         self.cf.read(file_path, encoding="utf-8")
    16. 15 
    17. 16     # 获取所有分组
    18. 17     def get_sections(self):
    19. 18         return self.cf.sections()
    20. 19 
    21. 20     # 获取指定分组的所有键
    22. 21     def get_options(self, section):
    23. 22         return self.cf.options(section)  # 注意，获取的键会自动转小写
    24. 23 
    25. 24     # 获取指定分组的所有键值对
    26. 25     def get_items(self, section):
    27. 26         return dict(self.cf.items(section))  # 注意，获取的键会自动转小写
    28. 27 
    29. 28     # 获取指定分组指定键的值
    30. 29     def get_value(self, section, option):
    31. 30         return self.cf.get(section, option)
    32. 31 
    33. 32 
    34. 33 if __name__ == "__main__":
    35. 34     from util.global_var import *
    36. 35     p = IniParser(INI_FILE_PATH)
    37. 36     print(p.get_sections())
    38. 37     print(p.get_options("desired_caps"))
    39. 38     print(p.get_items("desired_caps"))
    40. 39     print(p.get_value("desired_caps", "deviceName"))

    email_util.py

    本模块封装了邮件发送功能。（示例代码中的用户名/密码已隐藏）

    1.  
    2.  1 import yagmail
    3.  2 import traceback
    4.  3 from util.log_util import *
    5.  4 
    6.  5 
    7.  6 def send_mail(attachments_report_name, receiver, subject, content):
    8.  7     try:
    9.  8         # 连接邮箱服务器
    10.  9         # 注意：若使用QQ邮箱，则password为授权码而非邮箱密码；使用其它邮箱则为邮箱密码
    11. 10         # encoding设置为GBK，否则中文附件名会乱码
    12. 11         yag = yagmail.SMTP(user="*****@163.com", password="*****", host="smtp.163.com", encoding='GBK')
    13. 12 
    14. 13         # 收件人、标题、正文、附件（若多个收件人或多个附件，则可使用列表）
    15. 14         yag.send(to=receiver, subject=subject, contents=content, attachments=attachments_report_name)
    16. 15 
    17. 16         # 可简写：yag.send("****@163.com", subject, contents, report)
    18. 17 
    19. 18         info("测试报告邮件发送成功!【邮件标题：%s】【邮件附件：%s】【收件人：%s】" % (subject, attachments_report_name, receiver))
    20. 19     except:
    21. 20         error("测试报告邮件发送失败!【邮件标题：%s】【邮件附件：%s】【收件人：%s】" % (subject, attachments_report_name, receiver))
    22. 21         error(traceback.format_exc())
    23. 22 
    24. 23 
    25. 24 if __name__ == "__main__":
    26. 25    send_mail("e:\\code.txt", "182230124@qq.com", "测试邮件", "正文")
    27. 26

     

    datetime_util.py

    本模块实现了获取各种格式的当前日期时间。

    1.  
    2.  1 import time
    3.  2 
    4.  3 
    5.  4 # 返回中文格式的日期：xxxx年xx月xx日
    6.  5 def get_chinese_date():
    7.  6     year = time.localtime().tm_year
    8.  7     if len(str(year)) == 1:
    9.  8         year = "0" + str(year)
    10.  9     month = time.localtime().tm_mon
    11. 10     if len(str(month)) == 1:
    12. 11         month = "0" + str(month)
    13. 12     day = time.localtime().tm_mday
    14. 13     if len(str(day)) == 1:
    15. 14         day = "0" + str(day)
    16. 15     return "{}年{}月{}日".format(year, month, day)
    17. 16 
    18. 17 
    19. 18 # 返回英文格式的日期：xxxx/xx/xx
    20. 19 def get_english_date():
    21. 20     year = time.localtime().tm_year
    22. 21     if len(str(year)) == 1:
    23. 22         year = "0" + str(year)
    24. 23     month = time.localtime().tm_mon
    25. 24     if len(str(month)) == 1:
    26. 25         month = "0" + str(month)
    27. 26     day = time.localtime().tm_mday
    28. 27     if len(str(day)) == 1:
    29. 28         day = "0" + str(day)
    30. 29     return "{}/{}/{}".format(year, month, day)
    31. 30 
    32. 31 
    33. 32 # 返回中文格式的时间：xx时xx分xx秒
    34. 33 def get_chinese_time():
    35. 34     hour = time.localtime().tm_hour
    36. 35     if len(str(hour)) == 1:
    37. 36         hour = "0" + str(hour)
    38. 37     minute = time.localtime().tm_min
    39. 38     if len(str(minute)) == 1:
    40. 39         minute = "0" + str(minute)
    41. 40     second = time.localtime().tm_sec
    42. 41     if len(str(second)) == 1:
    43. 42         second = "0" + str(second)
    44. 43     return "{}时{}分{}秒".format(hour, minute, second)
    45. 44 
    46. 45 
    47. 46 # 返回英文格式的时间：xx:xx:xx
    48. 47 def get_english_time():
    49. 48     hour = time.localtime().tm_hour
    50. 49     if len(str(hour)) == 1:
    51. 50         hour = "0" + str(hour)
    52. 51     minute = time.localtime().tm_min
    53. 52     if len(str(minute)) == 1:
    54. 53         minute = "0" + str(minute)
    55. 54     second = time.localtime().tm_sec
    56. 55     if len(str(second)) == 1:
    57. 56         second = "0" + str(second)
    58. 57     return "{}:{}:{}".format(hour, minute, second)
    59. 58 
    60. 59 
    61. 60 # 返回中文格式的日期时间
    62. 61 def get_chinese_datetime():
    63. 62     return get_chinese_date() + " " + get_chinese_time()
    64. 63 
    65. 64 
    66. 65 # 返回英文格式的日期时间
    67. 66 def get_english_datetime():
    68. 67     return get_english_date() + " " + get_english_time()
    69. 68 
    70. 69 
    71. 70 # 返回时间戳
    72. 71 def get_timestamp():
    73. 72     year = time.localtime().tm_year
    74. 73     if len(str(year)) == 1:
    75. 74         year = "0" + str(year)
    76. 75     month = time.localtime().tm_mon
    77. 76     if len(str(month)) == 1:
    78. 77         month = "0" + str(month)
    79. 78     day = time.localtime().tm_mday
    80. 79     if len(str(day)) == 1:
    81. 80         day = "0" + str(day)
    82. 81     hour = time.localtime().tm_hour
    83. 82     if len(str(hour)) == 1:
    84. 83         hour = "0" + str(hour)
    85. 84     minute = time.localtime().tm_min
    86. 85     if len(str(minute)) == 1:
    87. 86         minute = "0" + str(minute)
    88. 87     second = time.localtime().tm_sec
    89. 88     if len(str(second)) == 1:
    90. 89         second = "0" + str(second)
    91. 90     return "{}{}{}_{}{}{}".format(year, month, day, hour, minute, second)
    92. 91 
    93. 92 
    94. 93 if __name__ == "__main__":
    95. 94     print(get_chinese_datetime())
    96. 95     print(get_english_datetime())

     

    get_desired_caps.py

    本模块实现了获取 ini 配置文件中的 Appium 创建 Session 的配置信息。

    1.  
    2.  1 from util.ini_reader import IniParser
    3.  2 from util.global_var import INI_FILE_PATH
    4.  3 
    5.  4 
    6.  5 def get_desired_caps():
    7.  6     pcf = IniParser(INI_FILE_PATH)
    8.  7     items = pcf.get_items("desired_caps")  # 获取的键会自动转成小写
    9.  8     desired_caps = {
    10.  9         "platformName": items.get("platformname"),
    11. 10         "platformVersion": items.get("platformversion"),
    12. 11         "deviceName": items.get("devicename"),
    13. 12         "appPackage": items.get("apppackage"),
    14. 13         "appActivity": items.get("appactivity"),
    15. 14         "unicodeKeyboard": items.get("unicodekeyboard"),
    16. 15         "autoAcceptAlerts": items.get("autoacceptalerts"),
    17. 16         "resetKeyboard": items.get("resetkeyboard"),
    18. 17         "noReset": items.get("noreset"),
    19. 18         "newCommandTimeout": items.get("newcommandtimeout")
    20. 19     }
    21. 20     return desired_caps
    22. 21 
    23. 22 
    24. 23 if __name__ == "__main__":
    25. 24     from util.global_var import *
    26. 25     print(get_desired_caps())

     

    log_util.py

    封装了日志打印输出、级别设定等功能。

    1.  
    2.  1 import logging
    3.  2 import logging.config
    4.  3 from util.global_var import *
    5.  4 
    6.  5 
    7.  6 # 日志配置文件：多个logger，每个logger指定不同的handler
    8.  7 # handler：设定了日志输出行的格式
    9.  8 #          以及设定写日志到文件（是否回滚）？还是到屏幕
    10.  9 #          还定了打印日志的级别
    11. 10 logging.config.fileConfig(LOG_CONF_FILE_PATH)
    12. 11 logger = logging.getLogger("example01")
    13. 12 
    14. 13 
    15. 14 def debug(message):
    16. 15     logging.debug(message)
    17. 16 
    18. 17 
    19. 18 def info(message):
    20. 19     logging.info(message)
    21. 20 
    22. 21 
    23. 22 def warning(message):
    24. 23     logging.warning(message)
    25. 24 
    26. 25 
    27. 26 def error(message):
    28. 27     logging.error(message)
    29. 28 
    30. 29 
    31. 30 if __name__ == "__main__":
    32. 31     debug("hi")
    33. 32     info("gloryroad")
    34. 33     warning("hello")
    35. 34     error("这是一个error日志")

     

    report_util.py

    生成测试结果文件并发送邮件。

    1.  
    2.  1 from util.email_util import send_mail
    3.  2 from util.log_util import *
    4.  3 from util.datetime_util import *
    5.  4 
    6.  5 
    7.  6 # 生成测试报告并发送邮件
    8.  7 def create_excel_report_and_send_email(excel_obj, receiver, subject, content):
    9.  8     """
    10.  9     :param excel_obj: excel对象用于保存文件
    11. 10     :param timestamp: 用于文件命名的时间戳
    12. 11     :return: 返回excel测试报告文件名
    13. 12     """
    14. 13     time_stamp = get_timestamp()
    15. 14     report_path = excel_obj.save(subject, time_stamp)
    16. 15     send_mail(report_path, receiver, subject+"_"+time_stamp, content)

     

    conf 目录

    conf 目录属于第一层测试工具层，用于存储各配置文件。

    desired_caps_config.ini

    本配置文件存储了 Appium 创建 Session 的配置信息。

    1.  
    2. [desired_caps]
    3. platformName=Android
    4. platformVersion=6
    5. deviceName=3DN6T16B26001805
    6. appPackage=com.xsteach.appedu
    7. appActivity=com.xsteach.appedu.StartActivity
    8. unicodeKeyboard=True
    9. autoAcceptAlerts=True
    10. resetKeyboard=True
    11. noReset=True
    12. newCommandTimeout=6000

    logger.conf

    本配置文件用于日志功能的具体配置。

    1.  
    2. ###############################################
    3. [loggers]
    4. keys=root,example01,example02
    5. [logger_root]
    6. level=DEBUG
    7. handlers=hand01,hand02
    8.  
    9. [logger_example01]
    10. handlers=hand01,hand02
    11. qualname=example01
    12. propagate=0
    13.  
    14. [logger_example02]
    15. handlers=hand01,hand03
    16. qualname=example02
    17. propagate=0
    18.  
    19. ###############################################
    20. [handlers]
    21. keys=hand01,hand02,hand03
    22.  
    23. [handler_hand01]
    24. class=StreamHandler
    25. level=INFO
    26. formatter=form01
    27. args=(sys.stderr,)
    28.  
    29. [handler_hand02]
    30. class=FileHandler
    31. level=DEBUG
    32. formatter=form01
    33. args=('E:\\pycharm_project_dir\\AppAutoTest\\log\\app_test.log', 'a')
    34.  
    35. [handler_hand03]
    36. class=handlers.RotatingFileHandler
    37. level=INFO
    38. formatter=form01
    39. args=('E:\\pycharm_project_dir\\AppAutoTest\\log\\app_test.log', 'a', 10*1024*1024, 5)
    40.  
    41. ###############################################
    42. [formatters]
    43. keys=form01,form02
    44.  
    45. [formatter_form01]
    46. format=%(asctime)s [%(levelname)s] %(message)s
    47. datefmt=%Y-%m-%d %H:%M:%S
    48.  
    49. [formatter_form02]
    50. format=%(name)-12s: [%(levelname)-8s] %(message)s
    51. datefmt=%Y-%m-%d %H:%M:%S

     

    test_data 目录

    test_data 目录用于存放测试数据文件（Excel），存储了用例步骤、用例执行关键字、数据源等测试数据。

     

    main.py

    本模块是本框架的运行主入口，属于第四层“测试场景层”，将测试用例组织成测试场景，实现各种级别 cases 的管理，如冒烟，回归等测试场景。

    • 基于 business_process/main_process.py 中的模块用例 sheet 执行函数或主 sheet 执行函数，组装测试场景。
    • 可直接用代码组装测试场景，也可根据 excel 数据文件的用例集合和用例步骤的维护来设定测试场景。
    • 完成测试执行后生成测试结果文件并发送邮件。

    1.  1 from bussiness_process.main_process import *
    2.  2 from util.report_util import *
    3.  3 
    4.  4 
    5.  5 # 组装测试场景
    6.  6 # 冒烟测试
    7.  7 def smoke_test(report_name):
    8.  8     excel, _ = suite_process(TEST_DATA_FILE_PATH, "进入主页")
    9.  9     excel, _ = suite_process(excel, "登录")
    10. 10     excel, _ = suite_process(excel, "退出")
    11. 11     # 生成测试报告并发送邮件
    12. 12     create_excel_report_and_send_email(excel, ['itsjuno@163.com', '182230124@qq.com'], report_name, "请查收附件：app自动化测试报告")
    13. 13 
    14. 14 
    15. 15 # 全量测试：执行主sheet的用例集
    16. 16 def suite_test(report_name):
    17. 17     excel = main_suite_process(TEST_DATA_FILE_PATH, "测试用例集")
    18. 18     create_excel_report_and_send_email(excel, ['itsjuno@163.com', '182230124@qq.com'], report_name, "请查收附件：app自动化测试报告")
    19. 19 
    20. 20 
    21. 21 if __name__ == "__main__":
    22. 22     # smoke_test("APP自动化测试报告_冒烟测试")
    23. 23     suite_test("APP自动化测试报告_全量测试")

     

    test_report 目录

    本目录用于存放测试结果文件。

     

    exception_pic 目录

    本目录用于存放失败用例的截图。

     

    log 目录

    本目录用于存放日志输出文件（日志内容同时也会输出到控制台）。

    log/app_test.log：

    Python接口自动化测试零基础入门到精通（2023最新版）

  • 相关阅读:
    HTML5学习系列之项目实战1
    Python之第十二章 异常处理
    刷题笔记16——数组的花式输出
    最大子数组问题的分治
    通过plesk面板的文件管理器上传文件
    torch.gather() 用法解读
    浅谈面试经验
    django框架基于Python实现的作业查重系统
    LVS负载均衡集群
    Websocket在Asp.net webApi（.net framework）上的应用
  • 原文地址：https://blog.csdn.net/mashang123123123/article/details/133797949