mangoautomation 1.0.0__py3-none-any.whl

mangoautomation/uidrive/_sync_element.py

@@ -0,0 +1,286 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: 
+# @Time   : 2025-04-12 15:55
+# @Author : 毛鹏
+import os
+import traceback
+
+import time
+from playwright._impl._errors import TargetClosedError, Error, TimeoutError
+
+from mangotools.assertion import PublicAssertion
+from mangotools.decorator import sync_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.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):
+        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,
+        )
+
+    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 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)
+
+    def element_main(self) -> ElementResultModel:
+        try:
+            self.__main()
+            if self.element_model.sleep:
+                time.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:
+            self.__error(error.msg)
+            self.base_data.log.debug(f'已知异常，类型：{type(error)}，失败详情：{error}')
+        except Error as error:
+            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
+            self.__error(error_msg)
+            self.base_data.log.error(
+                f'未知错误捕获-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+        return self.element_result_model
+
+    @sync_retry()
+    def __main(self):
+        self.clean_data()
+        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)
+
+    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)
+
+        self.__ope_value()
+        if self.drive_type == DriveTypeEnum.WEB.value:
+            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
+
+    def __ass(self):
+        if self.element_model.ope_value is None:
+            raise MangoAutomationError(*ERROR_MSG_0053)
+        self.__ope_value(True)
+        if self.drive_type == DriveTypeEnum.WEB.value:
+            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
+
+    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,))
+
+    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))
+
+    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 \
+                            = 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(SyncWebAssertion, 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)
+
+    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
+        self.__error_screenshot(file_path)
+
+    def __error_screenshot(self, file_path):
+        if self.drive_type == DriveTypeEnum.WEB.value:
+            try:
+                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/android/__init__.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台# @Description:
+# @Time   : 2023-09-09 23:17
+# @Author : 毛鹏
+
+from uiautomator2 import UiObject, UiObjectNotFoundError
+from uiautomator2.exceptions import XPathElementNotFoundError
+from uiautomator2.xpath import XPathSelector
+
+from mangotools.assertion import PublicAssertion
+from mangotools.assertion import SqlAssertion
+from ..android._application import AndroidApplication
+from ..android._assertion import AndroidAssertion
+from ..android._customization import AndroidCustomization
+from ..android._element import AndroidElement
+from ..android._equipment import AndroidEquipment
+from ..android._page import AndroidPage
+from ...enums import ElementExpEnum
+from ...exceptions import MangoAutomationError
+from ...exceptions._error_msg import *
+
+__all__ = [
+    'AndroidApplication',
+    'AndroidAssertion',
+    'AndroidElement',
+    'AndroidCustomization',
+    'AndroidEquipment',
+    'AndroidPage',
+    'AndroidDriver',
+]
+
+from mangotools.mangos import Mango
+
+
+class AndroidDriver(AndroidPage,
+                    AndroidElement,
+                    AndroidEquipment,
+                    AndroidCustomization,
+                    AndroidApplication):
+
+    def __init__(self, base_data):
+        super().__init__(base_data)
+
+    def open_app(self):
+        if not self.base_data.is_open_app:
+            self.base_data.is_open_app = True
+            self.a_press_home()
+            self.a_app_stop_all()
+            if self.base_data.android and self.base_data.package_name:
+                self.a_start_app(self.base_data.package_name)
+
+    def a_action_element(self, name, ope_key, ope_value):
+        self.base_data.log.debug(f'操作元素，名称：{name},key:{ope_key},value:{ope_value}')
+        try:
+            Mango.s_e(self, ope_key, ope_value)
+        except ValueError as error:
+            self.base_data.log.error(f'安卓自动化失败-1，类型：{type(error)}，失败详情：{error}')
+            raise MangoAutomationError(*ERROR_MSG_0012)
+        except UiObjectNotFoundError as error:
+            self.base_data.log.error(f'安卓自动化失败-2，类型：{type(error)}，失败详情：{error}')
+            raise MangoAutomationError(*ERROR_MSG_0032, value=(name,))
+        except XPathElementNotFoundError as error:
+            self.base_data.log.error(f'安卓自动化失败-3，类型：{type(error)}，失败详情：{error}')
+            raise MangoAutomationError(*ERROR_MSG_0050, value=(name,))
+
+    def a_assertion_element(self, name, ope_key, ope_value):
+        self.base_data.log.debug(f'断言元素，名称：{name},key:{ope_key},value:{ope_value}')
+
+        is_method = callable(getattr(AndroidAssertion(self.base_data), ope_key, None))
+        is_method_public = callable(getattr(PublicAssertion, ope_key, None))
+
+        if is_method or is_method_public:
+            if ope_value['value'] is None:
+                raise MangoAutomationError(*ERROR_MSG_0031, value=(name,))
+
+        try:
+            if is_method:
+                self.base_data.log.debug(f'开始断言-1，方法：{ope_key}，断言值：{ope_value}')
+                Mango.s_e(AndroidAssertion(self.base_data), ope_key, ope_value)
+            elif is_method_public:
+                self.base_data.log.debug(f'开始断言-2，方法：{ope_key}，断言值：{ope_value}')
+                Mango.s_e(PublicAssertion, ope_key, ope_value)
+            else:
+                if self.base_data.mysql_connect is not None:
+                    SqlAssertion.mysql_obj = self.base_data.mysql_connect
+                    self.base_data.log.debug(f'开始断言-3，方法：sql相等端游，实际值：{ope_value}')
+                    SqlAssertion.sql_is_equal(**ope_value)
+                else:
+                    raise MangoAutomationError(*ERROR_MSG_0019)
+        except AssertionError as error:
+            self.base_data.log.error(f'安卓自动化失败-1，类型：{type(error)}，失败详情：{error}')
+            raise MangoAutomationError(*ERROR_MSG_0017, value=error.args)
+        except AttributeError as error:
+            self.base_data.log.error(f'安卓自动化失败-2，类型：{type(error)}，失败详情：{error}')
+            raise MangoAutomationError(*ERROR_MSG_0030, )
+        except ValueError as error:
+            self.base_data.log.error(f'安卓自动化失败-3，类型：{type(error)}，失败详情：{error}')
+            raise MangoAutomationError(*ERROR_MSG_0005, )
+
+    def a_find_ele(self, name, _type, exp, loc, sub) -> tuple[UiObject, int, str] | tuple[XPathSelector, int, str]:
+        self.base_data.log.debug(
+            f'查找元素，名称：{name},_type:{_type},exp:{exp},loc:{loc},sub:{sub}')
+        match exp:
+            case ElementExpEnum.LOCATOR.value:
+                try:
+                    if loc[:5] == 'xpath':
+                        loc = eval(f"self.android.{loc}")
+                    else:
+                        loc = eval(f"self.android{loc}")
+                except SyntaxError:
+                    raise MangoAutomationError(*ERROR_MSG_0022)
+            case ElementExpEnum.XPATH.value:
+                loc = self.base_data.android.xpath(loc)
+            case ElementExpEnum.BOUNDS.value:
+                loc = self.base_data.android(text=loc)
+            case ElementExpEnum.DESCRIPTION.value:
+                loc = self.base_data.android(description=loc)
+            case ElementExpEnum.RESOURCE_ID.value:
+                loc = self.base_data.android(resourceId=loc)
+            case _:
+                raise MangoAutomationError(*ERROR_MSG_0020)
+        text = None
+        try:
+            text = self.a_get_text(loc)
+        except Exception:
+            pass
+        return loc, loc.count, text

mangoautomation/uidrive/android/_application.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台# @Description:
+# @Time   : 2023-09-09 23:17
+# @Author : 毛鹏
+import time
+
+from mangotools.decorator import sync_method_callback
+from mangotools.models import MethodModel
+from ...exceptions import MangoAutomationError
+from ...exceptions._error_msg import ERROR_MSG_0046
+from ...tools import Meta
+from ...uidrive._base_data import BaseData
+
+
+class AndroidApplication(metaclass=Meta):
+    """应用操作"""
+
+    def __init__(self, base_data: BaseData):
+        self.base_data = base_data
+
+    def is_app_installed(self, package_name: str) -> bool:
+        return any(package_name in str(i) for i in self.base_data.android.shell("pm list packages"))
+
+    @sync_method_callback('android', '应用操作', [
+        MethodModel(f='package_name', p='请输入应用名称', d=True)])
+    def a_start_app(self, package_name: str):
+        """启动应用"""
+        if not package_name:
+            raise MangoAutomationError(*ERROR_MSG_0046)
+        if not self.is_app_installed(package_name):
+            raise MangoAutomationError(*ERROR_MSG_0046)
+        self.base_data.android.app_start(package_name)
+        time.sleep(4)
+
+    @sync_method_callback('android', '应用操作', [
+        MethodModel(f='package_name', p='请输入应用名称', d=True)])
+    def a_close_app(self, package_name: str):
+        """关闭应用"""
+        if not package_name:
+            raise MangoAutomationError(*ERROR_MSG_0046)
+        if not self.is_app_installed(package_name):
+            raise MangoAutomationError(*ERROR_MSG_0046)
+
+        self.base_data.android.app_stop(package_name)
+
+    @sync_method_callback('android', '应用操作', [
+        MethodModel(f='package_name', p='请输入应用名称', d=True)])
+    def a_clear_app(self, package_name: str):
+        """清除app数据"""
+        if not package_name:
+            raise MangoAutomationError(*ERROR_MSG_0046)
+        if not self.is_app_installed(package_name):
+            raise MangoAutomationError(*ERROR_MSG_0046)
+
+        self.base_data.android.app_clear(package_name)
+
+    @sync_method_callback('android', '应用操作', )
+    def a_app_stop_all(self):
+        """停止所有app"""
+        self.base_data.android.app_stop_all()
+
+    @sync_method_callback('android', '应用操作', [
+        MethodModel(f='package_name', p='请输入应用名称列表', d=True)])
+    def a_app_stop_appoint(self, package_name_list: list):
+        """停止除指定app外所有app"""
+        for i in package_name_list:
+            if not self.is_app_installed(i):
+                raise MangoAutomationError(*ERROR_MSG_0046)
+        self.base_data.android.app_stop_all(excludes=package_name_list)

mangoautomation/uidrive/android/_assertion.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台# @Description:
+# @Time   : 2023-09-09 23:17
+# @Author : 毛鹏
+from uiautomator2 import UiObject
+
+from mangoautomation.tools import Meta
+from mangoautomation.uidrive._base_data import BaseData
+from mangotools.decorator import sync_method_callback
+from mangotools.models import MethodModel
+
+
+class AndroidAssertion(metaclass=Meta):
+    """元素断言"""
+
+    def __init__(self, base_data: BaseData):
+        self.base_data = base_data
+
+    @sync_method_callback('ass_android', '元素断言', [
+        MethodModel(f='actual')])
+    def a_assert_ele_exists(self, actual: UiObject):
+        """元素存在"""
+        assert actual.count
+
+    @sync_method_callback('ass_android', '元素断言', [
+        MethodModel(f='actual'),
+        MethodModel(f='expect', p='请输入预期内容', d=True)])
+    def a_assert_ele_count(self, actual: UiObject, expect):
+        """元素计数"""
+        assert int(actual.count) == int(expect)
+
+    @sync_method_callback('ass_android', '元素断言', [
+        MethodModel(f='actual'),
+        MethodModel(f='expect', p='请输入预期文本', d=True)])
+    def a_assert_ele_text(self, actual: UiObject, expect: str):
+        """元素文本内容"""
+        assert actual.get_text() == expect, \
+            f"实际='{actual.get_text()}', 预期='{expect}'"
+
+    @sync_method_callback('ass_android', '元素断言', [
+        MethodModel(f='actual')])
+    def a_assert_ele_clickable_true(self, actual: UiObject):
+        """元素可点击"""
+        assert actual.info['clickable'], \
+            f"实际={actual.info['clickable']}, 预期=可点击"
+
+    @sync_method_callback('ass_android', '元素断言', [
+        MethodModel(f='actual')])
+    def a_assert_ele_clickable_false(self, actual: UiObject):
+        """元素不可点击"""
+        assert not actual.info['clickable'], \
+            f"实际={actual.info['clickable']}, 预期=元素不可点击"
+
+    @sync_method_callback('ass_android', '元素断言', [
+        MethodModel(f='actual')])
+    def a_assert_ele_visible_true(self, actual: UiObject):
+        """元素可见"""
+        assert actual.exists and actual.info['visible'], \
+            f"实际={actual.info['visible']}, 预期=元素可见"
+
+    @sync_method_callback('ass_android', '元素断言', [
+        MethodModel(f='actual')])
+    def a_assert_ele_visible_false(self, actual: UiObject):
+        """元素不可见"""
+        assert actual.exists and not actual.info['visible'], \
+            f"实际={actual.info['visible']}, 预期=元素不可见"
+
+    @sync_method_callback('ass_android', '元素断言', [
+        MethodModel(f='expect', p='请输入弹窗标题文本', d=False)])
+    def a_assert_dialog_exists(self, expect: str):
+        """弹窗存在"""
+        dialog = self.base_data.android(text=expect) if expect else self.base_data.android(
+            className="android.app.AlertDialog")
+        assert dialog.exists, "未找到预期弹窗"
+
+    @sync_method_callback('ass_android', '元素断言', [
+        MethodModel(f='actual'),
+        MethodModel(f='expect', p='请输入断言目标文本', d=True)])
+    def a_assert_ele_in_list(self, actual: UiObject, expect: str):
+        """列表滑动后目标元素存在"""
+        if not actual.exists:
+            raise AssertionError("传入的元素不是可滑动的列表")
+        actual.scroll.vert.to(text=expect)
+        assert self.base_data.android(text=expect).exists, f"列表中未找到文本: {expect}"

mangoautomation/uidrive/android/_customization.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: # @Time   : 2023-04-26 22:22
+# @Author : 毛鹏
+
+
+from mangoautomation.tools import Meta
+from mangoautomation.uidrive._base_data import BaseData
+
+
+class AndroidCustomization(metaclass=Meta):
+    """定制开发"""
+
+    def __init__(self, base_data: BaseData):
+        self.base_data = base_data