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

pytest_dsl/__init__.py

@@ -2,9 +2,196 @@
 pytest-dsl - 基于pytest的DSL测试框架
 
 使用自定义的领域特定语言(DSL)来编写测试用例，使测试更加直观、易读和易维护。
+
+主要功能：
+- DSL语法解析和执行
+- 关键字管理和注册
+- Hook机制支持插件扩展
+- DSL格式校验
+- 远程关键字支持
+- 自定义关键字支持
 """
 
-__version__ = "0.1.0" 
+__version__ = "0.1.0"
+
+# 核心执行器
+from pytest_dsl.core.dsl_executor import DSLExecutor
+
+# 关键字管理器
+from pytest_dsl.core.keyword_manager import keyword_manager, KeywordManager
+
+# Hook系统
+from pytest_dsl.core.hookspecs import hookimpl, hookspec, DSLHookSpecs
+from pytest_dsl.core.hook_manager import hook_manager, DSLHookManager
+
+# DSL格式校验
+from pytest_dsl.core.validator import (
+    DSLValidator,
+    DSLValidationError,
+    validate_dsl,
+    check_dsl_syntax
+)
+
+# 自动装饰器
+from pytest_dsl.core.auto_decorator import auto_dsl
+
+# 核心工具类
+from pytest_dsl.core.parser import Node, get_parser
+from pytest_dsl.core.lexer import get_lexer
+from pytest_dsl.core.context import TestContext
+from pytest_dsl.core.global_context import global_context
+
+# 变量工具
+from pytest_dsl.core.variable_utils import VariableReplacer
+
+# 自定义关键字管理器
+from pytest_dsl.core.custom_keyword_manager import custom_keyword_manager
+
+# 关键字加载器
+from pytest_dsl.core.keyword_loader import (
+    keyword_loader, KeywordLoader,
+    load_all_keywords, categorize_keyword, get_keyword_source_info,
+    group_keywords_by_source, scan_project_custom_keywords
+)
+
+# 便捷导入的别名
+Executor = DSLExecutor
+Validator = DSLValidator
+HookManager = DSLHookManager
+KeywordLoader = KeywordLoader
+
+# 导出所有公共接口
+__all__ = [
+    # 版本信息
+    '__version__',
+
+    # 核心执行器
+    'DSLExecutor', 'Executor',
+
+    # 关键字管理
+    'keyword_manager', 'KeywordManager',
+    'custom_keyword_manager',
+
+    # 关键字加载器
+    'keyword_loader', 'KeywordLoader',
+    'load_all_keywords', 'categorize_keyword', 'get_keyword_source_info',
+    'group_keywords_by_source', 'scan_project_custom_keywords',
+
+    # Hook系统
+    'hookimpl', 'hookspec', 'DSLHookSpecs',
+    'hook_manager', 'DSLHookManager', 'HookManager',
+
+    # DSL校验
+    'DSLValidator', 'Validator',
+    'DSLValidationError',
+    'validate_dsl',
+    'check_dsl_syntax',
+
+    # 自动装饰器
+    'auto_dsl',
+
+    # 核心组件
+    'Node', 'get_parser', 'get_lexer',
+    'TestContext', 'global_context',
+    'VariableReplacer',
+]
+
+# 快捷函数
+
+
+def create_executor(enable_hooks: bool = True) -> DSLExecutor:
+    """创建DSL执行器实例
+
+    Args:
+        enable_hooks: 是否启用hook机制
+
+    Returns:
+        DSL执行器实例
+    """
+    return DSLExecutor(enable_hooks=enable_hooks)
+
+
+def parse_dsl(content: str) -> Node:
+    """解析DSL内容为AST
+
+    Args:
+        content: DSL内容
+
+    Returns:
+        解析后的AST根节点
+    """
+    lexer = get_lexer()
+    parser = get_parser()
+    return parser.parse(content, lexer=lexer)
+
+
+def execute_dsl(content: str, context: dict = None, enable_hooks: bool = True) -> any:
+    """执行DSL内容的便捷函数
+
+    Args:
+        content: DSL内容
+        context: 执行上下文（可选）
+        enable_hooks: 是否启用hook机制
+
+    Returns:
+        执行结果
+    """
+    executor = create_executor(enable_hooks=enable_hooks)
+    if context:
+        executor.variables.update(context)
+        for key, value in context.items():
+            executor.test_context.set(key, value)
+
+    ast = parse_dsl(content)
+    return executor.execute(ast)
+
+
+def register_keyword(name: str, parameters: list = None, source_type: str = "external",
+                     source_name: str = "user_defined"):
+    """注册关键字的装饰器
+
+    Args:
+        name: 关键字名称
+        parameters: 参数列表
+        source_type: 来源类型
+        source_name: 来源名称
+
+    Returns:
+        装饰器函数
+    """
+    if parameters is None:
+        parameters = []
+
+    return keyword_manager.register_with_source(
+        name=name,
+        parameters=parameters,
+        source_type=source_type,
+        source_name=source_name
+    )
+
+
+# 版本兼容性检查
+def check_version_compatibility():
+    """检查版本兼容性"""
+    try:
+        import sys
+        if sys.version_info < (3, 7):
+            import warnings
+            warnings.warn(
+                "pytest-dsl 需要 Python 3.7 或更高版本",
+                UserWarning,
+                stacklevel=2
+            )
+    except Exception:
+        pass
+
+
+# 初始化时进行版本检查
+check_version_compatibility()
 
-# 导出 auto_dsl 装饰器，使其可以直接从包导入
-from pytest_dsl.core.auto_decorator import auto_dsl
+# 自动初始化hook管理器
+try:
+    hook_manager.initialize()
+except Exception as e:
+    import warnings
+    warnings.warn(f"Hook管理器初始化失败: {e}", UserWarning, stacklevel=2)

pytest_dsl/cli.py

@@ -16,8 +16,9 @@ from pytest_dsl.core.yaml_loader import load_yaml_variables_from_args
 from pytest_dsl.core.auto_directory import (
     SETUP_FILE_NAME, TEARDOWN_FILE_NAME, execute_hook_file
 )
-from pytest_dsl.core.plugin_discovery import (
-    load_all_plugins, scan_local_keywords
+from pytest_dsl.core.keyword_loader import (
+    load_all_keywords, categorize_keyword, get_keyword_source_info,
+    group_keywords_by_source, scan_project_custom_keywords
 )
 from pytest_dsl.core.keyword_manager import keyword_manager
 
@@ -138,164 +139,7 @@ def parse_args():
         return args
 
 
-def load_all_keywords(include_remote=False):
-    """加载所有可用的关键字
 
-    Args:
-        include_remote: 是否包含远程关键字，默认为False
-    """
-    # 首先导入内置关键字模块，确保内置关键字被注册
-    try:
-        import pytest_dsl.keywords  # noqa: F401
-        print("内置关键字模块加载完成")
-    except ImportError as e:
-        print(f"加载内置关键字模块失败: {e}")
-
-    # 加载已安装的关键字插件
-    load_all_plugins()
-
-    # 扫描本地关键字
-    scan_local_keywords()
-
-    # 自动导入项目中的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)}")
-
-    # 扫描项目中的自定义关键字（.resource文件中定义的）
-    project_custom_keywords = scan_project_custom_keywords()
-    if project_custom_keywords:
-        print(f"发现 {len(project_custom_keywords)} 个项目自定义关键字")
-
-        # 加载.resource文件中的关键字到关键字管理器
-        from pytest_dsl.core.custom_keyword_manager import (
-            custom_keyword_manager
-        )
-        from pathlib import Path
-
-        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}")
-
-    # 根据参数决定是否加载远程关键字
-    if include_remote:
-        print("正在扫描远程关键字...")
-        # 这里可以添加远程关键字的扫描逻辑
-        # 目前远程关键字是通过DSL文件中的@remote导入指令动态加载的
-    else:
-        print("跳过远程关键字扫描")
-
-    return project_custom_keywords
-
-
-def categorize_keyword(keyword_name, keyword_info,
-                       project_custom_keywords=None):
-    """判断关键字的类别"""
-    # 优先使用存储的来源信息
-    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(keyword_info):
-    """获取关键字的详细来源信息"""
-    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(keywords_dict, project_custom_keywords=None):
-    """按来源分组关键字
-
-    Returns:
-        dict: 格式为 {source_group: {source_name: [keywords]}}
-    """
-    groups = {
-        'builtin': {},
-        'plugin': {},
-        'custom': {},
-        'project_custom': {},
-        'remote': {}
-    }
-
-    for keyword_name, keyword_info in keywords_dict.items():
-        category = categorize_keyword(
-            keyword_name, keyword_info, project_custom_keywords
-        )
-        source_info = 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 format_keyword_info_text(keyword_name, keyword_info, show_category=True,
@@ -724,12 +568,17 @@ def list_keywords(output_format='json', name_filter=None,
 
 def load_yaml_variables(args):
     """从命令行参数加载YAML变量"""
-    # 使用统一的加载函数，包含远程服务器自动连接功能
+    # 使用统一的加载函数，包含远程服务器自动连接功能和hook支持
     try:
+        # 尝试从环境变量获取环境名称
+        environment = (os.environ.get('PYTEST_DSL_ENVIRONMENT') or
+                       os.environ.get('ENVIRONMENT'))
+
         load_yaml_variables_from_args(
             yaml_files=args.yaml_vars,
             yaml_vars_dir=args.yaml_vars_dir,
-            project_root=os.getcwd()  # CLI模式下使用当前工作目录作为项目根目录
+            project_root=os.getcwd(),  # CLI模式下使用当前工作目录作为项目根目录
+            environment=environment
         )
     except Exception as e:
         print(f"加载YAML变量失败: {str(e)}")
@@ -774,6 +623,33 @@ def run_dsl_tests(args):
     # 加载YAML变量（包括远程服务器自动连接）
     load_yaml_variables(args)
 
+    # 支持hook机制的执行
+    from pytest_dsl.core.hookable_executor import hookable_executor
+
+    # 检查是否有hook提供的用例列表
+    hook_cases = hookable_executor.list_dsl_cases()
+    if hook_cases:
+        # 如果有hook提供的用例，优先执行这些用例
+        print(f"通过Hook发现 {len(hook_cases)} 个DSL用例")
+        failures = 0
+        for case in hook_cases:
+            case_id = case.get('id') or case.get('name', 'unknown')
+            try:
+                print(f"执行用例: {case.get('name', case_id)}")
+                hookable_executor.execute_dsl(str(case_id))
+                print(f"✓ 用例 {case.get('name', case_id)} 执行成功")
+            except Exception as e:
+                print(f"✗ 用例 {case.get('name', case_id)} 执行失败: {e}")
+                failures += 1
+
+        if failures > 0:
+            print(f"总计 {failures}/{len(hook_cases)} 个测试失败")
+            sys.exit(1)
+        else:
+            print(f"所有 {len(hook_cases)} 个测试成功完成")
+        return
+
+    # 如果没有hook用例，使用传统的文件执行方式
     lexer = get_lexer()
     parser = get_parser()
     executor = DSLExecutor()
@@ -900,106 +776,7 @@ def main_list_keywords():
     )
 
 
-def scan_project_custom_keywords(project_root=None):
-    """扫描项目中.resource文件中的自定义关键字
-
-    Args:
-        project_root: 项目根目录，默认为当前工作目录
-
-    Returns:
-        dict: 自定义关键字信息，格式为 
-              {keyword_name: {'file': file_path, 'node': ast_node}}
-    """
-    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 = read_file(str(file_path))
-            ast = parser.parse(content, lexer=lexer)
-
-            # 查找自定义关键字定义
-            keywords_in_file = 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 extract_custom_keywords_from_ast(ast, file_path):
-    """从AST中提取自定义关键字定义
-
-    Args:
-        ast: 抽象语法树
-        file_path: 文件路径
-
-    Returns:
-        dict: 自定义关键字信息
-    """
-    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
 
 
 if __name__ == '__main__':

pytest_dsl/core/custom_keyword_manager.py

@@ -200,23 +200,37 @@ class CustomKeywordManager:
             with open(file_path, 'r', encoding='utf-8') as f:
                 content = f.read()
 
-            # 解析资源文件
-            lexer = get_lexer()
-            parser = get_parser()
-            ast = parser.parse(content, lexer=lexer)
-
-            # 标记为已加载
+            # 标记为已加载（在解析前标记，避免循环导入）
             self.resource_cache[absolute_path] = True
 
-            # 处理导入指令
-            self._process_imports(ast, os.path.dirname(file_path))
+            # 使用公共方法解析和处理资源文件内容
+            self._process_resource_file_content(content, file_path)
 
-            # 注册关键字
-            self._register_keywords(ast, file_path)
         except Exception as e:
+            # 如果处理失败，移除缓存标记
+            self.resource_cache.pop(absolute_path, None)
             print(f"资源文件 {file_path} 加载失败: {str(e)}")
             raise
 
+    def _process_resource_file_content(self, content: str, 
+                                       file_path: str) -> None:
+        """处理资源文件内容
+
+        Args:
+            content: 文件内容
+            file_path: 文件路径
+        """
+        # 解析资源文件
+        lexer = get_lexer()
+        parser = get_parser()
+        ast = parser.parse(content, lexer=lexer)
+
+        # 处理导入指令
+        self._process_imports(ast, os.path.dirname(file_path))
+
+        # 注册关键字
+        self._register_keywords_from_ast(ast, file_path)
+
     def _process_imports(self, ast: Node, base_dir: str) -> None:
         """处理资源文件中的导入指令
 
@@ -244,12 +258,13 @@ class CustomKeywordManager:
                 # 递归加载导入的资源文件
                 self.load_resource_file(imported_file)
 
-    def _register_keywords(self, ast: Node, file_path: str) -> None:
-        """从AST中注册关键字
+    def _register_keywords_from_ast(self, ast: Node, 
+                                    source_name: str) -> None:
+        """从AST中注册关键字（重构后的版本）
 
         Args:
             ast: 抽象语法树
-            file_path: 文件路径
+            source_name: 来源名称
         """
         if ast.type != 'Start' or len(ast.children) < 2:
             return
@@ -261,7 +276,7 @@ class CustomKeywordManager:
 
         for node in statements_node.children:
             if node.type in ['CustomKeyword', 'Function']:
-                self._register_custom_keyword(node, file_path)
+                self._register_custom_keyword(node, source_name)
 
     def _register_custom_keyword(self, node: Node, file_path: str) -> None:
         """注册自定义关键字
@@ -342,6 +357,91 @@ class CustomKeywordManager:
 
         print(f"已注册自定义关键字: {keyword_name} 来自文件: {file_path}")
 
+    def register_keyword_from_dsl_content(self, dsl_content: str, 
+                                          source_name: str = "DSL内容") -> list:
+        """从DSL内容注册关键字（公共方法）
+
+        Args:
+            dsl_content: DSL文本内容
+            source_name: 来源名称，用于日志显示
+
+        Returns:
+            list: 注册成功的关键字名称列表
+
+        Raises:
+            Exception: 解析或注册失败时抛出异常
+        """
+        try:
+            # 解析DSL内容
+            lexer = get_lexer()
+            parser = get_parser()
+            ast = parser.parse(dsl_content, lexer=lexer)
+
+            # 收集注册前的关键字列表
+            existing_keywords = (
+                set(keyword_manager._keywords.keys()) 
+                if hasattr(keyword_manager, '_keywords') 
+                else set()
+            )
+
+            # 使用统一的注册方法
+            self._register_keywords_from_ast(ast, source_name)
+
+            # 计算新注册的关键字
+            new_keywords = (
+                set(keyword_manager._keywords.keys()) 
+                if hasattr(keyword_manager, '_keywords') 
+                else set()
+            )
+            registered_keywords = list(new_keywords - existing_keywords)
+
+            if not registered_keywords:
+                raise ValueError("在DSL内容中未找到任何关键字定义")
+
+            return registered_keywords
+
+        except Exception as e:
+            print(f"从DSL内容注册关键字失败（来源：{source_name}）: {e}")
+            raise
+
+    def register_specific_keyword_from_dsl_content(
+            self, keyword_name: str, dsl_content: str, 
+            source_name: str = "DSL内容") -> bool:
+        """从DSL内容注册指定的关键字（公共方法）
+
+        Args:
+            keyword_name: 要注册的关键字名称
+            dsl_content: DSL文本内容
+            source_name: 来源名称，用于日志显示
+
+        Returns:
+            bool: 是否注册成功
+
+        Raises:
+            Exception: 解析失败或未找到指定关键字时抛出异常
+        """
+        try:
+            # 解析DSL内容
+            lexer = get_lexer()
+            parser = get_parser()
+            ast = parser.parse(dsl_content, lexer=lexer)
+
+            # 查找指定的关键字定义
+            if ast.type == 'Start' and len(ast.children) >= 2:
+                statements_node = ast.children[1]
+                if statements_node.type == 'Statements':
+                    for node in statements_node.children:
+                        if (node.type in ['CustomKeyword', 'Function'] and
+                                node.value == keyword_name):
+                            self._register_custom_keyword(node, source_name)
+                            return True
+
+            raise ValueError(f"在DSL内容中未找到关键字定义: {keyword_name}")
+
+        except Exception as e:
+            print(f"从DSL内容注册关键字失败 {keyword_name}（来源：{source_name}）: {e}")
+            raise
+
 
 # 创建全局自定义关键字管理器实例
 custom_keyword_manager = CustomKeywordManager()