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

pytest_dsl/keywords/http_keywords.py

@@ -18,15 +18,15 @@ from pytest_dsl.core.context import TestContext
 
 def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: bool = True, test_context: TestContext = None) -> Any:
     """处理文件引用，加载外部文件内容
-    
+
     支持两种语法:
     1. 简单语法: "@file:/path/to/file.json" 或 "@file_template:/path/to/file.json"
     2. 详细语法: 使用file_ref结构提供更多的配置选项
-    
+
     Args:
         reference: 文件引用字符串或配置字典
         allow_vars: 是否允许在文件内容中替换变量
-        
+
     Returns:
         加载并处理后的文件内容
     """
@@ -35,16 +35,16 @@ def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: b
         # 匹配简单文件引用语法
         file_ref_pattern = r'^@file(?:_template)?:(.+)$'
         match = re.match(file_ref_pattern, reference.strip())
-        
+
         if match:
             file_path = match.group(1).strip()
             is_template = '_template' in reference[:15]  # 检查是否为模板
             return _load_file_content(file_path, is_template, 'auto', 'utf-8', test_context)
-    
+
     # 处理详细语法
     elif isinstance(reference, dict) and 'file_ref' in reference:
         file_ref = reference['file_ref']
-        
+
         if isinstance(file_ref, str):
             # 如果file_ref是字符串，使用默认配置
             return _load_file_content(file_ref, allow_vars, 'auto', 'utf-8', test_context)
@@ -53,44 +53,44 @@ def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: b
             file_path = file_ref.get('path')
             if not file_path:
                 raise ValueError("file_ref必须包含path字段")
-                
+
             template = file_ref.get('template', allow_vars)
             file_type = file_ref.get('type', 'auto')
             encoding = file_ref.get('encoding', 'utf-8')
-            
+
             return _load_file_content(file_path, template, file_type, encoding, test_context)
-    
+
     # 如果不是文件引用，返回原始值
     return reference
 
 
-def _load_file_content(file_path: str, is_template: bool = False, 
+def _load_file_content(file_path: str, is_template: bool = False,
                        file_type: str = 'auto', encoding: str = 'utf-8', test_context: TestContext = None) -> Any:
     """加载文件内容
-    
+
     Args:
         file_path: 文件路径
         is_template: 是否作为模板处理（替换变量引用）
         file_type: 文件类型 (auto, json, yaml, text)
         encoding: 文件编码
-        
+
     Returns:
         加载并处理后的文件内容
     """
     # 验证文件存在
     if not os.path.exists(file_path):
         raise FileNotFoundError(f"找不到引用的文件: {file_path}")
-    
+
     # 读取文件内容
     with open(file_path, 'r', encoding=encoding) as f:
         content = f.read()
-    
+
     # 如果是模板，处理变量替换
     if is_template:
         from pytest_dsl.core.variable_utils import VariableReplacer
         replacer = VariableReplacer(test_context=test_context)
         content = replacer.replace_in_string(content)
-    
+
     # 根据文件类型处理内容
     if file_type == 'auto':
         # 根据文件扩展名自动检测类型
@@ -101,7 +101,7 @@ def _load_file_content(file_path: str, is_template: bool = False,
             file_type = 'yaml'
         else:
             file_type = 'text'
-    
+
     # 处理不同类型的文件
     if file_type == 'json':
         try:
@@ -120,46 +120,46 @@ def _load_file_content(file_path: str, is_template: bool = False,
 
 def _process_request_config(config: Dict[str, Any], test_context: TestContext = None) -> Dict[str, Any]:
     """处理请求配置，检查并处理文件引用
-    
+
     Args:
         config: 请求配置
-        
+
     Returns:
         处理后的请求配置
     """
     if not isinstance(config, dict):
         return config
-    
+
     # 处理request部分
     if 'request' in config and isinstance(config['request'], dict):
         request = config['request']
-        
+
         # 处理json字段
         if 'json' in request:
             request['json'] = _process_file_reference(request['json'], test_context=test_context)
-            
+
         # 处理data字段
         if 'data' in request:
             request['data'] = _process_file_reference(request['data'], test_context=test_context)
-            
+
         # 处理headers字段
         if 'headers' in request:
             request['headers'] = _process_file_reference(request['headers'], test_context=test_context)
-    
+
     return config
 
 
 def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interval=None):
     """标准化断言重试配置
-    
+
     将不同来源的重试配置（命令行参数、retry配置、retry_assertions配置）
     统一转换为标准化的重试配置对象。
-    
+
     Args:
         config: 原始配置字典
         assert_retry_count: 命令行级别的重试次数参数
         assert_retry_interval: 命令行级别的重试间隔参数
-        
+
     Returns:
         标准化的重试配置字典，格式为:
         {
@@ -180,7 +180,7 @@ def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interv
         'indices': [],       # 默认不指定要重试的断言索引
         'specific': {}       # 默认不指定特定断言的重试配置
     }
-    
+
     # 处理命令行参数
     if assert_retry_count and int(assert_retry_count) > 0:
         standard_retry_config['enabled'] = True
@@ -188,12 +188,12 @@ def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interv
         standard_retry_config['all'] = True  # 命令行参数会重试所有断言
         if assert_retry_interval:
             standard_retry_config['interval'] = float(assert_retry_interval)
-    
+
     # 处理专用retry_assertions配置
     if 'retry_assertions' in config and config['retry_assertions']:
         retry_assertions = config['retry_assertions']
         standard_retry_config['enabled'] = True
-        
+
         if 'count' in retry_assertions:
             standard_retry_config['count'] = retry_assertions['count']
         if 'interval' in retry_assertions:
@@ -204,7 +204,7 @@ def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interv
             standard_retry_config['indices'] = retry_assertions['indices']
         if 'specific' in retry_assertions:
             standard_retry_config['specific'] = retry_assertions['specific']
-    
+
     # 处理传统retry配置（如果专用配置不存在）
     elif 'retry' in config and config['retry']:
         retry_config = config['retry']
@@ -214,7 +214,7 @@ def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interv
             standard_retry_config['all'] = True  # 传统配置会重试所有断言
             if 'interval' in retry_config:
                 standard_retry_config['interval'] = retry_config['interval']
-    
+
     return standard_retry_config
 
 
@@ -231,9 +231,9 @@ def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interv
 ])
 def http_request(context, **kwargs):
     """执行HTTP请求
-    
+
     根据YAML配置发送HTTP请求，支持客户端配置、会话管理、响应捕获和断言。
-    
+
     Args:
         context: 测试上下文
         client: 客户端名称
@@ -245,7 +245,7 @@ def http_request(context, **kwargs):
         template: 模板名称
         assert_retry_count: 断言失败时的重试次数
         assert_retry_interval: 断言重试间隔时间（秒）
-        
+
     Returns:
         捕获的变量字典或响应对象
     """
@@ -258,17 +258,17 @@ def http_request(context, **kwargs):
     template_name = kwargs.get('template')
     assert_retry_count = kwargs.get('assert_retry_count')
     assert_retry_interval = kwargs.get('assert_retry_interval')
-    
+
     with allure.step(f"发送HTTP请求 (客户端: {client_name}{', 会话: ' + session_name if session_name else ''})"):
         # 处理模板
         if template_name:
             # 从YAML变量中获取模板
             http_templates = yaml_vars.get_variable("http_templates") or {}
             template = http_templates.get(template_name)
-            
+
             if not template:
                 raise ValueError(f"未找到名为 '{template_name}' 的HTTP请求模板")
-            
+
             # 解析配置并合并模板
             if isinstance(config, str):
                 # 先进行变量替换，再解析YAML
@@ -277,7 +277,7 @@ def http_request(context, **kwargs):
                 config = replacer.replace_in_string(config)
                 try:
                     user_config = yaml.safe_load(config) if config else {}
-                    
+
                     # 深度合并
                     merged_config = _deep_merge(template.copy(), user_config)
                     config = merged_config
@@ -289,7 +289,7 @@ def http_request(context, **kwargs):
                 from pytest_dsl.core.variable_utils import VariableReplacer
                 replacer = VariableReplacer(test_context=context)
                 config = replacer.replace_in_string(config)
-        
+
         # 解析YAML配置
         if isinstance(config, str):
             try:
@@ -299,7 +299,7 @@ def http_request(context, **kwargs):
 
         # 统一处理重试配置
         retry_config = _normalize_retry_config(config, assert_retry_count, assert_retry_interval)
-        
+
         # 为了兼容性，将标准化后的重试配置写回到配置中
         if retry_config['enabled']:
             config['retry_assertions'] = {
@@ -309,22 +309,22 @@ def http_request(context, **kwargs):
                 'indices': retry_config['indices'],
                 'specific': retry_config['specific']
             }
-        
+
         config = _process_request_config(config, test_context=context)
-        
+
         # 创建HTTP请求对象
         http_req = HTTPRequest(config, client_name, session_name)
-        
+
         # 执行请求
         response = http_req.execute()
-        
+
         # 处理捕获
         captured_values = http_req.captured_values
-        
+
         # 将捕获的变量注册到上下文
         for var_name, value in captured_values.items():
             context.set(var_name, value)
-        
+
         # 保存完整响应（如果需要）
         if save_response:
             context.set(save_response, response)
@@ -337,18 +337,18 @@ def http_request(context, **kwargs):
             else:
                 # 不需要重试，直接断言
                 http_req.process_asserts()
-        
+
         # 返回捕获的变量
         return captured_values
 
 
 def _deep_merge(dict1, dict2):
     """深度合并两个字典
-    
+
     Args:
         dict1: 基础字典（会被修改）
         dict2: 要合并的字典（优先级更高）
-        
+
     Returns:
         合并后的字典
     """
@@ -362,7 +362,7 @@ def _deep_merge(dict1, dict2):
 
 def _process_assertions_with_unified_retry(http_req, retry_config):
     """使用统一的重试配置处理断言
-    
+
     Args:
         http_req: HTTP请求对象
         retry_config: 标准化的重试配置
@@ -379,21 +379,21 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
             name="断言验证失败详情",
             attachment_type=allure.attachment_type.TEXT
         )
-        
+
         # 添加一个特殊的标记到配置中，表示我们只想收集失败的断言而不抛出异常
         original_config = http_req.config.copy() if isinstance(http_req.config, dict) else {}
-        
+
         # 创建一个临时副本
         temp_config = original_config.copy()
-        
+
         # 添加特殊标记，用于指示http_request.py中的process_asserts在处理fail时不抛出异常
         # 注意：这需要对应修改HTTPRequest.process_asserts方法
         temp_config['_collect_failed_assertions_only'] = True
-        
+
         try:
             # 临时替换配置
             http_req.config = temp_config
-            
+
             # 重新运行断言，这次只收集失败的断言而不抛出异常
             _, failed_retryable_assertions = http_req.process_asserts()
         except Exception as collect_err:
@@ -407,23 +407,23 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
         finally:
             # 恢复原始配置
             http_req.config = original_config
-            
+
         # 有断言失败，判断是否有需要重试的断言
         if not failed_retryable_assertions:
             # 没有可重试的断言，重新抛出原始异常
             raise
-        
+
         # 过滤需要重试的断言
         retryable_assertions = []
-        
+
         for failed_assertion in failed_retryable_assertions:
             assertion_idx = failed_assertion['index']
-            
+
             # 判断该断言是否应该重试
             should_retry = False
             specific_retry_count = retry_config['count']
             specific_retry_interval = retry_config['interval']
-            
+
             # 检查特定断言配置
             if str(assertion_idx) in retry_config['specific']:
                 should_retry = True
@@ -439,39 +439,39 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
             # 检查是否重试所有
             elif retry_config['all']:
                 should_retry = True
-            
+
             # 如果应该重试，添加到可重试断言列表
             if should_retry:
                 # 添加重试配置到断言对象
                 failed_assertion['retry_count'] = specific_retry_count
                 failed_assertion['retry_interval'] = specific_retry_interval
                 retryable_assertions.append(failed_assertion)
-        
+
         # 如果没有可重试的断言，重新抛出异常
         if not retryable_assertions:
             raise
-        
+
         # 记录哪些断言会被重试
         retry_info = "\n".join([
-            f"{i+1}. {a['type']} " + 
-            (f"[{a['path']}]" if a['path'] else "") + 
-            f": 重试 {a['retry_count']} 次，间隔 {a['retry_interval']} 秒" 
+            f"{i+1}. {a['type']} " +
+            (f"[{a['path']}]" if a['path'] else "") +
+            f": 重试 {a['retry_count']} 次，间隔 {a['retry_interval']} 秒"
             for i, a in enumerate(retryable_assertions)
         ])
-        
+
         allure.attach(
             f"找到 {len(retryable_assertions)} 个可重试的断言:\n\n{retry_info}",
             name="重试断言列表",
             attachment_type=allure.attachment_type.TEXT
         )
-        
+
         # 开始重试循环
         max_retry_count = retry_config['count']
-        
+
         # 找出所有断言中最大的重试次数
         for retryable_assertion in retryable_assertions:
             max_retry_count = max(max_retry_count, retryable_assertion.get('retry_count', 3))
-        
+
         # 进行断言重试
         for attempt in range(1, max_retry_count + 1):  # 从1开始，因为第0次已经尝试过了
             # 等待重试间隔
@@ -480,41 +480,41 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
                 retry_interval = retry_config['interval']
                 for assertion in retryable_assertions:
                     retry_interval = max(retry_interval, assertion.get('retry_interval', 1.0))
-                
+
                 allure.attach(
                     f"重试 {len(retryable_assertions)} 个断言\n"
                     f"等待间隔: {retry_interval}秒",
                     name="断言重试信息",
                     attachment_type=allure.attachment_type.TEXT
                 )
-                
+
                 time.sleep(retry_interval)
-                
+
                 # 重新发送请求
                 http_req.execute()
-                
+
                 # 过滤出仍在重试范围内的断言
                 still_retryable_assertions = []
                 for assertion in retryable_assertions:
                     assertion_retry_count = assertion.get('retry_count', 3)
-                    
+
                     # 如果断言的重试次数大于当前尝试次数，继续重试该断言
                     if attempt < assertion_retry_count:
                         still_retryable_assertions.append(assertion)
-                
+
                 # 如果没有可以继续重试的断言，跳出循环
                 if not still_retryable_assertions:
                     break
-                
+
                 # 只重试那些仍在重试范围内的断言
                 try:
                     # 从原始断言配置中提取出需要重试的断言
                     retry_assertion_indexes = [a['index'] for a in still_retryable_assertions]
                     retry_assertions = [http_req.config.get('asserts', [])[idx] for idx in retry_assertion_indexes]
-                    
+
                     # 只处理需要重试的断言
                     results, new_failed_assertions = http_req.process_asserts(specific_asserts=retry_assertions)
-                    
+
                     # 如果所有断言都通过了，检查全部断言
                     if not new_failed_assertions:
                         # 执行一次完整的断言检查，确保所有断言都通过
@@ -534,10 +534,10 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
                                 attachment_type=allure.attachment_type.TEXT
                             )
                             continue
-                    
+
                     # 更新失败的可重试断言列表
                     retryable_assertions = new_failed_assertions
-                    
+
                 except AssertionError as retry_err:
                     # 重试时断言失败，记录后继续重试
                     allure.attach(
@@ -546,7 +546,7 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
                         attachment_type=allure.attachment_type.TEXT
                     )
                     continue
-        
+
         # 重试次数用完，执行一次完整的断言以获取最终结果和错误
         # 这会抛出异常，如果仍然有断言失败
         allure.attach(
@@ -554,7 +554,7 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
             name="重试完成",
             attachment_type=allure.attachment_type.TEXT
         )
-        
+
         try:
             results, _ = http_req.process_asserts()
             return results
@@ -575,7 +575,7 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
 # 以下函数保留用于向后兼容，但内部逻辑已更改为调用统一重试函数
 def _process_assertions_with_retry(http_req, retry_count, retry_interval):
     """处理断言并支持重试（向后兼容函数）
-    
+
     Args:
         http_req: HTTP请求对象
         retry_count: 重试次数
@@ -590,20 +590,20 @@ def _process_assertions_with_retry(http_req, retry_count, retry_interval):
         'indices': [],
         'specific': {}
     }
-    
+
     # 使用统一的重试处理函数
     return _process_assertions_with_unified_retry(http_req, retry_config)
 
 
 def _process_config_based_assertions_with_retry(http_req):
     """基于配置处理断言重试（向后兼容函数）
-    
+
     Args:
         http_req: HTTP请求对象
     """
     # 从配置中获取重试信息
     retry_assertions_config = http_req.config.get('retry_assertions', {})
-    
+
     # 创建统一的重试配置
     retry_config = {
         'enabled': True,
@@ -613,6 +613,6 @@ def _process_config_based_assertions_with_retry(http_req):
         'indices': retry_assertions_config.get('indices', []),
         'specific': retry_assertions_config.get('specific', {})
     }
-    
+
     # 使用统一的重试处理函数
-    return _process_assertions_with_unified_retry(http_req, retry_config) 
+    return _process_assertions_with_unified_retry(http_req, retry_config)