pytest-dsl 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

pytest_dsl/keywords/http_keywords.py

@@ -20,7 +20,10 @@ from pytest_dsl.core.context import TestContext
 # 配置日志
 logger = logging.getLogger(__name__)
 
-def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: bool = True, test_context: TestContext = None) -> Any:
+
+def _process_file_reference(reference: Union[str, Dict[str, Any]],
+                            allow_vars: bool = True,
+                            test_context: TestContext = None) -> Any:
     """处理文件引用，加载外部文件内容
 
     支持两种语法:
@@ -43,7 +46,8 @@ def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: b
         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)
+            return _load_file_content(file_path, is_template, 'auto', 'utf-8',
+                                      test_context)
 
     # 处理详细语法
     elif isinstance(reference, dict) and 'file_ref' in reference:
@@ -51,7 +55,8 @@ def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: b
 
         if isinstance(file_ref, str):
             # 如果file_ref是字符串，使用默认配置
-            return _load_file_content(file_ref, allow_vars, 'auto', 'utf-8', test_context)
+            return _load_file_content(file_ref, allow_vars, 'auto', 'utf-8',
+                                      test_context)
         elif isinstance(file_ref, dict):
             # 如果file_ref是字典，使用自定义配置
             file_path = file_ref.get('path')
@@ -62,14 +67,16 @@ def _process_file_reference(reference: Union[str, Dict[str, Any]], allow_vars: b
             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 _load_file_content(file_path, template, file_type, encoding,
+                                      test_context)
 
     # 如果不是文件引用，返回原始值
     return reference
 
 
 def _load_file_content(file_path: str, is_template: bool = False,
-                       file_type: str = 'auto', encoding: str = 'utf-8', test_context: TestContext = None) -> Any:
+                       file_type: str = 'auto', encoding: str = 'utf-8',
+                       test_context: TestContext = None) -> Any:
     """加载文件内容
 
     Args:
@@ -122,7 +129,8 @@ def _load_file_content(file_path: str, is_template: bool = False,
         return content
 
 
-def _process_request_config(config: Dict[str, Any], test_context: TestContext = None) -> Dict[str, Any]:
+def _process_request_config(config: Dict[str, Any],
+                            test_context: TestContext = None) -> Dict[str, Any]:
     """处理请求配置，检查并处理文件引用
 
     Args:
@@ -140,20 +148,24 @@ def _process_request_config(config: Dict[str, Any], test_context: TestContext =
 
         # 处理json字段
         if 'json' in request:
-            request['json'] = _process_file_reference(request['json'], test_context=test_context)
+            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)
+            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)
+            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):
+def _normalize_retry_config(config, assert_retry_count=None,
+                            assert_retry_interval=None):
     """标准化断言重试配置
 
     将不同来源的重试配置（命令行参数、retry配置、retry_assertions配置）
@@ -223,14 +235,23 @@ def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interv
 
 
 @keyword_manager.register('HTTP请求', [
-    {'name': '客户端', 'mapping': 'client', 'description': '客户端名称，对应YAML变量文件中的客户端配置', 'default': 'default'},
-    {'name': '配置', 'mapping': 'config', 'description': '包含请求、捕获和断言的YAML配置'},
-    {'name': '会话', 'mapping': 'session', 'description': '会话名称，用于在多个请求间保持会话状态'},
-    {'name': '保存响应', 'mapping': 'save_response', 'description': '将完整响应保存到指定变量名中'},
-    {'name': '禁用授权', 'mapping': 'disable_auth', 'description': '禁用客户端配置中的授权机制', 'default': False},
-    {'name': '模板', 'mapping': 'template', 'description': '使用YAML变量文件中定义的请求模板'},
-    {'name': '断言重试次数', 'mapping': 'assert_retry_count', 'description': '断言失败时的重试次数', 'default': 0},
-    {'name': '断言重试间隔', 'mapping': 'assert_retry_interval', 'description': '断言重试间隔时间（秒）', 'default': 1}
+    {'name': '客户端', 'mapping': 'client',
+     'description': '客户端名称，对应YAML变量文件中的客户端配置',
+     'default': 'default'},
+    {'name': '配置', 'mapping': 'config',
+     'description': '包含请求、捕获和断言的YAML配置'},
+    {'name': '会话', 'mapping': 'session',
+     'description': '会话名称，用于在多个请求间保持会话状态'},
+    {'name': '保存响应', 'mapping': 'save_response',
+     'description': '将完整响应保存到指定变量名中'},
+    {'name': '禁用授权', 'mapping': 'disable_auth',
+     'description': '禁用客户端配置中的授权机制', 'default': False},
+    {'name': '模板', 'mapping': 'template',
+     'description': '使用YAML变量文件中定义的请求模板'},
+    {'name': '断言重试次数', 'mapping': 'assert_retry_count',
+     'description': '断言失败时的重试次数', 'default': 0},
+    {'name': '断言重试间隔', 'mapping': 'assert_retry_interval',
+     'description': '断言重试间隔时间（秒）', 'default': 1}
 ])
 def http_request(context, **kwargs):
     """执行HTTP请求
@@ -260,7 +281,26 @@ def http_request(context, **kwargs):
     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 ''})"):
+    # 添加调试信息，检查客户端配置是否可用
+    print(f"🌐 HTTP请求 - 客户端: {client_name}")
+
+    # 检查YAML变量中的http_clients配置（现在包含同步的变量）
+    http_clients_config = yaml_vars.get_variable("http_clients")
+    if http_clients_config:
+        print(f"✓ 找到http_clients配置，包含 {len(http_clients_config)} 个客户端")
+        if client_name in http_clients_config:
+            print(f"✓ 找到客户端 '{client_name}' 的配置")
+            client_config = http_clients_config[client_name]
+            print(f"  - base_url: {client_config.get('base_url', 'N/A')}")
+            print(f"  - timeout: {client_config.get('timeout', 'N/A')}")
+        else:
+            print(f"⚠️ 未找到客户端 '{client_name}' 的配置")
+            print(f"  可用客户端: {list(http_clients_config.keys())}")
+    else:
+        print("⚠️ 未找到http_clients配置")
+
+    with allure.step(f"发送HTTP请求 (客户端: {client_name}"
+                     f"{', 会话: ' + session_name if session_name else ''})"):
         # 处理模板
         if template_name:
             # 从YAML变量中获取模板
@@ -299,7 +339,8 @@ def http_request(context, **kwargs):
                 raise ValueError(f"无效的YAML配置: {str(e)}")
 
         # 统一处理重试配置
-        retry_config = _normalize_retry_config(config, assert_retry_count, assert_retry_interval)
+        retry_config = _normalize_retry_config(config, assert_retry_count,
+                                               assert_retry_interval)
 
         # 为了兼容性，将标准化后的重试配置写回到配置中
         if retry_config['enabled']:
@@ -344,7 +385,8 @@ def http_request(context, **kwargs):
         if session_name:
             try:
                 from pytest_dsl.core.http_client import http_client_manager
-                session_client = http_client_manager.get_session(session_name, client_name)
+                session_client = http_client_manager.get_session(
+                    session_name, client_name)
                 if session_client and session_client._session:
                     session_state = {
                         "cookies": dict(session_client._session.cookies),
@@ -375,7 +417,8 @@ def http_request(context, **kwargs):
         return {
             "result": captured_values,  # 主要返回值保持兼容
             "captures": captured_values,  # 明确的捕获变量
-            "session_state": {session_name: session_state} if session_state else {},
+            "session_state": ({session_name: session_state}
+                              if session_state else {}),
             "response": response_data,  # 完整响应（如果需要）
             "metadata": {
                 "response_time": getattr(response, 'elapsed', None),
@@ -396,7 +439,8 @@ def _deep_merge(dict1, dict2):
         合并后的字典
     """
     for key in dict2:
-        if key in dict1 and isinstance(dict1[key], dict) and isinstance(dict2[key], dict):
+        if (key in dict1 and isinstance(dict1[key], dict) and
+                isinstance(dict2[key], dict)):
             _deep_merge(dict1[key], dict2[key])
         else:
             dict1[key] = dict2[key]
@@ -424,7 +468,8 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
         )
 
         # 添加一个特殊的标记到配置中，表示我们只想收集失败的断言而不抛出异常
-        original_config = http_req.config.copy() if isinstance(http_req.config, dict) else {}
+        original_config = (http_req.config.copy()
+                           if isinstance(http_req.config, dict) else {})
 
         # 创建一个临时副本
         temp_config = original_config.copy()
@@ -442,7 +487,8 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
         except Exception as collect_err:
             # 出现意外错误时记录
             allure.attach(
-                f"收集失败断言时出错: {type(collect_err).__name__}: {str(collect_err)}",
+                f"收集失败断言时出错: {type(collect_err).__name__}: "
+                f"{str(collect_err)}",
                 name="断言收集错误",
                 attachment_type=allure.attachment_type.TEXT
             )
@@ -513,16 +559,18 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
 
         # 找出所有断言中最大的重试次数
         for retryable_assertion in retryable_assertions:
-            max_retry_count = max(max_retry_count, retryable_assertion.get('retry_count', 3))
+            max_retry_count = max(max_retry_count,
+                                  retryable_assertion.get('retry_count', 3))
 
         # 进行断言重试
-        for attempt in range(1, max_retry_count + 1):  # 从1开始，因为第0次已经尝试过了
+        for attempt in range(1, max_retry_count + 1):
             # 等待重试间隔
             with allure.step(f"断言重试 (尝试 {attempt}/{max_retry_count})"):
                 # 确定本次重试的间隔时间（使用每个断言中最长的间隔时间）
                 retry_interval = retry_config['interval']
                 for assertion in retryable_assertions:
-                    retry_interval = max(retry_interval, assertion.get('retry_interval', 1.0))
+                    retry_interval = max(retry_interval,
+                                         assertion.get('retry_interval', 1.0))
 
                 allure.attach(
                     f"重试 {len(retryable_assertions)} 个断言\n"
@@ -552,14 +600,21 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
                 # 只重试那些仍在重试范围内的断言
                 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]
+                    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]
 
                     # 创建索引映射：新索引 -> 原始索引
-                    index_mapping = {new_idx: orig_idx for new_idx, orig_idx in enumerate(retry_assertion_indexes)}
+                    index_mapping = {
+                        new_idx: orig_idx for new_idx, orig_idx in
+                        enumerate(retry_assertion_indexes)}
 
                     # 只处理需要重试的断言，传递索引映射
-                    results, new_failed_assertions = http_req.process_asserts(specific_asserts=retry_assertions, index_mapping=index_mapping)
+                    results, new_failed_assertions = http_req.process_asserts(
+                        specific_asserts=retry_assertions,
+                        index_mapping=index_mapping)
 
                     # 如果所有断言都通过了，检查全部断言
                     if not new_failed_assertions:
@@ -607,7 +662,8 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
         except AssertionError as final_err:
             # 重新格式化错误消息，添加重试信息
             enhanced_error = (
-                f"断言验证失败 (已重试 {max_retry_count} 次):\n\n{str(final_err)}"
+                f"断言验证失败 (已重试 {max_retry_count} 次):\n\n"
+                f"{str(final_err)}"
             )
             allure.attach(
                 enhanced_error,
@@ -617,4 +673,4 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
             raise AssertionError(enhanced_error) from final_err
 
 
-# 注意：旧的重试函数已被移除，现在使用统一的重试机制
+# 注意：旧的重试函数已被移除，现在使用统一的重试机制