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

pytest_dsl/keywords/assertion_keywords.py

@@ -14,24 +14,24 @@ from pytest_dsl.core.keyword_manager import keyword_manager
 
 def _extract_jsonpath(json_data: Union[Dict, List], path: str) -> Any:
     """使用JSONPath从JSON数据中提取值
-    
+
     Args:
         json_data: 要提取数据的JSON对象或数组
         path: JSONPath表达式
-        
+
     Returns:
         提取的值或值列表
-    
+
     Raises:
         ValueError: 如果JSONPath表达式无效或找不到匹配项
     """
     try:
         if isinstance(json_data, str):
             json_data = json.loads(json_data)
-        
+
         jsonpath_expr = jsonpath.parse(path)
         matches = [match.value for match in jsonpath_expr.find(json_data)]
-        
+
         if not matches:
             return None
         elif len(matches) == 1:
@@ -44,12 +44,12 @@ def _extract_jsonpath(json_data: Union[Dict, List], path: str) -> Any:
 
 def _compare_values(actual: Any, expected: Any, operator: str = "==") -> bool:
     """比较两个值
-    
+
     Args:
         actual: 实际值
         expected: 预期值
         operator: 比较运算符 (==, !=, >, <, >=, <=, contains, not_contains, matches, and, or, not)
-        
+
     Returns:
         比较结果 (True/False)
     """
@@ -101,32 +101,32 @@ def _compare_values(actual: Any, expected: Any, operator: str = "==") -> bool:
 ])
 def assert_condition(**kwargs):
     """执行表达式断言
-    
+
     Args:
         condition: 断言条件表达式
         message: 断言失败时的错误消息
-        
+
     Returns:
         断言结果 (True/False)
-        
+
     Raises:
         AssertionError: 如果断言失败
     """
     condition = kwargs.get('condition')
     message = kwargs.get('message', '断言失败')
     context = kwargs.get('context')
-    
+
     # 简单解析表达式，支持 ==, !=, >, <, >=, <=, contains, not_contains, matches, in, and, or, not
     # 格式: "left_value operator right_value" 或 "boolean_expression"
     operators = ["==", "!=", ">", "<", ">=", "<=", "contains", "not_contains", "matches", "in", "and", "or", "not"]
-    
+
     # 先检查是否包含这些操作符
     operator_used = None
     for op in operators:
         if f" {op} " in condition:
             operator_used = op
             break
-    
+
     if not operator_used:
         # 如果没有找到操作符，尝试作为布尔表达式直接求值
         try:
@@ -142,36 +142,36 @@ def assert_condition(**kwargs):
             return True
         except Exception as e:
             raise AssertionError(f"{message}. 无法解析条件表达式: {condition}. 错误: {str(e)}")
-    
+
     # 解析左值和右值
     left_value, right_value = condition.split(f" {operator_used} ", 1)
     left_value = left_value.strip()
     right_value = right_value.strip()
-    
+
     # 移除引号（如果有）
     if left_value.startswith('"') and left_value.endswith('"'):
         left_value = left_value[1:-1]
     elif left_value.startswith("'") and left_value.endswith("'"):
         left_value = left_value[1:-1]
-        
+
     if right_value.startswith('"') and right_value.endswith('"'):
         right_value = right_value[1:-1]
     elif right_value.startswith("'") and right_value.endswith("'"):
         right_value = right_value[1:-1]
-    
+
     # 记录原始值（用于调试）
     allure.attach(
         f"原始左值: {left_value}\n原始右值: {right_value}\n操作符: {operator_used}",
         name="表达式解析",
         attachment_type=allure.attachment_type.TEXT
     )
-    
+
     # 对左值进行变量替换和表达式计算
     try:
         # 如果左值包含变量引用，先进行变量替换
         if '${' in left_value:
             left_value = context.executor.variable_replacer.replace_in_string(left_value)
-        
+
         # 检查是否需要计算表达式
         if any(op in str(left_value) for op in ['+', '-', '*', '/', '%', '(', ')']):
             try:
@@ -187,7 +187,7 @@ def assert_condition(**kwargs):
                     attachment_type=allure.attachment_type.TEXT
                 )
                 raise ValueError(f"表达式计算错误: {str(e)}")
-        
+
         # 处理布尔值字符串和数字字符串
         if isinstance(left_value, str):
             if left_value.lower() in ('true', 'false'):
@@ -210,13 +210,13 @@ def assert_condition(**kwargs):
             attachment_type=allure.attachment_type.TEXT
         )
         raise
-    
+
     # 对右值进行变量替换和表达式计算
     try:
         # 如果右值包含变量引用，先进行变量替换
         if '${' in right_value:
             right_value = context.executor.variable_replacer.replace_in_string(right_value)
-        
+
         # 检查是否需要计算表达式
         if any(op in str(right_value) for op in ['+', '-', '*', '/', '%', '(', ')']):
             try:
@@ -232,7 +232,7 @@ def assert_condition(**kwargs):
                     attachment_type=allure.attachment_type.TEXT
                 )
                 raise ValueError(f"表达式计算错误: {str(e)}")
-        
+
         # 处理布尔值字符串
         if isinstance(right_value, str):
             if right_value.lower() in ('true', 'false'):
@@ -246,7 +246,7 @@ def assert_condition(**kwargs):
             attachment_type=allure.attachment_type.TEXT
         )
         raise
-    
+
     # 类型转换和特殊处理
     if operator_used == "contains":
         # 特殊处理字符串包含操作
@@ -285,7 +285,7 @@ def assert_condition(**kwargs):
             # 尝试将右值解析为列表或字典
             if isinstance(right_value, str):
                 right_value = eval(right_value)
-            
+
             # 如果是字典，检查键
             if isinstance(right_value, dict):
                 result = left_value in right_value.keys()
@@ -310,17 +310,17 @@ def assert_condition(**kwargs):
                 right_value = float(right_value)
             except:
                 pass
-        
+
         # 记录类型转换后的值（用于调试）
         allure.attach(
             f"类型转换后左值: {left_value} ({type(left_value).__name__})\n类型转换后右值: {right_value} ({type(right_value).__name__})",
             name="类型转换",
             attachment_type=allure.attachment_type.TEXT
         )
-        
+
         # 执行比较
         result = _compare_values(left_value, right_value, operator_used)
-    
+
     # 记录和处理断言结果
     if not result:
         error_details = f"""
@@ -337,7 +337,7 @@ def assert_condition(**kwargs):
             attachment_type=allure.attachment_type.TEXT
         )
         raise AssertionError(error_details)
-    
+
     # 记录成功的断言
     allure.attach(
         f"实际值: {left_value}\n预期值: {right_value}\n操作符: {operator_used}",
@@ -356,17 +356,17 @@ def assert_condition(**kwargs):
 ])
 def assert_json(**kwargs):
     """执行JSON断言
-    
+
     Args:
         json_data: JSON数据（字符串或对象）
         jsonpath: JSONPath表达式
         expected_value: 预期的值
         operator: 比较操作符，默认为"=="
         message: 断言失败时的错误消息
-        
+
     Returns:
         断言结果 (True/False)
-        
+
     Raises:
         AssertionError: 如果断言失败
         ValueError: 如果JSONPath无效或找不到匹配项
@@ -376,27 +376,27 @@ def assert_json(**kwargs):
     expected_value = kwargs.get('expected_value')
     operator = kwargs.get('operator', '==')
     message = kwargs.get('message', 'JSON断言失败')
-    
+
     # 解析JSON（如果需要）
     if isinstance(json_data, str):
         try:
             json_data = json.loads(json_data)
         except json.JSONDecodeError as e:
             raise ValueError(f"无效的JSON数据: {str(e)}")
-    
+
     # 使用JSONPath提取值
     actual_value = _extract_jsonpath(json_data, path)
-    
+
     # 记录提取的值
     allure.attach(
         f"JSONPath: {path}\n提取值: {actual_value}",
         name="JSONPath提取结果",
         attachment_type=allure.attachment_type.TEXT
     )
-    
+
     # 比较值
     result = _compare_values(actual_value, expected_value, operator)
-    
+
     # 记录和处理断言结果
     if not result:
         allure.attach(
@@ -405,7 +405,7 @@ def assert_json(**kwargs):
             attachment_type=allure.attachment_type.TEXT
         )
         raise AssertionError(message)
-    
+
     # 记录成功的断言
     allure.attach(
         f"实际值: {actual_value}\n预期值: {expected_value}\n操作符: {operator}",
@@ -422,21 +422,23 @@ def assert_json(**kwargs):
 ])
 def extract_json(**kwargs):
     """从JSON数据中提取值并保存到变量
-    
+
     Args:
         json_data: JSON数据（字符串或对象）
         jsonpath: JSONPath表达式
         variable: 存储提取值的变量名
-        
+        context: 测试上下文
+
     Returns:
-        提取的值
-        
+        提取的值或包含提取值的字典（远程模式）
+
     Raises:
         ValueError: 如果JSONPath无效或找不到匹配项
     """
     json_data = kwargs.get('json_data')
     path = kwargs.get('jsonpath')
     variable = kwargs.get('variable')
+    context = kwargs.get('context')
 
     # 解析JSON（如果需要）
     if isinstance(json_data, str):
@@ -444,19 +446,31 @@ def extract_json(**kwargs):
             json_data = json.loads(json_data)
         except json.JSONDecodeError as e:
             raise ValueError(f"无效的JSON数据: {str(e)}")
-    
+
     # 使用JSONPath提取值
     value = _extract_jsonpath(json_data, path)
-    
+
+    # 将提取的值设置到上下文中（本地模式）
+    if context and variable:
+        context.set(variable, value)
+
     # 记录提取的值
     allure.attach(
         f"JSONPath: {path}\n提取值: {value}\n保存到变量: {variable}",
         name="JSON数据提取",
         attachment_type=allure.attachment_type.TEXT
     )
-    
-    # 返回提取的值用于变量赋值
-    return value
+
+    # 统一返回格式 - 支持远程关键字模式
+    return {
+        "result": value,  # 主要返回值保持兼容
+        "captures": {variable: value} if variable else {},  # 明确的捕获变量
+        "session_state": {},
+        "metadata": {
+            "jsonpath": path,
+            "variable_name": variable
+        }
+    }
 
 
 @keyword_manager.register('类型断言', [
@@ -466,22 +480,22 @@ def extract_json(**kwargs):
 ])
 def assert_type(**kwargs):
     """断言值的类型
-    
+
     Args:
         value: 要检查的值
         type: 预期的类型 (string, number, boolean, list, object, null)
         message: 断言失败时的错误消息
-        
+
     Returns:
         断言结果 (True/False)
-        
+
     Raises:
         AssertionError: 如果断言失败
     """
     value = kwargs.get('value')
     expected_type = kwargs.get('type')
     message = kwargs.get('message', '类型断言失败')
-    
+
     # 检查类型
     if expected_type == 'string':
         result = isinstance(value, str)
@@ -508,7 +522,7 @@ def assert_type(**kwargs):
         result = value is None
     else:
         raise ValueError(f"不支持的类型: {expected_type}")
-    
+
     # 记录和处理断言结果
     if not result:
         actual_type = type(value).__name__
@@ -518,7 +532,7 @@ def assert_type(**kwargs):
             attachment_type=allure.attachment_type.TEXT
         )
         raise AssertionError(message)
-    
+
     # 记录成功的断言
     allure.attach(
         f"值: {value}\n类型: {expected_type}",
@@ -536,16 +550,16 @@ def assert_type(**kwargs):
 ])
 def compare_values(**kwargs):
     """比较两个值
-    
+
     Args:
         actual: 实际值
         expected: 预期值
         operator: 比较操作符，默认为"=="
         message: 断言失败时的错误消息
-        
+
     Returns:
         比较结果 (True/False)
-        
+
     Raises:
         AssertionError: 如果比较失败
     """
@@ -553,7 +567,7 @@ def compare_values(**kwargs):
     expected = kwargs.get('expected')
     operator = kwargs.get('operator', '==')
     message = kwargs.get('message', '数据比较失败')
-    
+
     # 处理布尔值字符串和表达式
     if isinstance(actual, str):
         # 检查是否需要计算表达式
@@ -571,7 +585,7 @@ def compare_values(**kwargs):
             actual = actual.lower() == 'true'
         elif actual.lower() in ('yes', 'no', '1', '0', 't', 'f', 'y', 'n'):
             actual = actual.lower() in ('yes', '1', 't', 'y')
-    
+
     if isinstance(expected, str):
         # 检查是否需要计算表达式
         if any(op in expected for op in ['+', '-', '*', '/', '%', '(', ')']):
@@ -588,10 +602,10 @@ def compare_values(**kwargs):
             expected = expected.lower() == 'true'
         elif expected.lower() in ('yes', 'no', '1', '0', 't', 'f', 'y', 'n'):
             expected = expected.lower() in ('yes', '1', 't', 'y')
-    
+
     # 比较值
     result = _compare_values(actual, expected, operator)
-    
+
     # 记录和处理比较结果
     if not result:
         allure.attach(
@@ -600,11 +614,11 @@ def compare_values(**kwargs):
             attachment_type=allure.attachment_type.TEXT
         )
         raise AssertionError(message)
-    
+
     # 记录成功的比较
     allure.attach(
         f"实际值: {actual}\n预期值: {expected}\n操作符: {operator}",
         name="数据比较成功",
         attachment_type=allure.attachment_type.TEXT
     )
-    return result 
+    return result

pytest_dsl/keywords/global_keywords.py

@@ -12,7 +12,17 @@ from pytest_dsl.core.global_context import global_context
 def set_global_variable(name, value, context):
     """设置全局变量"""
     global_context.set_variable(name, value)
-    return value
+
+    # 统一返回格式 - 支持远程关键字模式
+    return {
+        "result": value,  # 主要返回值保持兼容
+        "captures": {},
+        "session_state": {},
+        "metadata": {
+            "variable_name": name,
+            "operation": "set_global_variable"
+        }
+    }
 
 
 @keyword_manager.register(
@@ -26,7 +36,17 @@ def get_global_variable(name, context):
     value = global_context.get_variable(name)
     if value is None:
         raise Exception(f"全局变量未定义: {name}")
-    return value
+
+    # 统一返回格式 - 支持远程关键字模式
+    return {
+        "result": value,  # 主要返回值保持兼容
+        "captures": {},
+        "session_state": {},
+        "metadata": {
+            "variable_name": name,
+            "operation": "get_global_variable"
+        }
+    }
 
 
 @keyword_manager.register(
@@ -38,7 +58,17 @@ def get_global_variable(name, context):
 def delete_global_variable(name, context):
     """删除全局变量"""
     global_context.delete_variable(name)
-    return True
+
+    # 统一返回格式 - 支持远程关键字模式
+    return {
+        "result": True,  # 主要返回值保持兼容
+        "captures": {},
+        "session_state": {},
+        "metadata": {
+            "variable_name": name,
+            "operation": "delete_global_variable"
+        }
+    }
 
 
 @keyword_manager.register(
@@ -48,4 +78,13 @@ def delete_global_variable(name, context):
 def clear_all_global_variables(context):
     """清除所有全局变量"""
     global_context.clear_all()
-    return True
+
+    # 统一返回格式 - 支持远程关键字模式
+    return {
+        "result": True,  # 主要返回值保持兼容
+        "captures": {},
+        "session_state": {},
+        "metadata": {
+            "operation": "clear_all_global_variables"
+        }
+    }

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)
+# 注意：旧的重试函数已被移除，现在使用统一的重试机制