mangoautomation 1.0.0__py3-none-any.whl

mangoautomation/uidrive/_async_element.py

@@ -0,0 +1,286 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: 
+# @Time   : 2025-04-12 15:53
+# @Author : 毛鹏
+import asyncio
+import os
+import traceback
+
+from playwright._impl._errors import TargetClosedError, Error, TimeoutError
+
+from mangotools.assertion import PublicAssertion
+from mangotools.decorator import async_retry
+from mangotools.enums import StatusEnum
+from ..enums import ElementOperationEnum, DriveTypeEnum
+from ..exceptions import MangoAutomationError
+from ..exceptions._error_msg import *
+from ..models import ElementResultModel, ElementModel
+from ..uidrive.android import AndroidDriver
+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):
+        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_result_model = ElementResultModel(
+            id=self.element_model.id,
+            name=self.element_model.name,
+            loc=self.element_model.loc,
+            exp=self.element_model.exp,
+            sub=self.element_model.sub,
+            sleep=self.element_model.sleep,
+
+            type=self.element_model.type,
+            ope_key=self.element_model.ope_key,
+            sql=self.element_model.sql,
+            key_list=self.element_model.key_list,
+            key=self.element_model.key,
+            value=self.element_model.value,
+
+            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 clean_data(self):
+        try:
+            for field_name, field_value in self.element_model:
+                if field_value is None:
+                    continue
+                if field_name == "ope_value":
+                    for method_model in field_value:
+                        for method_field, method_val in method_model:
+                            if isinstance(method_val, str):
+                                setattr(method_model, method_field, self.base_data.test_data.replace(method_val))
+                elif isinstance(field_value, str):
+                    setattr(self.element_model, field_name, self.base_data.test_data.replace(field_value))
+        except MangoAutomationError as error:
+            self.base_data.log.debug(f'操作元素解析数据失败，类型：{type(error)}, 详情：{error}')
+            raise MangoAutomationError(error.code, error.msg)
+
+    async def element_main(self) -> ElementResultModel:
+        try:
+            await self.__main()
+            if self.element_model.sleep:
+                await asyncio.sleep(self.element_model.sleep)
+            self.element_result_model.status = StatusEnum.SUCCESS.value
+            self.element_result_model.error_message = None
+        except TargetClosedError as error:
+            self.base_data.setup()
+            self.base_data.log.debug(
+                f'浏览器关闭异常，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+            self.element_result_model.status = StatusEnum.FAIL.value
+            self.element_result_model.error_message = '浏览器被关闭，请不要认关闭浏览器，非认为管理请联系管理员解决！'
+        except MangoAutomationError as error:
+            await self.__error(error.msg)
+            self.base_data.log.debug(f'已知异常，类型：{type(error)}，失败详情：{error}')
+        except Error as error:
+            await self.__error(f'未知错误失败，请检查测试数据，如果需要明确的提示请联系管理员，提示：{error.message}')
+            self.base_data.log.error(
+                f'未知错误捕获-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+        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()}')
+        return self.element_result_model
+
+    @async_retry()
+    async def __main(self):
+        await self.clean_data()
+        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)
+
+    async def __ope(self):
+        method_name = getattr(self.element_model, 'ope_key', None)
+        if not method_name:
+            self.base_data.log.debug('操作失败-1，ope_key 不存在或为空')
+            raise MangoAutomationError(*ERROR_MSG_0048)
+        if not hasattr(self, method_name):
+            self.base_data.log.debug(f'操作失败-2，方法不存在: {method_name}')
+            raise MangoAutomationError(*ERROR_MSG_0048)
+        if not callable(getattr(self, method_name)):
+            self.base_data.log.debug(f'操作失败-3，属性不可调用: {method_name}')
+            raise MangoAutomationError(*ERROR_MSG_0048)
+        if self.element_model.ope_value is None:
+            raise MangoAutomationError(*ERROR_MSG_0054)
+
+        await self.__ope_value()
+        if self.drive_type == DriveTypeEnum.WEB.value:
+            await self.web_action_element(
+                self.element_model.name,
+                self.element_model.ope_key,
+                {i.f: i.v for i in self.element_model.ope_value}
+            )
+        elif self.drive_type == DriveTypeEnum.ANDROID.value:
+            self.a_action_element(
+                self.element_model.name,
+                self.element_model.ope_key,
+                {i.f: i.v for i in self.element_model.ope_value}
+            )
+        else:
+            pass
+        for i in self.element_model.ope_value:
+            if i.d:
+                self.element_result_model.ope_value[i.f] = i.v
+
+    async def __ass(self):
+        if self.element_model.ope_value is None:
+            raise MangoAutomationError(*ERROR_MSG_0053)
+        await self.__ope_value(True)
+        if self.drive_type == DriveTypeEnum.WEB.value:
+            await self.web_assertion_element(
+                self.element_model.name,
+                self.element_model.ope_key,
+                {i.f: i.v for i in self.element_model.ope_value}
+            )
+        elif self.drive_type == DriveTypeEnum.ANDROID.value:
+            self.a_assertion_element(
+                self.element_model.name,
+                self.element_model.ope_key,
+                {i.f: i.v for i in self.element_model.ope_value}
+            )
+        else:
+            pass
+        for i in self.element_model.ope_value:
+            if i.d:
+                self.element_result_model.ope_value[i.f] = i.v
+
+    async def __sql(self):
+        if not self.element_data:
+            sql = self.base_data.test_data.replace(self.element_model.sql)
+            key_list = self.element_model.key_list
+        else:
+            sql = self.base_data.test_data.replace(self.element_data.get('sql'))
+            key_list = self.element_data.get('key_list')
+        if self.base_data.mysql_connect:
+            result_list: list[dict] = self.base_data.mysql_connect.condition_execute(sql)
+            if isinstance(result_list, list):
+                for result in result_list:
+                    try:
+                        for value, key in zip(result, key_list):
+                            self.base_data.test_data.set_cache(key, result.get(value))
+                    except SyntaxError as error:
+                        self.base_data.log.debug(
+                            f'SQL执行失败-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+                        raise MangoAutomationError(*ERROR_MSG_0038)
+
+                if not result_list:
+                    raise MangoAutomationError(*ERROR_MSG_0036, value=(self.element_model.sql,))
+
+    async def __custom(self):
+        if not self.element_data:
+            key = self.element_model.key
+            value = self.element_model.value
+        else:
+            key = self.element_data.get('key')
+            value = self.element_data.get('value')
+        self.base_data.test_data.set_cache(key, self.base_data.test_data.replace(value))
+
+    async def __ope_value(self, is_ass: bool = False):
+        try:
+            ope_key = 'actual' if is_ass else 'locating'
+            for i in self.element_model.ope_value:
+                if i.f == ope_key and self.element_model.loc:
+                    find_params = {
+                        'name': self.element_model.name,
+                        '_type': self.element_model.type,
+                        'exp': self.element_model.exp,
+                        'loc': self.element_model.loc,
+                        'sub': self.element_model.sub
+                    }
+                    if self.drive_type == DriveTypeEnum.WEB.value:
+                        loc, \
+                            self.element_result_model.ele_quantity, \
+                            self.element_result_model.element_text \
+                            = await self.web_find_ele(**find_params, is_iframe=self.element_model.is_iframe)
+                    elif self.drive_type == DriveTypeEnum.ANDROID.value:
+                        loc, \
+                            self.element_result_model.ele_quantity, \
+                            self.element_result_model.element_text \
+                            = self.a_find_ele(**find_params)
+                    else:
+                        loc, \
+                            self.element_result_model.ele_quantity, \
+                            self.element_result_model.element_text \
+                            = None, 0, None
+
+                    if is_ass:
+                        if callable(getattr(AsyncWebAssertion, self.element_model.ope_key, None)):
+                            i.v = loc
+                        elif callable(getattr(PublicAssertion, self.element_model.ope_key, None)):
+                            i.v = self.element_result_model.element_text
+                    else:
+                        i.v = loc
+                else:
+                    if self.element_data:
+                        for ele_name, case_data in self.element_data.items():
+                            if ele_name == i.f:
+                                value = case_data
+                                i.v = self.base_data.test_data.replace(value)
+
+        except AttributeError as error:
+            self.base_data.log.debug(
+                f'获取操作值失败-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+            raise MangoAutomationError(*ERROR_MSG_0027)
+
+    async def __error(self, msg: str):
+        self.element_result_model.status = StatusEnum.FAIL.value
+        self.element_result_model.error_message = msg
+        self.base_data.log.debug(
+            f"""
+            元素操作失败----->
+            元 素 对 象：{self.element_model.model_dump() if self.element_model else self.element_model}
+            元素测试结果：{
+            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.element_result_model.picture_path = file_path
+        self.element_result_model.picture_name = file_name
+        await self.__error_screenshot(file_path)
+
+    async def __error_screenshot(self, file_path):
+        if self.drive_type == DriveTypeEnum.WEB.value:
+            try:
+                await self.w_screenshot(file_path)
+            except (TargetClosedError, TimeoutError) as error:
+                self.base_data.log.debug(
+                    f'截图出现异常失败-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+                self.base_data.setup()
+                raise MangoAutomationError(*ERROR_MSG_0010)
+            except AttributeError as error:
+                self.base_data.log.debug(
+                    f'截图出现异常失败-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+                self.base_data.setup()
+                raise MangoAutomationError(*ERROR_MSG_0010)
+        elif self.drive_type == DriveTypeEnum.ANDROID.value:
+            self.a_screenshot(file_path)
+        else:
+            pass

mangoautomation/uidrive/_base_data.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: 
+# @Time   : 2024-02-04 10:43
+# @Author : 毛鹏
+from typing import Optional
+from unittest.mock import MagicMock
+
+import sys
+from uiautomator2 import Device
+
+from mangotools.data_processor import DataProcessor
+from mangotools.database import MysqlConnect
+from mangotools.enums import StatusEnum
+from mangotools.models import MysqlConingModel
+
+if not sys.platform.startswith('win32'):
+    WindowControl = MagicMock()
+    print("警告: uiautomation 仅支持 Windows，当前环境已自动跳过")
+else:
+    from uiautomation import WindowControl
+
+
+class BaseData:
+
+    def __init__(self, test_data: DataProcessor, log):
+        super().__init__()
+        self.test_data = test_data
+        self.log = log
+        self.download_path: Optional[str | None] = None
+        self.screenshot_path: Optional[str | None] = None
+
+        self.mysql_config: Optional[MysqlConingModel | None] = None
+        self.mysql_connect: Optional[MysqlConnect | None] = None
+
+        self.url: Optional[str | None] = None
+        self.is_open_url = False
+        self.page = None
+        self.context = None
+
+        self.package_name: Optional[str | None] = None
+        self.android: Optional[Device | None] = None
+        self.is_open_app = False
+
+        self.window: Optional[None | WindowControl] = None
+
+    def set_file_path(self, download_path, screenshot_path):
+        self.download_path = download_path
+        self.screenshot_path = screenshot_path
+        return self
+
+    def set_url(self, url: str):
+        self.url = url
+        return self
+
+    def set_page_context(self, page, context):
+        self.page = page
+        self.context = context
+        return self
+
+    def set_package_name(self, package_name: str):
+        self.package_name = package_name
+        return self
+
+    def set_android(self, android: Device):
+        self.android = android
+        return self
+
+    def setup(self) -> None:
+        self.url = None
+        self.page = None
+        self.context = None
+
+        self.package_name = None
+        self.android = None
+        self.mysql_connect = None
+        self.mysql_config = None
+
+    async def async_base_close(self):
+        if self.context:
+            await self.context.close()
+        if self.page:
+            await self.page.close()
+        if self.mysql_connect:
+            self.mysql_connect.close()
+        self.setup()
+
+    def sync_base_close(self):
+        if self.context:
+            self.context.close()
+        if self.page:
+            self.page.close()
+        if self.mysql_connect:
+            self.mysql_connect.close()
+        self.setup()
+
+    def set_mysql(self, db_c_status, db_rud_status, mysql_config: MysqlConingModel):
+        self.mysql_config = mysql_config
+        if StatusEnum.SUCCESS.value in [db_c_status, db_rud_status]:
+            self.mysql_connect = MysqlConnect(mysql_config,
+                                              bool(db_c_status),
+                                              bool(db_rud_status))
+        return self

mangoautomation/uidrive/_driver_object.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description:
+# @Time   : 2024-04-24 10:43
+# @Author : 毛鹏
+
+from typing import Optional
+
+from ..uidrive.android._new_android import NewAndroid
+from ..uidrive.pc.new_windows import NewWindows
+from ..uidrive.web.async_web._new_browser import AsyncWebNewBrowser
+from ..uidrive.web.sync_web._new_browser import SyncWebNewBrowser
+
+
+class DriverObject:
+
+    def __init__(self, is_async=False):
+        self.is_async = is_async
+        self.web: Optional[AsyncWebNewBrowser | SyncWebNewBrowser] = None
+        self.android: Optional[NewAndroid] = None
+        self.windows: Optional[NewWindows] = None
+
+    def set_web(self,
+                web_type: int,
+                web_path: str | None = None,
+                web_max=False,
+                web_headers=False,
+                web_recording=False,
+                web_h5=None,
+                is_header_intercept=False,
+                web_is_default=False,
+                videos_path=None
+                ):
+        if self.is_async:
+            self.web = AsyncWebNewBrowser(
+                web_type,
+                web_path,
+                web_max,
+                web_headers,
+                web_recording,
+                web_h5,
+                is_header_intercept,
+                web_is_default,
+                videos_path
+            )
+        else:
+            self.web = SyncWebNewBrowser(
+                web_type,
+                web_path,
+                web_max,
+                web_headers,
+                web_recording,
+                web_h5,
+                is_header_intercept,
+                web_is_default,
+                videos_path
+            )
+
+    def set_android(self, and_equipment: str):
+        self.android = NewAndroid(and_equipment)
+
+    def set_windows(self, win_path: str, win_title: str):
+        self.windows = NewWindows(win_path, win_title)