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

pytest_dsl/core/variable_utils.py

@@ -8,44 +8,44 @@ from pytest_dsl.core.yaml_vars import yaml_vars
 
 class VariableReplacer:
     """统一的变量替换工具类
-    
+
     提供统一的变量替换功能，支持字符串、字典和列表中的变量替换。
     变量查找优先级：本地变量 > 测试上下文 > YAML变量 > 全局上下文
     """
-    
+
     def __init__(self, local_variables: Dict[str, Any] = None, test_context: TestContext = None):
         """初始化变量替换器
-        
+
         Args:
             local_variables: 本地变量字典
             test_context: 测试上下文对象
         """
         self.local_variables = local_variables or {}
         self._test_context = test_context or TestContext()
-        
+
     @property
     def test_context(self) -> TestContext:
         """获取测试上下文，确保始终使用最新的上下文对象
-        
+
         如果上下文对象中包含executor属性，则使用executor的上下文
         （这确保即使上下文被替换也能获取正确的引用）
-        
+
         Returns:
             测试上下文对象
         """
         if hasattr(self._test_context, 'executor') and self._test_context.executor is not None:
             return self._test_context.executor.test_context
         return self._test_context
-        
+
     def get_variable(self, var_name: str) -> Any:
         """获取变量值，按照优先级查找
-        
+
         Args:
             var_name: 变量名
-            
+
         Returns:
             变量值，如果变量不存在则抛出 KeyError
-            
+
         Raises:
             KeyError: 当变量不存在时
         """
@@ -53,31 +53,31 @@ class VariableReplacer:
         if var_name in self.local_variables:
             value = self.local_variables[var_name]
             return self._convert_value(value)
-        
+
         # 从测试上下文中获取
         if self.test_context.has(var_name):
             value = self.test_context.get(var_name)
             return self._convert_value(value)
-        
+
         # 从YAML变量中获取
         yaml_value = yaml_vars.get_variable(var_name)
         if yaml_value is not None:
             return self._convert_value(yaml_value)
-            
+
         # 从全局上下文获取
         if global_context.has_variable(var_name):
             value = global_context.get_variable(var_name)
             return self._convert_value(value)
-            
+
         # 如果变量不存在，抛出异常
         raise KeyError(f"变量 '{var_name}' 不存在")
-    
+
     def _convert_value(self, value: Any) -> Any:
         """转换值为正确的类型
-        
+
         Args:
             value: 要转换的值
-            
+
         Returns:
             转换后的值
         """
@@ -93,68 +93,213 @@ class VariableReplacer:
             except (ValueError, TypeError):
                 pass
         return value
-    
+
     def replace_in_string(self, value: str) -> str:
         """替换字符串中的变量引用
-        
+
+        支持多种访问语法：
+        - 基本变量: ${variable}
+        - 点号访问: ${object.property}
+        - 数组索引: ${array[0]}, ${array[-1]}
+        - 字典键访问: ${dict["key"]}, ${dict['key']}
+        - 混合访问: ${users[0].name}, ${data["users"][0]["name"]}
+
         Args:
             value: 包含变量引用的字符串
-            
+
         Returns:
             替换后的字符串
-            
+
         Raises:
             KeyError: 当变量不存在时
         """
         if not isinstance(value, str) or '${' not in value:
             return value
-            
-        # 处理变量引用模式: ${variable} 或 ${variable.field.subfield}
-        pattern = r'\$\{([a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*(?:\.[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*)*)\}'
-        
+
+        # 扩展的变量引用模式，支持数组索引和字典键访问
+        # 匹配: ${variable}, ${obj.prop}, ${arr[0]}, ${dict["key"]}, ${obj[0].prop} 等
+        pattern = r'\$\{([a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*(?:(?:\.[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*)|(?:\[[^\]]+\]))*)\}'
+
         result = value
         matches = list(re.finditer(pattern, result))
-        
+
         # 从后向前替换，避免位置偏移
         for match in reversed(matches):
-            var_ref = match.group(1)  # 例如: "api_test_data.user_id" 或 "variable"
-            parts = var_ref.split('.')
-            
-            # 获取根变量
-            root_var_name = parts[0]
+            var_ref = match.group(1)  # 例如: "users[0].name" 或 "data['key']"
+
             try:
-                root_var = self.get_variable(root_var_name)
-            except KeyError:
-                raise KeyError(f"变量 '{root_var_name}' 不存在")
-            
-            # 递归访问嵌套属性
-            var_value = root_var
-            for part in parts[1:]:
-                if isinstance(var_value, dict) and part in var_value:
-                    var_value = var_value[part]
-                else:
-                    raise KeyError(f"无法访问属性 '{part}'，变量 '{root_var_name}' 的类型是 {type(var_value).__name__}")
-            
-            # 替换变量引用
-            result = result[:match.start()] + str(var_value) + result[match.end():]
-        
+                var_value = self._parse_variable_path(var_ref)
+                # 替换变量引用
+                result = result[:match.start()] + str(var_value) + result[match.end():]
+            except (KeyError, IndexError, TypeError) as e:
+                raise KeyError(f"无法解析变量引用 '${{{var_ref}}}': {str(e)}")
+
         return result
-    
+
+    def _parse_variable_path(self, var_ref: str):
+        """解析复杂的变量访问路径
+
+        支持的语法：
+        - variable
+        - object.property
+        - array[0]
+        - dict["key"]
+        - users[0].name
+        - data["users"][0]["name"]
+
+        Args:
+            var_ref: 变量引用路径，如 "users[0].name"
+
+        Returns:
+            解析后的变量值
+
+        Raises:
+            KeyError: 当变量不存在时
+            IndexError: 当数组索引超出范围时
+            TypeError: 当类型不匹配时
+        """
+        # 解析访问路径
+        path_parts = self._tokenize_path(var_ref)
+
+        # 获取根变量
+        root_var_name = path_parts[0]
+        try:
+            current_value = self.get_variable(root_var_name)
+        except KeyError:
+            raise KeyError(f"变量 '{root_var_name}' 不存在")
+
+        # 逐步访问路径
+        for part in path_parts[1:]:
+            current_value = self._access_value(current_value, part, root_var_name)
+
+        return current_value
+
+    def _tokenize_path(self, var_ref: str) -> list:
+        """将变量路径分解为访问令牌
+
+        例如：
+        - "users[0].name" -> ["users", "[0]", "name"]
+        - "data['key'].items[1]" -> ["data", "['key']", "items", "[1]"]
+
+        Args:
+            var_ref: 变量引用路径
+
+        Returns:
+            访问令牌列表
+        """
+        tokens = []
+        current_token = ""
+        i = 0
+
+        while i < len(var_ref):
+            char = var_ref[i]
+
+            if char == '.':
+                if current_token:
+                    tokens.append(current_token)
+                    current_token = ""
+            elif char == '[':
+                if current_token:
+                    tokens.append(current_token)
+                    current_token = ""
+
+                # 找到匹配的右括号
+                bracket_count = 1
+                bracket_content = "["
+                i += 1
+
+                while i < len(var_ref) and bracket_count > 0:
+                    char = var_ref[i]
+                    bracket_content += char
+                    if char == '[':
+                        bracket_count += 1
+                    elif char == ']':
+                        bracket_count -= 1
+                    i += 1
+
+                tokens.append(bracket_content)
+                i -= 1  # 回退一位，因为外层循环会自增
+            else:
+                current_token += char
+
+            i += 1
+
+        if current_token:
+            tokens.append(current_token)
+
+        return tokens
+
+    def _access_value(self, current_value, access_token: str, root_var_name: str):
+        """根据访问令牌获取值
+
+        Args:
+            current_value: 当前值
+            access_token: 访问令牌，如 "name", "[0]", "['key']"
+            root_var_name: 根变量名（用于错误信息）
+
+        Returns:
+            访问后的值
+
+        Raises:
+            KeyError: 当键不存在时
+            IndexError: 当索引超出范围时
+            TypeError: 当类型不匹配时
+        """
+        if access_token.startswith('[') and access_token.endswith(']'):
+            # 数组索引或字典键访问
+            key_content = access_token[1:-1].strip()
+
+            # 处理字符串键（带引号）
+            if (key_content.startswith('"') and key_content.endswith('"')) or \
+               (key_content.startswith("'") and key_content.endswith("'")):
+                key = key_content[1:-1]  # 去掉引号
+                if isinstance(current_value, dict):
+                    if key not in current_value:
+                        raise KeyError(f"字典中不存在键 '{key}'")
+                    return current_value[key]
+                else:
+                    raise TypeError(f"无法在 {type(current_value).__name__} 类型上使用字符串键访问")
+
+            # 处理数字索引
+            try:
+                index = int(key_content)
+                if isinstance(current_value, (list, tuple)):
+                    if index >= len(current_value) or index < -len(current_value):
+                        raise IndexError(f"数组索引 {index} 超出范围，数组长度为 {len(current_value)}")
+                    return current_value[index]
+                elif isinstance(current_value, dict):
+                    # 字典也可以用数字键
+                    str_key = str(index)
+                    if str_key not in current_value and index not in current_value:
+                        raise KeyError(f"字典中不存在键 '{index}' 或 '{str_key}'")
+                    return current_value.get(index, current_value.get(str_key))
+                else:
+                    raise TypeError(f"无法在 {type(current_value).__name__} 类型上使用索引访问")
+            except ValueError:
+                raise ValueError(f"无效的索引格式: '{key_content}'")
+
+        else:
+            # 属性访问（点号语法）
+            if isinstance(current_value, dict) and access_token in current_value:
+                return current_value[access_token]
+            else:
+                raise KeyError(f"无法访问属性 '{access_token}'，当前值类型是 {type(current_value).__name__}")
+
     def replace_in_dict(self, data: Dict[str, Any]) -> Dict[str, Any]:
         """递归替换字典中的变量引用
-        
+
         Args:
             data: 包含变量引用的字典
-            
+
         Returns:
             替换后的字典
-            
+
         Raises:
             KeyError: 当变量不存在时
         """
         if not isinstance(data, dict):
             return data
-            
+
         result = {}
         for key, value in data.items():
             # 替换键中的变量
@@ -162,35 +307,35 @@ class VariableReplacer:
             # 替换值中的变量
             new_value = self.replace_in_value(value)
             result[new_key] = new_value
-            
+
         return result
-    
+
     def replace_in_list(self, data: List[Any]) -> List[Any]:
         """递归替换列表中的变量引用
-        
+
         Args:
             data: 包含变量引用的列表
-            
+
         Returns:
             替换后的列表
-            
+
         Raises:
             KeyError: 当变量不存在时
         """
         if not isinstance(data, list):
             return data
-            
+
         return [self.replace_in_value(item) for item in data]
-    
+
     def replace_in_value(self, value: Any) -> Any:
         """递归替换任意值中的变量引用
-        
+
         Args:
             value: 任意值，可能是字符串、字典、列表等
-            
+
         Returns:
             替换后的值
-            
+
         Raises:
             KeyError: 当变量不存在时
         """
@@ -217,16 +362,16 @@ class VariableReplacer:
                 return value
             except:
                 return value
-    
+
     def replace_in_json(self, json_str: str) -> str:
         """替换JSON字符串中的变量引用
-        
+
         Args:
             json_str: 包含变量引用的JSON字符串
-            
+
         Returns:
             替换后的JSON字符串
-            
+
         Raises:
             KeyError: 当变量不存在时
             json.JSONDecodeError: 当JSON解析失败时
@@ -241,16 +386,16 @@ class VariableReplacer:
         except json.JSONDecodeError:
             # 如果JSON解析失败，直接作为字符串处理
             return self.replace_in_string(json_str)
-    
+
     def replace_in_yaml(self, yaml_str: str) -> str:
         """替换YAML字符串中的变量引用
-        
+
         Args:
             yaml_str: 包含变量引用的YAML字符串
-            
+
         Returns:
             替换后的YAML字符串
-            
+
         Raises:
             KeyError: 当变量不存在时
         """
@@ -264,4 +409,4 @@ class VariableReplacer:
             return yaml.dump(replaced_data, allow_unicode=True)
         except:
             # 如果YAML解析失败，直接作为字符串处理
-            return self.replace_in_string(yaml_str) 
+            return self.replace_in_string(yaml_str)

pytest_dsl/core/yaml_loader.py

@@ -10,7 +10,7 @@ from pytest_dsl.core.yaml_vars import yaml_vars
 
 def add_yaml_options(parser):
     """添加YAML变量相关的命令行参数选项
-    
+
     Args:
         parser: pytest命令行参数解析器
     """
@@ -29,34 +29,111 @@ def add_yaml_options(parser):
     )
 
 
-def load_yaml_variables(config):
-    """加载YAML变量文件
-    
-    从命令行参数指定的文件和目录加载YAML变量。
-    
+def load_yaml_variables_from_args(yaml_files=None, yaml_vars_dir=None, project_root=None):
+    """从参数加载YAML变量文件（通用函数）
+
     Args:
-        config: pytest配置对象
+        yaml_files: YAML文件列表
+        yaml_vars_dir: YAML变量目录路径
+        project_root: 项目根目录（用于默认config目录）
     """
     # 加载单个YAML文件
-    yaml_files = config.getoption('--yaml-vars')
     if yaml_files:
         yaml_vars.load_yaml_files(yaml_files)
         print(f"已加载YAML变量文件: {', '.join(yaml_files)}")
 
     # 加载目录中的YAML文件
-    yaml_vars_dir = config.getoption('--yaml-vars-dir')
-    if yaml_vars_dir is None:
-        # 默认使用使用者项目根目录下的config目录
-        # 通过pytest的rootdir获取使用者的项目根目录
-        project_root = config.rootdir
-        yaml_vars_dir = str(project_root / 'config')
+    if yaml_vars_dir is None and project_root:
+        # 默认使用项目根目录下的config目录
+        yaml_vars_dir = str(Path(project_root) / 'config')
         print(f"使用默认YAML变量目录: {yaml_vars_dir}")
-    
-    if Path(yaml_vars_dir).exists():
+
+    if yaml_vars_dir and Path(yaml_vars_dir).exists():
         yaml_vars.load_from_directory(yaml_vars_dir)
         print(f"已加载YAML变量目录: {yaml_vars_dir}")
         loaded_files = yaml_vars.get_loaded_files()
         if loaded_files:
-            print(f"目录中加载的文件: {', '.join(loaded_files)}")
-    else:
-        print(f"YAML变量目录不存在: {yaml_vars_dir}")
+            # 过滤出当前目录的文件
+            if 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:
+                print(f"加载的文件: {', '.join(loaded_files)}")
+    elif yaml_vars_dir:
+        print(f"YAML变量目录不存在: {yaml_vars_dir}")
+
+    # 加载完YAML变量后，自动连接远程服务器
+    load_remote_servers_from_yaml()
+
+
+def load_yaml_variables(config):
+    """加载YAML变量文件（pytest插件接口）
+
+    从pytest配置对象中获取命令行参数并加载YAML变量。
+
+    Args:
+        config: pytest配置对象
+    """
+    # 获取命令行参数
+    yaml_files = config.getoption('--yaml-vars')
+    yaml_vars_dir = config.getoption('--yaml-vars-dir')
+    project_root = config.rootdir
+
+    # 调用通用加载函数
+    load_yaml_variables_from_args(
+        yaml_files=yaml_files,
+        yaml_vars_dir=yaml_vars_dir,
+        project_root=project_root
+    )
+
+
+def load_remote_servers_from_yaml():
+    """从YAML配置中自动加载远程服务器
+
+    检查YAML变量中是否包含remote_servers配置，如果有则自动连接这些服务器。
+    """
+    try:
+        # 获取远程服务器配置
+        remote_servers_config = yaml_vars.get_variable('remote_servers')
+        if not remote_servers_config:
+            
+            return
+
+        print(f"发现 {len(remote_servers_config)} 个远程服务器配置")
+
+        # 导入远程关键字管理器
+        from pytest_dsl.remote.keyword_client import remote_keyword_manager
+
+        # 遍历配置并连接服务器
+        for server_name, server_config in remote_servers_config.items():
+            try:
+                url = server_config.get('url')
+                alias = server_config.get('alias', server_name)
+                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)}")
+
+    except Exception as e:
+        print(f"加载远程服务器配置时发生错误: {str(e)}")

pytest_dsl/examples/assert/assertion_example.auto

@@ -39,6 +39,6 @@ username = [JSON提取],JSON数据:${json_data},JSONPath:'$.user.name',变量名
 bool_value = True
 [断言],条件:'${bool_value} == True',消息:'布尔值断言失败'
 
-@teardown do
+teardown do
     [打印],内容:'所有断言测试通过!'
 end 

pytest_dsl/examples/assert/boolean_test.auto

@@ -29,6 +29,6 @@ bool_true = True
 bool_false = False
 [断言],条件:'${bool_true} and not ${bool_false}',消息:'变量布尔值表达式断言失败'
 
-@teardown do
+teardown do
     [打印],内容:'所有布尔值断言测试通过!'
-end 
+end

pytest_dsl/examples/assert/expression_test.auto

@@ -44,6 +44,6 @@ text = "Hello, World!"
 [数据比较],实际值:'10 + 10',预期值:20,消息:'数据比较表达式失败'
 [数据比较],实际值:'len("Hello")',预期值:5,消息:'函数表达式比较失败'
 
-@teardown do
+teardown do
     [打印],内容:'所有表达式断言测试通过!'
 end 

pytest_dsl/examples/custom/test_advanced_keywords.auto

@@ -26,6 +26,6 @@
 # 不进行复杂断言，只确认返回结果不为空
 [断言],条件:'${报告结果} != ""',消息:'报告结果不应为空'
 
-@teardown do
+teardown do
     [打印],内容:'高级自定义关键字测试完成'
-end 
+end

pytest_dsl/examples/custom/test_custom_keywords.auto

@@ -32,6 +32,6 @@
 
 [断言],条件:'${文本长度} == 10',消息:'长度不匹配'
 
-@teardown do
+teardown do
     [打印],内容:'自定义关键字测试完成'
-end 
+end

pytest_dsl/examples/custom/test_default_values.auto

@@ -29,6 +29,6 @@
 报告结果1 = [生成报告消息],标题:"仅标题测试"
 [打印],内容:'使用默认内容的报告:\n${报告结果1}'
 
-@teardown do
+teardown do
     [打印],内容:'默认值测试完成'
-end 
+end

pytest_dsl/examples/http/file_reference_test.auto

@@ -106,6 +106,6 @@ current_date = "2024-04-08T12:00:00Z"
 
 [打印],内容:'请求JSON已合并: ${request_json}'
 
-@teardown do
+teardown do
     [打印],内容:'外部文件引用测试完成!'
 end 

pytest_dsl/examples/http/http_advanced.auto

@@ -86,6 +86,6 @@
 
 [打印],内容:'段落文本: ${p_text}'
 
-@teardown do
+teardown do
     [打印],内容:'HTTP高级测试完成!'
 end 

pytest_dsl/examples/http/http_example.auto

@@ -142,6 +142,6 @@
 [打印],内容:'获取的随机数: ${random_number}'
 [打印],内容:'断言重试测试完成!'
 
-@teardown do
+teardown do
     [打印],内容:'HTTP请求测试完成!'
 end 

pytest_dsl/examples/http/http_length_test.auto

@@ -50,6 +50,6 @@
 [打印],内容:'正文: ${body}'
 [打印],内容:'正文长度: ${body_length}'
 
-@teardown do
+teardown do
     [打印],内容:'HTTP请求长度捕获测试完成!'
 end 

pytest_dsl/examples/http/http_retry_assertions.auto

@@ -86,6 +86,6 @@
             all: true  # 重试所有断言
     ''',步骤名称:"全局断言重试示例"
 
-@teardown do
+teardown do
     [打印],内容:'断言重试测试完成!'
 end