mangoautomation 1.0.36__tar.gz → 1.0.38__tar.gz

{mangoautomation-1.0.36/mangoautomation.egg-info → mangoautomation-1.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mangoautomation
-Version: 1.0.36
+Version: 1.0.38
 Summary: 测试工具
 Home-page: https://gitee.com/mao-peng/testkit
 Author: 毛鹏

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/exceptions/_error_msg.py

@@ -1,68 +1,68 @@
-# -*- coding: utf-8 -*-
-# @Project: 芒果测试平台
-# @Description: 错误消息统一管理
-# @Time   : 2024-02-01 10:00
-# @Author : 毛鹏
-
-ERROR_MSG_0001 = (4001, '')
-ERROR_MSG_0002 = (4002, '')
-ERROR_MSG_0003 = (4003, '')
-ERROR_MSG_0004 = (4004, '')
-ERROR_MSG_0005 = (4018, '断言失败，断言输入值是：空字符串、null或不满足函数接受类型')
-ERROR_MSG_0006 = (4006, '')
-ERROR_MSG_0007 = (4007, '安卓设备被关闭，请检查设备')
-ERROR_MSG_0008 = (4008, '浏览器类型不正确，请联系管理员检查')
-ERROR_MSG_0009 = (4009, '浏览器路径不正确，请手动设置一个正确的浏览器路径，现在的路径：{}')
-ERROR_MSG_0010 = (4010, '浏览器被关闭，请不要手动关闭浏览器')
-ERROR_MSG_0011 = (4011, '操作元素【{}】超时，请检查元素可见但是是否可操作或调整定位方式')
-ERROR_MSG_0012 = (4012, '操作失败，请检查输入的值是否有空字符串，null或不满足传参的值')
-ERROR_MSG_0013 = (
-    313, '打开url时超时，分为2个问题：1.启用的浏览器过多，应当减少浏览器并发个数；2.自行查看为啥60秒还未打开：{}')
-ERROR_MSG_0014 = (4014, '')
-ERROR_MSG_0015 = (4015, '的类型错误，请联系管理员进行排查问题')
-ERROR_MSG_0016 = (4016, '')
-ERROR_MSG_0017 = (4017, '断言失败： {}')
-ERROR_MSG_0018 = (4018, '')
-ERROR_MSG_0019 = (4019, '配置了sql断言，但是并没有配置mysql的数据库配置，请检查！')
-ERROR_MSG_0020 = (4020, '没有更多的断言方式，请检查是否选择了非该设备类型的元素定位方式')
-ERROR_MSG_0021 = (4021, '元素未找到，请检查断言前操作是否正常完成')
-ERROR_MSG_0022 = (4022, '页面无此元素，请检查传入的元素是否正确')
-ERROR_MSG_0023 = (4023, 'iframe中未找到此元素，请检查元素表达式是否是正确的')
-ERROR_MSG_0024 = (4024, '上传文件的元素必须要是input标签中的')
-ERROR_MSG_0025 = (4025, '无法元素对应的下标，请检查通过下标获取元素的数是否正确，当前元素个数：{}')
-ERROR_MSG_0026 = (4026, '')
-ERROR_MSG_0027 = (4027,
-                  '您元素的操作内容中没有任何的数据，请检查：1.页面步骤详情中字段->元素操作值是否是空，是空可能是你删除了，也可能是执行器的操作选项没有同步需要点击执行器的同步发送缓存数据；2.元素表达式错误导致查询不到元素；')
-ERROR_MSG_0028 = (4028, '')
-ERROR_MSG_0029 = (4029, '页面无元素【{}】，表达式：{}')
-ERROR_MSG_0030 = (4030, '断言时没有找到元素')
-ERROR_MSG_0031 = (4031, '元素未找到准备进行断言获取元素文本类容异常')
-ERROR_MSG_0032 = (4032, '元素【{}】的元素表达式定位有多个，或其他元素异常，请检查元素是否可用')
-ERROR_MSG_0036 = (4036, '公共参数sql在数据库中查询不到结果，sql：{}')
-ERROR_MSG_0038 = (4038, '公共参数的sql_key不是列表')
-ERROR_MSG_0040 = (
-    340, '设备启动超时！请检查设备是否开启了：文件传输模式、开发者模式、usb调试，开启后请重新连接电脑，设备号：{}')
-ERROR_MSG_0041 = (4041, '查找页面元素【{}】时直接失败，报错信息：{}')
-ERROR_MSG_0042 = (4042, '实例化对象错误，设备信息是空无法实例化，请联系管理员检查')
-ERROR_MSG_0043 = (4043, '元素【{}】可能不存在，报错信息：{}')
-ERROR_MSG_0044 = (4044, '元素【{}】可能无法消失，报错信息：{}')
-ERROR_MSG_0045 = (4045, '设备启动超时！请检查设备是否已成功连接电脑，设备号：{}')
-ERROR_MSG_0046 = (4046, '您要测试的设备中，没有您输入的包名，请检查包名是否正确，或者设备是否安装了这个软件包')
-ERROR_MSG_0047 = (4047, '')
-ERROR_MSG_0048 = (4048, '选项发生错误，请在执行器点击发送缓存数据，然后重新修改步骤的操作！或联系管理员处理！')
-ERROR_MSG_0049 = (4049, 'url格式错误，请检查url或者是选择的测试环境不正确')
-ERROR_MSG_0050 = (4050, 'xpath定位未找到元素')
-ERROR_MSG_0051 = (4051, '')
-ERROR_MSG_0052 = (4052, '元素【{}】 进行断言时发生异常，请检查元素是否可以正常使用')
-ERROR_MSG_0053 = (4053, '步骤是断言类型，但是你没有输入断言内容，请查看文档中对元素断言的介绍')
-ERROR_MSG_0054 = (4054, '步骤是操作类型，但是你没有输入操作内容，请查看文档中对元素操作的介绍')
-ERROR_MSG_0055 = (4055, '您的电脑未安装指定浏览器！')
-ERROR_MSG_0056 = (4056, '输入的参数类型不正确，请检查操作输入框的类型是否正确')
-ERROR_MSG_0057 = (
-    357,
-    '创建浏览器的时候失败,如果你开启了视频录制，则需要执行帮助文档中，windows部署的模块最后的安装playwright依赖。如果不是视频录制原因，则请发给管理员！')
-ERROR_MSG_0058 = (4058, '电脑可能无网络，或者设置了代理，浏览器无法进行请求！')
-ERROR_MSG_0059 = (4059, '输入内容的类型不正确')
-ERROR_MSG_0060 = (4060, '请把元素等信息都发给管理员来解决这个报错，报错：{}')
-ERROR_MSG_0061 = (4061, '')
-ERROR_MSG_0062 = (4062, '请执行：playwright install 命令，安装符合要求的浏览器再运行命令行模式的执行器')
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: 错误消息统一管理
+# @Time   : 2024-02-01 10:00
+# @Author : 毛鹏
+
+ERROR_MSG_0001 = (4001, '')
+ERROR_MSG_0002 = (4002, '')
+ERROR_MSG_0003 = (4003, '')
+ERROR_MSG_0004 = (4004, '')
+ERROR_MSG_0005 = (4018, '断言失败，断言输入值是：空字符串、null或不满足函数接受类型')
+ERROR_MSG_0006 = (4006, '')
+ERROR_MSG_0007 = (4007, '安卓设备被关闭，请检查设备')
+ERROR_MSG_0008 = (4008, '浏览器类型不正确，请联系管理员检查')
+ERROR_MSG_0009 = (4009, '浏览器路径不正确，请手动设置一个正确的浏览器路径，现在的路径：{}')
+ERROR_MSG_0010 = (4010, '浏览器被关闭，请不要手动关闭浏览器')
+ERROR_MSG_0011 = (4011, '操作元素【{}】超时，请检查元素可见但是是否可操作或调整定位方式')
+ERROR_MSG_0012 = (4012, '操作失败，请检查输入的值是否有空字符串，null或不满足传参的值')
+ERROR_MSG_0013 = (
+    313, '打开url时超时，分为2个问题：1.启用的浏览器过多，应当减少浏览器并发个数；2.自行查看为啥60秒还未打开：{}')
+ERROR_MSG_0014 = (4014, '')
+ERROR_MSG_0015 = (4015, '的类型错误，请联系管理员进行排查问题')
+ERROR_MSG_0016 = (4016, '')
+ERROR_MSG_0017 = (4017, '断言失败： {}')
+ERROR_MSG_0018 = (4018, '')
+ERROR_MSG_0019 = (4019, '配置了sql断言，但是并没有配置mysql的数据库配置，请检查！')
+ERROR_MSG_0020 = (4020, '没有更多的断言方式，请检查是否选择了非该设备类型的元素定位方式')
+ERROR_MSG_0021 = (4021, '元素未找到，请检查断言前操作是否正常完成')
+ERROR_MSG_0022 = (4022, '页面无此元素，请检查传入的元素是否正确')
+ERROR_MSG_0023 = (4023, 'iframe中未找到此元素，请检查元素表达式是否是正确的')
+ERROR_MSG_0024 = (4024, '上传文件的元素必须要是input标签中的')
+ERROR_MSG_0025 = (4025, '无法元素对应的下标，请检查通过下标获取元素的数是否正确，当前元素个数：{}')
+ERROR_MSG_0026 = (4026, '')
+ERROR_MSG_0027 = (4027,
+                  '您元素的操作内容中没有任何的数据，请检查：1.页面步骤详情中字段->元素操作值是否是空，是空可能是你删除了，也可能是执行器的操作选项没有同步需要点击执行器的同步发送缓存数据；2.元素表达式错误导致查询不到元素；')
+ERROR_MSG_0028 = (4028, '')
+ERROR_MSG_0029 = (4029, '页面无元素【{}】，表达式：{}')
+ERROR_MSG_0030 = (4030, '断言时没有找到元素')
+ERROR_MSG_0031 = (4031, '元素未找到准备进行断言获取元素文本类容异常')
+ERROR_MSG_0032 = (4032, '元素【{}】的元素表达式定位有多个，或其他元素异常，请检查元素是否可用')
+ERROR_MSG_0036 = (4036, '公共参数sql在数据库中查询不到结果，sql：{}')
+ERROR_MSG_0038 = (4038, '公共参数的sql_key不是列表')
+ERROR_MSG_0040 = (
+    340, '设备启动超时！请检查设备是否开启了：文件传输模式、开发者模式、usb调试，开启后请重新连接电脑，设备号：{}')
+ERROR_MSG_0041 = (4041, '查找页面元素【{}】时直接失败，报错信息：{}')
+ERROR_MSG_0042 = (4042, '实例化对象错误，设备信息是空无法实例化，请联系管理员检查')
+ERROR_MSG_0043 = (4043, '元素【{}】可能不存在，报错信息：{}')
+ERROR_MSG_0044 = (4044, '元素【{}】可能无法消失，报错信息：{}')
+ERROR_MSG_0045 = (4045, '设备启动超时！请检查设备是否已成功连接电脑，设备号：{}')
+ERROR_MSG_0046 = (4046, '您要测试的设备中，没有您输入的包名，请检查包名是否正确，或者设备是否安装了这个软件包')
+ERROR_MSG_0047 = (4047, '')
+ERROR_MSG_0048 = (4048, '选项发生错误，请在执行器点击发送缓存数据，然后重新修改步骤的操作！或联系管理员处理！')
+ERROR_MSG_0049 = (4049, 'url格式错误，请检查url或者是选择的测试环境不正确')
+ERROR_MSG_0050 = (4050, 'xpath定位未找到元素')
+ERROR_MSG_0051 = (4051, '')
+ERROR_MSG_0052 = (4052, '元素【{}】 进行断言时发生异常，请检查元素是否可以正常使用')
+ERROR_MSG_0053 = (4053, '步骤是断言类型，但是你没有输入断言内容，请查看文档中对元素断言的介绍')
+ERROR_MSG_0054 = (4054, '步骤是操作类型，但是你没有输入操作内容，请查看文档中对元素操作的介绍')
+ERROR_MSG_0055 = (4055, '您的电脑未安装指定浏览器！')
+ERROR_MSG_0056 = (4056, '输入的参数类型不正确，请检查操作输入框的类型是否正确')
+ERROR_MSG_0057 = (
+    357,
+    '创建浏览器的时候失败,如果你开启了视频录制，则需要执行帮助文档中，windows部署的模块最后的安装playwright依赖。如果不是视频录制原因，则请发给管理员！')
+ERROR_MSG_0058 = (4058, '电脑可能无网络，或者设置了代理，浏览器无法进行请求！')
+ERROR_MSG_0059 = (4059, '输入内容的类型不正确')
+ERROR_MSG_0060 = (4060, '请把元素等信息都发给管理员来解决这个报错，报错：{}')
+ERROR_MSG_0061 = (4061, '')
+ERROR_MSG_0062 = (4062, '请执行：playwright install 命令，安装符合要求的浏览器再运行命令行模式的执行器')

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/exceptions/_exceptions.py

@@ -1,14 +1,14 @@
-# -*- coding: utf-8 -*-
-# @Project: 芒果测试平台
-# @Description:
-# @Time: 2023-07-16 15:17
-# @Author : 毛鹏
-
-class MangoAutomationError(Exception):
-
-    def __init__(self, code: int, msg: str, value: tuple = None):
-        self.msg = msg.format(*value) if value else msg
-        self.code = code
-
-    def __str__(self):
-        return f"[{self.code}] {self.msg}"
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description:
+# @Time: 2023-07-16 15:17
+# @Author : 毛鹏
+
+class MangoAutomationError(Exception):
+
+    def __init__(self, code: int, msg: str, value: tuple = None):
+        self.msg = msg.format(*value) if value else msg
+        self.code = code
+
+    def __str__(self):
+        return f"[{self.code}] {self.msg}"

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/uidrive/_async_element.py

@@ -6,6 +6,7 @@
 import asyncio
 import os
 import traceback
+from typing import Optional
 
 from playwright._impl._errors import TargetClosedError, Error
 
@@ -22,12 +23,28 @@ from ..uidrive.web.async_web import AsyncWebDevice, AsyncWebAssertion
 
 class AsyncElement(AsyncWebDevice, AndroidDriver):
 
-    def __init__(self, base_data, element_model: ElementModel, drive_type: int, element_data: dict | None = None):
+    def __init__(self, base_data, drive_type: int, ):
         super().__init__(base_data)
-        self.element_data = element_data
-        self.element_model = element_model
         self.drive_type = drive_type
-        self.ope_name = element_model.name if element_model.name else element_model.ope_key
+        self.element_model: Optional[ElementModel | None] = None
+        self.element_data: dict | None = None
+        self.element_result_model: Optional[ElementResultModel | None] = None
+
+    async def open_device(self, is_open: bool = False):
+        if self.drive_type == DriveTypeEnum.WEB.value:
+            await self.open_url(is_open)
+        elif self.drive_type == DriveTypeEnum.ANDROID.value:
+            self.open_app()
+        elif self.drive_type == DriveTypeEnum.DESKTOP.value:
+            pass
+        else:
+            self.base_data.log.debug(f'不存在这个类型，如果是非管理员看到这种提示，请联系管理员')
+            raise Exception('不存在的设备类型')
+
+
+    async def element_main(self, element_model: ElementModel, element_data: dict | None = None) -> ElementResultModel:
+        self.element_model = element_model
+        self.element_data = element_data
         self.element_result_model = ElementResultModel(
             id=self.element_model.id,
             name=self.element_model.name,
@@ -45,19 +62,6 @@ class AsyncElement(AsyncWebDevice, AndroidDriver):
 
             status=StatusEnum.FAIL.value,
         )
-
-    async def open_device(self, is_open: bool = False):
-        if self.drive_type == DriveTypeEnum.WEB.value:
-            await self.open_url(is_open)
-        elif self.drive_type == DriveTypeEnum.ANDROID.value:
-            self.open_app()
-        elif self.drive_type == DriveTypeEnum.DESKTOP.value:
-            pass
-        else:
-            self.base_data.log.debug(f'不存在这个类型，如果是非管理员看到这种提示，请联系管理员')
-            raise Exception('不存在的设备类型')
-
-    async def element_main(self) -> ElementResultModel:
         try:
             await self.__main()
             if self.element_model.sleep:
@@ -65,19 +69,24 @@ class AsyncElement(AsyncWebDevice, AndroidDriver):
             self.element_result_model.status = StatusEnum.SUCCESS.value
             self.element_result_model.error_message = None
         except MangoAutomationError as error:
+            self.base_data.log.debug(f'操作元素异常-1，类型：{type(error)}，失败详情：{error}')
             await self.__error(error.msg)
-            self.base_data.log.debug(f'已知异常，类型：{type(error)}，失败详情：{error}')
+        except TargetClosedError as error:
+            self.base_data.setup()
+            self.base_data.log.debug(
+                f'操作元素异常-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+            await self.__error(ERROR_MSG_0010[1], False)
         except Error as error:
-            await self.__error(f'未知错误失败，请检查测试数据，如果需要明确的提示请联系管理员，提示：{error.message}')
             self.base_data.log.error(
-                f'未知错误捕获-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+                f'操作元素异常-3，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+            await self.__error(f'未知错误失败，请检查测试数据，如果需要明确的提示请联系管理员，提示：{error.message}')
         except Exception as error:
             error_msg = f'未知错误失败，请检查测试数据，如果需要明确的提示请联系管理员，提示：{error.args}'
             if hasattr(error, 'msg'):
                 error_msg = error.msg
-            await self.__error(error_msg)
             self.base_data.log.error(
-                f'未知错误捕获-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+                f'操作元素异常-4，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+            await self.__error(error_msg)
         return self.element_result_model
 
     @async_retry()
@@ -87,32 +96,19 @@ class AsyncElement(AsyncWebDevice, AndroidDriver):
             self.element_model.sleep = self.base_data.test_data.replace(self.element_model.sleep)
             self.element_model.sub = self.base_data.test_data.replace(self.element_model.sub)
         except MangoAutomationError as error:
-            self.base_data.log.debug(f'操作元素解析数据失败，类型：{type(error)}, 详情：{error}')
+            self.base_data.log.error(f'操作元素解析数据失败，类型：{type(error)}, 详情：{error}')
             raise MangoAutomationError(error.code, error.msg)
-        if self.drive_type == DriveTypeEnum.WEB.value:
-            if not self.base_data.page and self.base_data.context:
-                raise MangoAutomationError(*ERROR_MSG_0010)
-        elif self.drive_type == DriveTypeEnum.ANDROID.value:
-            if not self.base_data.android:
-                raise MangoAutomationError(*ERROR_MSG_0007)
+        self.base_data.verify_equipment(self.drive_type)
+        if self.element_model.type == ElementOperationEnum.OPE.value:
+            await self.__ope()
+        elif self.element_model.type == ElementOperationEnum.ASS.value:
+            await self.__ass()
+        elif self.element_model.type == ElementOperationEnum.SQL.value:
+            await self.__sql()
+        elif self.element_model.type == ElementOperationEnum.CUSTOM.value:
+            await self.__custom()
         else:
-            pass
-        try:
-            if self.element_model.type == ElementOperationEnum.OPE.value:
-                await self.__ope()
-            elif self.element_model.type == ElementOperationEnum.ASS.value:
-                await self.__ass()
-            elif self.element_model.type == ElementOperationEnum.SQL.value:
-                await self.__sql()
-            elif self.element_model.type == ElementOperationEnum.CUSTOM.value:
-                await self.__custom()
-            else:
-                raise MangoAutomationError(*ERROR_MSG_0015)
-        except TargetClosedError as error:
-            self.base_data.setup()
-            self.base_data.log.debug(
-                f'浏览器关闭异常，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
-            raise MangoAutomationError(*ERROR_MSG_0010)
+            raise MangoAutomationError(*ERROR_MSG_0015)
 
     async def __ope(self):
         method_name = getattr(self.element_model, 'ope_key', None)
@@ -142,9 +138,7 @@ class AsyncElement(AsyncWebDevice, AndroidDriver):
             )
         else:
             pass
-        for i in self.element_model.ope_value:
-            if i.d:
-                self.element_result_model.ope_value[i.f] = i.v
+        self.element_result_model.ope_value = {i.f: i.v for i in self.element_model.ope_value if i.d}
 
     async def __ass(self):
         if self.element_model.ope_value is None:
@@ -164,9 +158,7 @@ class AsyncElement(AsyncWebDevice, AndroidDriver):
             )
         else:
             pass
-        for i in self.element_model.ope_value:
-            if i.d:
-                self.element_result_model.ope_value[i.f] = i.v
+        self.element_result_model.ope_value = {i.f: i.v for i in self.element_model.ope_value if i.d}
 
     async def __sql(self):
         if not self.element_data:
@@ -241,7 +233,7 @@ class AsyncElement(AsyncWebDevice, AndroidDriver):
                 f'获取操作值失败-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
             raise MangoAutomationError(*ERROR_MSG_0027)
 
-    async def __error(self, msg: str):
+    async def __error(self, msg: str, is_screenshot: bool = True):
         try:
             self.element_result_model.status = StatusEnum.FAIL.value
             self.element_result_model.error_message = msg
@@ -253,11 +245,12 @@ class AsyncElement(AsyncWebDevice, AndroidDriver):
                 self.element_result_model.model_dump() if self.element_result_model else self.element_result_model}
                 """
             )
-            file_name = f'失败截图-{self.element_model.name}{self.base_data.test_data.get_time_for_min()}.jpg'
-            file_path = os.path.join(self.base_data.screenshot_path, file_name)
-            await self.__error_screenshot(file_path)
-            self.element_result_model.picture_path = file_path
-            self.element_result_model.picture_name = file_name
+            if is_screenshot:
+                file_name = f'失败截图-{self.element_model.name}{self.base_data.test_data.get_time_for_min()}.jpg'
+                file_path = os.path.join(self.base_data.screenshot_path, file_name)
+                await self.__error_screenshot(file_path)
+                self.element_result_model.picture_path = file_path
+                self.element_result_model.picture_name = file_name
         except MangoAutomationError as error:
             self.element_result_model.error_message += f'执行过程中发生失败，准备截图时截图失败，失败原因：{error.msg}'
         except Exception as error:

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/uidrive/_base_data.py

@@ -9,6 +9,9 @@ from unittest.mock import MagicMock
 import sys
 from uiautomator2 import Device
 
+from mangoautomation.enums import DriveTypeEnum
+from mangoautomation.exceptions import MangoAutomationError
+from mangoautomation.exceptions._error_msg import ERROR_MSG_0010, ERROR_MSG_0007
 from mangotools.data_processor import DataProcessor
 from mangotools.database import MysqlConnect
 from mangotools.enums import StatusEnum
@@ -101,3 +104,13 @@ class BaseData:
                                               bool(db_c_status),
                                               bool(db_rud_status))
         return self
+
+    def verify_equipment(self, drive_type: int):
+        if drive_type == DriveTypeEnum.WEB.value:
+            if not self.page or not self.context:
+                raise MangoAutomationError(*ERROR_MSG_0010)
+        elif drive_type == DriveTypeEnum.ANDROID.value:
+            if not self.android:
+                raise MangoAutomationError(*ERROR_MSG_0007)
+        else:
+            pass

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/uidrive/_sync_element.py

@@ -5,6 +5,7 @@
 # @Author : 毛鹏
 import os
 import traceback
+from typing import Optional
 
 import time
 from playwright._impl._errors import TargetClosedError, Error
@@ -22,12 +23,27 @@ from ..uidrive.web.sync_web import SyncWebDevice, SyncWebAssertion
 
 class SyncElement(SyncWebDevice, AndroidDriver):
 
-    def __init__(self, base_data, element_model: ElementModel, drive_type: int, element_data: dict | None = None):
+    def __init__(self, base_data, drive_type: int, ):
         super().__init__(base_data)
-        self.element_data = element_data
-        self.element_model = element_model
         self.drive_type = drive_type
-        self.ope_name = element_model.name if element_model.name else element_model.ope_key
+        self.element_model: Optional[ElementModel | None] = None
+        self.element_data: dict | None = None
+        self.element_result_model: Optional[ElementResultModel | None] = None
+
+    def open_device(self, is_open: bool = False):
+        if self.drive_type == DriveTypeEnum.WEB.value:
+            self.open_url(is_open)
+        elif self.drive_type == DriveTypeEnum.ANDROID.value:
+            self.open_app()
+        elif self.drive_type == DriveTypeEnum.DESKTOP.value:
+            pass
+        else:
+            self.base_data.log.error(f'不存在这个类型，如果是非管理员看到这种提示，请联系管理员')
+            raise Exception('不存在的设备类型')
+
+    def element_main(self, element_model: ElementModel, element_data: dict | None = None) -> ElementResultModel:
+        self.element_model = element_model
+        self.element_data = element_data
         self.element_result_model = ElementResultModel(
             id=self.element_model.id,
             name=self.element_model.name,
@@ -45,19 +61,6 @@ class SyncElement(SyncWebDevice, AndroidDriver):
 
             status=StatusEnum.FAIL.value,
         )
-
-    def open_device(self, is_open: bool = False):
-        if self.drive_type == DriveTypeEnum.WEB.value:
-            self.open_url(is_open)
-        elif self.drive_type == DriveTypeEnum.ANDROID.value:
-            self.open_app()
-        elif self.drive_type == DriveTypeEnum.DESKTOP.value:
-            pass
-        else:
-            self.base_data.log.error(f'不存在这个类型，如果是非管理员看到这种提示，请联系管理员')
-            raise Exception('不存在的设备类型')
-
-    def element_main(self) -> ElementResultModel:
         try:
             self.__main()
             if self.element_model.sleep:
@@ -65,19 +68,24 @@ class SyncElement(SyncWebDevice, AndroidDriver):
             self.element_result_model.status = StatusEnum.SUCCESS.value
             self.element_result_model.error_message = None
         except MangoAutomationError as error:
+            self.base_data.log.debug(f'操作元素异常-1，类型：{type(error)}，失败详情：{error}')
             self.__error(error.msg)
-            self.base_data.log.debug(f'已知异常，类型：{type(error)}，失败详情：{error}')
+        except TargetClosedError as error:
+            self.base_data.setup()
+            self.base_data.log.debug(
+                f'操作元素异常-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+            self.__error(ERROR_MSG_0010[1], False)
         except Error as error:
-            self.__error(f'未知错误失败，请检查测试数据，如果需要明确的提示请联系管理员，提示：{error.message}')
             self.base_data.log.error(
-                f'未知错误捕获-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+                f'操作元素异常-3，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+            self.__error(f'未知错误失败，请检查测试数据，如果需要明确的提示请联系管理员，提示：{error.message}')
         except Exception as error:
             error_msg = f'未知错误失败，请检查测试数据，如果需要明确的提示请联系管理员，提示：{error.args}'
             if hasattr(error, 'msg'):
                 error_msg = error.msg
-            self.__error(error_msg)
             self.base_data.log.error(
-                f'未知错误捕获-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+                f'操作元素异常-4，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+            self.__error(error_msg)
         return self.element_result_model
 
     @sync_retry()
@@ -89,30 +97,17 @@ class SyncElement(SyncWebDevice, AndroidDriver):
         except MangoAutomationError as error:
             self.base_data.log.debug(f'操作元素解析数据失败，类型：{type(error)}, 详情：{error}')
             raise MangoAutomationError(error.code, error.msg)
-        if self.drive_type == DriveTypeEnum.WEB.value:
-            if not self.base_data.page and self.base_data.context:
-                raise MangoAutomationError(*ERROR_MSG_0010)
-        elif self.drive_type == DriveTypeEnum.ANDROID.value:
-            if not self.base_data.android:
-                raise MangoAutomationError(*ERROR_MSG_0007)
+        self.base_data.verify_equipment(self.drive_type)
+        if self.element_model.type == ElementOperationEnum.OPE.value:
+            self.__ope()
+        elif self.element_model.type == ElementOperationEnum.ASS.value:
+            self.__ass()
+        elif self.element_model.type == ElementOperationEnum.SQL.value:
+            self.__sql()
+        elif self.element_model.type == ElementOperationEnum.CUSTOM.value:
+            self.__custom()
         else:
-            pass
-        try:
-            if self.element_model.type == ElementOperationEnum.OPE.value:
-                self.__ope()
-            elif self.element_model.type == ElementOperationEnum.ASS.value:
-                self.__ass()
-            elif self.element_model.type == ElementOperationEnum.SQL.value:
-                self.__sql()
-            elif self.element_model.type == ElementOperationEnum.CUSTOM.value:
-                self.__custom()
-            else:
-                raise MangoAutomationError(*ERROR_MSG_0015)
-        except TargetClosedError as error:
-            self.base_data.setup()
-            self.base_data.log.debug(
-                f'浏览器关闭异常，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
-            raise MangoAutomationError(*ERROR_MSG_0010)
+            raise MangoAutomationError(*ERROR_MSG_0015)
 
     def __ope(self):
         method_name = getattr(self.element_model, 'ope_key', None)
@@ -142,9 +137,7 @@ class SyncElement(SyncWebDevice, AndroidDriver):
             )
         else:
             pass
-        for i in self.element_model.ope_value:
-            if i.d:
-                self.element_result_model.ope_value[i.f] = i.v
+        self.element_result_model.ope_value = {i.f: i.v for i in self.element_model.ope_value if i.d}
 
     def __ass(self):
         if self.element_model.ope_value is None:
@@ -164,9 +157,7 @@ class SyncElement(SyncWebDevice, AndroidDriver):
             )
         else:
             pass
-        for i in self.element_model.ope_value:
-            if i.d:
-                self.element_result_model.ope_value[i.f] = i.v
+        self.element_result_model.ope_value = {i.f: i.v for i in self.element_model.ope_value if i.d}
 
     def __sql(self):
         if not self.element_data:
@@ -241,7 +232,7 @@ class SyncElement(SyncWebDevice, AndroidDriver):
                 f'获取操作值失败-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
             raise MangoAutomationError(*ERROR_MSG_0027)
 
-    def __error(self, msg: str):
+    def __error(self, msg: str, is_screenshot: bool = True):
         try:
             self.element_result_model.status = StatusEnum.FAIL.value
             self.element_result_model.error_message = msg
@@ -253,11 +244,12 @@ class SyncElement(SyncWebDevice, AndroidDriver):
                 self.element_result_model.model_dump() if self.element_result_model else self.element_result_model}
                 """
             )
-            file_name = f'失败截图-{self.element_model.name}{self.base_data.test_data.get_time_for_min()}.jpg'
-            file_path = os.path.join(self.base_data.screenshot_path, file_name)
-            self.__error_screenshot(file_path)
-            self.element_result_model.picture_path = file_path
-            self.element_result_model.picture_name = file_name
+            if is_screenshot:
+                file_name = f'失败截图-{self.element_model.name}{self.base_data.test_data.get_time_for_min()}.jpg'
+                file_path = os.path.join(self.base_data.screenshot_path, file_name)
+                self.__error_screenshot(file_path)
+                self.element_result_model.picture_path = file_path
+                self.element_result_model.picture_name = file_name
         except MangoAutomationError as error:
             self.element_result_model.error_message += f'执行过程中发生失败，准备截图时截图失败，失败原因：{error.msg}'
         except Exception as error:

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/uidrive/web/async_web/__init__.py

@@ -6,7 +6,7 @@
 import re
 import traceback
 
-from playwright._impl._errors import TimeoutError, Error, TargetClosedError
+from playwright._impl._errors import TimeoutError, Error
 from playwright.async_api._generated import Locator
 
 from mangotools.assertion import PublicAssertion, SqlAssertion
@@ -57,9 +57,6 @@ class AsyncWebDevice(AsyncWebBrowser,
         except TimeoutError as error:
             self.base_data.log.error(f'WEB自动化操作失败-1，类型：{type(error)}，失败详情：{error}')
             raise MangoAutomationError(*ERROR_MSG_0011, value=(name,))
-        except TargetClosedError:
-            self.base_data.setup()
-            raise MangoAutomationError(*ERROR_MSG_0010)
         except Error as error:
             self.base_data.log.error(f'WEB自动化操作失败-2，类型：{type(error)}，失败详情：{error}')
             raise MangoAutomationError(*ERROR_MSG_0032, value=(name,))
@@ -97,9 +94,7 @@ class AsyncWebDevice(AsyncWebBrowser,
         except ValueError as error:
             self.base_data.log.error(f'WEB自动化断言失败-3，类型：{type(error)}，失败详情：{error}')
             raise MangoAutomationError(*ERROR_MSG_0005)
-        except TargetClosedError:
-            self.base_data.setup()
-            raise MangoAutomationError(*ERROR_MSG_0010)
+
         except Error as error:
             self.base_data.log.error(f'WEB自动化断言失败-4，类型：{type(error)}，失败详情：{error}')
             raise MangoAutomationError(*ERROR_MSG_0052, value=(name,), )
@@ -119,7 +114,7 @@ class AsyncWebDevice(AsyncWebBrowser,
                     text = None
                 return loc, count, text
             except Error as error:
-                self.base_data.log.error(
+                self.base_data.log.debug(
                     f'WEB自动化查找元素失败-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
                 raise MangoAutomationError(*ERROR_MSG_0041, value=(name, loc))
         else:
@@ -129,7 +124,7 @@ class AsyncWebDevice(AsyncWebBrowser,
                 try:
                     count = await locator.count()
                 except Error as error:
-                    self.base_data.log.error(
+                    self.base_data.log.debug(
                         f'WEB自动化查找元素失败-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
                     raise MangoAutomationError(*ERROR_MSG_0041, )
                 if count > 0:

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/uidrive/web/async_web/_browser.py

@@ -49,7 +49,7 @@ class AsyncWebBrowser(metaclass=Meta):
             raise MangoAutomationError(*ERROR_MSG_0010, value=(url,))
         except Error as error:
             self.base_data.log.debug(
-                f'打开URL失败-3，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+                f'打开URL失败-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
             raise MangoAutomationError(*ERROR_MSG_0058, value=(url,))
 
     @async_method_callback('web', '浏览器操作', 2, [

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/uidrive/web/async_web/_element.py

@@ -71,6 +71,7 @@ class AsyncWebElement(metaclass=Meta):
     @async_method_callback('web', '元素操作', 6, [MethodModel(f='locating')])
     async def w_many_click(self, locating: Locator):
         """多元素循环单击"""
+        await asyncio.sleep(1)
         elements = await locating.all()
         for element in elements:
             await element.click()

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/uidrive/web/async_web/_new_browser.py

@@ -101,16 +101,15 @@ class AsyncWebNewBrowser:
                 raise MangoAutomationError(*ERROR_MSG_0009, value=(self.web_path,))
 
     async def new_context(self) -> BrowserContext:
-        args_dict = {
-            'no_viewport': True,
-        }
-
-        if self.web_recording and self.videos_path:
-            args_dict['record_video_dir'] = self.videos_path
-
+        args_dict = {}
+        if self.web_is_default:
+            args_dict["viewport"] = {"width": 1600, "height": 1080}
         if self.web_h5:
-            del args_dict['no_viewport']
             args_dict.update(self.playwright.devices[self.web_h5])
+        if not (self.web_is_default or self.web_h5):
+            args_dict["no_viewport"] = True
+        if self.web_recording and self.videos_path:
+            args_dict["record_video_dir"] = self.videos_path
         return await self.browser.new_context(**args_dict)
 
     async def new_page(self, context: BrowserContext) -> Page:

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/uidrive/web/sync_web/__init__.py

@@ -6,12 +6,12 @@
 import re
 import traceback
 
-from playwright._impl._errors import TimeoutError, Error, TargetClosedError
+from playwright._impl._errors import TimeoutError, Error
 from playwright.sync_api._generated import Locator
 
 from mangotools.assertion import PublicAssertion, SqlAssertion
-from mangotools.mangos import Mango
 from mangotools.enums import StatusEnum
+from mangotools.mangos import Mango
 from ....enums import ElementExpEnum
 from ....exceptions import MangoAutomationError
 from ....exceptions._error_msg import *
@@ -57,9 +57,6 @@ class SyncWebDevice(SyncWebBrowser,
         except TimeoutError as error:
             self.base_data.log.error(f'WEB自动化操作失败-1，类型：{type(error)}，失败详情：{error}')
             raise MangoAutomationError(*ERROR_MSG_0011, value=(name,))
-        except TargetClosedError:
-            self.base_data.setup()
-            raise MangoAutomationError(*ERROR_MSG_0010)
         except Error as error:
             self.base_data.log.error(f'WEB自动化操作失败-2，类型：{type(error)}，失败详情：{error}')
             raise MangoAutomationError(*ERROR_MSG_0032, value=(name,))
@@ -96,9 +93,6 @@ class SyncWebDevice(SyncWebBrowser,
         except ValueError as error:
             self.base_data.log.error(f'WEB自动化断言失败-3，类型：{type(error)}，失败详情：{error}')
             raise MangoAutomationError(*ERROR_MSG_0005)
-        except TargetClosedError:
-            self.base_data.setup()
-            raise MangoAutomationError(*ERROR_MSG_0010)
         except Error as error:
             self.base_data.log.error(f'WEB自动化断言失败-4，类型：{type(error)}，失败详情：{error}')
             raise MangoAutomationError(*ERROR_MSG_0052, value=(name,), )
@@ -118,7 +112,7 @@ class SyncWebDevice(SyncWebBrowser,
                     text = None
                 return loc, count, text
             except Error as error:
-                self.base_data.log.error(
+                self.base_data.log.debug(
                     f'WEB自动化查找元素失败-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
                 raise MangoAutomationError(*ERROR_MSG_0041, )
         else:
@@ -128,7 +122,7 @@ class SyncWebDevice(SyncWebBrowser,
                 try:
                     count = locator.count()
                 except Error as error:
-                    self.base_data.log.error(
+                    self.base_data.log.debug(
                         f'WEB自动化查找元素失败-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
                     raise MangoAutomationError(*ERROR_MSG_0041, )
                 if count > 0:

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/uidrive/web/sync_web/_element.py

@@ -70,6 +70,7 @@ class SyncWebElement(metaclass=Meta):
     @sync_method_callback('web', '元素操作', 6, [MethodModel(f='locating')])
     def w_many_click(self, locating: Locator):
         """多元素循环单击"""
+        time.sleep(1)
         elements = locating.all()
         for element in elements:
             element.click()

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/mangoautomation/uidrive/web/sync_web/_new_browser.py

@@ -101,16 +101,15 @@ class SyncWebNewBrowser:
                 raise MangoAutomationError(*ERROR_MSG_0009, value=(self.web_path,))
 
     def new_context(self) -> BrowserContext:
-        args_dict = {
-            'no_viewport': True,
-        }
-
-        if self.web_recording and self.videos_path:
-            args_dict['record_video_dir'] = self.videos_path
-
+        args_dict = {}
+        if self.web_is_default:
+            args_dict["viewport"] = {"width": 1600, "height": 1080}
         if self.web_h5:
-            del args_dict['no_viewport']
             args_dict.update(self.playwright.devices[self.web_h5])
+        if not (self.web_is_default or self.web_h5):
+            args_dict["no_viewport"] = True
+        if self.web_recording and self.videos_path:
+            args_dict["record_video_dir"] = self.videos_path
         return self.browser.new_context(**args_dict)
 
     def new_page(self, context: BrowserContext) -> Page:

{mangoautomation-1.0.36 → mangoautomation-1.0.38/mangoautomation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mangoautomation
-Version: 1.0.36
+Version: 1.0.38
 Summary: 测试工具
 Home-page: https://gitee.com/mao-peng/testkit
 Author: 毛鹏

{mangoautomation-1.0.36 → mangoautomation-1.0.38}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-__version__ = '1.0.36'
+__version__ = '1.0.38'
 
 with open("README.md", "r", encoding='utf-8') as fh:
     long_description = fh.read()