自动化测试平台(十一)：UI自动化用例图形化编写及执行的实现

转x33g5p2x  于2022-03-14 转载在 其他  
字(10.6k)|赞(0)|评价(0)|浏览(707)

一、前言

上一章我们完成了UI元素及元素页面的管理功能，这一章节将实现UI自动化用例的编辑管理功能和执行功能。

完整教程地址：《从0搭建自动化测试平台》

项目在线演示地址：http://121.43.43.59/ （帐号：admin 密码：123456）

本章内容实现效果如下：

编辑用例

执行用例（需要执行客户端！联系博主获取）

二、前端页面

1. 创建元素页面模块文件

  1. npx umi g page uiCases/index --typescript

2. 概览页修改

增加提示和跳转功能

我们可以使用antd的Tooltip组件对卡片内容进行包裹，然后增加点击跳转到uicase路由的事件即可，代码如下：

  1. <Tooltip placement="top" title="点我查看UI用例">
  2.      <ul style={{ listStyleType: 'none', cursor: 'pointer', padding: 0 }} className={styles.card} onClick={() => history.push('/case/uiCaseOverview/UiCases')}>
  3.        <Badge status="error" text="用例失败数量：" />
  4.        {item.status1}
  5.        <li>
  6.          <Badge status="default" text="等待执行数量：" />
  7.          {item.status0}
  8.        </li>
  9.        <li>
  10.          <Badge status="warning" text="正在执行数量：" />
  11.          {item.status2}
  12.        </li>
  13.        <li>
  14.          <Badge status="processing" text="执行完成数量：" />
  15.          {item.status3}
  16.        </li>
  17.        <li>
  18.          <Badge status="success" text="测试通过数量：" />
  19.          {item.status4}
  20.        </li>
  21.      </ul>
  22.    </Tooltip>

这样点击卡片就能够调整到UI用例列表的页面了：

3. UI用例列表页

查询树和查询列表与之前的模块大同小异；直接CURD就可以了

3. 编辑UI用例弹窗

弹窗可以动态的增加步骤并根据选择操作不同显示/隐藏不同组件：

跳转新页面修改数据后，会自动更新数据

下方选择页面的名称在修改后由“百度搜索主页”自动变为“百度搜索”了：

这里和我们之前实现的页面主要不同点如下：

  1. 执行步骤在点击加减图标后会动态的增加减少；
  2. 切换了操作类型后，界面的组件（输入框、选择框）会动态的显示或隐藏；
  3. 跳转新页面修改数据后，会自动更新数据；

实现思路如下

3.1 动态增加步骤

我们可以使用antd的ProFormList组件来实现，文档地址：https://procomponents.ant.design/components/group

参考代码：

  1. <ProFormList
  2.      name="steps"
  3.      style={{
  4.        border: '1px solid #f0f0f0',
  5.        borderRadius: 6,
  6.        marginTop: 20,
  7.        marginBottom: 20,
  8.        paddingLeft: 10,
  9.      }}
  10.      alwaysShowItemLabel
  11.      initialValue={caseSteps}
  12.      creatorButtonProps={false}
  13.      copyIconProps={false}
  14.      deleteIconProps={false}
  15.    >
  16.      {(f, index, { add, remove }) => {
  17.        return (
  18.          <div style={{ marginTop: 20 }}>
  19.            <h3 style={{ fontWeight: 'bold' }}>步骤 {index + 1}</h3>
  20.            <ProFormSelect
  21.              name="ui_action_id"
  22.              label="选择操作"
  23.              width="md"
  24.              allowClear={false}
  25.              fieldProps={{
  26.                options: actionData,
  27.                showSearch: true,
  28.                onChange: (v: any, record: any) => {
  29.                  const c_step = formRef.current.getFieldValue('steps');
  30.                  c_step[index].show_type = record.show_type;
  31.                  formRef.current.setFieldsValue({ steps: c_step });
  32.                },
  33.              }}
  34.              placeholder="请选择操作"
  35.              rules={[{ required: true, message: '请选择操作！' }]}
  36.            />
  37.            <ProFormDependency
  38.              name={['show_type', 'cascader_pages', 'element_id']}
  39.            >
  40.              {({ show_type, cascader_pages, element_id }) => {
  41.                var stepItems: any;
  42.                if (show_type == 1 || show_type == 3) {
  43.                  stepItems = (
  44.                    <>
  45.                      <div style={{ display: 'flex' }}>
  46.                        <ProFormCascader
  47.                          name="cascader_pages"
  48.                          label="选择页面"
  49.                          width="md"
  50.                          fieldProps={{
  51.                            changeOnSelect: true,
  52.                            expandTrigger: 'hover',
  53.                            fieldNames: {
  54.                              label: 'name',
  55.                              value: 'id',
  56.                              children: 'children',
  57.                            },
  58.                            options: pageTreeData,
  59.                            onChange: async (page: any) => {
  60.                              if (page) {
  61.                                const page_id = page[0];
  62.                                const c_step =
  63.                                  formRef.current.getFieldValue('steps');
  64.                                c_step[index].element_id = null; //将选择的步骤值设置为空
  65.                                formRef.current.setFieldsValue({
  66.                                  steps: c_step,
  67.                                });
  69.                                await getUiPagesElements({
  70.                                  page_ids: page_id,
  71.                                }).then((res) => {
  72.                                  let pageEle = Object.assign(
  73.                                    pageElement,
  74.                                    res.data,
  75.                                  );
  76.                                  console.log('d1', pageEle)
  77.                                  setPageElement(pageEle);
  78.                                  const c_step =
  79.                                    formRef.current.getFieldValue('steps');
  80.                                  c_step[index].cascader_pages = page; //将选择的步骤值设置为空
  81.                                  formRef.current.setFieldsValue({
  82.                                    steps: c_step,
  83.                                  });
  84.                                });
  85.                              }
  86.                            },
  87.                          }}
  88.                          rules={[
  89.                            { required: true, message: '请选择页面！' },
  90.                          ]}
  91.                        />
  92.                        <span
  93.                          className={styles.operationStyle}
  94.                          style={{ marginTop: 5 }}
  95.                          onClick={() =>
  96.                            window.open(
  97.                              `/case/uiCaseOverview/UiPage?project_id=${projectId}`,
  98.                            )
  99.                          }
  100.                        >
  101.                          维护页面
  102.                        </span>
  103.                      </div>
  104.                      <div style={{ display: 'flex' }}>
  105.                        <ProFormSelect
  106.                          name="element_id"
  107.                          label="选择元素"
  108.                          width="md"
  109.                          fieldProps={{
  110.                            showSearch: true,
  111.                            options: cascader_pages
  112.                              ? parsePageElement(
  113.                                pageElement[cascader_pages.slice(-1)],
  114.                              )
  115.                              : [],
  116.                          }}
  117.                          placeholder="请选择元素"
  118.                          rules={[
  119.                            { required: true, message: '请选择元素！' },
  120.                          ]}
  121.                        />
  122.                        <div style={{ marginTop: 5 }}>
  123.                          <span
  124.                            className={styles.operationStyle}
  125.                            onClick={() => {
  126.                              if (cascader_pages?.length > 0) {
  127.                                showEleModal(
  128.                                  REQ_CREATE,
  129.                                  cascader_pages.slice(-1)[0],
  130.                                  index,
  131.                                );
  132.                              } else {
  133.                                message.error('请先选择页面！');
  134.                              }
  135.                            }}
  136.                          >
  137.                            创建元素
  138.                          </span>
  139.                          <span
  140.                            className={styles.operationStyle}
  141.                            style={{ marginLeft: 8 }}
  142.                            onClick={() => {
  143.                              console.log('ee', element_id);
  144.                              if (element_id) {
  145.                                showEleModal(
  146.                                  REQ_UPDATE,
  147.                                  cascader_pages.slice(-1)[0],
  148.                                  index,
  149.                                  { id: element_id },
  150.                                );
  151.                              } else {
  152.                                message.error('请先选择元素！');
  153.                              }
  154.                            }}
  155.                          >
  156.                            修改元素
  157.                          </span>
  158.                        </div>
  159.                      </div>
  160.                    </>
  161.                  );
  162.                }
  163.                if (show_type == 2 || show_type == 3) {
  164.                  return (
  165.                    <div style={{ marginBottom: 20 }}>
  166.                      {stepItems}
  167.                      <ProFormText
  168.                        allowClear={false}
  169.                        width="xl"
  170.                        name="value"
  171.                        rules={[
  172.                          { required: true, message: '请输入值' },
  173.                          { type: 'string' },
  174.                          { max: 255, message: '最多18个字' },
  175.                        ]}
  176.                        label="操作数值"
  177.                        placeholder="请输入操作值"
  178.                      />
  179.                    </div>
  180.                  );
  181.                }
  182.                return <div style={{ marginBottom: 20 }}>{stepItems} </div>;
  183.              }}
  184.            </ProFormDependency>
  185.            <PlusCircleOutlined onClick={() => add({}, index + 1)} />
  186.            <MinusCircleOutlined
  187.              onClick={() => {
  188.                if (index > 0) {
  189.                  remove(index);
  190.                }
  191.              }}
  192.            />
  193.          </div>
  194.        );
  195.      }}
  196.    </ProFormList>

3.2 界面的组件动态的显示/隐藏

在数据库中我们对每个操作需要的内容都用show_type这个字段做了区分：

show_type的值对应的含义如下：

  1. show_type = 0  # 只需要操作类型 例如：dirver.close()
  2. show_type = 1  # 需要操作元素,例如:driver.click()
  3. show_type = 2  # 需要操作值，例如：driver.get(url)
  4. show_type = 3  # 即需要元素也需要值，例如:driver.send_keys()

这样我们后续增加操作，也可以直接在数据库中进行添加而不动代码。

然后前端可以使用antd的ProFormDependency组件来收集每个步骤的show_type的值，然后根据其不同来返回不同的UI组件即可：

参考代码

  1. <ProFormDependency
  2.         name={['show_type', 'cascader_pages', 'element_id']}
  3.       >
  4.         {({ show_type, cascader_pages, element_id }) => {
  5.           var stepItems: any;
  6.           if (show_type == 1 || show_type == 3) {
  7.             stepItems = (
  8.               <>
  9.                 <div style={{ display: 'flex' }}>
  10.                   <ProFormCascader
  11.                     name="cascader_pages"
  12.                     label="选择页面"
  13.                     width="md"
  14.                     fieldProps={{
  15.                       changeOnSelect: true,
  16.                       expandTrigger: 'hover',
  17.                       fieldNames: {
  18.                         label: 'name',
  19.                         value: 'id',
  20.                         children: 'children',
  21.                       },
  22.                       options: pageTreeData,
  23.                       onChange: async (page: any) => {
  24.                         if (page) {
  25.                           const page_id = page[0];
  26.                           const c_step =
  27.                             formRef.current.getFieldValue('steps');
  28.                           c_step[index].element_id = null; //将选择的步骤值设置为空
  29.                           formRef.current.setFieldsValue({
  30.                             steps: c_step,
  31.                           });
  33.                           await getUiPagesElements({
  34.                             page_ids: page_id,
  35.                           }).then((res) => {
  36.                             let pageEle = Object.assign(
  37.                               pageElement,
  38.                               res.data,
  39.                             );
  40.                             console.log('d1', pageEle)
  41.                             setPageElement(pageEle);
  42.                             const c_step =
  43.                               formRef.current.getFieldValue('steps');
  44.                             c_step[index].cascader_pages = page; //将选择的步骤值设置为空
  45.                             formRef.current.setFieldsValue({
  46.                               steps: c_step,
  47.                             });
  48.                           });
  49.                         }
  50.                       },
  51.                     }}
  52.                     rules={[
  53.                       { required: true, message: '请选择页面！' },
  54.                     ]}
  55.                   />
  56.                   <span
  57.                     className={styles.operationStyle}
  58.                     style={{ marginTop: 5 }}
  59.                     onClick={() =>
  60.                       window.open(
  61.                         `/case/uiCaseOverview/UiPage?project_id=${projectId}`,
  62.                       )
  63.                     }
  64.                   >
  65.                     维护页面
  66.                   </span>
  67.                 </div>
  68.                 <div style={{ display: 'flex' }}>
  69.                   <ProFormSelect
  70.                     name="element_id"
  71.                     label="选择元素"
  72.                     width="md"
  73.                     fieldProps={{
  74.                       showSearch: true,
  75.                       options: cascader_pages
  76.                         ? parsePageElement(
  77.                           pageElement[cascader_pages.slice(-1)],
  78.                         )
  79.                         : [],
  80.                     }}
  81.                     placeholder="请选择元素"
  82.                     rules={[
  83.                       { required: true, message: '请选择元素！' },
  84.                     ]}
  85.                   />
  86.                   <div style={{ marginTop: 5 }}>
  87.                     <span
  88.                       className={styles.operationStyle}
  89.                       onClick={() => {
  90.                         if (cascader_pages?.length > 0) {
  91.                           showEleModal(
  92.                             REQ_CREATE,
  93.                             cascader_pages.slice(-1)[0],
  94.                             index,
  95.                           );
  96.                         } else {
  97.                           message.error('请先选择页面！');
  98.                         }
  99.                       }}
  100.                     >
  101.                       创建元素
  102.                     </span>
  103.                     <span
  104.                       className={styles.operationStyle}
  105.                       style={{ marginLeft: 8 }}
  106.                       onClick={() => {
  107.                         console.log('ee', element_id);
  108.                         if (element_id) {
  109.                           showEleModal(
  110.                             REQ_UPDATE,
  111.                             cascader_pages.slice(-1)[0],
  112.                             index,
  113.                             { id: element_id },
  114.                           );
  115.                         } else {
  116.                           message.error('请先选择元素！');
  117.                         }
  118.                       }}
  119.                     >
  120.                       修改元素
  121.                     </span>
  122.                   </div>
  123.                 </div>
  124.               </>
  125.             );
  126.           }
  127.           if (show_type == 2 || show_type == 3) {
  128.             return (
  129.               <div style={{ marginBottom: 20 }}>
  130.                 {stepItems}
  131.                 <ProFormText
  132.                   allowClear={false}
  133.                   width="xl"
  134.                   name="value"
  135.                   rules={[
  136.                     { required: true, message: '请输入值' },
  137.                     { type: 'string' },
  138.                     { max: 255, message: '最多18个字' },
  139.                   ]}
  140.                   label="操作数值"
  141.                   placeholder="请输入操作值"
  142.                 />
  143.               </div>
  144.             );
  145.           }
  146.           return <div style={{ marginBottom: 20 }}>{stepItems} </div>;
  147.         }}
  148.       </ProFormDependency>

3.3 切换页面自动刷新数据显示

实现这个功能我们需要使用到窗口监听事件visibilitychange，在我们监听到窗口切换后，则自动请求获取元素页面数据的接口：

请求元素页面的方法

  1. const refreshPageTree = useCallback(() => {
  2.   if (!window.document.hidden) {
  3.     //当页面显示的时候重新请求一次页面树
  4.     treeUiPage({ project_id: projectId }).then((res) =>
  5.       setPageTree(res.data),
  6.     );
  7.   }
  8. }, []);

注册监听事件

  1. useEffect(() => {
  2.     window.addEventListener('visibilitychange', refreshPageTree);
  3.   }, []);

这样在我们每次切换页面后就会调用刷新页面数据的接口进行数据刷新了。

当然，我们处于其他页面时，并不想再让它刷新数据，所以我们可以再关闭弹窗的时候，移除这个监听事件：

  1. modalProps={{
  2.         destroyOnClose: true,
  3.         maskClosable: false,
  4.         onCancel: () => {
  5.           window.removeEventListener('visibilitychange', refreshPageTree);
  6.           cancel();
  7.         },
  8.       }}

其他地方的功能都没啥难点了，将填写的数据收集好保存到库中，然后通过执行用例的接口（需自己实现）进行任务的执行即可，小伙伴可以自己动手实现。

三、执行任务思路讲解

selenium有自己的分布式执行方案，也可以远程执行等。但这里存在一个明显的问题（主机和客户机需要再同一网络环境下），在公司还好大家都在局域网，但是想通过平台控制家里的电脑来执行任务就不行了。
为了扩展灵活性并解决这个问题，我采取了心跳机制的方式：服务暴露一个心跳接口，客户端定时轮询请求这个接口，当用户在平台点击执行任务的操作后，服务器会改变执行状态，由于状态的变更，客户端此时请求心跳接口就会拉取任务进行执行了。

拉取到任务后我们就可以根据约定的格式来执行任务了，格式约定可以根据大家的喜好来。也可以参考之前教程：《曲鸟全栈UI自动化教学(八)：框架代码讲解和进一步优化》 的执行方式来实现。

至于一些配置（请求密钥、步骤失败后的重试次数、请求的服务器地址等）我采用yaml来管理：

执行UI步骤的dirver代码如下（主要通过反射的方式来选择元素定位方式和要执行的操作），可以参考之前教程：《曲鸟全栈UI自动化教学(八)：框架代码讲解和进一步优化》 ：

  1. import time
  3. from retrying import retry
  4. from selenium import webdriver
  5. from selenium.common.exceptions import WebDriverException
  6. from selenium.webdriver.common.by import By
  8. from constant import STEP_ONLY_ACTION, PATH_ELEMENT, STEP_NEED_ELEMENT, STEP_NEED_VALUE, STEP_NEED_ALL, IMAGE_ELEMENT
  10. wait_fixed = 1000
  11. stop_max_attempt_number = 6
  13. class UiDriver():
  14.     """
  15.     ui自动化对象
  16.     """
  18.     def __init__(self, case_data, settings):
  19.         self.driver = None
  20.         self.case_data = case_data
  21.         self.step_sleep = settings['step_sleep']
  22.         globals()['wait_fixed'] = settings['wait_fixed']
  23.         globals()['stop_max_attempt_number'] = settings['stop_max_attempt_number']
  25.     def run_case(self):
  26.         """
  27.         执行UI自动化的入口方法
  28.         :return:
  29.         """
  30.         print("开始执行UI自动化......")
  31.         try:
  32.             self.driver = webdriver.Chrome()
  33.         except WebDriverException:
  34.             input("请下载与谷歌浏览器版本对应的chromedirver!")
  35.         cases = self.case_data# case_steps
  36.         for step in cases:
  37.             time.sleep(self.step_sleep)
  38.             self.run_step(step)
  39.         return True
  41.     @retry(wait_fixed=wait_fixed, stop_max_attempt_number=stop_max_attempt_number)
  42.     def run_step(self, step):
  43.         """
  44.         执行用例步骤的具体方法
  45.         """
  47.         show_type = step['show_type']
  48.         print('s', step['ui_action'])
  50.         if show_type == STEP_ONLY_ACTION:
  51.             getattr(self.driver, step['ui_action'])()
  52.         elif show_type == STEP_NEED_ELEMENT:
  53.             driver = choose_location_method(step['element_data'], self.driver)
  54.             getattr(driver, step['ui_action'])()
  55.         elif show_type == STEP_NEED_VALUE:
  56.             getattr(self.driver, step['ui_action'])(step['value'])
  57.         elif show_type == STEP_NEED_ALL:
  58.             driver = choose_location_method(step['element_data'], self.driver)
  59.             getattr(driver, step['ui_action'])(step['value'])
  61. def choose_location_method(element, driver):
  62.     """
  63.     根据元素类型不同选择不同方式进行定位
  64.     :return:
  65.     """
  66.     if element['type'] == PATH_ELEMENT:
  67.         driver = driver.find_element(getattr(By, element['location_method']), element['path'])
  68.     elif element['type'] == IMAGE_ELEMENT:
  69.         pass
  70.     return driver

四、将客户端打包

当我们完成执行客户端的代码编写后，可以通过pyinstaller第三方库将其打包为可执行文件，这样别人使用时就不需要考虑环境配置的问题了。谁有，谁就是执行客户端。

五、总结

这一章完成了UI用例编辑和执行的功能，当然还有很多需要完善的地方，比如增加执行日志，执行完成后的结果判断及变更等。小伙伴们可以按文中的思路和操作方式继续完善。

下一章节将开始接口自动化的教学了。

平台在线演示地址：http://121.43.43.59/ （帐号：admin 密码：123456）

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://quniao.blog.csdn.net/article/details/122330808

内容来源于网络，如有侵权，请联系作者删除！

pythondjango前端自动化曲鸟

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com