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

mangoautomation/uidrives/web/async_web/_assertion.py

@@ -1,303 +0,0 @@
-# -*- 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 ....uidrives._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(n='预期值', 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
-        return f'实际={await actual.count()}, 预期={expect}'
-
-    @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'
-        return f'实际={count}, 预期>0'
-
-    @async_method_callback('ass_web', '元素断言', 1, [
-        MethodModel(f='actual'),
-        MethodModel(n='预期值', 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}'
-            return f'实际={actual}, 预期={expect}'
-
-        else:
-            if actual:
-                try:
-                    await exp(actual).to_have_count(int(expect))
-                    return f'实际={actual.count()}, 预期={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(n='预期值', 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
-        return f'实际={actual}, 预期={expect}'
-
-    @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
-        return f'实际={actual}, 预期=不为空'
-
-    @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
-        return f'实际={actual}, 预期=不启用'
-
-    @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
-        return f'实际={actual}, 预期=不聚焦'
-
-    @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
-        return f'实际={actual}, 预期=不可隐藏'
-
-    @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
-        return f'实际={actual}, 预期=不在视窗中'
-
-    @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
-        return f'实际={actual}, 预期=不可见'
-
-    @async_method_callback('ass_web', '元素断言', 9, [
-        MethodModel(f='actual'),
-        MethodModel(n='预期值', 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
-        return f'实际={actual}, 预期=没有阶级'
-
-    @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
-        return f'实际={actual}, 预期=复选框已选中'
-
-    @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
-        return f'实际={actual}, 预期=已禁用'
-
-    @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
-        return f'实际={actual}, 预期=已启用'
-
-    @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}, 预期=为空'
-            return f'实际={actual}, 预期=为空'
-        else:
-            try:
-                await exp(actual).to_be_empty()
-                return f'实际={actual}, 预期=为空'
-            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
-        return f'实际={actual}, 预期=可见'
-    # @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]"))

mangoautomation/uidrives/web/async_web/_browser.py

@@ -1,112 +0,0 @@
-# -*- 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, TargetClosedError
-
-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_0049, ERROR_MSG_0013, ERROR_MSG_0058, ERROR_MSG_0059, ERROR_MSG_0010
-from ....tools import Meta
-
-
-class AsyncWebBrowser(metaclass=Meta):
-    """浏览器操作"""
-
-    def __init__(self, base_data: BaseData):
-        self.base_data = base_data
-
-    @async_method_callback('web', '浏览器操作', 0, [
-        MethodModel(n='等待时间', 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(n='url地址', 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失败-1，类型：{type(error)}，失败详情：{error}')
-            raise MangoAutomationError(*ERROR_MSG_0013, value=(url,))
-        except TargetClosedError as error:
-            self.base_data.setup()
-            self.base_data.log.debug(f'打开URL失败-2，类型：{type(error)}，失败详情：{error}')
-            raise MangoAutomationError(*ERROR_MSG_0010, 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(n='存储路径', f='path', p='请输入截图名称', d=True)])
-    async def w_screenshot(self, path: str):
-        """整个页面截图"""
-        try:
-            await self.base_data.page.screenshot(path=os.path.join(self.base_data.screenshot_path, path), full_page=True, timeout=10000)
-        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)
-
-    @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(n='获取cookie方法的值', 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/uidrives/web/async_web/_customization.py

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

mangoautomation/uidrives/web/async_web/_element.py

@@ -1,240 +0,0 @@
-# -*- 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, TimeoutError
-
-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(n='输入内容', 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(n='缓存的key', f='set_cache_key', p='请输入获取元素文本后存储的key', d=True)])
-    async def w_get_text(self, locating: Locator, set_cache_key=None):
-        """获取元素文本"""
-        methods = [
-            ("inner_text", locating.inner_text),
-            ("text_content", locating.text_content),
-            ("input_value", locating.input_value),
-            ("get_attribute", lambda: locating.get_attribute("value")),
-            ("evaluate", lambda: locating.evaluate("el => el.value")),
-        ]
-        for method_name, method in methods:
-            try:
-                value = await method()
-                if value is not None and str(value).strip() and set_cache_key:
-                    self.base_data.test_data.set_cache(key=set_cache_key, value=value)
-                    return value
-                elif value is not None and str(value).strip():
-                    return value
-            except Exception:
-                continue
-        return None
-
-    @async_method_callback('web', '元素操作', 5, [
-        MethodModel(f='locating'),
-        MethodModel(n='输入文本', f='input_value', p='请输入输入内容', d=True)])
-    async def w_clear_input(self, locating: Locator, input_value: str):
-        """元素清空再输入"""
-        await locating.clear()
-        await locating.fill(str(input_value))
-
-    @async_method_callback('web', '元素操作', 6, [MethodModel(f='locating')])
-    async def w_many_click(self, locating: Locator):
-        """多元素循环单击"""
-        await asyncio.sleep(1)
-        elements = await locating.all()
-        for element in elements:
-            await element.click()
-            await asyncio.sleep(0.2)
-
-    @async_method_callback('web', '元素操作', 6, [
-        MethodModel(f='locating'),
-        MethodModel(n='文件名称', 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, timeout=30000)
-            else:
-                for file in file_path:
-                    await locating.set_input_files(file, timeout=30000)
-        except Error:
-            raise MangoAutomationError(*ERROR_MSG_0024)
-
-    @async_method_callback('web', '元素操作', 7, [
-        MethodModel(f='locating'),
-        MethodModel(n='文件名称', 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(timeout=30000) 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(n='存储key值', 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(timeout=30000) 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='locating')])
-    async def w_element_wheel(self, locating: Locator):
-        """滚动到元素位置"""
-        await locating.scroll_into_view_if_needed()
-
-    @async_method_callback('web', '元素操作', 9, [MethodModel(f='locating')])
-    async def w_right_click(self, locating: Locator):
-        """元素右键点击"""
-        await locating.click(button='right')
-
-    @async_method_callback('web', '元素操作', 10, [
-        MethodModel(f='locating'),
-        MethodModel(n='点击时间', 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(n='像素大小', 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(n='像素大小', 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(n='像素大小', 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(n='像素大小', 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(n='保存路径', f='path', p='请输入截图名称', d=True)])
-    async def w_ele_screenshot(self, locating: Locator, path: str):
-        """元素截图"""
-        await locating.screenshot(path=os.path.join(self.base_data.download_path, path))
-
-    @async_method_callback('web', '元素操作', 20, [
-        MethodModel(f='locating1'),
-        MethodModel(f='locating2')])
-    async def w_drag_to(self, locating1: Locator, locating2: Locator):
-        """拖动A元素到达B"""
-        await locating1.drag_to(locating2)