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

pytest_dsl/keywords/http_keywords.py

@@ -9,6 +9,7 @@ import yaml
 import json
 import os
 import time
+import logging
 from typing import Dict, Any, Union
 
 from pytest_dsl.core.keyword_manager import keyword_manager
@@ -16,6 +17,9 @@ from pytest_dsl.core.http_request import HTTPRequest
 from pytest_dsl.core.yaml_vars import yaml_vars
 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:
     """处理文件引用，加载外部文件内容
 
@@ -223,8 +227,7 @@ def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interv
     {'name': '配置', 'mapping': 'config', 'description': '包含请求、捕获和断言的YAML配置'},
     {'name': '会话', 'mapping': 'session', 'description': '会话名称，用于在多个请求间保持会话状态'},
     {'name': '保存响应', 'mapping': 'save_response', 'description': '将完整响应保存到指定变量名中'},
-    {'name': '重试次数', 'mapping': 'retry_count', 'description': '请求失败时的重试次数'},
-    {'name': '重试间隔', 'mapping': 'retry_interval', 'description': '重试间隔时间（秒）'},
+    {'name': '禁用授权', 'mapping': 'disable_auth', 'description': '禁用客户端配置中的授权机制，默认为false'},
     {'name': '模板', 'mapping': 'template', 'description': '使用YAML变量文件中定义的请求模板'},
     {'name': '断言重试次数', 'mapping': 'assert_retry_count', 'description': '断言失败时的重试次数'},
     {'name': '断言重试间隔', 'mapping': 'assert_retry_interval', 'description': '断言重试间隔时间（秒）'}
@@ -240,8 +243,7 @@ def http_request(context, **kwargs):
         config: YAML配置
         session: 会话名称
         save_response: 保存响应的变量名
-        retry_count: 重试次数
-        retry_interval: 重试间隔
+        disable_auth: 禁用客户端配置中的授权机制
         template: 模板名称
         assert_retry_count: 断言失败时的重试次数
         assert_retry_interval: 断言重试间隔时间（秒）
@@ -253,8 +255,7 @@ def http_request(context, **kwargs):
     config = kwargs.get('config', '{}')
     session_name = kwargs.get('session')
     save_response = kwargs.get('save_response')
-    retry_count = kwargs.get('retry_count')
-    retry_interval = kwargs.get('retry_interval')
+    disable_auth = kwargs.get('disable_auth', False)
     template_name = kwargs.get('template')
     assert_retry_count = kwargs.get('assert_retry_count')
     assert_retry_interval = kwargs.get('assert_retry_interval')
@@ -316,7 +317,7 @@ def http_request(context, **kwargs):
         http_req = HTTPRequest(config, client_name, session_name)
 
         # 执行请求
-        response = http_req.execute()
+        response = http_req.execute(disable_auth=disable_auth)
 
         # 处理捕获
         captured_values = http_req.captured_values
@@ -338,8 +339,50 @@ def http_request(context, **kwargs):
                 # 不需要重试，直接断言
                 http_req.process_asserts()
 
-        # 返回捕获的变量
-        return captured_values
+        # 获取会话状态（如果使用了会话）
+        session_state = None
+        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)
+                if session_client and session_client._session:
+                    session_state = {
+                        "cookies": dict(session_client._session.cookies),
+                        "headers": dict(session_client._session.headers)
+                    }
+            except Exception as e:
+                # 会话状态获取失败不影响主要功能
+                logger.warning(f"获取会话状态失败: {str(e)}")
+
+        # 准备响应数据（如果需要保存响应）
+        response_data = None
+        if save_response:
+            # 确保响应数据是可序列化的
+            try:
+                import json
+                json.dumps(response.__dict__)
+                response_data = response.__dict__
+            except (TypeError, AttributeError):
+                # 如果无法序列化，转换为基本信息
+                response_data = {
+                    "status_code": getattr(response, 'status_code', None),
+                    "headers": dict(getattr(response, 'headers', {})),
+                    "text": getattr(response, 'text', ''),
+                    "url": getattr(response, 'url', '')
+                }
+
+        # 统一返回格式 - 支持远程关键字模式
+        return {
+            "result": captured_values,  # 主要返回值保持兼容
+            "captures": captured_values,  # 明确的捕获变量
+            "session_state": {session_name: session_state} if session_state else {},
+            "response": response_data,  # 完整响应（如果需要）
+            "metadata": {
+                "response_time": getattr(response, 'elapsed', None),
+                "status_code": getattr(response, 'status_code', None),
+                "url": getattr(response, 'url', '')
+            }
+        }
 
 
 def _deep_merge(dict1, dict2):
@@ -512,8 +555,11 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
                     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)
+                    # 创建索引映射：新索引 -> 原始索引
+                    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)
 
                     # 如果所有断言都通过了，检查全部断言
                     if not new_failed_assertions:
@@ -571,48 +617,4 @@ def _process_assertions_with_unified_retry(http_req, retry_config):
             raise AssertionError(enhanced_error) from final_err
 
 
-# 移除旧的重试函数，使用统一的重试机制
-# 以下函数保留用于向后兼容，但内部逻辑已更改为调用统一重试函数
-def _process_assertions_with_retry(http_req, retry_count, retry_interval):
-    """处理断言并支持重试（向后兼容函数）
-
-    Args:
-        http_req: HTTP请求对象
-        retry_count: 重试次数
-        retry_interval: 重试间隔（秒）
-    """
-    # 创建统一的重试配置
-    retry_config = {
-        'enabled': True,
-        'count': retry_count,
-        'interval': retry_interval,
-        'all': True,
-        '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,
-        'count': retry_assertions_config.get('count', 3),
-        'interval': retry_assertions_config.get('interval', 1.0),
-        'all': retry_assertions_config.get('all', False),
-        'indices': retry_assertions_config.get('indices', []),
-        'specific': retry_assertions_config.get('specific', {})
-    }
-
-    # 使用统一的重试处理函数
-    return _process_assertions_with_unified_retry(http_req, retry_config)
+# 注意：旧的重试函数已被移除，现在使用统一的重试机制