mangoautomation 1.1.23__py3-none-any.whl → 1.1.25__py3-none-any.whl

mangoautomation/uidrives/web/async_web/_input_device.py

@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Project: 芒果测试平台
-# @Description: # @Time   : 2023-04-29 12:11
-# @Author : 毛鹏
-
-from mangotools.decorator import async_method_callback
-from mangotools.models import MethodModel
-from ....tools import Meta
-from ....uidrives._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(n='按键值', f='keyboard', p='请输入键盘名称，首字母大写', d=True)])
-    async def w_keys(self, keyboard: str):
-        """模拟按下指定的键"""
-        await self.base_data.page.keyboard.press(str(keyboard))
-
-    @async_method_callback('web', '输入设备', 1, [
-        MethodModel(n='滚动像素', 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(n='x坐标', f='x', p='请输入点击的x轴', d=True),
-        MethodModel(n='y坐标', 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(n='输入文本', 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(n='输入文本', 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(n='删除个数', 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/uidrives/web/async_web/_new_browser.py

@@ -1,153 +0,0 @@
-# -*- 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,
-                 log=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.log = log
-        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:
-            self.log.error(f'初始化page失败，错误信息：{traceback.format_exc()}')
-            self.browser = None
-            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 as error:
-                self.log.error(f'初始化浏览器失败-1，类型：{error}，详情：{traceback.format_exc()}')
-                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 as error:
-                self.log.error(f'初始化浏览器失败-2，类型：{error}，详情：{traceback.format_exc()}')
-                raise MangoAutomationError(*ERROR_MSG_0009, value=(self.web_path,))
-
-    async def new_context(self) -> BrowserContext:
-        args_dict = {'ignore_https_errors': True}
-        if self.web_is_default:
-            args_dict["viewport"] = {"width": 1920, "height": 1080}
-        if self.web_h5:
-            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
-        context = await self.browser.new_context(**args_dict)
-        context.set_default_timeout(3000)
-        return context
-
-    async def new_page(self, context: BrowserContext) -> Page:
-        try:
-            page = await context.new_page()
-            page.set_default_timeout(3000)
-            if self.is_header_intercept:
-                await page.route("**/*", self.wen_intercept_request)  # 应用拦截函数到页面的所有请求
-            return page
-        except Error as error:
-            self.log.error(f'初始化page失败，类型：{error}，详情：{traceback.format_exc()}')
-            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/uidrives/web/async_web/_page.py

@@ -1,63 +0,0 @@
-# -*- 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 ....uidrives._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(n='页签下标', 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/uidrives/web/sync_web/__init__.py

@@ -1,160 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Project: 芒果测试平台
-# @Description: 
-# @Time   : 2025-04-04 21:42
-# @Author : 毛鹏
-import re
-import traceback
-
-from playwright.sync_api import Locator, TimeoutError, Error
-
-from mangotools.assertion import MangoAssertion
-from mangotools.enums import StatusEnum
-from mangotools.mangos import Mango
-from ....enums import ElementExpEnum
-from ....exceptions import MangoAutomationError
-from ....exceptions.error_msg import *
-from ....uidrives._base_data import BaseData
-from ....uidrives.web.sync_web._assertion import SyncWebAssertion
-from ....uidrives.web.sync_web._browser import SyncWebBrowser
-from ....uidrives.web.sync_web._customization import SyncWebCustomization
-from ....uidrives.web.sync_web._element import SyncWebElement
-from ....uidrives.web.sync_web._input_device import SyncWebDeviceInput
-from ....uidrives.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.debug(f'WEB自动化操作失败-1，类型：{type(error)}，失败详情：{error}')
-            raise MangoAutomationError(*ERROR_MSG_0011, value=(name,))
-        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) -> str:
-        self.base_data.log.debug(f'断言元素，名称：{name},key:{ope_key},value:{ope_value}')
-        is_method = callable(getattr(SyncWebAssertion, 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}')
-                return Mango.s_e(SyncWebAssertion(self.base_data), ope_key, ope_value)
-            else:
-                self.base_data.log.debug(f'开始断言-2，方法：{ope_key}，断言值：{ope_value}')
-                return MangoAssertion(self.base_data.mysql_connect, self.base_data.test_data) \
-                    .ass(ope_key, ope_value.get('actual'), ope_value.get('expect'))
-        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 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.debug(
-                    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.debug(
-                        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)