pytest-dsl 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

pytest_dsl/cli.py

@@ -13,8 +13,9 @@ from pathlib import Path
 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_vars import yaml_vars
+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
 
 
 def read_file(filename):
@@ -27,35 +28,26 @@ def parse_args():
     """解析命令行参数"""
     parser = argparse.ArgumentParser(description='执行DSL测试文件')
     parser.add_argument('path', help='要执行的DSL文件路径或包含DSL文件的目录')
-    parser.add_argument('--yaml-vars', action='append', default=[], 
+    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文件')
-    
+
     return parser.parse_args()
 
 
 def load_yaml_variables(args):
     """从命令行参数加载YAML变量"""
-    # 加载单个YAML文件
-    if args.yaml_vars:
-        yaml_vars.load_yaml_files(args.yaml_vars)
-        print(f"已加载YAML变量文件: {', '.join(args.yaml_vars)}")
-    
-    # 加载目录中的YAML文件
-    if args.yaml_vars_dir:
-        yaml_vars_dir = args.yaml_vars_dir
-        try:
-            yaml_vars.load_from_directory(yaml_vars_dir)
-            print(f"已加载YAML变量目录: {yaml_vars_dir}")
-            loaded_files = yaml_vars.get_loaded_files()
-            if loaded_files:
-                dir_files = [f for f in loaded_files if Path(f).parent == Path(yaml_vars_dir)]
-                if dir_files:
-                    print(f"目录中加载的文件: {', '.join(dir_files)}")
-        except NotADirectoryError:
-            print(f"YAML变量目录不存在: {yaml_vars_dir}")
-            sys.exit(1)
+    # 使用统一的加载函数，包含远程服务器自动连接功能
+    try:
+        load_yaml_variables_from_args(
+            yaml_files=args.yaml_vars,
+            yaml_vars_dir=args.yaml_vars_dir,
+            project_root=os.getcwd()  # CLI模式下使用当前工作目录作为项目根目录
+        )
+    except Exception as e:
+        print(f"加载YAML变量失败: {str(e)}")
+        sys.exit(1)
 
 
 def execute_dsl_file(file_path, lexer, parser, executor):
@@ -85,14 +77,17 @@ def main():
     """命令行入口点"""
     args = parse_args()
     path = args.path
-    
-    # 加载YAML变量
+
+    # 加载内置关键字插件
+    load_all_plugins()
+
+    # 加载YAML变量（包括远程服务器自动连接）
     load_yaml_variables(args)
-    
+
     lexer = get_lexer()
     parser = get_parser()
     executor = DSLExecutor()
-    
+
     # 检查路径是文件还是目录
     if os.path.isfile(path):
         # 执行单个文件
@@ -102,32 +97,32 @@ def main():
     elif os.path.isdir(path):
         # 执行目录中的所有DSL文件
         print(f"执行目录: {path}")
-        
+
         # 先执行目录的setup文件（如果存在）
         setup_file = os.path.join(path, SETUP_FILE_NAME)
         if os.path.exists(setup_file):
             execute_hook_file(Path(setup_file), True, path)
-        
+
         # 查找并执行所有DSL文件
         dsl_files = find_dsl_files(path)
         if not dsl_files:
             print(f"目录中没有找到DSL文件: {path}")
             sys.exit(1)
-            
+
         print(f"找到 {len(dsl_files)} 个DSL文件")
-        
+
         # 执行所有DSL文件
         failures = 0
         for file_path in dsl_files:
             success = execute_dsl_file(file_path, lexer, parser, executor)
             if not success:
                 failures += 1
-        
+
         # 最后执行目录的teardown文件（如果存在）
         teardown_file = os.path.join(path, TEARDOWN_FILE_NAME)
         if os.path.exists(teardown_file):
             execute_hook_file(Path(teardown_file), False, path)
-        
+
         # 如果有失败的测试，返回非零退出码
         if failures > 0:
             print(f"总计 {failures}/{len(dsl_files)} 个测试失败")
@@ -140,4 +135,4 @@ def main():
 
 
 if __name__ == '__main__':
-    main() 
+    main()

pytest_dsl/core/auto_decorator.py

@@ -1,6 +1,6 @@
 """自动测试装饰器模块
 
-该模块提供装饰器功能，用于将指定目录下的.auto文件动态添加为测试方法到被装饰的类中。
+该模块提供装饰器功能，用于将指定目录下的.auto和.dsl文件动态添加为测试方法到被装饰的类中。
 这种方式更贴合pytest的设计理念，可以充分利用pytest的fixture、参数化等功能。
 """
 
@@ -15,7 +15,11 @@ from pytest_dsl.core.dsl_executor import DSLExecutor
 from pytest_dsl.core.dsl_executor_utils import read_file, execute_dsl_file, extract_metadata_from_ast
 from pytest_dsl.core.lexer import get_lexer
 from pytest_dsl.core.parser import get_parser
-from pytest_dsl.core.auto_directory import SETUP_FILE_NAME, TEARDOWN_FILE_NAME, execute_hook_file
+from pytest_dsl.core.auto_directory import (
+    SETUP_FILE_NAME, TEARDOWN_FILE_NAME,
+    SETUP_DSL_FILE_NAME, TEARDOWN_DSL_FILE_NAME,
+    execute_hook_file
+)
 
 # 获取词法分析器和解析器实例
 lexer = get_lexer()
@@ -24,12 +28,12 @@ parser = get_parser()
 
 def auto_dsl(directory: Union[str, Path], is_file: bool = False):
     """
-    装饰器函数，用于将指定目录下的.auto文件动态添加为测试方法到被装饰的类中。
-    
+    装饰器函数，用于将指定目录下的.auto和.dsl文件动态添加为测试方法到被装饰的类中。
+
     Args:
-        directory: 包含.auto文件的目录路径，可以是相对路径或绝对路径
+        directory: 包含.auto或.dsl文件的目录路径，可以是相对路径或绝对路径
         is_file: 是否是文件路径而不是目录路径
-        
+
     Returns:
         装饰器函数
     """
@@ -40,7 +44,7 @@ def auto_dsl(directory: Union[str, Path], is_file: bool = False):
         caller_file = caller_frame.f_globals['__file__']
         caller_dir = Path(caller_file).parent
         path = (caller_dir / path).resolve()
-    
+
     if is_file:
         # 路径是文件
         if not path.exists() or not path.is_file():
@@ -51,109 +55,124 @@ def auto_dsl(directory: Union[str, Path], is_file: bool = False):
         if not path.exists() or not path.is_dir():
             raise ValueError(f"目录不存在或不是有效目录: {path}")
         directory_path = path
-    
+
     def decorator(cls):
         if is_file:
             # 如果是文件路径，只添加这个文件的测试方法
             _add_test_method(cls, file_path)
         else:
-            # 检查setup.auto和teardown.auto文件
-            setup_file = directory_path / SETUP_FILE_NAME
-            teardown_file = directory_path / TEARDOWN_FILE_NAME
-            
+            # 检查setup和teardown文件（支持.auto和.dsl扩展名）
+            setup_file = None
+            teardown_file = None
+
+            # 优先查找.auto文件，然后查找.dsl文件
+            for setup_name in [SETUP_FILE_NAME, SETUP_DSL_FILE_NAME]:
+                potential_setup = directory_path / setup_name
+                if potential_setup.exists():
+                    setup_file = potential_setup
+                    break
+
+            for teardown_name in [TEARDOWN_FILE_NAME, TEARDOWN_DSL_FILE_NAME]:
+                potential_teardown = directory_path / teardown_name
+                if potential_teardown.exists():
+                    teardown_file = potential_teardown
+                    break
+
             # 添加setup和teardown方法
-            if setup_file.exists():
+            if setup_file:
                 @classmethod
                 @pytest.fixture(scope="class", autouse=True)
                 def setup_class(cls, request):
                     execute_hook_file(setup_file, True, str(directory_path))
-                    
+
                 setattr(cls, "setup_class", setup_class)
-            
-            if teardown_file.exists():
+
+            if teardown_file:
                 @classmethod
                 @pytest.fixture(scope="class", autouse=True)
                 def teardown_class(cls, request):
                     request.addfinalizer(lambda: execute_hook_file(teardown_file, False, str(directory_path)))
-                    
+
                 setattr(cls, "teardown_class", teardown_class)
-            
-            # 处理目录中的测试文件
-            for auto_file in directory_path.glob("*.auto"):
-                if auto_file.name not in [SETUP_FILE_NAME, TEARDOWN_FILE_NAME]:
-                    _add_test_method(cls, auto_file)
-        
+
+            # 处理目录中的测试文件，支持.auto和.dsl扩展名
+            excluded_files = [SETUP_FILE_NAME, TEARDOWN_FILE_NAME, SETUP_DSL_FILE_NAME, TEARDOWN_DSL_FILE_NAME]
+            for pattern in ["*.auto", "*.dsl"]:
+                for test_file in directory_path.glob(pattern):
+                    if test_file.name not in excluded_files:
+                        _add_test_method(cls, test_file)
+
         return cls
-    
+
     return decorator
 
 
-def _add_test_method(cls: Type, auto_file: Path) -> None:
+def _add_test_method(cls: Type, test_file: Path) -> None:
     """
-    为.auto文件创建测试方法并添加到类中
-    
+    为DSL测试文件创建测试方法并添加到类中
+
     Args:
         cls: 要添加测试方法的类
-        auto_file: .auto文件路径
+        test_file: DSL测试文件路径（.auto或.dsl）
     """
-    test_name = f"test_{auto_file.stem}"
-    
+    test_name = f"test_{test_file.stem}"
+
     # 读取DSL文件内容并解析
-    dsl_code = read_file(str(auto_file))
+    dsl_code = read_file(str(test_file))
     ast = parser.parse(dsl_code, lexer=lexer)
-    
+
     # 检查是否有数据驱动标记和测试名称
     data_source, test_title = extract_metadata_from_ast(ast)
-    
+
     if data_source:
-        test_method = _create_data_driven_test(auto_file, data_source, test_title)
+        test_method = _create_data_driven_test(test_file, data_source, test_title)
     else:
-        test_method = _create_simple_test(auto_file)
-    
+        test_method = _create_simple_test(test_file)
+
     # 将测试方法添加到类
     setattr(cls, test_name, test_method)
 
 
-def _create_simple_test(auto_file: Path) -> Callable:
+def _create_simple_test(test_file: Path) -> Callable:
     """
     创建普通的测试方法
-    
+
     Args:
-        auto_file: .auto文件路径
-        
+        test_file: DSL测试文件路径（.auto或.dsl）
+
     Returns:
         function: 测试方法
     """
     def test_method(self):
-        execute_dsl_file(str(auto_file))
-    
+        execute_dsl_file(str(test_file))
+
     return test_method
 
 
-def _create_data_driven_test(auto_file: Path, data_source: Dict, test_title: Optional[str]) -> Callable:
+def _create_data_driven_test(test_file: Path, data_source: Dict, test_title: Optional[str]) -> Callable:
     """
     创建数据驱动的测试方法
-    
+
     Args:
-        auto_file: .auto文件路径
+        test_file: DSL测试文件路径（.auto或.dsl）
         data_source: 数据源
         test_title: 测试标题
-        
+
     Returns:
         function: 装饰后的测试方法
     """
     def test_method(self, test_data):
         executor = DSLExecutor()
         executor.set_current_data(test_data)
-        execute_dsl_file(str(auto_file), executor)
-    
+        execute_dsl_file(str(test_file), executor)
+
     # 加载测试数据
     executor = DSLExecutor()
     test_data_list = executor._load_test_data(data_source)
-    
+
     # 为每个数据集创建一个唯一的ID
-    test_ids = _generate_test_ids(test_data_list, test_title or auto_file.stem)
-    
+    test_ids = _generate_test_ids(test_data_list, test_title or test_file.stem)
+
     # 使用pytest.mark.parametrize装饰测试方法
     return pytest.mark.parametrize(
         'test_data',
@@ -165,11 +184,11 @@ def _create_data_driven_test(auto_file: Path, data_source: Dict, test_title: Opt
 def _generate_test_ids(test_data_list: List[Dict[str, Any]], base_name: str) -> List[str]:
     """
     为数据驱动测试生成ID
-    
+
     Args:
         test_data_list: 测试数据列表
         base_name: 基础名称
-        
+
     Returns:
         List[str]: 测试ID列表
     """

pytest_dsl/core/auto_directory.py

@@ -32,6 +32,9 @@ _teardown_executed = set()
 # 常量定义
 SETUP_FILE_NAME = "setup.auto"
 TEARDOWN_FILE_NAME = "teardown.auto"
+# 支持.dsl扩展名的setup和teardown文件
+SETUP_DSL_FILE_NAME = "setup.dsl"
+TEARDOWN_DSL_FILE_NAME = "teardown.dsl"
 TMP_DIR = "/tmp"
 LOCK_FILE_SUFFIX = ".lock"
 EXECUTED_FILE_SUFFIX = ".lock.executed"
@@ -39,11 +42,11 @@ EXECUTED_FILE_SUFFIX = ".lock.executed"
 
 def get_lock_file_path(dir_path: str, is_setup: bool) -> str:
     """获取锁文件路径
-    
+
     Args:
         dir_path: 目录路径
         is_setup: 是否为setup锁文件
-        
+
     Returns:
         str: 锁文件路径
     """
@@ -53,7 +56,7 @@ def get_lock_file_path(dir_path: str, is_setup: bool) -> str:
 
 def execute_hook_file(file_path: Path, is_setup: bool, dir_path_str: str) -> None:
     """执行setup或teardown钩子文件
-    
+
     Args:
         file_path: 钩子文件路径
         is_setup: 是否为setup钩子
@@ -62,12 +65,12 @@ def execute_hook_file(file_path: Path, is_setup: bool, dir_path_str: str) -> Non
     hook_type = "Setup" if is_setup else "Teardown"
     executed_set = _setup_executed if is_setup else _teardown_executed
     lock_file = get_lock_file_path(dir_path_str, is_setup)
-    
+
     # 检查是否已执行过
     if dir_path_str in executed_set:
         logger.info(f"{hook_type} for directory already executed: {dir_path_str}")
         return
-    
+
     # 使用filelock获取锁并执行
     with FileLock(lock_file):
         if dir_path_str not in executed_set:  # 再次检查，防止在获取锁期间被其他进程执行

pytest_dsl/core/dsl_executor.py

@@ -11,7 +11,6 @@ from pytest_dsl.core.context import TestContext
 import pytest_dsl.keywords
 from pytest_dsl.core.yaml_vars import yaml_vars
 from pytest_dsl.core.variable_utils import VariableReplacer
-from pytest_dsl.remote.keyword_client import remote_keyword_manager
 
 
 class DSLExecutor:
@@ -218,6 +217,8 @@ class DSLExecutor:
         Args:
             node: RemoteImport节点
         """
+        from pytest_dsl.remote.keyword_client import remote_keyword_manager
+
         remote_info = node.value
         url = self._replace_variables_in_string(remote_info['url'])
         alias = remote_info['alias']
@@ -395,20 +396,40 @@ class DSLExecutor:
         result = self.execute(keyword_call_node)
 
         if result is not None:
+            # 处理新的统一返回格式（支持远程关键字模式）
+            if isinstance(result, dict) and 'result' in result:
+                # 提取主要返回值
+                main_result = result['result']
+
+                # 处理captures字段中的变量
+                captures = result.get('captures', {})
+                for capture_var, capture_value in captures.items():
+                    if capture_var.startswith('g_'):
+                        global_context.set_variable(capture_var, capture_value)
+                    else:
+                        self.variable_replacer.local_variables[capture_var] = capture_value
+                        self.test_context.set(capture_var, capture_value)
+
+                # 将主要结果赋值给指定变量
+                actual_result = main_result
+            else:
+                # 传统格式，直接使用结果
+                actual_result = result
+
             # 检查变量名是否以g_开头，如果是则设置为全局变量
             if var_name.startswith('g_'):
-                global_context.set_variable(var_name, result)
+                global_context.set_variable(var_name, actual_result)
                 allure.attach(
-                    f"全局变量: {var_name}\n值: {result}",
+                    f"全局变量: {var_name}\n值: {actual_result}",
                     name="全局变量赋值",
                     attachment_type=allure.attachment_type.TEXT
                 )
             else:
                 # 存储在本地变量字典和测试上下文中
-                self.variable_replacer.local_variables[var_name] = result
-                self.test_context.set(var_name, result)  # 同时添加到测试上下文
+                self.variable_replacer.local_variables[var_name] = actual_result
+                self.test_context.set(var_name, actual_result)  # 同时添加到测试上下文
                 allure.attach(
-                    f"变量: {var_name}\n值: {result}",
+                    f"变量: {var_name}\n值: {actual_result}",
                     name="赋值详情",
                     attachment_type=allure.attachment_type.TEXT
                 )
@@ -511,6 +532,8 @@ class DSLExecutor:
         Returns:
             执行结果
         """
+        from pytest_dsl.remote.keyword_client import remote_keyword_manager
+
         call_info = node.value
         alias = call_info['alias']
         keyword_name = call_info['keyword']
@@ -560,20 +583,42 @@ class DSLExecutor:
         result = self.execute(remote_keyword_call_node)
 
         if result is not None:
+            # 注意：远程关键字客户端已经处理了新格式的返回值，
+            # 这里接收到的result应该已经是主要返回值，而不是完整的字典格式
+            # 但为了保险起见，我们仍然检查是否为新格式
+            if isinstance(result, dict) and 'result' in result:
+                # 如果仍然是新格式（可能是嵌套的远程调用），提取主要返回值
+                main_result = result['result']
+
+                # 处理captures字段中的变量
+                captures = result.get('captures', {})
+                for capture_var, capture_value in captures.items():
+                    if capture_var.startswith('g_'):
+                        global_context.set_variable(capture_var, capture_value)
+                    else:
+                        self.variable_replacer.local_variables[capture_var] = capture_value
+                        self.test_context.set(capture_var, capture_value)
+
+                # 将主要结果赋值给指定变量
+                actual_result = main_result
+            else:
+                # 传统格式或已经处理过的格式，直接使用结果
+                actual_result = result
+
             # 检查变量名是否以g_开头，如果是则设置为全局变量
             if var_name.startswith('g_'):
-                global_context.set_variable(var_name, result)
+                global_context.set_variable(var_name, actual_result)
                 allure.attach(
-                    f"全局变量: {var_name}\n值: {result}",
+                    f"全局变量: {var_name}\n值: {actual_result}",
                     name="全局变量赋值",
                     attachment_type=allure.attachment_type.TEXT
                 )
             else:
                 # 存储在本地变量字典和测试上下文中
-                self.variable_replacer.local_variables[var_name] = result
-                self.test_context.set(var_name, result)  # 同时添加到测试上下文
+                self.variable_replacer.local_variables[var_name] = actual_result
+                self.test_context.set(var_name, actual_result)  # 同时添加到测试上下文
                 allure.attach(
-                    f"变量: {var_name}\n值: {result}",
+                    f"变量: {var_name}\n值: {actual_result}",
                     name="赋值详情",
                     attachment_type=allure.attachment_type.TEXT
                 )