kdtest-pw 2.0.0__py3-none-any.whl

kdtest_pw/__init__.py

@@ -0,0 +1,50 @@
+"""KDTest-Playwright 关键字驱动测试框架
+
+基于 Playwright 的关键字驱动测试框架，专为 Element Plus/Vue3 优化。
+"""
+
+from .product import __version__, __author__, __description__
+from .reference import (
+    GSTORE,
+    GSDSTORE,
+    MODULEDATA,
+    PRIVATEDATA,
+    CASESDATA,
+    INFO,
+    get_global,
+    set_global,
+    get_element_value,
+    set_element_value,
+    clear_element_values,
+)
+from .common import (
+    DEFAULT_CONFIG,
+    BROWSER_TYPES,
+    LOCATOR_TYPES,
+    KEY_MAP,
+)
+
+__all__ = [
+    # 版本信息
+    '__version__',
+    '__author__',
+    '__description__',
+    # 全局存储
+    'GSTORE',
+    'GSDSTORE',
+    'MODULEDATA',
+    'PRIVATEDATA',
+    'CASESDATA',
+    # 工具函数
+    'INFO',
+    'get_global',
+    'set_global',
+    'get_element_value',
+    'set_element_value',
+    'clear_element_values',
+    # 常量
+    'DEFAULT_CONFIG',
+    'BROWSER_TYPES',
+    'LOCATOR_TYPES',
+    'KEY_MAP',
+]

kdtest_pw/action/__init__.py

@@ -0,0 +1,7 @@
+"""动作模块 - 关键字实现"""
+
+from .base_keyword import BaseKeyword
+from .page_action import KeyWordTest
+from .key_retrieval import KeyRetrieval
+
+__all__ = ['BaseKeyword', 'KeyWordTest', 'KeyRetrieval']

kdtest_pw/action/base_keyword.py

@@ -0,0 +1,292 @@
+"""基础关键字类 - 元素定位和通用操作"""
+
+from playwright.sync_api import Page, Locator, FrameLocator
+from typing import Optional, Union, Literal, List
+
+from ..common import LOCATOR_TYPES
+from ..reference import INFO
+
+LocatorType = Literal[
+    'id', 'name', 'class_name', 'class', 'css', 'xpath',
+    'text', 'role', 'data_testid', 'placeholder', 'link_text', 'partial_link_text'
+]
+
+
+class BaseKeyword:
+    """基础关键字类
+
+    提供元素定位和通用操作方法，是所有关键字类的基类。
+    """
+
+    def __init__(self, page: Page):
+        """初始化基础关键字
+
+        Args:
+            page: Playwright Page 实例
+        """
+        self.page = page
+        self._current_frame: Optional[FrameLocator] = None
+        self._frame_stack: List[FrameLocator] = []
+
+    def locator(
+        self,
+        targeting: LocatorType,
+        element: str,
+        index: Optional[Union[int, str]] = None,
+        parent: Optional[Locator] = None
+    ) -> Locator:
+        """统一元素定位方法
+
+        Args:
+            targeting: 定位类型 (id, name, class_name, css, xpath, text, role, data_testid, placeholder)
+            element: 定位表达式
+            index: 索引 (数字、'first'、'last')，None 表示不使用索引
+            parent: 父元素定位器，用于链式定位
+
+        Returns:
+            Locator: Playwright Locator 实例
+        """
+        # 确定基础定位上下文
+        base = parent or self._current_frame or self.page
+
+        # 标准化定位类型
+        targeting = LOCATOR_TYPES.get(targeting, targeting)
+
+        # 根据定位类型创建 Locator
+        locator_map = {
+            'id': lambda: base.locator(f'#{element}'),
+            'name': lambda: base.locator(f'[name="{element}"]'),
+            'class_name': lambda: base.locator(f'.{element}'),
+            'css': lambda: base.locator(element),
+            'xpath': lambda: base.locator(f'xpath={element}'),
+            'text': lambda: base.get_by_text(element, exact=False),
+            'role': lambda: base.get_by_role(element),
+            'data_testid': lambda: base.get_by_test_id(element),
+            'placeholder': lambda: base.get_by_placeholder(element),
+        }
+
+        loc = locator_map.get(targeting, lambda: base.locator(element))()
+
+        # 处理索引
+        if index is not None:
+            if index == 'first' or index == 0:
+                loc = loc.first
+            elif index == 'last' or index == -1:
+                loc = loc.last
+            elif isinstance(index, int):
+                loc = loc.nth(index)
+            elif isinstance(index, str) and index.isdigit():
+                loc = loc.nth(int(index))
+
+        return loc
+
+    def locator_by_expression(self, expression: str, index: Optional[Union[int, str]] = None) -> Locator:
+        """通过表达式定位元素
+
+        支持格式：
+        - "xpath=//div" 或 "xpath://div"
+        - "css=.class" 或 "css:.class"
+        - "text=文本"
+        - "id=elementId"
+        - 纯 CSS 选择器
+
+        Args:
+            expression: 定位表达式
+            index: 索引
+
+        Returns:
+            Locator: Playwright Locator 实例
+        """
+        base = self._current_frame or self.page
+
+        # 解析表达式
+        if '=' in expression:
+            parts = expression.split('=', 1)
+            prefix = parts[0].lower().rstrip(':')
+            value = parts[1]
+
+            if prefix == 'xpath':
+                loc = base.locator(f'xpath={value}')
+            elif prefix == 'css':
+                loc = base.locator(value)
+            elif prefix == 'text':
+                loc = base.get_by_text(value)
+            elif prefix == 'id':
+                loc = base.locator(f'#{value}')
+            elif prefix == 'name':
+                loc = base.locator(f'[name="{value}"]')
+            elif prefix == 'class':
+                loc = base.locator(f'.{value}')
+            else:
+                loc = base.locator(expression)
+        else:
+            # 纯 CSS 选择器
+            loc = base.locator(expression)
+
+        # 处理索引
+        if index is not None:
+            if index == 'first' or index == 0:
+                loc = loc.first
+            elif index == 'last' or index == -1:
+                loc = loc.last
+            elif isinstance(index, int):
+                loc = loc.nth(index)
+
+        return loc
+
+    def switch_frame(self, targeting: str, element: str) -> None:
+        """切换到 iframe
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+        """
+        if targeting == 'xpath':
+            frame_locator = self.page.frame_locator(f'xpath={element}')
+        elif targeting in ('css', 'selector'):
+            frame_locator = self.page.frame_locator(element)
+        elif targeting == 'name':
+            frame_locator = self.page.frame_locator(f'[name="{element}"]')
+        elif targeting == 'id':
+            frame_locator = self.page.frame_locator(f'#{element}')
+        else:
+            frame_locator = self.page.frame_locator(element)
+
+        self._frame_stack.append(self._current_frame)
+        self._current_frame = frame_locator
+        INFO(f"切换到 iframe: {element}")
+
+    def switch_frame_parent(self) -> None:
+        """切换到父级 frame"""
+        if self._frame_stack:
+            self._current_frame = self._frame_stack.pop()
+        else:
+            self._current_frame = None
+        INFO("切换到父级 frame")
+
+    def frame_default(self) -> None:
+        """返回主文档"""
+        self._current_frame = None
+        self._frame_stack.clear()
+        INFO("切换到主文档")
+
+    def wait_for_loading(self, timeout: int = 30000) -> None:
+        """等待页面加载完成
+
+        Args:
+            timeout: 超时时间 (毫秒)
+        """
+        self.page.wait_for_load_state('networkidle', timeout=timeout)
+
+    def wait_for_dom_ready(self, timeout: int = 30000) -> None:
+        """等待 DOM 加载完成
+
+        Args:
+            timeout: 超时时间 (毫秒)
+        """
+        self.page.wait_for_load_state('domcontentloaded', timeout=timeout)
+
+    def wait_for_element_plus_loading(self, timeout: int = 30000) -> None:
+        """等待 Element Plus 的 v-loading 消失
+
+        Args:
+            timeout: 超时时间 (毫秒)
+        """
+        loading = self.page.locator('.el-loading-mask')
+        try:
+            if loading.count() > 0:
+                loading.first.wait_for(state='hidden', timeout=timeout)
+        except Exception:
+            pass  # loading 可能已经消失
+
+    def wait_for_element(
+        self,
+        targeting: str,
+        element: str,
+        state: str = 'visible',
+        timeout: int = 30000
+    ) -> None:
+        """等待元素状态
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            state: 等待状态 (visible, hidden, attached, detached)
+            timeout: 超时时间 (毫秒)
+        """
+        loc = self.locator(targeting, element)
+        loc.wait_for(state=state, timeout=timeout)
+
+    def is_element_visible(self, targeting: str, element: str, index: Optional[int] = None) -> bool:
+        """检查元素是否可见
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            index: 索引
+
+        Returns:
+            bool: 元素是否可见
+        """
+        loc = self.locator(targeting, element, index)
+        return loc.is_visible()
+
+    def is_element_enabled(self, targeting: str, element: str, index: Optional[int] = None) -> bool:
+        """检查元素是否可用
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            index: 索引
+
+        Returns:
+            bool: 元素是否可用
+        """
+        loc = self.locator(targeting, element, index)
+        return loc.is_enabled()
+
+    def get_element_count(self, targeting: str, element: str) -> int:
+        """获取元素数量
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+
+        Returns:
+            int: 元素数量
+        """
+        loc = self.locator(targeting, element)
+        return loc.count()
+
+    def execute_script(self, script: str, *args) -> any:
+        """执行 JavaScript
+
+        Args:
+            script: JavaScript 代码
+            *args: 脚本参数
+
+        Returns:
+            脚本执行结果
+        """
+        return self.page.evaluate(script, args if args else None)
+
+    def execute_script_on_element(
+        self,
+        targeting: str,
+        element: str,
+        script: str,
+        index: Optional[int] = None
+    ) -> any:
+        """在元素上执行 JavaScript
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            script: JavaScript 代码 (使用 el 引用元素)
+            index: 索引
+
+        Returns:
+            脚本执行结果
+        """
+        loc = self.locator(targeting, element, index)
+        return loc.evaluate(script)

kdtest_pw/action/element_plus/__init__.py

@@ -0,0 +1,23 @@
+"""Element Plus 专用关键字模块"""
+
+from .el_select import ElSelectKeyword
+from .el_datepicker import ElDatePickerKeyword
+from .el_dialog import ElDialogKeyword
+from .el_table import ElTableKeyword
+from .el_cascader import ElCascaderKeyword
+from .el_tree import ElTreeKeyword
+from .el_upload import ElUploadKeyword
+from .el_form import ElFormKeyword
+from .el_menu import ElMenuKeyword
+
+__all__ = [
+    'ElSelectKeyword',
+    'ElDatePickerKeyword',
+    'ElDialogKeyword',
+    'ElTableKeyword',
+    'ElCascaderKeyword',
+    'ElTreeKeyword',
+    'ElUploadKeyword',
+    'ElFormKeyword',
+    'ElMenuKeyword',
+]

kdtest_pw/action/element_plus/el_cascader.py

@@ -0,0 +1,263 @@
+"""Element Plus Cascader 组件关键字"""
+
+from playwright.sync_api import Page, Locator
+from typing import Optional, List
+
+from ..base_keyword import BaseKeyword
+from ...reference import INFO, set_element_value
+
+
+class ElCascaderKeyword(BaseKeyword):
+    """Element Plus Cascader 级联选择器关键字
+
+    处理级联选择器的多级选择、搜索等操作。
+    """
+
+    def __init__(self, page: Page):
+        super().__init__(page)
+
+    def el_cascader(
+        self,
+        targeting: str,
+        element: str,
+        index: Optional[int] = None,
+        *,
+        content: str
+    ) -> None:
+        """级联选择
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            index: 索引
+            content: 选项路径 (格式: "一级/二级/三级")
+        """
+        options = [opt.strip() for opt in str(content).split('/')]
+        INFO(f"级联选择: {options}")
+
+        cascader = self.locator(targeting, element, index)
+        cascader.click()
+
+        # 等待面板出现
+        panel = self.page.locator('.el-cascader-panel:visible, .el-cascader__dropdown:visible')
+        panel.wait_for(state='visible', timeout=5000)
+
+        # 逐级选择
+        for i, opt in enumerate(options):
+            # 找到当前级别的菜单
+            menus = panel.locator('.el-cascader-menu')
+            if menus.count() > i:
+                menu = menus.nth(i)
+                node = menu.locator(f'.el-cascader-node:has-text("{opt}")')
+                if node.count() > 0:
+                    node.first.click()
+                    self.page.wait_for_timeout(200)
+
+        # 关闭面板
+        self.page.keyboard.press('Escape')
+
+    def el_cascader_search(
+        self,
+        targeting: str,
+        element: str,
+        index: Optional[int] = None,
+        *,
+        content: str,
+        select_first: bool = True
+    ) -> None:
+        """搜索并选择
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            index: 索引
+            content: 搜索关键词
+            select_first: 是否选择第一个结果
+        """
+        INFO(f"级联搜索: {content}")
+
+        cascader = self.locator(targeting, element, index)
+        cascader.click()
+
+        # 输入搜索
+        input_el = cascader.locator('.el-input__inner')
+        input_el.fill(str(content))
+        self.page.wait_for_timeout(300)
+
+        # 选择结果
+        if select_first:
+            suggestion = self.page.locator('.el-cascader__suggestion-panel:visible, .el-cascader-panel:visible')
+            if suggestion.is_visible():
+                first_item = suggestion.locator('.el-cascader__suggestion-item, .el-cascader-node').first
+                if first_item.is_visible():
+                    first_item.click()
+
+    def el_cascader_clear(
+        self,
+        targeting: str,
+        element: str,
+        index: Optional[int] = None
+    ) -> None:
+        """清除选择
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            index: 索引
+        """
+        INFO("清除级联选择")
+
+        cascader = self.locator(targeting, element, index)
+        cascader.hover()
+        self.page.wait_for_timeout(200)
+
+        clear_btn = cascader.locator('.el-cascader__clear-icon, .el-icon-circle-close')
+        if clear_btn.is_visible():
+            clear_btn.click()
+
+    def el_cascader_get_value(
+        self,
+        targeting: str,
+        element: str,
+        index: Optional[int] = None
+    ) -> str:
+        """获取当前选中值
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            index: 索引
+
+        Returns:
+            str: 选中的值（路径格式）
+        """
+        cascader = self.locator(targeting, element, index)
+
+        # 尝试获取标签
+        tags = cascader.locator('.el-cascader__tags .el-tag')
+        if tags.count() > 0:
+            values = [tag.text_content().strip() for tag in tags.all()]
+            return ' / '.join(values)
+
+        # 获取输入框值
+        input_el = cascader.locator('.el-input__inner')
+        value = input_el.get_attribute('value') or input_el.text_content()
+        return (value or '').strip()
+
+    def el_cascader_expand(
+        self,
+        targeting: str,
+        element: str,
+        index: Optional[int] = None,
+        *,
+        content: str
+    ) -> None:
+        """展开到指定节点（不选择）
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            index: 索引
+            content: 展开路径 (格式: "一级/二级")
+        """
+        options = [opt.strip() for opt in str(content).split('/')]
+        INFO(f"展开级联: {options}")
+
+        cascader = self.locator(targeting, element, index)
+        cascader.click()
+
+        panel = self.page.locator('.el-cascader-panel:visible')
+        panel.wait_for(state='visible', timeout=5000)
+
+        # 逐级展开（不选择叶子节点）
+        for i, opt in enumerate(options):
+            menus = panel.locator('.el-cascader-menu')
+            if menus.count() > i:
+                menu = menus.nth(i)
+                # 悬停展开
+                node = menu.locator(f'.el-cascader-node:has-text("{opt}")')
+                if node.count() > 0:
+                    node.first.hover()
+                    self.page.wait_for_timeout(200)
+
+    def el_cascader_select_multiple(
+        self,
+        targeting: str,
+        element: str,
+        index: Optional[int] = None,
+        *,
+        content: str
+    ) -> None:
+        """多选级联
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            index: 索引
+            content: 多个路径 (格式: "一级/二级,一级/三级")
+        """
+        paths = [path.strip() for path in str(content).split(',')]
+        INFO(f"级联多选: {paths}")
+
+        cascader = self.locator(targeting, element, index)
+        cascader.click()
+
+        panel = self.page.locator('.el-cascader-panel:visible')
+        panel.wait_for(state='visible', timeout=5000)
+
+        for path in paths:
+            options = [opt.strip() for opt in path.split('/')]
+
+            # 逐级选择
+            for i, opt in enumerate(options):
+                menus = panel.locator('.el-cascader-menu')
+                if menus.count() > i:
+                    menu = menus.nth(i)
+                    node = menu.locator(f'.el-cascader-node:has-text("{opt}")')
+                    if node.count() > 0:
+                        # 如果是最后一级，点击复选框
+                        if i == len(options) - 1:
+                            checkbox = node.first.locator('.el-checkbox')
+                            if checkbox.count() > 0:
+                                checkbox.click()
+                            else:
+                                node.first.click()
+                        else:
+                            node.first.click()
+                        self.page.wait_for_timeout(200)
+
+        # 关闭面板
+        self.page.keyboard.press('Escape')
+
+    def el_cascader_assert(
+        self,
+        targeting: str,
+        element: str,
+        index: Optional[int] = None,
+        *,
+        content: str,
+        mode: str = 'equals'
+    ) -> bool:
+        """断言选中值
+
+        Args:
+            targeting: 定位类型
+            element: 定位表达式
+            index: 索引
+            content: 期望值
+            mode: 断言模式
+
+        Returns:
+            bool: 断言结果
+        """
+        actual = self.el_cascader_get_value(targeting, element, index)
+
+        if mode == 'equals':
+            result = actual == content
+        elif mode == 'contains':
+            result = content in actual
+        else:
+            result = actual == content
+
+        INFO(f"级联断言: '{actual}' {mode} '{content}' -> {result}")
+        return result