pytest-dsl 0.14.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

pytest_dsl/core/keyword_loader.py

@@ -0,0 +1,402 @@
+"""
+pytest-dsl关键字加载器
+
+提供统一的关键字加载和管理功能，包括：
+- 内置关键字加载
+- 插件关键字发现和加载
+- 本地关键字扫描
+- 项目自定义关键字扫描
+- 远程关键字支持
+- 关键字分类和信息获取
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+
+from pytest_dsl.core.plugin_discovery import load_all_plugins, scan_local_keywords
+from pytest_dsl.core.keyword_manager import keyword_manager
+from pytest_dsl.core.lexer import get_lexer
+from pytest_dsl.core.parser import get_parser
+
+
+class KeywordLoader:
+    """关键字加载器类"""
+    
+    def __init__(self):
+        self._project_custom_keywords = None
+    
+    def load_all_keywords(self, include_remote: bool = False) -> Dict[str, Any]:
+        """加载所有可用的关键字
+
+        Args:
+            include_remote: 是否包含远程关键字，默认为False
+
+        Returns:
+            项目自定义关键字信息字典
+        """
+        # 首先导入内置关键字模块，确保内置关键字被注册
+        try:
+            import pytest_dsl.keywords  # noqa: F401
+            print("内置关键字模块加载完成")
+        except ImportError as e:
+            print(f"加载内置关键字模块失败: {e}")
+
+        # 加载已安装的关键字插件
+        load_all_plugins()
+
+        # 扫描本地关键字
+        scan_local_keywords()
+
+        # 自动导入项目中的resources目录
+        self._load_resources_directory()
+
+        # 扫描项目中的自定义关键字（.resource文件中定义的）
+        project_custom_keywords = self.scan_project_custom_keywords()
+        if project_custom_keywords:
+            print(f"发现 {len(project_custom_keywords)} 个项目自定义关键字")
+            self._load_resource_files(project_custom_keywords)
+
+        # 根据参数决定是否加载远程关键字
+        if include_remote:
+            print("正在扫描远程关键字...")
+            # 这里可以添加远程关键字的扫描逻辑
+            # 目前远程关键字是通过DSL文件中的@remote导入指令动态加载的
+        else:
+            print("跳过远程关键字扫描")
+
+        self._project_custom_keywords = project_custom_keywords
+        return project_custom_keywords
+
+    def _load_resources_directory(self):
+        """自动导入项目中的resources目录"""
+        try:
+            from pytest_dsl.core.custom_keyword_manager import custom_keyword_manager
+
+            # 尝试从多个可能的项目根目录位置导入resources
+            possible_roots = [
+                os.getcwd(),  # 当前工作目录
+                os.path.dirname(os.getcwd()),  # 上级目录
+            ]
+
+            # 尝试每个可能的根目录
+            for project_root in possible_roots:
+                if project_root and os.path.exists(project_root):
+                    resources_dir = os.path.join(project_root, "resources")
+                    if (os.path.exists(resources_dir) and
+                            os.path.isdir(resources_dir)):
+                        custom_keyword_manager.auto_import_resources_directory(
+                            project_root)
+                        break
+        except Exception as e:
+            print(f"自动导入resources目录时出现警告: {str(e)}")
+
+    def _load_resource_files(self, project_custom_keywords: Dict[str, Any]):
+        """加载.resource文件中的关键字到关键字管理器"""
+        from pytest_dsl.core.custom_keyword_manager import custom_keyword_manager
+
+        project_root = Path(os.getcwd())
+        resource_files = list(project_root.glob('**/*.resource'))
+
+        for resource_file in resource_files:
+            try:
+                custom_keyword_manager.load_resource_file(str(resource_file))
+                print(f"已加载资源文件: {resource_file}")
+            except Exception as e:
+                print(f"加载资源文件失败 {resource_file}: {e}")
+
+    def scan_project_custom_keywords(self, project_root: Optional[str] = None) -> Dict[str, Any]:
+        """扫描项目中.resource文件中的自定义关键字
+
+        Args:
+            project_root: 项目根目录，默认为当前工作目录
+
+        Returns:
+            自定义关键字信息，格式为 
+            {keyword_name: {'file': file_path, 'node': ast_node, 'parameters': [...]}}
+        """
+        if project_root is None:
+            project_root = os.getcwd()
+
+        project_root = Path(project_root)
+        custom_keywords = {}
+
+        # 查找所有.resource文件
+        resource_files = list(project_root.glob('**/*.resource'))
+
+        if not resource_files:
+            return custom_keywords
+
+        lexer = get_lexer()
+        parser = get_parser()
+
+        for file_path in resource_files:
+            try:
+                # 读取并解析文件
+                content = self._read_file(str(file_path))
+                ast = parser.parse(content, lexer=lexer)
+
+                # 查找自定义关键字定义
+                keywords_in_file = self._extract_custom_keywords_from_ast(
+                    ast, str(file_path)
+                )
+                custom_keywords.update(keywords_in_file)
+
+            except Exception as e:
+                print(f"解析资源文件 {file_path} 时出错: {e}")
+
+        return custom_keywords
+
+    def _read_file(self, filename: str) -> str:
+        """读取文件内容"""
+        with open(filename, 'r', encoding='utf-8') as f:
+            return f.read()
+
+    def _extract_custom_keywords_from_ast(self, ast, file_path: str) -> Dict[str, Any]:
+        """从AST中提取自定义关键字定义
+
+        Args:
+            ast: 抽象语法树
+            file_path: 文件路径
+
+        Returns:
+            自定义关键字信息字典
+        """
+        custom_keywords = {}
+
+        if ast.type != 'Start' or len(ast.children) < 2:
+            return custom_keywords
+
+        # 遍历语句节点
+        statements_node = ast.children[1]
+        if statements_node.type != 'Statements':
+            return custom_keywords
+
+        for node in statements_node.children:
+            # 支持两种格式：CustomKeyword（旧格式）和Function（新格式）
+            if node.type in ['CustomKeyword', 'Function']:
+                keyword_name = node.value
+
+                # 提取参数信息
+                params_node = node.children[0] if node.children else None
+                parameters = []
+
+                if params_node:
+                    for param in params_node:
+                        param_name = param.value
+                        param_default = None
+
+                        # 检查是否有默认值
+                        if param.children and param.children[0]:
+                            param_default = param.children[0].value
+
+                        param_info = {
+                            'name': param_name,
+                            'mapping': param_name,
+                            'description': f'自定义关键字参数 {param_name}'
+                        }
+
+                        if param_default is not None:
+                            param_info['default'] = param_default
+
+                        parameters.append(param_info)
+
+                custom_keywords[keyword_name] = {
+                    'file': file_path,
+                    'node': node,
+                    'type': 'project_custom',
+                    'parameters': parameters
+                }
+
+        return custom_keywords
+
+    def categorize_keyword(self, keyword_name: str, keyword_info: Dict[str, Any],
+                          project_custom_keywords: Optional[Dict[str, Any]] = None) -> str:
+        """判断关键字的类别
+
+        Args:
+            keyword_name: 关键字名称
+            keyword_info: 关键字信息
+            project_custom_keywords: 项目自定义关键字信息
+
+        Returns:
+            关键字类别：'builtin', 'plugin', 'custom', 'project_custom', 'remote'
+        """
+        # 优先使用存储的来源信息
+        source_type = keyword_info.get('source_type')
+        if source_type:
+            if source_type == 'builtin':
+                return 'builtin'
+            elif source_type == 'plugin':
+                return 'plugin'
+            elif source_type in ['external', 'local']:
+                return 'custom'
+            elif source_type == 'project_custom':
+                return 'project_custom'
+
+        # 向后兼容：使用原有的判断逻辑
+        if keyword_info.get('remote', False):
+            return 'remote'
+
+        # 检查是否是项目自定义关键字（DSL文件中定义的）
+        if project_custom_keywords and keyword_name in project_custom_keywords:
+            return 'project_custom'
+
+        # 检查是否是内置关键字（通过检查函数所在模块）
+        func = keyword_info.get('func')
+        if func and hasattr(func, '__module__'):
+            module_name = func.__module__
+            if module_name and module_name.startswith('pytest_dsl.keywords'):
+                return 'builtin'
+
+        return 'custom'
+
+    def get_keyword_source_info(self, keyword_info: Dict[str, Any]) -> Dict[str, Any]:
+        """获取关键字的详细来源信息
+
+        Args:
+            keyword_info: 关键字信息
+
+        Returns:
+            来源信息字典
+        """
+        source_type = keyword_info.get('source_type', 'unknown')
+        source_name = keyword_info.get('source_name', '未知')
+
+        return {
+            'type': source_type,
+            'name': source_name,
+            'display_name': source_name,
+            'module': keyword_info.get('module_name', ''),
+            'plugin_module': keyword_info.get('plugin_module', '')
+        }
+
+    def group_keywords_by_source(self, keywords_dict: Dict[str, Any],
+                                project_custom_keywords: Optional[Dict[str, Any]] = None) -> Dict[str, Dict[str, List]]:
+        """按来源分组关键字
+
+        Args:
+            keywords_dict: 关键字字典
+            project_custom_keywords: 项目自定义关键字信息
+
+        Returns:
+            分组后的关键字字典，格式为 {source_group: {source_name: [keywords]}}
+        """
+        groups = {
+            'builtin': {},
+            'plugin': {},
+            'custom': {},
+            'project_custom': {},
+            'remote': {}
+        }
+
+        for keyword_name, keyword_info in keywords_dict.items():
+            category = self.categorize_keyword(
+                keyword_name, keyword_info, project_custom_keywords
+            )
+            source_info = self.get_keyword_source_info(keyword_info)
+
+            # 特殊处理项目自定义关键字
+            if category == 'project_custom' and project_custom_keywords:
+                custom_info = project_custom_keywords[keyword_name]
+                source_name = custom_info['file']
+            else:
+                source_name = source_info['name']
+
+            if source_name not in groups[category]:
+                groups[category][source_name] = []
+
+            groups[category][source_name].append({
+                'name': keyword_name,
+                'info': keyword_info,
+                'source_info': source_info
+            })
+
+        return groups
+
+    def get_all_keywords(self) -> Dict[str, Any]:
+        """获取所有已注册的关键字
+
+        Returns:
+            所有关键字的字典
+        """
+        return keyword_manager._keywords
+
+    def get_project_custom_keywords(self) -> Optional[Dict[str, Any]]:
+        """获取项目自定义关键字信息
+
+        Returns:
+            项目自定义关键字信息，如果尚未加载则返回None
+        """
+        return self._project_custom_keywords
+
+
+# 创建全局实例
+keyword_loader = KeywordLoader()
+
+
+# 便捷函数
+def load_all_keywords(include_remote: bool = False) -> Dict[str, Any]:
+    """加载所有可用的关键字
+
+    Args:
+        include_remote: 是否包含远程关键字，默认为False
+
+    Returns:
+        项目自定义关键字信息字典
+    """
+    return keyword_loader.load_all_keywords(include_remote=include_remote)
+
+
+def categorize_keyword(keyword_name: str, keyword_info: Dict[str, Any],
+                      project_custom_keywords: Optional[Dict[str, Any]] = None) -> str:
+    """判断关键字的类别
+
+    Args:
+        keyword_name: 关键字名称
+        keyword_info: 关键字信息
+        project_custom_keywords: 项目自定义关键字信息
+
+    Returns:
+        关键字类别
+    """
+    return keyword_loader.categorize_keyword(keyword_name, keyword_info, project_custom_keywords)
+
+
+def get_keyword_source_info(keyword_info: Dict[str, Any]) -> Dict[str, Any]:
+    """获取关键字的详细来源信息
+
+    Args:
+        keyword_info: 关键字信息
+
+    Returns:
+        来源信息字典
+    """
+    return keyword_loader.get_keyword_source_info(keyword_info)
+
+
+def group_keywords_by_source(keywords_dict: Dict[str, Any],
+                            project_custom_keywords: Optional[Dict[str, Any]] = None) -> Dict[str, Dict[str, List]]:
+    """按来源分组关键字
+
+    Args:
+        keywords_dict: 关键字字典
+        project_custom_keywords: 项目自定义关键字信息
+
+    Returns:
+        分组后的关键字字典
+    """
+    return keyword_loader.group_keywords_by_source(keywords_dict, project_custom_keywords)
+
+
+def scan_project_custom_keywords(project_root: Optional[str] = None) -> Dict[str, Any]:
+    """扫描项目中.resource文件中的自定义关键字
+
+    Args:
+        project_root: 项目根目录，默认为当前工作目录
+
+    Returns:
+        自定义关键字信息字典
+    """
+    return keyword_loader.scan_project_custom_keywords(project_root) 

pytest_dsl/core/keyword_manager.py

@@ -18,7 +18,7 @@ class KeywordManager:
 
     def register(self, name: str, parameters: List[Dict], source_info: Optional[Dict] = None):
         """关键字注册装饰器
-        
+
         Args:
             name: 关键字名称
             parameters: 参数列表
@@ -29,23 +29,29 @@ class KeywordManager:
             def wrapper(**kwargs):
                 # 获取自定义步骤名称，如果未指定则使用关键字名称
                 step_name = kwargs.pop('step_name', name)
-                
+
+                # 检查是否已经在DSL执行器的步骤中，避免重复记录
+                skip_logging = kwargs.pop('skip_logging', False)
+
                 with allure.step(f"{step_name}"):
                     try:
                         result = func(**kwargs)
-                        self._log_execution(step_name, kwargs, result)
+                        if not skip_logging:
+                            self._log_execution(step_name, kwargs, result)
                         return result
                     except Exception as e:
-                        self._log_failure(step_name, kwargs, e)
+                        if not skip_logging:
+                            self._log_failure(step_name, kwargs, e)
                         raise
 
             param_list = [Parameter(**p) for p in parameters]
             mapping = {p.name: p.mapping for p in param_list}
-            defaults = {p.mapping: p.default for p in param_list if p.default is not None}
-            
+            defaults = {
+                p.mapping: p.default for p in param_list if p.default is not None}
+
             # 自动添加 step_name 到 mapping 中
             mapping["步骤名称"] = "step_name"
-            
+
             # 构建关键字信息，包含来源信息
             keyword_info = {
                 'func': wrapper,
@@ -53,14 +59,14 @@ class KeywordManager:
                 'parameters': param_list,
                 'defaults': defaults  # 存储默认值
             }
-            
+
             # 添加来源信息
             if source_info:
                 keyword_info.update(source_info)
             else:
                 # 尝试从函数模块推断来源信息
                 keyword_info.update(self._infer_source_info(func))
-            
+
             self._keywords[name] = keyword_info
             return wrapper
         return decorator
@@ -68,11 +74,11 @@ class KeywordManager:
     def _infer_source_info(self, func: Callable) -> Dict:
         """从函数推断来源信息"""
         source_info = {}
-        
+
         if hasattr(func, '__module__'):
             module_name = func.__module__
             source_info['module_name'] = module_name
-            
+
             if module_name.startswith('pytest_dsl.keywords'):
                 # 内置关键字
                 source_info['source_type'] = 'builtin'
@@ -90,13 +96,13 @@ class KeywordManager:
                     source_info['source_name'] = parts[0]
                 else:
                     source_info['source_name'] = module_name
-        
+
         return source_info
 
-    def register_with_source(self, name: str, parameters: List[Dict], 
-                           source_type: str, source_name: str, **kwargs):
+    def register_with_source(self, name: str, parameters: List[Dict],
+                             source_type: str, source_name: str, **kwargs):
         """带来源信息的关键字注册装饰器
-        
+
         Args:
             name: 关键字名称
             parameters: 参数列表
@@ -116,18 +122,18 @@ class KeywordManager:
         keyword_info = self._keywords.get(keyword_name)
         if not keyword_info:
             raise KeyError(f"未注册的关键字: {keyword_name}")
-        
+
         # 应用默认值
         final_params = {}
         defaults = keyword_info.get('defaults', {})
-        
+
         # 首先设置所有默认值
         for param_key, default_value in defaults.items():
             final_params[param_key] = default_value
-        
+
         # 然后用传入的参数覆盖默认值
         final_params.update(params)
-        
+
         return keyword_info['func'](**final_params)
 
     def get_keyword_info(self, keyword_name: str) -> Dict:
@@ -135,7 +141,7 @@ class KeywordManager:
         keyword_info = self._keywords.get(keyword_name)
         if not keyword_info:
             return None
-            
+
         # 动态添加step_name参数到参数列表中
         if not any(p.name == "步骤名称" for p in keyword_info['parameters']):
             keyword_info['parameters'].append(Parameter(
@@ -143,19 +149,19 @@ class KeywordManager:
                 mapping="step_name",
                 description="自定义的步骤名称，用于在报告中显示"
             ))
-            
+
         return keyword_info
 
     def get_keywords_by_source(self) -> Dict[str, List[str]]:
         """按来源分组获取关键字"""
         by_source = {}
-        
+
         for name, info in self._keywords.items():
             source_name = info.get('source_name', '未知来源')
             if source_name not in by_source:
                 by_source[source_name] = []
             by_source[source_name].append(name)
-        
+
         return by_source
 
     def _log_execution(self, keyword_name: str, params: Dict, result: Any) -> None: