mangoautomation 1.0.0__py3-none-any.whl

mangoautomation/uidrive/pc/new_windows.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: 
+# @Time   : 2024-11-30 13:12
+# @Author : 毛鹏
+import subprocess
+from typing import Optional
+
+import sys
+import time
+
+if not sys.platform.startswith('win32'):
+    print("警告: uiautomation 仅支持 Windows，当前环境已自动跳过")
+
+
+    class Auto:
+        pass
+
+
+    auto = Auto()
+
+
+    class Control:
+        pass
+else:
+
+    from uiautomation import Control, WindowControl
+    import uiautomation
+
+
+class NewWindows:
+
+    def __init__(self, win_path: str, win_title: str, timeout=10):
+        self.win_path = win_path
+        self.win_title = win_title
+        self.timeout = timeout
+        self.window: Optional[None | WindowControl] = None
+
+    def new_windows(self, retry=3):
+        subprocess.Popen(self.win_path)
+        for _ in range(retry):
+            self.window = uiautomation.WindowControl(
+                searchDepth=1,
+                Name=self.win_title,
+                Timeout=self.timeout * 1000
+            )
+            if self.window.Exists():
+                return self.window
+            time.sleep(1)
+
+    def find_control(self,
+                     parent=None,
+                     control_type: str = "Control",
+                     name: str = None,
+                     automation_id: str = None,
+                     **kwargs) -> Control:
+        """
+        查找控件（支持多条件组合）
+        :param parent: 父控件（默认从窗口开始查找）
+        :param control_type: 控件类型（如 Button、Edit、ListItem）
+        :param name: 控件名称（Name 属性）
+        :param automation_id: AutomationId 属性
+        :return: Control 对象
+        """
+        search_params = {
+            "searchDepth": 2,
+            "Timeout": self.timeout * 1000,
+            **kwargs
+        }
+        if name:
+            search_params["Name"] = name
+        if automation_id:
+            search_params["AutomationId"] = automation_id
+
+        parent = parent or self.window
+        control = getattr(uiautomation, f"{control_type}Control")(parent=parent, **search_params)
+        if not control.Exists():
+            raise Exception(f"未找到控件: {control_type}/{name}/{automation_id}")
+        return control

mangoautomation/uidrive/web/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description:
+# @Time   : 2023/5/16 14:50
+# @Author : 毛鹏

mangoautomation/uidrive/web/async_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.async_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.async_web._assertion import AsyncWebAssertion
+from ....uidrive.web.async_web._browser import AsyncWebBrowser
+from ....uidrive.web.async_web._customization import AsyncWebCustomization
+from ....uidrive.web.async_web._element import AsyncWebElement
+from ....uidrive.web.async_web._input_device import AsyncWebDeviceInput
+from ....uidrive.web.async_web._page import AsyncWebPage
+
+re = re
+__all__ = [
+    'AsyncWebPage',
+    'AsyncWebElement',
+    'AsyncWebDeviceInput',
+    'AsyncWebCustomization',
+    'AsyncWebBrowser',
+    'AsyncWebAssertion',
+    'AsyncWebDevice',
+]
+
+
+class AsyncWebDevice(AsyncWebBrowser,
+                     AsyncWebPage,
+                     AsyncWebElement,
+                     AsyncWebDeviceInput,
+                     AsyncWebCustomization):
+
+    def __init__(self, base_data: BaseData):
+        super().__init__(base_data)
+
+    async 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}')
+            await self.w_goto(self.base_data.url)
+            self.base_data.is_open_url = True
+
+    async def web_action_element(self, name, ope_key, ope_value, ):
+        self.base_data.log.debug(f'操作元素，名称：{name},key:{ope_key},value:{ope_value}')
+        try:
+            await Mango.a_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)
+
+    async 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(AsyncWebAssertion, ope_key, None))
+        is_method_public = callable(getattr(PublicAssertion, ope_key, None))
+        try:
+            if is_method:
+                if ope_value.get('actual', None) is None:
+                    traceback.print_exc()
+                    raise MangoAutomationError(*ERROR_MSG_0031, value=(name,))
+                self.base_data.log.debug(f'开始断言-1，方法：{ope_key}，断言值：{ope_value}')
+                await Mango.a_e(AsyncWebAssertion(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}')
+                    await 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,), )
+
+    async 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 = await self.__find_ele(self.base_data.page, exp, loc)
+            try:
+                count = await locator.count()
+                loc = locator.nth(sub - 1) if sub else locator
+                try:
+                    text = await 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, value=(name, loc))
+        else:
+            ele_list: list[Locator] = []
+            for i in self.base_data.page.frames:
+                locator: Locator = await self.__find_ele(i, exp, loc)
+                try:
+                    count = await 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
+                try:
+                    text = await self.w_get_text(loc)
+                except Exception:
+                    text = None
+                return loc, count, text
+            except IndexError:
+                raise MangoAutomationError(*ERROR_MSG_0025, value=(len(ele_list),))
+
+    async def __find_ele(self, page, exp, loc) -> Locator:
+        match exp:
+            case ElementExpEnum.LOCATOR.value:
+                try:
+                    return eval(f"await page.{loc}")
+                except SyntaxError:
+                    try:
+                        return eval(f"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)

mangoautomation/uidrive/web/async_web/_assertion.py

@@ -0,0 +1,290 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: # @Time   : 2023-04-26 22:25
+# @Author : 毛鹏
+
+from playwright.async_api import Locator, expect as exp
+
+from mangotools.decorator import async_method_callback
+from mangotools.models import MethodModel
+from ....exceptions import MangoAutomationError
+from ....exceptions._error_msg import ERROR_MSG_0021
+from ....tools import Meta
+from ....uidrive._base_data import BaseData
+
+
+class AsyncWebAssertion(metaclass=Meta):
+    """元素断言"""
+
+    def __init__(self, base_data: BaseData):
+        self.base_data = base_data
+
+    @async_method_callback('ass_web', '元素断言', 0, [
+        MethodModel(f='actual'),
+        MethodModel(f='expect', p='请输入元素个数', d=True)])
+    async def w_to_have_count(self, actual: Locator, expect: str):
+        """元素是几个"""
+        try:
+            await exp(actual).to_have_count(int(expect))
+        except AssertionError as e:
+            raise AssertionError(f'实际={await actual.count()}, 预期={expect}') from e
+
+    @async_method_callback('ass_web', '元素断言', 1, [MethodModel(f='actual')])
+    async def w_all_not_to_be_empty(self, actual: Locator):
+        """元素存在"""
+        count = await actual.count()
+        if count == 0:
+            assert False, f'实际={count}, 预期>0'
+
+    @async_method_callback('ass_web', '元素断言', 1, [
+        MethodModel(f='actual'),
+        MethodModel(f='expect', p='请输入元素存输入1，不存输入0', d=True)])
+    async def w_to_element_count(self, actual: Locator, expect: int):
+        """元素是否存在"""
+        if int(expect) == 0:
+            assert actual is None, f'实际={actual}, 预期={expect}'
+        else:
+            if actual:
+                try:
+                    await exp(actual).to_have_count(int(expect)),
+                except AssertionError as e:
+                    raise AssertionError(f'实际={actual.count()}, 预期={expect}') from e
+            else:
+                raise MangoAutomationError(*ERROR_MSG_0021)
+
+    @async_method_callback('ass_web', '元素断言', 2, [
+        MethodModel(f='actual'),
+        MethodModel(f='expect', p='请输入不包含的文本', d=True)])
+    async def w_not_to_contain_text(self, actual: Locator, expect: str):
+        """元素不包含文本"""
+        try:
+            await exp(actual).not_to_contain_text(expect)
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期={expect}') from e
+
+    @async_method_callback('ass_web', '元素断言', 3, [MethodModel(f='actual')])
+    async def w_not_to_be_empty(self, actual: Locator):
+        """元素不为空"""
+        try:
+            await exp(actual).not_to_be_empty()
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=不为空') from e
+
+    @async_method_callback('ass_web', '元素断言', 4, [MethodModel(f='actual')])
+    async def w_not_to_be_enabled(self, actual: Locator):
+        """元素不启用"""
+        try:
+            await exp(actual).not_to_be_enabled()
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=不启用') from e
+
+    @async_method_callback('ass_web', '元素断言', 5, [MethodModel(f='actual')])
+    async def w_not_to_be_focused(self, actual: Locator):
+        """元素不聚焦"""
+        try:
+            await exp(actual).not_to_be_focused()
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=不聚焦') from e
+
+    @async_method_callback('ass_web', '元素断言', 6, [MethodModel(f='actual')])
+    async def w_not_to_be_hidden(self, actual: Locator):
+        """元素不可隐藏"""
+        try:
+            await exp(actual).not_to_be_hidden()
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=不可隐藏') from e
+
+    @async_method_callback('ass_web', '元素断言', 7, [MethodModel(f='actual')])
+    async def w_not_to_be_in_viewport(self, actual: Locator):
+        """元素不在视窗中"""
+        try:
+            await exp(actual).not_to_be_in_viewport()
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=不在视窗中') from e
+
+    @async_method_callback('ass_web', '元素断言', 8, [MethodModel(f='actual')])
+    async def w_not_to_be_visible(self, actual: Locator):
+        """元素不可见"""
+        try:
+            await exp(actual).not_to_be_visible()
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=不可见') from e
+
+    @async_method_callback('ass_web', '元素断言', 9, [
+        MethodModel(f='actual'),
+        MethodModel(f='expect', p='请输入样式', d=True)])
+    async def w_not_to_have_class(self, actual: Locator, expect: str):
+        """元素没有阶级"""
+        try:
+            await exp(actual).not_to_have_class(expect)
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=没有阶级') from e
+
+    @async_method_callback('ass_web', '元素断言', 10, [MethodModel(f='actual')])
+    async def w_to_be_checked(self, actual: Locator):
+        """复选框已选中"""
+        try:
+            await exp(actual).to_be_checked()
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=复选框已选中') from e
+
+    @async_method_callback('ass_web', '元素断言', 11, [MethodModel(f='actual')])
+    async def w_to_be_disabled(self, actual: Locator):
+        """元素已禁用"""
+        try:
+            await exp(actual).to_be_disabled()
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=已禁用') from e
+
+    @async_method_callback('ass_web', '元素断言', 12, [MethodModel(f='actual')])
+    async def w_not_to_be_editable(self, actual: Locator):
+        """元素已启用"""
+        try:
+            await exp(actual).to_be_editable()
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=已启用') from e
+
+    @async_method_callback('ass_web', '元素断言', 13, [MethodModel(f='actual')])
+    async def w_to_be_empty(self, actual: Locator | list | None):
+        """元素为空"""
+        if actual is None:
+            assert True, f'实际={actual}, 预期=为空'
+        else:
+            try:
+                await exp(actual).to_be_empty()
+            except AssertionError as e:
+                raise AssertionError(f'实际={actual}, 预期=为空') from e
+
+    @async_method_callback('ass_web', '元素断言', 14, [MethodModel(f='actual')])
+    async def w_to_be_visible(self, actual: Locator):
+        """元素可见"""
+        try:
+            await exp(actual).to_be_visible()
+        except AssertionError as e:
+            raise AssertionError(f'实际={actual}, 预期=可见') from e
+    # @staticmethod
+    # async def w_not_to_have_actuals(actual: Locator, actuals: list):
+    #     """选择已选择选项"""
+    #     await exp(actual).to_have_actuals(actuals)
+
+    # @staticmethod
+    # def w_not_to_have_attribute(locating: Locator, name: str, actual: str):
+    #     """元素不具有属性"""
+    #     exp(locating).not_to_have_attribute(name, actual)
+    # @staticmethod
+
+    # @staticmethod
+    # def w_not_to_have_css(locating: Locator, name: str, actual: str):
+    #     """元素不使用CSS"""
+    #     exp(locating).not_to_have_css(name, actual)
+
+    # @staticmethod
+    # def w_not_to_have_id(locating: Locator, _id: str):
+    #     """元素没有ID"""
+    #     exp(locating).not_to_have_id(_id)
+    #
+    # @staticmethod
+    # def w_not_to_have_js_property(locating: Locator, name: str, actual):
+    #     """元素不具有js属性"""
+    #     exp(locating).not_to_have_js_property(name, actual)
+    #
+    # @staticmethod
+    # def w_not_to_have_text(locating: Locator, expected: str):
+    #     """元素没有文本"""
+    #     exp(locating).not_to_have_text(expected)
+
+    # @staticmethod
+    # def w_not_to_have_actual(locating: Locator, actual: str):
+    #     """元素无价值"""
+    #     exp(locating).not_to_have_actual(actual)
+
+    #
+    # def w_to_be_attached(self, hidden_text: str):
+    #     """待连接"""
+    #     exp(self.page.get_by_text(hidden_text)).to_be_attached()
+
+    #
+    # def w_to_be_editable(self, hidden_text: str):
+    #     """可编辑"""
+    #     locator = self.page.get_by_role("textbox")
+    #     exp(locator).to_be_editable()
+
+    # def w_to_be_enabled(self, hidden_text: str):
+    #     """为空"""
+    #     locator = self.page.locator("button.submit")
+    #     exp(locator).to_be_enabled()
+
+    # def w_to_be_focused(self, hidden_text: str):
+    #     """聚焦"""
+    #     locator = self.page.get_by_role("textbox")
+    #     exp(locator).to_be_focused()
+    #
+    # def w_to_be_hidden(self, hidden_text: str):
+    #     """隐藏"""
+    #     locator = self.page.locator('.my-element')
+    #     exp(locator).to_be_hidden()
+    #
+    # def w_to_be_in_viewport(self, hidden_text: str):
+    #     """待在视口中"""
+    #     locator = self.page.get_by_role("button")
+    #     # Make sure at least some part of element intersects viewport.
+    #     exp(locator).to_be_in_viewport()
+    #     # Make sure element is fully outside of viewport.
+    #     exp(locator).not_to_be_in_viewport()
+    #     # Make sure that at least half of the element intersects viewport.
+    #     exp(locator).to_be_in_viewport(ratio=0.5)
+    #
+
+    # def w_to_contain_text(self, hidden_text: str):
+    #     """包含文本"""
+    #     locator = self.page.locator('.title')
+    #     exp(locator).to_contain_text("substring")
+    #     exp(locator).to_contain_text(re.compile(r"\d messages"))
+    #
+    # def w_to_have_attribute(self, hidden_text: str):
+    #     """具有属性"""
+    #     locator = self.page.locator("input")
+    #     exp(locator).to_have_attribute("type", "text")
+    #
+    # def w_to_have_class(self, hidden_text: str):
+    #     """到保存类别"""
+    #     locator = self.page.locator("#component")
+    #     exp(locator).to_have_class(re.compile(r"selected"))
+    #     exp(locator).to_have_class("selected row")
+    #
+    # def w_to_have_count(self, hidden_text: str):
+    #     """有计数"""
+    #     locator = self.page.locator("list > .component")
+    #     exp(locator).to_have_count(3)
+    #
+    # def w_to_have_css(self, hidden_text: str):
+    #     """使用CSS"""
+    #     locator = self.page.get_by_role("button")
+    #     exp(locator).to_have_css("display", "flex")
+    #
+    # def w_to_have_id(self, hidden_text: str):
+    #     """到id"""
+    #     locator = self.page.get_by_role("textbox")
+    #     exp(locator).to_have_id("lastname")
+    #
+    # def w_to_have_js_property(self, hidden_text: str):
+    #     """拥有js属性"""
+    #     locator = self.page.locator(".component")
+    #     exp(locator).to_have_js_property("loaded", True)
+    #
+    # def w_to_have_text(self, hidden_text: str):
+    #     """有文本"""
+    #     locator = self.page.locator(".title")
+    #     exp(locator).to_have_text(re.compile(r"Welcome, Test User"))
+    #     exp(locator).to_have_text(re.compile(r"Welcome, .*"))
+    #
+    # def w_to_have_actual(self, hidden_text: str):
+    #     """有价值"""
+    #     locator = self.page.locator("input[type=number]")
+    #     exp(locator).to_have_actual(re.compile(r"[0-9]"))
+
+
+if __name__ == '__main__':
+    from mangokit.decorator import func_info
+
+    print(func_info)

mangoautomation/uidrive/web/async_web/_browser.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+# @Project: 芒果测试平台
+# @Description: # @Time   : 2023-04-25 22:33
+# @Author : 毛鹏
+import asyncio
+import json
+import os.path
+import traceback
+from urllib.parse import urlparse
+
+from playwright._impl._errors import TimeoutError, Error
+
+from mangotools.decorator import async_method_callback
+from mangotools.models import MethodModel
+from ....exceptions import MangoAutomationError
+from ....exceptions._error_msg import ERROR_MSG_0049, ERROR_MSG_0013, ERROR_MSG_0058, ERROR_MSG_0059
+from ....tools import Meta
+from ..._base_data import BaseData
+
+
+class AsyncWebBrowser(metaclass=Meta):
+    """浏览器操作"""
+
+    def __init__(self, base_data: BaseData):
+        self.base_data = base_data
+
+    @async_method_callback('web', '浏览器操作', 0, [
+        MethodModel(f='_time', p='请输入等待时间', d=True)])
+    async def w_wait_for_timeout(self, _time: int):
+        """强制等待"""
+        await asyncio.sleep(int(_time))
+
+    @async_method_callback('web', '浏览器操作', 1, [
+        MethodModel(f='url', p='请输入URL', d=True)])
+    async def w_goto(self, url: str):
+        """打开URL"""
+        try:
+            result = urlparse(url)
+            if not all([result.scheme, result.netloc]):
+                raise MangoAutomationError(*ERROR_MSG_0049)
+            await self.base_data.page.goto(url, timeout=60000)
+            await asyncio.sleep(2)
+        except TimeoutError as error:
+            self.base_data.log.debug(f'打开URL失败-2，类型：{type(error)}，失败详情：{error}')
+            raise MangoAutomationError(*ERROR_MSG_0013, value=(url,))
+        except Error as error:
+            self.base_data.log.debug(
+                f'打开URL失败-2，类型：{type(error)}，失败详情：{error}，失败明细：{traceback.format_exc()}')
+            raise MangoAutomationError(*ERROR_MSG_0058, value=(url,))
+
+    @async_method_callback('web', '浏览器操作', 2, [
+        MethodModel(f='path', p='请输入截图保存路径', d=True)])
+    async def w_screenshot(self, path: str):
+        """整个页面截图"""
+        await self.base_data.page.screenshot(path=path, full_page=True)
+
+    @async_method_callback('web', '浏览器操作', 3)
+    async def w_alert(self):
+        """设置弹窗不予处理"""
+        self.base_data.page.on("dialog", lambda dialog: dialog.accept())
+
+    @async_method_callback('web', '浏览器操作', 4)
+    async def w_get_cookie(self):
+        """获取cookie"""
+        with open(os.path.join(self.base_data.download_path, 'storage_state.json'), 'w') as file:
+            file.write(json.dumps(await self.base_data.context.storage_state()))
+
+    @async_method_callback('web', '浏览器操作', 5, [
+        MethodModel(f='storage_state', p='请输入获取cookie方法中获取的内容', d=True)])
+    async def w_set_cookie(self, storage_state: str):
+        """设置cookie"""
+        if isinstance(storage_state, str):
+            storage_state = json.loads(storage_state)
+        else:
+            raise MangoAutomationError(*ERROR_MSG_0059)
+        await self.base_data.context.add_cookies(storage_state['cookies'])
+        for storage in storage_state['origins']:
+            local_storage = storage.get('localStorage', [])
+            session_storage = storage.get('sessionStorage', [])
+            for item in local_storage:
+                await self.base_data.context.add_init_script(
+                    f"window.localStorage.setItem('{item['name']}', '{item['value']}');")
+            for item in session_storage:
+                await self.base_data.context.add_init_script(
+                    f"window.sessionStorage.setItem('{item['name']}', '{item['value']}');")
+        await self.base_data.page.reload()
+
+    @async_method_callback('web', '浏览器操作', 6)
+    async def w_clear_cookies(self):
+        """清除所有cookie"""
+        await self.base_data.context.clear_cookies()
+
+    @async_method_callback('web', '浏览器操作', 7)
+    async def w_clear_storage(self):
+        """清除本地存储和会话存储"""
+        await self.base_data.page.evaluate("() => localStorage.clear()")
+        await self.base_data.page.evaluate("() => sessionStorage.clear()")

mangoautomation/uidrive/web/async_web/_customization.py

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