mangoautomation 1.0.0__py3-none-any.whl

mangoautomation/uidrive/web/async_web/_element.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: # @Time   : 2023-04-26 22:22
+# @Author : 毛鹏
+import asyncio
+import os
+
+import time
+from playwright.async_api import Locator, Error
+
+from mangotools.decorator import async_method_callback
+from mangotools.models import MethodModel
+from ..._base_data import BaseData
+from ....exceptions import MangoAutomationError
+from ....exceptions._error_msg import ERROR_MSG_0024, ERROR_MSG_0056
+from ....tools import Meta
+
+
+class AsyncWebElement(metaclass=Meta):
+    """元素操作"""
+
+    def __init__(self, base_data: BaseData):
+        self.base_data = base_data
+
+    @async_method_callback('web', '元素操作', 0, [MethodModel(f='locating')])
+    async def w_click(self, locating: Locator):
+        """元素单击"""
+        await locating.click()
+
+    @async_method_callback('web', '元素操作', 1, [MethodModel(f='locating')])
+    async def w_dblclick(self, locating: Locator):
+        """元素双击"""
+        await locating.dblclick()
+
+    @async_method_callback('web', '元素操作', 2, [MethodModel(f='locating')])
+    async def w_force_click(self, locating: Locator):
+        """强制单击"""
+        await locating.evaluate('element => element.click()')
+
+    @async_method_callback('web', '元素操作', 3, [
+        MethodModel(f='locating'),
+        MethodModel(f='input_value', p='请输入输入内容', d=True)])
+    async def w_input(self, locating: Locator, input_value: str):
+        """元素输入"""
+        await locating.fill(str(input_value))
+
+    @async_method_callback('web', '元素操作', 4, [MethodModel(f='locating')])
+    async def w_hover(self, locating: Locator):
+        """鼠标悬停"""
+        await locating.hover()
+        await asyncio.sleep(1)
+
+    @async_method_callback('web', '元素操作', 5, [
+        MethodModel(f='locating'),
+        MethodModel(f='set_cache_key', p='请输入获取元素文本后存储的key', d=True)])
+    async def w_get_text(self, locating: Locator, set_cache_key=None):
+        """获取元素文本"""
+        value = await locating.inner_text()
+        if set_cache_key:
+            self.base_data.test_data.set_cache(key=set_cache_key, value=value)
+
+        return value
+
+    @async_method_callback('web', '元素操作', 6, [
+        MethodModel(f='locating'),
+        MethodModel(f='file_path', p='请输入文件路径，参照帮助文档', d=True)])
+    async def w_upload_files(self, locating: Locator, file_path: str | list):
+        """拖拽文件上传"""
+        try:
+            if isinstance(file_path, str):
+                await locating.set_input_files(file_path)
+            else:
+                for file in file_path:
+                    await locating.set_input_files(file)
+        except Error:
+            raise MangoAutomationError(*ERROR_MSG_0024)
+
+    @async_method_callback('web', '元素操作', 7, [
+        MethodModel(f='locating'),
+        MethodModel(f='file_path', p='请输入文件路径，参照帮助文档', d=True)])
+    async def w_click_upload_files(self, locating: Locator, file_path: str | list):
+        """点击并选择文件上传"""
+        async with self.base_data.page.expect_file_chooser() as fc_info:
+            await locating.click()
+        file_chooser = await fc_info.value
+        await file_chooser.set_files(file_path)
+
+    @async_method_callback('web', '元素操作', 8, [
+        MethodModel(f='locating'),
+        MethodModel(f='file_key', p='请输入文件存储路径的key，后续通过key获取文件保存的绝对路径', d=True)])
+    async def w_download(self, locating: Locator, file_key: str):
+        """下载文件"""
+        async with self.base_data.page.expect_download() as download_info:
+            await locating.click()
+        download = await download_info.value
+        file_name = download.suggested_filename
+        save_path = os.path.join(self.base_data.download_path, file_name)
+        await download.save_as(save_path)
+        self.base_data.test_data.set_cache(file_key, file_name)
+
+    @async_method_callback('web', '元素操作', 9, [
+        MethodModel(f='locating1'),
+        MethodModel(f='locating2')])
+    async def w_drag_to(self, locating1: Locator, locating2: Locator):
+        """拖动A元素到达B"""
+        await locating1.drag_to(locating2)
+
+    @async_method_callback('web', '元素操作', 10, [
+        MethodModel(f='locating'),
+        MethodModel(f='n', p='请输入循环点击的时间', d=True)])
+    async def w_time_click(self, locating: Locator, n: int):
+        """循环点击N秒"""
+        try:
+            n = int(n)
+        except ValueError:
+            raise MangoAutomationError(*ERROR_MSG_0056)
+        s = time.time()
+        while True:
+            await locating.click()
+            if time.time() - s > n:
+                return
+
+    @async_method_callback('web', '元素操作', 11, [
+        MethodModel(f='locating'),
+        MethodModel(f='n', p='请输入向上像素', d=True)])
+    async def w_drag_up_pixel(self, locating: Locator, n: int):
+        """往上拖动N个像素"""
+        try:
+            n = int(n)
+        except ValueError:
+            raise MangoAutomationError(*ERROR_MSG_0056)
+
+        box = await locating.bounding_box()
+
+        if box:
+            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2)
+            await self.base_data.page.mouse.down()
+            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2 - n)
+            await self.base_data.page.mouse.up()
+
+    @async_method_callback('web', '元素操作', 12, [
+        MethodModel(f='locating'),
+        MethodModel(f='n', p='请输入向下像素', d=True)])
+    async def w_drag_down_pixel(self, locating: Locator, n: int):
+        """往下拖动N个像素"""
+        try:
+            n = int(n)
+        except ValueError:
+            raise MangoAutomationError(*ERROR_MSG_0056)
+
+        box = await locating.bounding_box()
+
+        if box:
+            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2)
+            await self.base_data.page.mouse.down()
+            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2 + n)
+            await self.base_data.page.mouse.up()
+
+    @async_method_callback('web', '元素操作', 13, [
+        MethodModel(f='locating'),
+        MethodModel(f='n', p='请输入向左像素', d=True)])
+    async def w_drag_left_pixel(self, locating: Locator, n: int):
+        """往左拖动N个像素"""
+        try:
+            n = int(n)
+        except ValueError:
+            raise MangoAutomationError(*ERROR_MSG_0056)
+
+        box = await locating.bounding_box()
+
+        if box:
+            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2)
+            await self.base_data.page.mouse.down()
+            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2 - n, box['y'] + box['height'] / 2)
+            await self.base_data.page.mouse.up()
+
+    @async_method_callback('web', '元素操作', 14, [
+        MethodModel(f='locating'),
+        MethodModel(f='n', p='请输入向右像素', d=True)])
+    async def w_drag_right_pixel(self, locating: Locator, n: int):
+        """往右拖动N个像素"""
+        try:
+            n = int(n)
+        except ValueError:
+            raise MangoAutomationError(*ERROR_MSG_0056)
+        box = await locating.bounding_box()
+
+        if box:
+            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2, box['y'] + box['height'] / 2)
+            await self.base_data.page.mouse.down()
+            await self.base_data.page.mouse.move(box['x'] + box['width'] / 2 + n, box['y'] + box['height'] / 2)
+            await self.base_data.page.mouse.up()
+
+    @async_method_callback('web', '元素操作', 15, [
+        MethodModel(f='locating'),
+        MethodModel(f='path', p='请输入截图保存路径', d=True)])
+    async def w_ele_screenshot(self, locating: Locator, path: str):
+        """元素截图"""
+        await locating.screenshot(path=path)

mangoautomation/uidrive/web/async_web/_input_device.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: # @Time   : 2023-04-29 12:11
+# @Author : 毛鹏
+from playwright.async_api import Locator
+
+from mangotools.decorator import async_method_callback
+from mangotools.models import MethodModel
+from ....tools import Meta
+from ....uidrive._base_data import BaseData
+
+
+class AsyncWebDeviceInput(metaclass=Meta):
+    """输入设备"""
+
+    def __init__(self, base_data: BaseData):
+        self.base_data = base_data
+
+    @async_method_callback('web', '输入设备', 0, [
+        MethodModel(f='keyboard', p='请输入键盘名称，首字母大写', d=True)])
+    async def w_keys(self, keyboard: str):
+        """模拟按下指定的键"""
+        await self.base_data.page.keyboard.press(str(keyboard))
+
+    async def w_element_wheel(self, locating: Locator):
+        """滚动到元素位置"""
+        await locating.scroll_into_view_if_needed()
+
+    @async_method_callback('web', '输入设备', 1, [
+        MethodModel(f='y', p='请输入向上滚动像素', d=True)])
+    async def w_wheel(self, y):
+        """鼠标上下滚动像素，负数代表向上"""
+        await self.base_data.page.mouse.wheel(0, int(y))
+
+    @async_method_callback('web', '输入设备', 2, [
+        MethodModel(f='x', p='请输入点击的x轴', d=True), MethodModel(f='y', p='请输入点击的y轴', d=True)])
+    async def w_mouse_click(self, x: float, y: float):
+        """鼠标点击坐标"""
+        await self.base_data.page.mouse.click(float(x), float(y))
+
+    @async_method_callback('web', '输入设备', 3)
+    async def w_mouse_center(self):
+        """鼠标移动到中间"""
+
+        viewport_size = await self.base_data.page.evaluate('''() => {
+            return {
+                width: window.innerWidth,
+                height: window.innerHeight
+            }
+        }''')
+        center_x = viewport_size['width'] / 2
+        center_y = viewport_size['height'] / 2
+        await self.base_data.page.mouse.move(center_x, center_y)
+
+    @async_method_callback('web', '输入设备', 4)
+    async def w_mouse_center(self):
+        """鼠标移动到中间并点击"""
+
+        viewport_size = await self.base_data.page.evaluate('''() => {
+            return {
+                width: window.innerWidth,
+                height: window.innerHeight
+            }
+        }''')
+        center_x = viewport_size['width'] / 2
+        center_y = viewport_size['height'] / 2
+        await self.base_data.page.mouse.click(center_x, center_y)
+
+    @async_method_callback('web', '输入设备', 5, [MethodModel(f='text', p='请输入键盘输入的内容', d=True)])
+    async def w_keyboard_type_text(self, text: str):
+        """模拟人工输入文字"""
+        await self.base_data.page.keyboard.type(str(text))
+
+    @async_method_callback('web', '输入设备', 6, [MethodModel(f='text', p='请输入键盘输入的内容', d=True)])
+    async def w_keyboard_insert_text(self, text: str):
+        """直接输入文字"""
+        await self.base_data.page.keyboard.insert_text(str(text))
+
+    @async_method_callback('web', '输入设备', 7, [MethodModel(f='count', p='请输入要删除字符串的个数', d=True)])
+    async def w_keyboard_delete_text(self, count: int):
+        """删除光标左侧的字符"""
+        for _ in range(0, int(count) + 1):
+            await self.base_data.page.keyboard.press("Backspace")

mangoautomation/uidrive/web/async_web/_new_browser.py

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: 
+# @Time   : 2024-05-23 15:04
+# @Author : 毛鹏
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description:
+# @Time   : 2024-04-24 10:43
+# @Author : 毛鹏
+import asyncio
+import ctypes
+import os
+import string
+import traceback
+from typing import Optional
+
+from playwright._impl._errors import Error
+from playwright.async_api import async_playwright, Page, BrowserContext, Browser, Playwright, Request, Route
+
+from ....enums import BrowserTypeEnum
+from ....exceptions import MangoAutomationError
+from ....exceptions._error_msg import ERROR_MSG_0057, ERROR_MSG_0008, ERROR_MSG_0062, ERROR_MSG_0009, ERROR_MSG_0055
+
+"""
+python -m uiautomator2 init
+python -m weditor
+
+"""
+
+
+class AsyncWebNewBrowser:
+
+    def __init__(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
+                 ):
+        self.lock = asyncio.Lock()
+        self.web_type = web_type
+        self.web_path = web_path
+        self.web_max = web_max
+        self.web_headers = web_headers
+        self.web_recording = web_recording
+        self.web_h5 = web_h5
+        self.web_is_default = web_is_default
+        self.is_header_intercept = is_header_intercept
+        self.videos_path = videos_path
+        self.browser_path = ['chrome.exe', 'msedge.exe', 'firefox.exe', '苹果', '360se.exe']
+        self.browser: Optional[None | Browser] = None
+        self.playwright: Optional[None | Playwright] = None
+
+    async def new_web_page(self, count=0) -> tuple[BrowserContext, Page]:
+        if self.browser is None:
+            async with self.lock:
+                if self.browser is None:
+                    self.browser = await self.new_browser()
+                    await asyncio.sleep(1)
+        try:
+            context = await self.new_context()
+            page = await self.new_page(context)
+            return context, page
+        except Exception as error:
+            self.browser = None
+            traceback.format_exc()
+            if count >= 3:
+                raise MangoAutomationError(*ERROR_MSG_0057)
+            else:
+                return await self.new_web_page(count=count + 1)
+
+    async def new_browser(self) -> Browser:
+        self.playwright = await async_playwright().start()
+        if self.web_type == BrowserTypeEnum.CHROMIUM.value or self.web_type == BrowserTypeEnum.EDGE.value:
+            browser = self.playwright.chromium
+        elif self.web_type == BrowserTypeEnum.FIREFOX.value:
+            browser = self.playwright.firefox
+        elif self.web_type == BrowserTypeEnum.WEBKIT.value:
+            browser = self.playwright.webkit
+        else:
+            raise MangoAutomationError(*ERROR_MSG_0008)
+        if self.web_is_default:
+            try:
+                return await browser.launch()
+            except Error:
+                raise MangoAutomationError(*ERROR_MSG_0062)
+        else:
+            try:
+                if self.web_max:
+                    return await browser.launch(
+                        headless=self.web_headers,
+                        executable_path=self.web_path if self.web_path else self.__search_path(),
+                        args=['--start-maximized']
+                    )
+                else:
+                    return await browser.launch(
+                        headless=self.web_headers,
+                        executable_path=self.web_path if self.web_path else self.__search_path()
+                    )
+            except Error:
+                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
+
+        if self.web_h5:
+            del args_dict['no_viewport']
+            args_dict.update(self.playwright.devices[self.web_h5])
+        return await self.browser.new_context(**args_dict)
+
+    async def new_page(self, context: BrowserContext) -> Page:
+        try:
+            page = await context.new_page()
+            if self.is_header_intercept:
+                await page.route("**/*", self.wen_intercept_request)  # 应用拦截函数到页面的所有请求
+            return page
+        except Error:
+            raise MangoAutomationError(*ERROR_MSG_0009, value=(self.web_path,))
+
+    async def close(self):
+        if self.browser:
+            await self.browser.close()
+
+    def __search_path(self, ):
+        drives = []
+        for letter in string.ascii_uppercase:
+            drive = f"{letter}:\\"
+            if ctypes.windll.kernel32.GetDriveTypeW(drive) == 3:
+                drives.append(drive)
+        for i in drives:
+            for root, dirs, files in os.walk(i):
+                if self.browser_path[self.web_type] in files:
+                    return os.path.join(root, self.browser_path[self.web_type])
+
+        raise MangoAutomationError(*ERROR_MSG_0055)
+
+    async def wen_intercept_request(self, route: Route, request: Request):
+        pass
+
+    async def wen_recording_api(self, request: Request, project_product: int):
+        pass

mangoautomation/uidrive/web/async_web/_page.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: # @Time   : 2023-04-25 22:33
+# @Author : 毛鹏
+import asyncio
+
+from playwright.async_api import Locator
+
+from mangotools.decorator import async_method_callback
+from mangotools.models import MethodModel
+from ....tools import Meta
+from ....uidrive._base_data import BaseData
+
+
+class AsyncWebPage(metaclass=Meta):
+    """页面操作"""
+
+    def __init__(self, base_data: BaseData):
+        self.base_data = base_data
+
+    @async_method_callback('web', '页面操作', 0, [MethodModel(f='individual', p='请输入页签下标，从1开始数', d=True)])
+    async def w_switch_tabs(self, individual: int):
+        """切换页签"""
+        pages = self.base_data.context.pages
+        await pages[int(individual) + 1].bring_to_front()
+        self.base_data.page = pages[int(individual) + 1]
+        await asyncio.sleep(1)
+
+    @async_method_callback('web', '页面操作', 1)
+    async def w_close_current_tab(self):
+        """关闭当前页签"""
+        await asyncio.sleep(2)
+        pages = self.base_data.context.pages
+        await pages[-1].close()
+        self.base_data.page = pages[0]
+
+    @async_method_callback('web', '页面操作', 2, [MethodModel(f='locating')])
+    async def w_open_new_tab_and_switch(self, locating: Locator):
+        """点击并打开新页签"""
+
+        await locating.click()
+        await asyncio.sleep(2)
+        pages = self.base_data.context.pages
+        new_page = pages[-1]
+        await new_page.bring_to_front()
+        self.base_data.page = new_page
+        await asyncio.sleep(1)
+
+    @async_method_callback('web', '页面操作', 3)
+    async def w_refresh(self):
+        """刷新页面"""
+        await self.base_data.page.reload()
+
+    @async_method_callback('web', '页面操作', 4)
+    async def w_go_back(self):
+        """返回上一页"""
+        await self.base_data.page.go_back()
+
+    @async_method_callback('web', '页面操作', 5)
+    async def w_go_forward(self):
+        """前进到下一页"""
+        await self.base_data.page.go_forward()

mangoautomation/uidrive/web/sync_web/__init__.py

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: 
+# @Time   : 2025-04-04 21:42
+# @Author : 毛鹏
+import re
+import traceback
+
+from playwright._impl._errors import TimeoutError, Error, TargetClosedError
+from playwright.sync_api._generated import Locator
+
+from mangotools.assertion import PublicAssertion, SqlAssertion
+from mangotools.mangos import Mango
+from mangotools.enums import StatusEnum
+from ....enums import ElementExpEnum
+from ....exceptions import MangoAutomationError
+from ....exceptions._error_msg import *
+from ....uidrive._base_data import BaseData
+from ....uidrive.web.sync_web._assertion import SyncWebAssertion
+from ....uidrive.web.sync_web._browser import SyncWebBrowser
+from ....uidrive.web.sync_web._customization import SyncWebCustomization
+from ....uidrive.web.sync_web._element import SyncWebElement
+from ....uidrive.web.sync_web._input_device import SyncWebDeviceInput
+from ....uidrive.web.sync_web._page import SyncWebPage
+
+re = re
+__all__ = [
+    'SyncWebAssertion',
+    'SyncWebBrowser',
+    'SyncWebCustomization',
+    'SyncWebDeviceInput',
+    'SyncWebElement',
+    'SyncWebPage',
+    'SyncWebDevice',
+]
+
+
+class SyncWebDevice(SyncWebBrowser,
+                    SyncWebPage,
+                    SyncWebElement,
+                    SyncWebDeviceInput,
+                    SyncWebCustomization):
+
+    def __init__(self, base_data: BaseData):
+        super().__init__(base_data)
+
+    def open_url(self, is_open: bool = False):
+        if not self.base_data.is_open_url or is_open:
+            self.base_data.log.debug(f'打开url，is_open_url：{self.base_data.is_open_url},url:{self.base_data.url}')
+            self.w_goto(self.base_data.url)
+            self.base_data.is_open_url = True
+
+    def web_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 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,))
+        except ValueError as error:
+            self.base_data.log.error(f'WEB自动化操作失败-3，类型：{type(error)}，失败详情：{error}')
+            raise MangoAutomationError(*ERROR_MSG_0012)
+
+    def web_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(SyncWebAssertion, ope_key, None))
+        is_method_public = callable(getattr(PublicAssertion, ope_key, None))
+        try:
+            if is_method:
+                if ope_value.get('actual', None) is None:
+                    raise MangoAutomationError(*ERROR_MSG_0031, value=(name,))
+                self.base_data.log.debug(f'开始断言-1，方法：{ope_key}，断言值：{ope_value}')
+                Mango.s_e(SyncWebAssertion(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.debug(f'WEB自动化断言失败-1，类型：{type(error)}，失败详情：{error}')
+            raise MangoAutomationError(*ERROR_MSG_0017, value=error.args)
+        except AttributeError as error:
+            self.base_data.log.error(f'WEB自动化断言失败-2，类型：{type(error)}，失败详情：{error}')
+            raise MangoAutomationError(*ERROR_MSG_0048)
+        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,), )
+
+    def web_find_ele(self, name, _type, exp, loc, sub, is_iframe) \
+            -> tuple[Locator, int, str] | tuple[list[Locator], int, str]:
+        self.base_data.log.debug(
+            f'查找元素，名称：{name},_type:{_type},exp:{exp},loc:{loc},sub:{sub},is_iframe:{is_iframe}')
+        if is_iframe != StatusEnum.SUCCESS.value:
+            locator: Locator = self.__find_ele(self.base_data.page, exp, loc)
+            try:
+                count = locator.count()
+                loc = locator.nth(sub - 1) if sub else locator
+                try:
+                    text = self.w_get_text(loc)
+                except Exception:
+                    text = None
+                return loc, count, text
+            except Error as error:
+                self.base_data.log.error(
+                    f'WEB自动化查找元素失败-1，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+                raise MangoAutomationError(*ERROR_MSG_0041, )
+        else:
+            ele_list: list[Locator] = []
+            for i in self.base_data.page.frames:
+                locator: Locator = self.__find_ele(i, exp, loc)
+                try:
+                    count = locator.count()
+                except Error as error:
+                    self.base_data.log.error(
+                        f'WEB自动化查找元素失败-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+                    raise MangoAutomationError(*ERROR_MSG_0041, )
+                if count > 0:
+                    for nth in range(0, count):
+                        ele_list.append(locator.nth(nth))
+                else:
+                    raise MangoAutomationError(*ERROR_MSG_0023)
+
+            try:
+                count = len(ele_list)
+                loc = ele_list[sub - 1] if sub else ele_list[0]
+                try:
+                    text = self.w_get_text(loc)
+                except Exception:
+                    text = None
+                return loc, count, text
+            except IndexError:
+                raise MangoAutomationError(*ERROR_MSG_0025, value=(len(ele_list),))
+
+    def __find_ele(self, page, exp, loc) -> Locator:
+        match exp:
+            case ElementExpEnum.LOCATOR.value:
+                try:
+                    return eval(f"page.{loc}")
+                except SyntaxError:
+                    try:
+                        return eval(f"await page.{loc}")
+                    except SyntaxError as error:
+                        self.base_data.log.error(f'WEB自动化查找元素失败-3，类型：{type(error)}，失败详情：{error}')
+                        raise MangoAutomationError(*ERROR_MSG_0022)
+                    except NameError as error:
+                        self.base_data.log.error(f'WEB自动化查找元素失败-4，类型：{type(error)}，失败详情：{error}')
+                        raise MangoAutomationError(*ERROR_MSG_0060)
+            case ElementExpEnum.XPATH.value:
+                return page.locator(f'xpath={loc}')
+            case ElementExpEnum.CSS.value:
+                return page.locator(loc)
+            case ElementExpEnum.TEXT.value:
+                return page.get_by_text(loc, exact=True)
+            case ElementExpEnum.PLACEHOLDER.value:
+                return page.get_by_placeholder(loc)
+            case _:
+                raise MangoAutomationError(*ERROR_MSG_0020)