pytest-dsl 0.13.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

pytest_dsl/core/validator.py

@@ -0,0 +1,417 @@
+"""
+pytest-dsl DSL格式校验模块
+
+提供DSL语法验证、语义验证、关键字验证等功能
+"""
+
+import re
+from typing import List, Dict, Optional, Tuple
+from pytest_dsl.core.lexer import get_lexer
+from pytest_dsl.core.parser import get_parser, Node, parse_with_error_handling
+from pytest_dsl.core.keyword_manager import keyword_manager
+
+
+class DSLValidationError:
+    """DSL验证错误"""
+
+    def __init__(
+            self,
+            error_type: str,
+            message: str,
+            line: Optional[int] = None,
+            column: Optional[int] = None,
+            suggestion: Optional[str] = None):
+        self.error_type = error_type
+        self.message = message
+        self.line = line
+        self.column = column
+        self.suggestion = suggestion
+
+    def __str__(self):
+        location = ""
+        if self.line is not None:
+            location = f"第{self.line}行"
+            if self.column is not None:
+                location += f"第{self.column}列"
+            location += ": "
+
+        result = f"{location}{self.error_type}: {self.message}"
+        if self.suggestion:
+            result += f"\n建议: {self.suggestion}"
+        return result
+
+
+class DSLValidator:
+    """DSL格式校验器"""
+
+    def __init__(self):
+        self.errors: List[DSLValidationError] = []
+        self.warnings: List[DSLValidationError] = []
+
+    def validate(self, content: str, dsl_id: Optional[str] = None
+                 ) -> Tuple[bool, List[DSLValidationError]]:
+        """验证DSL内容
+
+        Args:
+            content: DSL内容
+            dsl_id: DSL标识符（可选）
+
+        Returns:
+            (是否验证通过, 错误列表)
+        """
+        self.errors = []
+        self.warnings = []
+
+        # 基础验证
+        self._validate_basic_format(content)
+
+        # 语法验证
+        ast = self._validate_syntax(content)
+
+        # 如果语法验证通过，进行语义验证
+        if ast and not self.errors:
+            self._validate_semantics(ast)
+
+        # 元数据验证
+        if ast and not self.errors:
+            self._validate_metadata(ast)
+
+        # 关键字验证
+        if ast and not self.errors:
+            self._validate_keywords(ast)
+
+        return len(self.errors) == 0, self.errors + self.warnings
+
+    def _validate_basic_format(self, content: str) -> None:
+        """基础格式验证"""
+        if not content or not content.strip():
+            self.errors.append(DSLValidationError(
+                "格式错误", "DSL内容不能为空"
+            ))
+            return
+
+        lines = content.split('\n')
+
+        # 检查编码
+        try:
+            content.encode('utf-8')
+        except UnicodeEncodeError as e:
+            self.errors.append(DSLValidationError(
+                "编码错误", f"DSL内容包含无效字符: {str(e)}"
+            ))
+
+        # 检查行长度
+        for i, line in enumerate(lines, 1):
+            if len(line) > 1000:
+                self.warnings.append(DSLValidationError(
+                    "格式警告", f"第{i}行过长，建议控制在1000字符以内", line=i
+                ))
+
+        # 检查嵌套层级
+        max_indent = 0
+        for i, line in enumerate(lines, 1):
+            if line.strip():
+                indent = len(line) - len(line.lstrip())
+                if indent > max_indent:
+                    max_indent = indent
+
+        if max_indent > 40:  # 假设每层缩进4个空格，最多10层
+            self.warnings.append(DSLValidationError(
+                "格式警告", f"嵌套层级过深（{max_indent//4}层），建议简化结构"
+            ))
+
+    def _validate_syntax(self, content: str) -> Optional[Node]:
+        """语法验证"""
+        try:
+            lexer = get_lexer()
+            ast, parse_errors = parse_with_error_handling(content, lexer)
+
+            # 如果有解析错误，添加到错误列表
+            if parse_errors:
+                for error in parse_errors:
+                    self.errors.append(DSLValidationError(
+                        "语法错误",
+                        error['message'],
+                        line=error['line'],
+                        suggestion=self._suggest_syntax_fix(error['message'])
+                    ))
+                return None
+
+            return ast
+
+        except Exception as e:
+            error_msg = str(e)
+            line_num = self._extract_line_number(error_msg)
+
+            self.errors.append(DSLValidationError(
+                "语法错误",
+                error_msg,
+                line=line_num,
+                suggestion=self._suggest_syntax_fix(error_msg)
+            ))
+            return None
+
+    def _validate_semantics(self, ast: Node) -> None:
+        """语义验证"""
+        self._check_node_semantics(ast)
+
+    def _check_node_semantics(self, node: Node) -> None:
+        """检查节点语义"""
+        if node.type == 'Assignment':
+            # 检查变量名
+            var_name = node.value
+            if not self._is_valid_variable_name(var_name):
+                self.errors.append(DSLValidationError(
+                    "语义错误",
+                    f"无效的变量名: {var_name}",
+                    suggestion="变量名应以字母或下划线开头，只包含字母、数字、下划线或中文字符"
+                ))
+
+        elif node.type == 'ForLoop':
+            # 检查循环变量名
+            loop_var = node.value
+            if not self._is_valid_variable_name(loop_var):
+                self.errors.append(DSLValidationError(
+                    "语义错误",
+                    f"无效的循环变量名: {loop_var}",
+                    suggestion="循环变量名应以字母或下划线开头，只包含字母、数字、下划线或中文字符"
+                ))
+
+        elif node.type == 'Expression':
+            # 检查表达式中的变量引用
+            if isinstance(node.value, str):
+                self._validate_variable_references(node.value)
+
+        # 递归检查子节点
+        for child in node.children:
+            if isinstance(child, Node):
+                self._check_node_semantics(child)
+
+    def _validate_metadata(self, ast: Node) -> None:
+        """验证元数据"""
+        metadata_node = None
+        for child in ast.children:
+            if child.type == 'Metadata':
+                metadata_node = child
+                break
+
+        if not metadata_node:
+            self.warnings.append(DSLValidationError(
+                "元数据警告", "建议添加@name元数据以描述测试用例名称"
+            ))
+            return
+
+        has_name = False
+        has_description = False
+
+        for item in metadata_node.children:
+            if item.type == '@name':
+                has_name = True
+                if not item.value or not item.value.strip():
+                    self.errors.append(DSLValidationError(
+                        "元数据错误", "@name不能为空"
+                    ))
+            elif item.type == '@description':
+                has_description = True
+                if not item.value or not item.value.strip():
+                    self.warnings.append(DSLValidationError(
+                        "元数据警告", "@description不应为空"
+                    ))
+            elif item.type == '@tags':
+                # 验证标签格式
+                if not item.value or len(item.value) == 0:
+                    self.warnings.append(DSLValidationError(
+                        "元数据警告", "@tags不应为空列表"
+                    ))
+
+        if not has_name:
+            self.warnings.append(DSLValidationError(
+                "元数据警告", "建议添加@name元数据以描述测试用例名称"
+            ))
+
+        if not has_description:
+            self.warnings.append(DSLValidationError(
+                "元数据警告", "建议添加@description元数据以描述测试用例功能"
+            ))
+
+    def _validate_keywords(self, ast: Node) -> None:
+        """验证关键字"""
+        self._check_node_keywords(ast)
+
+    def _check_node_keywords(self, node: Node) -> None:
+        """检查节点中的关键字"""
+        if node.type == 'KeywordCall':
+            keyword_name = node.value
+            keyword_info = keyword_manager.get_keyword_info(keyword_name)
+
+            if not keyword_info:
+                self.errors.append(DSLValidationError(
+                    "关键字错误",
+                    f"未注册的关键字: {keyword_name}",
+                    suggestion=self._suggest_similar_keyword(keyword_name)
+                ))
+            else:
+                # 验证参数
+                self._validate_keyword_parameters(node, keyword_info)
+
+        # 递归检查子节点
+        for child in node.children:
+            if isinstance(child, Node):
+                self._check_node_keywords(child)
+
+    def _validate_keyword_parameters(self, keyword_node: Node,
+                                     keyword_info: Dict) -> None:
+        """验证关键字参数"""
+        if not keyword_node.children or not keyword_node.children[0]:
+            return
+
+        provided_params = set()
+        for param in keyword_node.children[0]:
+            param_name = param.value
+            provided_params.add(param_name)
+
+            # 检查参数名是否有效
+            mapping = keyword_info.get('mapping', {})
+            if param_name not in mapping:
+                self.errors.append(DSLValidationError(
+                    "参数错误",
+                    f"关键字 {keyword_node.value} 不支持参数: {param_name}",
+                    suggestion=f"支持的参数: {', '.join(mapping.keys())}"
+                ))
+
+        # 检查必需参数（这里简化处理，实际可能需要更复杂的逻辑）
+        required_params = set()
+        parameters = keyword_info.get('parameters', [])
+        for param in parameters:
+            if not hasattr(param, 'default') or param.default is None:
+                required_params.add(param.name)
+
+        missing_params = required_params - provided_params
+        if missing_params:
+            self.warnings.append(DSLValidationError(
+                "参数警告",
+                f"关键字 {keyword_node.value} 缺少建议参数: "
+                f"{', '.join(missing_params)}"
+            ))
+
+    def _is_valid_variable_name(self, name: str) -> bool:
+        """检查变量名是否有效"""
+        if not name:
+            return False
+        # 支持中文、英文、数字、下划线，以字母或下划线开头
+        pattern = r'^[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*$'
+        return bool(re.match(pattern, name))
+
+    def _validate_variable_references(self, text: str) -> None:
+        """验证文本中的变量引用"""
+        # 匹配 ${变量名} 格式
+        pattern = r'\$\{([^}]+)\}'
+        matches = re.findall(pattern, text)
+
+        for var_ref in matches:
+            # 检查变量引用格式是否正确
+            if not self._is_valid_variable_reference(var_ref):
+                self.errors.append(DSLValidationError(
+                    "变量引用错误",
+                    f"无效的变量引用格式: ${{{var_ref}}}",
+                    suggestion="变量引用应为 ${变量名} 格式，支持点号访问和数组索引"
+                ))
+
+    def _is_valid_variable_reference(self, var_ref: str) -> bool:
+        """检查变量引用是否有效"""
+        # 支持: variable, obj.prop, arr[0], dict["key"] 等格式
+        pattern = (r'^[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*'
+                   r'(?:(?:\.[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*)'
+                   r'|(?:\[[^\]]+\]))*$')
+        return bool(re.match(pattern, var_ref))
+
+    def _extract_line_number(self, error_msg: str) -> Optional[int]:
+        """从错误消息中提取行号"""
+        # 尝试匹配常见的行号模式
+        patterns = [
+            r'line (\d+)',
+            r'第(\d+)行',
+            r'在行 (\d+)',
+            r'at line (\d+)'
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, error_msg)
+            if match:
+                return int(match.group(1))
+        return None
+
+    def _suggest_syntax_fix(self, error_msg: str) -> Optional[str]:
+        """根据错误消息建议语法修复"""
+        suggestions = {
+            "Syntax error": "检查语法是否正确，特别是括号、引号的匹配",
+            "unexpected token": "检查是否有多余或缺失的符号",
+            "Unexpected end of input": "检查是否缺少end关键字或右括号",
+            "illegal character": "检查是否有非法字符，确保使用UTF-8编码"
+        }
+
+        for key, suggestion in suggestions.items():
+            if key.lower() in error_msg.lower():
+                return suggestion
+        return None
+
+    def _suggest_similar_keyword(self, keyword_name: str) -> Optional[str]:
+        """建议相似的关键字"""
+        all_keywords = list(keyword_manager._keywords.keys())
+
+        # 简单的相似度匹配（可以使用更复杂的算法）
+        similar_keywords = []
+        for kw in all_keywords:
+            similarity = self._calculate_similarity(
+                keyword_name.lower(), kw.lower())
+            if similarity > 0.6:
+                similar_keywords.append(kw)
+
+        if similar_keywords:
+            return f"您是否想使用: {', '.join(similar_keywords[:3])}"
+        return None
+
+    def _calculate_similarity(self, s1: str, s2: str) -> float:
+        """计算字符串相似度（简单的Jaccard相似度）"""
+        if not s1 or not s2:
+            return 0.0
+
+        set1 = set(s1)
+        set2 = set(s2)
+        intersection = len(set1.intersection(set2))
+        union = len(set1.union(set2))
+
+        return intersection / union if union > 0 else 0.0
+
+
+def validate_dsl(content: str, dsl_id: Optional[str] = None
+                 ) -> Tuple[bool, List[DSLValidationError]]:
+    """验证DSL内容的便捷函数
+
+    Args:
+        content: DSL内容
+        dsl_id: DSL标识符（可选）
+
+    Returns:
+        (是否验证通过, 错误列表)
+    """
+    validator = DSLValidator()
+    return validator.validate(content, dsl_id)
+
+
+def check_dsl_syntax(content: str) -> bool:
+    """快速检查DSL语法是否正确
+
+    Args:
+        content: DSL内容
+
+    Returns:
+        语法是否正确
+    """
+    try:
+        lexer = get_lexer()
+        parser = get_parser()
+        parser.parse(content, lexer=lexer)
+        return True
+    except Exception:
+        return False

pytest_dsl/core/yaml_loader.py

@@ -1,6 +1,7 @@
 """YAML变量加载器模块
 
 该模块负责处理YAML变量文件的加载和管理，支持从命令行参数加载单个文件或目录。
+同时支持通过hook机制从外部系统动态加载变量。
 """
 
 import os
@@ -29,14 +30,25 @@ def add_yaml_options(parser):
     )
 
 
-def load_yaml_variables_from_args(yaml_files=None, yaml_vars_dir=None, project_root=None):
+def load_yaml_variables_from_args(yaml_files=None, yaml_vars_dir=None,
+                                  project_root=None, environment=None):
     """从参数加载YAML变量文件（通用函数）
 
     Args:
         yaml_files: YAML文件列表
         yaml_vars_dir: YAML变量目录路径
         project_root: 项目根目录（用于默认config目录）
+        environment: 环境名称（用于hook加载）
     """
+    # 首先尝试通过hook加载变量
+    hook_variables = _load_variables_through_hooks(
+        project_root=project_root, environment=environment)
+
+    if hook_variables:
+        print(f"通过Hook加载了 {len(hook_variables)} 个变量")
+        # 将hook变量加载到yaml_vars中
+        yaml_vars._variables.update(hook_variables)
+
     # 加载单个YAML文件
     if yaml_files:
         yaml_vars.load_yaml_files(yaml_files)
@@ -55,7 +67,8 @@ def load_yaml_variables_from_args(yaml_files=None, yaml_vars_dir=None, project_r
         if loaded_files:
             # 过滤出当前目录的文件
             if yaml_vars_dir:
-                dir_files = [f for f in loaded_files if Path(f).parent == Path(yaml_vars_dir)]
+                dir_files = [f for f in loaded_files if Path(
+                    f).parent == Path(yaml_vars_dir)]
                 if dir_files:
                     print(f"目录中加载的文件: {', '.join(dir_files)}")
             else:
@@ -67,6 +80,103 @@ def load_yaml_variables_from_args(yaml_files=None, yaml_vars_dir=None, project_r
     load_remote_servers_from_yaml()
 
 
+def _load_variables_through_hooks(project_root=None, environment=None):
+    """通过hook机制加载变量
+
+    Args:
+        project_root: 项目根目录
+        environment: 环境名称
+
+    Returns:
+        dict: 通过hook加载的变量字典
+    """
+    try:
+        from .hook_manager import hook_manager
+
+        # 确保hook管理器已初始化
+        hook_manager.initialize()
+
+        # 如果没有已注册的插件，直接返回
+        if not hook_manager.get_plugins():
+            return {}
+
+        # 提取project_id（如果可以从项目根目录推断）
+        project_id = None
+        if project_root:
+            # 可以根据项目结构推断project_id，这里暂时不实现
+            pass
+
+        # 通过hook加载变量
+        hook_variables = {}
+
+        # 调用dsl_load_variables hook
+        try:
+            variable_results = hook_manager.pm.hook.dsl_load_variables(
+                project_id=project_id,
+                environment=environment,
+                filters={}
+            )
+
+            # 合并所有hook返回的变量
+            for result in variable_results:
+                if result and isinstance(result, dict):
+                    hook_variables.update(result)
+
+        except Exception as e:
+            print(f"通过Hook加载变量时出现警告: {e}")
+
+        # 列出变量源（用于调试）
+        try:
+            source_results = hook_manager.pm.hook.dsl_list_variable_sources(
+                project_id=project_id
+            )
+
+            sources = []
+            for result in source_results:
+                if result and isinstance(result, list):
+                    sources.extend(result)
+
+            if sources:
+                print(f"发现 {len(sources)} 个变量源")
+                for source in sources:
+                    source_name = source.get('name', '未知')
+                    source_type = source.get('type', '未知')
+                    print(f"  - {source_name} ({source_type})")
+
+        except Exception as e:
+            print(f"列出变量源时出现警告: {e}")
+
+        # 验证变量（如果有变量的话）
+        if hook_variables:
+            try:
+                validation_results = hook_manager.pm.hook.dsl_validate_variables(
+                    variables=hook_variables,
+                    project_id=project_id
+                )
+
+                validation_errors = []
+                for result in validation_results:
+                    if result and isinstance(result, list):
+                        validation_errors.extend(result)
+
+                if validation_errors:
+                    print(f"变量验证发现 {len(validation_errors)} 个问题:")
+                    for error in validation_errors:
+                        print(f"  - {error}")
+
+            except Exception as e:
+                print(f"验证变量时出现警告: {e}")
+
+        return hook_variables
+
+    except ImportError:
+        # 如果没有安装pluggy或hook_manager不可用，跳过hook加载
+        return {}
+    except Exception as e:
+        print(f"Hook变量加载失败: {e}")
+        return {}
+
+
 def load_yaml_variables(config):
     """加载YAML变量文件（pytest插件接口）
 
@@ -80,60 +190,50 @@ def load_yaml_variables(config):
     yaml_vars_dir = config.getoption('--yaml-vars-dir')
     project_root = config.rootdir
 
+    # 尝试从环境变量获取环境名称
+    environment = os.environ.get(
+        'PYTEST_DSL_ENVIRONMENT') or os.environ.get('ENVIRONMENT')
+
     # 调用通用加载函数
     load_yaml_variables_from_args(
         yaml_files=yaml_files,
         yaml_vars_dir=yaml_vars_dir,
-        project_root=project_root
+        project_root=project_root,
+        environment=environment
     )
 
 
 def load_remote_servers_from_yaml():
-    """从YAML配置中自动加载远程服务器
-
-    检查YAML变量中是否包含remote_servers配置，如果有则自动连接这些服务器。
-    """
+    """从YAML变量中加载远程服务器配置"""
     try:
+        from pytest_dsl.remote.keyword_client import remote_keyword_manager
+
         # 获取远程服务器配置
-        remote_servers_config = yaml_vars.get_variable('remote_servers')
-        if not remote_servers_config:
-            
+        remote_servers = yaml_vars.get_variable('remote_servers')
+        if not remote_servers:
             return
 
-        print(f"发现 {len(remote_servers_config)} 个远程服务器配置")
-
-        # 导入远程关键字管理器
-        from pytest_dsl.remote.keyword_client import remote_keyword_manager
+        print(f"发现 {len(remote_servers)} 个远程服务器配置")
 
-        # 遍历配置并连接服务器
-        for server_name, server_config in remote_servers_config.items():
-            try:
+        # 注册远程服务器
+        for server_config in remote_servers:
+            if isinstance(server_config, dict):
                 url = server_config.get('url')
-                alias = server_config.get('alias', server_name)
+                alias = server_config.get('alias')
                 api_key = server_config.get('api_key')
-                sync_config = server_config.get('sync_config')
-
-                if not url:
-                    print(f"跳过服务器 {server_name}: 缺少URL配置")
-                    continue
-
-                print(f"正在连接远程服务器: {server_name} ({url}) 别名: {alias}")
-
-                # 注册远程服务器
-                success = remote_keyword_manager.register_remote_server(
-                    url=url,
-                    alias=alias,
-                    api_key=api_key,
-                    sync_config=sync_config
-                )
-
-                if success:
-                    print(f"成功连接到远程服务器: {server_name} ({url})")
-                else:
-                    print(f"连接远程服务器失败: {server_name} ({url})")
-
-            except Exception as e:
-                print(f"连接远程服务器 {server_name} 时发生错误: {str(e)}")
 
+                if url and alias:
+                    print(f"自动连接远程服务器: {alias} -> {url}")
+                    success = remote_keyword_manager.register_remote_server(
+                        url, alias, api_key=api_key
+                    )
+                    if success:
+                        print(f"✓ 远程服务器 {alias} 连接成功")
+                    else:
+                        print(f"✗ 远程服务器 {alias} 连接失败")
+
+    except ImportError:
+        # 如果远程功能不可用，跳过
+        pass
     except Exception as e:
-        print(f"加载远程服务器配置时发生错误: {str(e)}")
+        print(f"自动连接远程服务器时出现警告: {e}")