pytest-dsl 0.8.0__py3-none-any.whl → 0.9.0__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,34 @@ 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)
+
+
 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()

pytest_dsl/core/dsl_executor.py

@@ -23,6 +23,14 @@ class ContinueException(Exception):
     pass
 
 
+class ReturnException(Exception):
+    """Return控制流异常"""
+
+    def __init__(self, return_value=None):
+        self.return_value = return_value
+        super().__init__(f"Return with value: {return_value}")
+
+
 class DSLExecutor:
     """DSL执行器，负责执行解析后的AST
 
@@ -30,12 +38,14 @@ class DSLExecutor:
     - PYTEST_DSL_KEEP_VARIABLES=1: 执行完成后保留变量，用于单元测试中检查变量值
     - PYTEST_DSL_KEEP_VARIABLES=0: (默认) 执行完成后清空变量，用于正常DSL执行
     """
+
     def __init__(self):
         """初始化DSL执行器"""
         self.variables = {}
         self.test_context = TestContext()
         self.test_context.executor = self  # 让 test_context 能够访问到 executor
-        self.variable_replacer = VariableReplacer(self.variables, self.test_context)
+        self.variable_replacer = VariableReplacer(
+            self.variables, self.test_context)
         self.imported_files = set()  # 跟踪已导入的文件，避免循环导入
 
     def set_current_data(self, data):
@@ -279,7 +289,8 @@ class DSLExecutor:
                     # 导入自定义关键字管理器
                     from pytest_dsl.core.custom_keyword_manager import custom_keyword_manager
                     # 注册自定义关键字
-                    custom_keyword_manager._register_custom_keyword(stmt, "current_file")
+                    custom_keyword_manager._register_custom_keyword(
+                        stmt, "current_file")
 
     def _handle_start(self, node):
         """处理开始节点"""
@@ -377,7 +388,8 @@ class DSLExecutor:
             # 当 PYTEST_DSL_KEEP_VARIABLES=1 时，保留变量（用于单元测试）
             # 否则清空变量（用于正常DSL执行）
             import os
-            keep_variables = os.environ.get('PYTEST_DSL_KEEP_VARIABLES', '0') == '1'
+            keep_variables = os.environ.get(
+                'PYTEST_DSL_KEEP_VARIABLES', '0') == '1'
 
             if not keep_variables:
                 self.variables.clear()
@@ -387,7 +399,11 @@ class DSLExecutor:
     def _handle_statements(self, node):
         """处理语句列表"""
         for stmt in node.children:
-            self.execute(stmt)
+            try:
+                self.execute(stmt)
+            except ReturnException as e:
+                # 将return异常向上传递，不在这里处理
+                raise e
 
     @allure.step("变量赋值")
     def _handle_assignment(self, node):
@@ -491,6 +507,14 @@ class DSLExecutor:
                         attachment_type=allure.attachment_type.TEXT
                     )
                     continue
+                except ReturnException as e:
+                    # 遇到return语句，将异常向上传递
+                    allure.attach(
+                        f"在 {var_name} = {i} 时遇到return语句，退出函数",
+                        name="循环Return",
+                        attachment_type=allure.attachment_type.TEXT
+                    )
+                    raise e
 
     def _execute_keyword_call(self, node):
         """执行关键字调用"""
@@ -537,11 +561,12 @@ class DSLExecutor:
         Args:
             node: Return节点
 
-        Returns:
-            表达式求值结果
+        Raises:
+            ReturnException: 抛出异常来实现return控制流
         """
         expr_node = node.children[0]
-        return self.eval_expression(expr_node)
+        return_value = self.eval_expression(expr_node)
+        raise ReturnException(return_value)
 
     @allure.step("执行break语句")
     def _handle_break(self, node):
@@ -580,7 +605,8 @@ class DSLExecutor:
         if condition:
             # 执行if分支
             with allure.step("执行if分支"):
-                return self.execute(node.children[1])
+                self.execute(node.children[1])
+                return
 
         # 如果if条件为假，检查elif分支
         for i in range(2, len(node.children)):
@@ -591,13 +617,15 @@ class DSLExecutor:
                 elif_condition = self.eval_expression(child.children[0])
                 if elif_condition:
                     with allure.step(f"执行elif分支 {i-1}"):
-                        return self.execute(child.children[1])
+                        self.execute(child.children[1])
+                        return
 
             # 如果是普通的statements节点（else分支）
             elif not hasattr(child, 'type') or child.type == 'Statements':
                 # 这是else分支，只有在所有前面的条件都为假时才执行
                 with allure.step("执行else分支"):
-                    return self.execute(child)
+                    self.execute(child)
+                    return
 
         # 如果所有条件都为假且没有else分支，则不执行任何操作
         return None
@@ -634,7 +662,8 @@ class DSLExecutor:
         with allure.step(f"执行远程关键字: {alias}|{keyword_name}"):
             try:
                 # 执行远程关键字
-                result = remote_keyword_manager.execute_remote_keyword(alias, keyword_name, **kwargs)
+                result = remote_keyword_manager.execute_remote_keyword(
+                    alias, keyword_name, **kwargs)
                 allure.attach(
                     f"远程关键字参数: {kwargs}\n"
                     f"远程关键字结果: {result}",
@@ -730,6 +759,7 @@ class DSLExecutor:
             return handler(node)
         raise Exception(f"未知的节点类型: {node.type}")
 
+
 def read_file(filename):
     """读取 DSL 文件内容"""
     with open(filename, 'r', encoding='utf-8') as f:

{pytest_dsl-0.8.0.dist-info → pytest_dsl-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-dsl
-Version: 0.8.0
+Version: 0.9.0
 Summary: A DSL testing framework based on pytest
 Author: Chen Shuanglin
 License: MIT

{pytest_dsl-0.8.0.dist-info → pytest_dsl-0.9.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pytest_dsl/__init__.py,sha256=FzwXGvmuvMhRBKxvCdh1h-yJ2wUOnDxcTbU4Nt5fHn8,301
-pytest_dsl/cli.py,sha256=rOkGrHaBJE0a0QmT1YTob-z8N5kpnzYowrgCdZrfVzE,4467
+pytest_dsl/cli.py,sha256=4X-nq7TdBgFGN9oDBhgNHaoLBmTV0WQ_uxNY6cdRS4M,14944
 pytest_dsl/conftest_adapter.py,sha256=cevEb0oEZKTZfUrGe1-CmkFByxKhUtjuurBJP7kpLc0,149
 pytest_dsl/main_adapter.py,sha256=pUIPN_EzY3JCDlYK7yF_OeLDVqni8vtG15G7gVzPJXg,181
 pytest_dsl/plugin.py,sha256=MEQcdK0xdxwxCxPEDLNHX_kGF9Jc7bNxlNi4mx588DU,1190
@@ -8,8 +8,8 @@ pytest_dsl/core/auth_provider.py,sha256=IZfXXrr4Uuc8QHwRPvhHSzNa2fwrqhjYts1xh78D
 pytest_dsl/core/auto_decorator.py,sha256=9Mga-GB4AzV5nkB6zpfaq8IuHa0KOH8LlFvnWyH_tnU,6623
 pytest_dsl/core/auto_directory.py,sha256=egyTnVxtGs4P75EIivRauLRPJfN9aZpoGVvp_Ma72AM,2714
 pytest_dsl/core/context.py,sha256=fXpVQon666Lz_PCexjkWMBBr-Xcd1SkDMp2vHar6eIs,664
-pytest_dsl/core/custom_keyword_manager.py,sha256=QY-wXvzON2kkFwojBSXqWcQpo_aKixKhG-rsacV8gzE,7955
-pytest_dsl/core/dsl_executor.py,sha256=-pOZ-FAU6BqUhjydE2a9uUOolxAtVwrKWSD9j_5rYGk,29488
+pytest_dsl/core/custom_keyword_manager.py,sha256=Y3MftSklqGSS3FfeZjmyfcGHfQw6FrhFTwgS_O8zQh4,7606
+pytest_dsl/core/dsl_executor.py,sha256=aEEfocFCFxNDN1puBFhQzL5fzw9eZx8BAyYJI5XSt4Y,30472
 pytest_dsl/core/dsl_executor_utils.py,sha256=cFoR2p3qQ2pb-UhkoefleK-zbuFqf0aBLh2Rlp8Ebs4,2180
 pytest_dsl/core/global_context.py,sha256=NcEcS2V61MT70tgAsGsFWQq0P3mKjtHQr1rgT3yTcyY,3535
 pytest_dsl/core/http_client.py,sha256=1AHqtM_fkXf8JrM0ljMsJwUkyt-ysjR16NoyCckHfGc,15810
@@ -59,9 +59,9 @@ pytest_dsl/keywords/assertion_keywords.py,sha256=WOCGP7WX2wZ6mQPDGmi38LWdG2NaThH
 pytest_dsl/keywords/global_keywords.py,sha256=4yw5yeXoGf_4W26F39EA2Pp-mH9GiKGy2jKgFO9a_wM,2509
 pytest_dsl/keywords/http_keywords.py,sha256=DY1SvUgOziN6Ga-QgE0q4XFd2qGGwvbv1B_k2gTdPLw,25554
 pytest_dsl/keywords/system_keywords.py,sha256=n_jRrMvSv2v6Pm_amokfyLNVOLYP7CFWbBE3_dlO7h4,11299
-pytest_dsl-0.8.0.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
-pytest_dsl-0.8.0.dist-info/METADATA,sha256=hdWrlddZUtb3iV3hpz1YJdiv2y7jgWMnPPB_k6wyKP4,26712
-pytest_dsl-0.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytest_dsl-0.8.0.dist-info/entry_points.txt,sha256=qqxFwSHQtjoae8_WWiO6w8y0N9nC4H8eFRvOnr_OipE,152
-pytest_dsl-0.8.0.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
-pytest_dsl-0.8.0.dist-info/RECORD,,
+pytest_dsl-0.9.0.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
+pytest_dsl-0.9.0.dist-info/METADATA,sha256=it5pFZgvhb4OBllvC5vPxn-rezLeMsvGVtjPrtEDw6g,26712
+pytest_dsl-0.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytest_dsl-0.9.0.dist-info/entry_points.txt,sha256=vuYIReCjHhS_cpaPAbQxOnFavQAwW0K66dKxUQSsRvc,190
+pytest_dsl-0.9.0.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
+pytest_dsl-0.9.0.dist-info/RECORD,,

{pytest_dsl-0.8.0.dist-info → pytest_dsl-0.9.0.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 pytest-dsl = pytest_dsl.cli:main
+pytest-dsl-list = pytest_dsl.cli:main
 pytest-dsl-server = pytest_dsl.remote.keyword_server:main
 
 [pytest11]