pytest-dsl 0.8.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

pytest_dsl/cli.py

@@ -6,7 +6,6 @@ pytest-dsl命令行入口
 
 import sys
 import argparse
-import pytest
 import os
 from pathlib import Path
 
@@ -14,8 +13,13 @@ from pytest_dsl.core.lexer import get_lexer
 from pytest_dsl.core.parser import get_parser
 from pytest_dsl.core.dsl_executor import DSLExecutor
 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
+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_manager import keyword_manager
 
 
 def read_file(filename):
@@ -26,14 +30,296 @@ def read_file(filename):
 
 def parse_args():
     """解析命令行参数"""
-    parser = argparse.ArgumentParser(description='执行DSL测试文件')
-    parser.add_argument('path', help='要执行的DSL文件路径或包含DSL文件的目录')
-    parser.add_argument('--yaml-vars', action='append', default=[],
-                       help='YAML变量文件路径，可以指定多个文件 (例如: --yaml-vars vars1.yaml --yaml-vars vars2.yaml)')
-    parser.add_argument('--yaml-vars-dir', default=None,
-                       help='YAML变量文件目录路径，将加载该目录下所有.yaml文件')
+    import sys
+    argv = sys.argv[1:]  # 去掉脚本名
 
-    return parser.parse_args()
+    # 检查是否使用了子命令格式
+    if argv and argv[0] in ['run', 'list-keywords']:
+        # 使用新的子命令格式
+        parser = argparse.ArgumentParser(description='执行DSL测试文件')
+        subparsers = parser.add_subparsers(dest='command', help='可用命令')
+
+        # 执行命令
+        run_parser = subparsers.add_parser('run', help='执行DSL文件')
+        run_parser.add_argument(
+            'path',
+            help='要执行的DSL文件路径或包含DSL文件的目录'
+        )
+        run_parser.add_argument(
+            '--yaml-vars', action='append', default=[],
+            help='YAML变量文件路径，可以指定多个文件 '
+                 '(例如: --yaml-vars vars1.yaml '
+                 '--yaml-vars vars2.yaml)'
+        )
+        run_parser.add_argument(
+            '--yaml-vars-dir', default=None,
+            help='YAML变量文件目录路径，'
+                 '将加载该目录下所有.yaml文件'
+        )
+
+        # 关键字列表命令
+        list_parser = subparsers.add_parser(
+            'list-keywords',
+            help='罗列所有可用关键字和参数信息'
+        )
+        list_parser.add_argument(
+            '--format', choices=['text', 'json'],
+            default='text',
+            help='输出格式：text(默认) 或 json'
+        )
+        list_parser.add_argument(
+            '--filter', type=str, default=None,
+            help='过滤关键字名称（支持部分匹配）'
+        )
+        list_parser.add_argument(
+            '--category',
+            choices=['builtin', 'custom', 'remote', 'all'],
+            default='all',
+            help='关键字类别：builtin(内置)、custom(自定义)、'
+                 'remote(远程)、all(全部，默认)'
+        )
+
+        return parser.parse_args(argv)
+    else:
+        # 向后兼容模式
+        parser = argparse.ArgumentParser(description='执行DSL测试文件')
+
+        # 检查是否是list-keywords的旧格式
+        if '--list-keywords' in argv:
+            parser.add_argument('--list-keywords', action='store_true')
+            parser.add_argument(
+                '--format', choices=['text', 'json'], default='text'
+            )
+            parser.add_argument('--filter', type=str, default=None)
+            parser.add_argument(
+                '--category',
+                choices=['builtin', 'custom', 'remote', 'all'],
+                default='all'
+            )
+            parser.add_argument('path', nargs='?')  # 可选的路径参数
+            parser.add_argument(
+                '--yaml-vars', action='append', default=[]
+            )
+            parser.add_argument('--yaml-vars-dir', default=None)
+
+            args = parser.parse_args(argv)
+            args.command = 'list-keywords-compat'  # 标记为兼容模式
+        else:
+            # 默认为run命令的向后兼容模式
+            parser.add_argument('path', nargs='?')
+            parser.add_argument(
+                '--yaml-vars', action='append', default=[]
+            )
+            parser.add_argument('--yaml-vars-dir', default=None)
+
+            args = parser.parse_args(argv)
+            args.command = 'run-compat'  # 标记为兼容模式
+
+        return args
+
+
+def load_all_keywords():
+    """加载所有可用的关键字"""
+    # 首先导入内置关键字模块，确保内置关键字被注册
+    try:
+        import pytest_dsl.keywords  # noqa: F401
+        print("内置关键字模块加载完成")
+    except ImportError as e:
+        print(f"加载内置关键字模块失败: {e}")
+
+    # 加载已安装的关键字插件
+    load_all_plugins()
+
+    # 扫描本地关键字
+    scan_local_keywords()
+
+
+def categorize_keyword(keyword_name, keyword_info):
+    """判断关键字的类别"""
+    if keyword_info.get('remote', False):
+        return 'remote'
+
+    # 检查是否是内置关键字（通过检查函数所在模块）
+    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 format_keyword_info_text(keyword_name, keyword_info, show_category=True):
+    """格式化关键字信息为文本格式"""
+    lines = []
+
+    # 关键字名称和类别
+    category = categorize_keyword(keyword_name, keyword_info)
+    category_names = {'builtin': '内置', 'custom': '自定义', 'remote': '远程'}
+
+    if show_category:
+        category_display = category_names.get(category, '未知')
+        lines.append(f"关键字: {keyword_name} [{category_display}]")
+    else:
+        lines.append(f"关键字: {keyword_name}")
+
+    # 远程关键字特殊标识
+    if keyword_info.get('remote', False):
+        alias = keyword_info.get('alias', '未知')
+        original_name = keyword_info.get('original_name', keyword_name)
+        lines.append(f"  远程服务器: {alias}")
+        lines.append(f"  原始名称: {original_name}")
+
+    # 参数信息
+    parameters = keyword_info.get('parameters', [])
+    if parameters:
+        lines.append("  参数:")
+        for param in parameters:
+            param_name = getattr(param, 'name', str(param))
+            param_mapping = getattr(param, 'mapping', '')
+            param_desc = getattr(param, 'description', '')
+
+            if param_mapping and param_mapping != param_name:
+                lines.append(
+                    f"    {param_name} ({param_mapping}): {param_desc}"
+                )
+            else:
+                lines.append(f"    {param_name}: {param_desc}")
+    else:
+        lines.append("  参数: 无")
+
+    # 函数文档
+    func = keyword_info.get('func')
+    if func and hasattr(func, '__doc__') and func.__doc__:
+        lines.append(f"  说明: {func.__doc__.strip()}")
+
+    return '\n'.join(lines)
+
+
+def format_keyword_info_json(keyword_name, keyword_info):
+    """格式化关键字信息为JSON格式"""
+    category = categorize_keyword(keyword_name, keyword_info)
+
+    keyword_data = {
+        'name': keyword_name,
+        'category': category,
+        'parameters': []
+    }
+
+    # 远程关键字特殊信息
+    if keyword_info.get('remote', False):
+        keyword_data['remote'] = {
+            'alias': keyword_info.get('alias', ''),
+            'original_name': keyword_info.get('original_name', keyword_name)
+        }
+
+    # 参数信息
+    parameters = keyword_info.get('parameters', [])
+    for param in parameters:
+        param_data = {
+            'name': getattr(param, 'name', str(param)),
+            'mapping': getattr(param, 'mapping', ''),
+            'description': getattr(param, 'description', '')
+        }
+        keyword_data['parameters'].append(param_data)
+
+    # 函数文档
+    func = keyword_info.get('func')
+    if func and hasattr(func, '__doc__') and func.__doc__:
+        keyword_data['documentation'] = func.__doc__.strip()
+
+    return keyword_data
+
+
+def list_keywords(output_format='text', name_filter=None,
+                  category_filter='all'):
+    """罗列所有关键字信息"""
+    import json
+
+    print("正在加载关键字...")
+    load_all_keywords()
+
+    # 获取所有注册的关键字
+    all_keywords = keyword_manager._keywords
+
+    if not all_keywords:
+        print("未发现任何关键字")
+        return
+
+    # 过滤关键字
+    filtered_keywords = {}
+
+    for name, info in all_keywords.items():
+        # 名称过滤
+        if name_filter and name_filter.lower() not in name.lower():
+            continue
+
+        # 类别过滤
+        if category_filter != 'all':
+            keyword_category = categorize_keyword(name, info)
+            if keyword_category != category_filter:
+                continue
+
+        filtered_keywords[name] = info
+
+    if not filtered_keywords:
+        if name_filter:
+            print(f"未找到包含 '{name_filter}' 的关键字")
+        else:
+            print(f"未找到 {category_filter} 类别的关键字")
+        return
+
+    # 输出统计信息
+    total_count = len(filtered_keywords)
+    category_counts = {}
+    for name, info in filtered_keywords.items():
+        cat = categorize_keyword(name, info)
+        category_counts[cat] = category_counts.get(cat, 0) + 1
+
+    if output_format == 'text':
+        print(f"\n找到 {total_count} 个关键字:")
+        for cat, count in category_counts.items():
+            cat_names = {'builtin': '内置', 'custom': '自定义', 'remote': '远程'}
+            print(f"  {cat_names.get(cat, cat)}: {count} 个")
+        print("-" * 60)
+
+        # 按类别分组显示
+        for category in ['builtin', 'custom', 'remote']:
+            cat_keywords = {
+                name: info for name, info in filtered_keywords.items()
+                if categorize_keyword(name, info) == category
+            }
+
+            if cat_keywords:
+                cat_names = {
+                    'builtin': '内置关键字',
+                    'custom': '自定义关键字',
+                    'remote': '远程关键字'
+                }
+                print(f"\n=== {cat_names[category]} ===")
+
+                for name in sorted(cat_keywords.keys()):
+                    info = cat_keywords[name]
+                    print()
+                    print(format_keyword_info_text(
+                        name, info, show_category=False
+                    ))
+
+    elif output_format == 'json':
+        keywords_data = {
+            'summary': {
+                'total_count': total_count,
+                'category_counts': category_counts
+            },
+            'keywords': []
+        }
+
+        for name in sorted(filtered_keywords.keys()):
+            info = filtered_keywords[name]
+            keyword_data = format_keyword_info_json(name, info)
+            keywords_data['keywords'].append(keyword_data)
+
+        print(json.dumps(keywords_data, ensure_ascii=False, indent=2))
 
 
 def load_yaml_variables(args):
@@ -68,18 +354,22 @@ def find_dsl_files(directory):
     dsl_files = []
     for root, _, files in os.walk(directory):
         for file in files:
-            if file.endswith(('.dsl', '.auto')) and file not in [SETUP_FILE_NAME, TEARDOWN_FILE_NAME]:
+            if (file.endswith(('.dsl', '.auto')) and
+                    file not in [SETUP_FILE_NAME, TEARDOWN_FILE_NAME]):
                 dsl_files.append(os.path.join(root, file))
     return dsl_files
 
 
-def main():
-    """命令行入口点"""
-    args = parse_args()
+def run_dsl_tests(args):
+    """执行DSL测试的主函数"""
     path = args.path
 
+    if not path:
+        print("错误: 必须指定要执行的DSL文件路径或目录")
+        sys.exit(1)
+
     # 加载内置关键字插件
-    load_all_plugins()
+    load_all_keywords()
 
     # 加载YAML变量（包括远程服务器自动连接）
     load_yaml_variables(args)
@@ -134,5 +424,62 @@ def main():
         sys.exit(1)
 
 
+def main():
+    """命令行入口点"""
+    args = parse_args()
+
+    # 处理子命令
+    if args.command == 'list-keywords':
+        list_keywords(
+            output_format=args.format,
+            name_filter=args.filter,
+            category_filter=args.category
+        )
+    elif args.command == 'run':
+        run_dsl_tests(args)
+    elif args.command == 'list-keywords-compat':
+        # 向后兼容：旧的--list-keywords格式
+        list_keywords(
+            output_format=args.format,
+            name_filter=args.filter,
+            category_filter=args.category
+        )
+    elif args.command == 'run-compat':
+        # 向后兼容：默认执行DSL测试
+        run_dsl_tests(args)
+    else:
+        # 如果没有匹配的命令，显示帮助
+        print("错误: 未知命令")
+        sys.exit(1)
+
+
+def main_list_keywords():
+    """关键字列表命令的专用入口点"""
+    parser = argparse.ArgumentParser(description='查看pytest-dsl可用关键字列表')
+    parser.add_argument(
+        '--format', choices=['text', 'json'],
+        default='text',
+        help='输出格式：text(默认) 或 json'
+    )
+    parser.add_argument(
+        '--filter', type=str, default=None,
+        help='过滤关键字名称（支持部分匹配）'
+    )
+    parser.add_argument(
+        '--category',
+        choices=['builtin', 'custom', 'remote', 'all'],
+        default='all',
+        help='关键字类别：builtin(内置)、custom(自定义)、remote(远程)、all(全部，默认)'
+    )
+
+    args = parser.parse_args()
+
+    list_keywords(
+        output_format=args.format,
+        name_filter=args.filter,
+        category_filter=args.category
+    )
+
+
 if __name__ == '__main__':
     main()

pytest_dsl/core/custom_keyword_manager.py

@@ -10,38 +10,38 @@ from pytest_dsl.core.context import TestContext
 
 class CustomKeywordManager:
     """自定义关键字管理器
-    
+
     负责加载和注册自定义关键字
     """
-    
+
     def __init__(self):
         """初始化自定义关键字管理器"""
         self.resource_cache = {}  # 缓存已加载的资源文件
         self.resource_paths = []  # 资源文件搜索路径
-    
+
     def add_resource_path(self, path: str) -> None:
         """添加资源文件搜索路径
-        
+
         Args:
             path: 资源文件路径
         """
         if path not in self.resource_paths:
             self.resource_paths.append(path)
-    
+
     def load_resource_file(self, file_path: str) -> None:
         """加载资源文件
-        
+
         Args:
             file_path: 资源文件路径
         """
         # 规范化路径，解决路径叠加的问题
         file_path = os.path.normpath(file_path)
-        
+
         # 如果已经缓存，则跳过
         absolute_path = os.path.abspath(file_path)
         if absolute_path in self.resource_cache:
             return
-        
+
         # 读取文件内容
         if not os.path.exists(file_path):
             # 尝试在资源路径中查找
@@ -54,84 +54,85 @@ class CustomKeywordManager:
             else:
                 # 如果文件不存在，尝试在根项目目录中查找
                 # 一般情况下文件路径可能是相对于项目根目录的
-                project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+                project_root = os.path.dirname(
+                    os.path.dirname(os.path.dirname(__file__)))
                 full_path = os.path.join(project_root, file_path)
                 if os.path.exists(full_path):
                     file_path = full_path
                     absolute_path = os.path.abspath(file_path)
                 else:
                     raise FileNotFoundError(f"资源文件不存在: {file_path}")
-        
+
         try:
             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._register_keywords(ast, file_path)
         except Exception as e:
             print(f"资源文件 {file_path} 加载失败: {str(e)}")
             raise
-    
+
     def _process_imports(self, ast: Node, base_dir: str) -> None:
         """处理资源文件中的导入指令
-        
+
         Args:
             ast: 抽象语法树
             base_dir: 基础目录
         """
         if ast.type != 'Start' or not ast.children:
             return
-        
+
         metadata_node = ast.children[0]
         if metadata_node.type != 'Metadata':
             return
-        
+
         for item in metadata_node.children:
             if item.type == '@import':
                 imported_file = item.value
                 # 处理相对路径
                 if not os.path.isabs(imported_file):
                     imported_file = os.path.join(base_dir, imported_file)
-                    
+
                 # 规范化路径，避免路径叠加问题
                 imported_file = os.path.normpath(imported_file)
-                
+
                 # 递归加载导入的资源文件
                 self.load_resource_file(imported_file)
-    
+
     def _register_keywords(self, ast: Node, file_path: str) -> None:
         """从AST中注册关键字
-        
+
         Args:
             ast: 抽象语法树
             file_path: 文件路径
         """
         if ast.type != 'Start' or len(ast.children) < 2:
             return
-        
+
         # 遍历语句节点
         statements_node = ast.children[1]
         if statements_node.type != 'Statements':
             return
-        
+
         for node in statements_node.children:
             if node.type == 'CustomKeyword':
                 self._register_custom_keyword(node, file_path)
-    
+
     def _register_custom_keyword(self, node: Node, file_path: str) -> None:
         """注册自定义关键字
-        
+
         Args:
             node: 关键字节点
             file_path: 资源文件路径
@@ -140,74 +141,74 @@ class CustomKeywordManager:
         keyword_name = node.value
         params_node = node.children[0]
         body_node = node.children[1]
-        
+
         # 构建参数列表
         parameters = []
         param_mapping = {}
         param_defaults = {}  # 存储参数默认值
-        
+
         for param in params_node if params_node else []:
             param_name = param.value
             param_default = None
-            
+
             # 检查是否有默认值
             if param.children and param.children[0]:
                 param_default = param.children[0].value
                 param_defaults[param_name] = param_default  # 保存默认值
-            
+
             # 添加参数定义
             parameters.append({
                 'name': param_name,
                 'mapping': param_name,  # 中文参数名和内部参数名相同
                 'description': f'自定义关键字参数 {param_name}'
             })
-            
+
             param_mapping[param_name] = param_name
-        
+
         # 注册自定义关键字到关键字管理器
         @keyword_manager.register(keyword_name, parameters)
         def custom_keyword_executor(**kwargs):
             """自定义关键字执行器"""
             # 创建一个新的DSL执行器
             executor = DSLExecutor()
-            
+
+            # 导入ReturnException以避免循环导入
+            from pytest_dsl.core.dsl_executor import ReturnException
+
             # 获取传递的上下文
             context = kwargs.get('context')
             if context:
                 executor.test_context = context
-            
+
             # 先应用默认值
             for param_name, default_value in param_defaults.items():
                 executor.variables[param_name] = default_value
                 executor.test_context.set(param_name, default_value)
-            
+
             # 然后应用传入的参数值（覆盖默认值）
             for param_name, param_mapping_name in param_mapping.items():
                 if param_mapping_name in kwargs:
                     # 确保参数值在标准变量和测试上下文中都可用
                     executor.variables[param_name] = kwargs[param_mapping_name]
-                    executor.test_context.set(param_name, kwargs[param_mapping_name])
-            
+                    executor.test_context.set(
+                        param_name, kwargs[param_mapping_name])
+
             # 执行关键字体中的语句
             result = None
             try:
                 for stmt in body_node.children:
-                    # 检查是否是return语句
-                    if stmt.type == 'Return':
-                        # 对表达式求值
-                        result = executor.eval_expression(stmt.children[0])
-                        break
-                    else:
-                        # 执行普通语句
-                        executor.execute(stmt)
+                    executor.execute(stmt)
+            except ReturnException as e:
+                # 捕获return异常，提取返回值
+                result = e.return_value
             except Exception as e:
                 print(f"执行自定义关键字 {keyword_name} 时发生错误: {str(e)}")
                 raise
-            
+
             return result
-        
+
         print(f"已注册自定义关键字: {keyword_name} 来自文件: {file_path}")
 
 
 # 创建全局自定义关键字管理器实例
-custom_keyword_manager = CustomKeywordManager() 
+custom_keyword_manager = CustomKeywordManager()