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

pytest_dsl/core/http_client.py

@@ -132,7 +132,7 @@ class HTTPClient:
             request_kwargs = self.auth_provider.pre_request_hook(method, url, request_kwargs)
 
         # 记录请求详情
-        logger.debug(f"=== HTTP请求详情 ===")
+        logger.debug("=== HTTP请求详情 ===")
         logger.debug(f"方法: {method}")
         logger.debug(f"URL: {url}")
         if 'headers' in request_kwargs:
@@ -171,7 +171,7 @@ class HTTPClient:
                 response = requests.request(method, url, **request_kwargs)
 
             # 记录响应详情
-            logger.debug(f"\n=== HTTP响应详情 ===")
+            logger.debug("\n=== HTTP响应详情 ===")
             logger.debug(f"状态码: {response.status_code}")
             logger.debug(f"响应头: {json.dumps(dict(response.headers), indent=2, ensure_ascii=False)}")
             try:

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

pytest_dsl/remote/keyword_client.py

@@ -7,16 +7,19 @@ from pytest_dsl.core.keyword_manager import keyword_manager, Parameter
 # 配置日志
 logger = logging.getLogger(__name__)
 
+
 class RemoteKeywordClient:
     """远程关键字客户端，用于连接远程关键字服务器并执行关键字"""
 
-    def __init__(self, url='http://localhost:8270/', api_key=None, alias=None, sync_config=None):
+    def __init__(self, url='http://localhost:8270/', api_key=None, alias=None,
+                 sync_config=None):
         self.url = url
         self.server = xmlrpc.client.ServerProxy(url, allow_none=True)
         self.keyword_cache = {}
         self.param_mappings = {}  # 存储每个关键字的参数映射
         self.api_key = api_key
-        self.alias = alias or url.replace('http://', '').replace('https://', '').split(':')[0]
+        self.alias = alias or url.replace('http://', '').replace(
+            'https://', '').split(':')[0]
 
         # 变量传递配置（简化版）
         self.sync_config = sync_config or {
@@ -24,7 +27,6 @@ class RemoteKeywordClient:
             'sync_yaml_vars': True,     # 连接时传递YAML配置变量
             'yaml_sync_keys': None,     # 指定要同步的YAML键列表，None表示同步所有（除了排除的）
             'yaml_exclude_patterns': [  # 排除包含这些模式的YAML变量
-                'password', 'secret', 'key', 'token', 'credential', 'auth',
                 'private', 'remote_servers'  # 排除远程服务器配置避免循环
             ]
         }
@@ -42,7 +44,8 @@ class RemoteKeywordClient:
             self._send_initial_variables()
 
             logger.info(f"已连接到远程关键字服务器: {self.url}, 别名: {self.alias}")
-            print(f"RemoteKeywordClient: 成功连接到远程服务器 {self.url}, 别名: {self.alias}")
+            print(f"RemoteKeywordClient: 成功连接到远程服务器 {self.url}, "
+                  f"别名: {self.alias}")
             return True
         except Exception as e:
             error_msg = f"连接远程关键字服务器失败: {str(e)}"
@@ -81,7 +84,8 @@ class RemoteKeywordClient:
             for param_detail in param_details:
                 param_name = param_detail['name']
                 param_mapping_name = param_detail.get('mapping', param_name)
-                param_desc = param_detail.get('description', f'远程关键字参数: {param_name}')
+                param_desc = param_detail.get('description',
+                                              f'远程关键字参数: {param_name}')
                 param_default = param_detail.get('default')
                 
                 # 确保参数名称正确映射
@@ -114,7 +118,8 @@ class RemoteKeywordClient:
                 'func': remote_func,
                 'mapping': {p['name']: p['mapping'] for p in parameters},
                 'parameters': [Parameter(**p) for p in parameters],
-                'defaults': {p['mapping']: p['default'] for p in parameters if p['default'] is not None},  # 添加默认值支持
+                'defaults': {p['mapping']: p['default'] for p in parameters
+                           if p['default'] is not None},  # 添加默认值支持
                 'remote': True,  # 标记为远程关键字
                 'alias': self.alias,
                 'original_name': name
@@ -161,7 +166,7 @@ class RemoteKeywordClient:
         else:
             # 如果没有任何映射，使用原始参数名
             param_mapping = None
-            print(f"没有找到参数映射，使用原始参数名")
+            print("没有找到参数映射，使用原始参数名")
 
         # 映射参数名称
         mapped_kwargs = {}
@@ -209,10 +214,11 @@ class RemoteKeywordClient:
 
                 # 处理响应数据
                 if 'response' in return_data and return_data['response']:
-                    print(f"远程关键字响应数据: 已接收")
+                    print("远程关键字响应数据: 已接收")
 
                 # 检查是否为新的统一返回格式（包含captures等字段）
-                if 'captures' in return_data or 'session_state' in return_data or 'metadata' in return_data:
+                if ('captures' in return_data or 'session_state' in return_data or
+                        'metadata' in return_data):
                     # 返回完整的新格式，让DSL执行器处理变量捕获
                     return return_data
                 elif 'result' in return_data:
@@ -243,11 +249,13 @@ class RemoteKeywordClient:
             if variables_to_send:
                 try:
                     # 调用远程服务器的变量接收接口
-                    result = self.server.sync_variables_from_client(variables_to_send, self.api_key)
+                    result = self.server.sync_variables_from_client(
+                        variables_to_send, self.api_key)
                     if result.get('status') == 'success':
                         print(f"成功传递 {len(variables_to_send)} 个变量到远程服务器")
                     else:
-                        print(f"传递变量到远程服务器失败: {result.get('error', '未知错误')}")
+                        print(f"传递变量到远程服务器失败: "
+                              f"{result.get('error', '未知错误')}")
                 except Exception as e:
                     print(f"调用远程变量接口失败: {str(e)}")
             else:
@@ -295,10 +303,12 @@ class RemoteKeywordClient:
             # 获取所有YAML变量
             yaml_data = yaml_vars._variables
             if yaml_data:
+                print(f"客户端YAML变量总数: {len(yaml_data)}")
+                
                 # 检查同步配置中是否指定了特定的键
                 sync_keys = self.sync_config.get('yaml_sync_keys', None)
                 exclude_patterns = self.sync_config.get('yaml_exclude_patterns', [
-                    'password', 'secret', 'key', 'token', 'credential', 'auth',
+                    'password', 'secret', 'token', 'credential', 'auth',
                     'private', 'remote_servers'  # 排除远程服务器配置避免循环
                 ])
 
@@ -307,6 +317,7 @@ class RemoteKeywordClient:
                     for key in sync_keys:
                         if key in yaml_data:
                             variables[key] = yaml_data[key]
+                            print(f"传递指定YAML变量: {key}")
                 else:
                     # 传递所有YAML变量，但排除敏感信息
                     for key, value in yaml_data.items():
@@ -323,7 +334,8 @@ class RemoteKeywordClient:
                         if not should_exclude and isinstance(value, str):
                             value_lower = value.lower()
                             for pattern in exclude_patterns:
-                                if pattern.lower() in value_lower and len(value) < 100:  # 只检查短字符串
+                                if (pattern.lower() in value_lower and
+                                        len(value) < 100):  # 只检查短字符串
                                     should_exclude = True
                                     break
 
@@ -336,11 +348,11 @@ class RemoteKeywordClient:
 
         except Exception as e:
             logger.warning(f"收集YAML变量失败: {str(e)}")
+            print(f"收集YAML变量失败: {str(e)}")
 
         return variables
 
 
-
 # 远程关键字客户端管理器
 class RemoteKeywordManager:
     """远程关键字客户端管理器，管理多个远程服务器连接"""
@@ -348,7 +360,8 @@ class RemoteKeywordManager:
     def __init__(self):
         self.clients = {}  # 别名 -> 客户端实例
 
-    def register_remote_server(self, url, alias, api_key=None, sync_config=None):
+    def register_remote_server(self, url, alias, api_key=None,
+                               sync_config=None):
         """注册远程关键字服务器
 
         Args:
@@ -361,7 +374,8 @@ class RemoteKeywordManager:
             bool: 是否成功连接
         """
         print(f"RemoteKeywordManager: 正在注册远程服务器 {url} 别名 {alias}")
-        client = RemoteKeywordClient(url=url, api_key=api_key, alias=alias, sync_config=sync_config)
+        client = RemoteKeywordClient(url=url, api_key=api_key, alias=alias,
+                                     sync_config=sync_config)
         success = client.connect()
 
         if success:
@@ -394,6 +408,5 @@ class RemoteKeywordManager:
         return client._execute_remote_keyword(name=keyword_name, **kwargs)
 
 
-
 # 创建全局远程关键字管理器实例
 remote_keyword_manager = RemoteKeywordManager()

pytest_dsl/remote/keyword_server.py

@@ -403,9 +403,26 @@ class RemoteKeywordServer:
                 self.shared_variables[name] = value
                 print(f"接收到客户端变量: {name}")
 
+            # 将所有同步的变量直接注入到yaml_vars中，实现无缝访问
+            from pytest_dsl.core.yaml_vars import yaml_vars
+            
+            for name, value in variables.items():
+                # 直接设置到yaml_vars中，确保所有关键字都能无缝访问
+                yaml_vars._variables[name] = value
+                print(f"✓ 变量 {name} 已注入到yaml_vars，实现无缝访问")
+
+            # 同时处理全局变量到global_context
+            from pytest_dsl.core.global_context import global_context
+            for name, value in variables.items():
+                if name.startswith('g_'):
+                    global_context.set_variable(name, value)
+                    print(f"✓ 全局变量 {name} 已注入到global_context")
+
+            print(f"✅ 总共同步了 {len(variables)} 个变量，全部实现无缝访问")
+            
             return {
                 'status': 'success',
-                'message': f'成功同步 {len(variables)} 个变量'
+                'message': f'成功同步 {len(variables)} 个变量，全部实现无缝访问'
             }
         except Exception as e:
             return {

pytest_dsl/remote/variable_bridge.py

@@ -6,7 +6,8 @@
 
 import logging
 from typing import Any, Optional
-from pytest_dsl.remote.hook_manager import register_startup_hook, register_before_keyword_hook
+from pytest_dsl.remote.hook_manager import (register_startup_hook, 
+                                            register_before_keyword_hook)
 from pytest_dsl.core.yaml_vars import yaml_vars
 from pytest_dsl.core.global_context import global_context
 
@@ -43,24 +44,28 @@ class VariableBridge:
         
         self._bridge_installed = True
         logger.info("变量桥接机制已安装")
+        print(f"🔗 变量桥接机制已安装，可桥接 {len(shared_variables)} 个同步变量")
     
     def _bridged_yaml_get_variable(self, name: str) -> Optional[Any]:
         """桥接的YAML变量获取方法
         
         优先级：
-        1. 原始YAML变量
+        1. 原始YAML变量（服务器本地的）
         2. 客户端同步的变量
         """
         # 首先尝试从原始YAML变量获取
         original_value = self.original_yaml_get_variable(name)
         if original_value is not None:
+            logger.debug(f"从原始YAML获取变量: {name}")
             return original_value
         
         # 如果原始YAML中没有，尝试从同步变量获取
         if name in self.shared_variables:
             logger.debug(f"从同步变量获取YAML变量: {name}")
+            print(f"🔗 变量桥接: 从同步变量获取 {name}")
             return self.shared_variables[name]
         
+        logger.debug(f"变量 {name} 在原始YAML和同步变量中都不存在")
         return None
     
     def _bridged_global_get_variable(self, name: str) -> Any:
@@ -74,17 +79,20 @@ class VariableBridge:
             # 首先尝试从原始全局上下文获取
             original_value = self.original_global_get_variable(name)
             if original_value is not None:
+                logger.debug(f"从原始全局上下文获取变量: {name}")
                 return original_value
-        except:
+        except Exception as e:
             # 如果原始方法抛出异常，继续尝试同步变量
-            pass
+            logger.debug(f"原始全局上下文获取变量 {name} 失败，尝试同步变量: {e}")
         
         # 如果原始全局变量中没有，尝试从同步变量获取
         if name in self.shared_variables:
             logger.debug(f"从同步变量获取全局变量: {name}")
+            print(f"🔗 变量桥接: 从同步变量获取全局变量 {name}")
             return self.shared_variables[name]
         
         # 如果都没有找到，返回None（保持原有行为）
+        logger.debug(f"变量 {name} 在所有来源中都不存在")
         return None
     
     def uninstall_bridge(self):
@@ -113,6 +121,7 @@ def setup_variable_bridge(context):
     if shared_variables is not None:
         variable_bridge.install_bridge(shared_variables)
         logger.info("变量桥接机制已在服务器启动时安装")
+        print(f"🔗 服务器启动时安装变量桥接机制，可桥接 {len(shared_variables)} 个变量")
     else:
         logger.warning("无法获取shared_variables，变量桥接机制安装失败")
 
@@ -124,11 +133,14 @@ def ensure_variable_bridge(context):
     shared_variables = context.get('shared_variables')
     keyword_name = context.get('keyword_name')
     
-    # 只对特定关键字进行调试日志
-    if keyword_name in ['HTTP请求', '数据库查询'] and shared_variables:
+    # 对所有关键字进行调试日志（如果有同步变量）
+    if shared_variables and len(shared_variables) > 0:
         synced_count = len(shared_variables)
-        if synced_count > 0:
-            logger.debug(f"关键字 {keyword_name} 执行前，可用同步变量数量: {synced_count}")
+        logger.debug(f"关键字 {keyword_name} 执行前，可用同步变量数量: {synced_count}")
+        
+        # 对重要关键字显示详细信息
+        if keyword_name in ['HTTP请求', '数据库查询', 'API调用']:
+            print(f"🔗 关键字 {keyword_name} 可访问 {synced_count} 个同步变量")
 
 
 def get_synced_variable(name: str) -> Optional[Any]:
@@ -162,3 +174,24 @@ def has_synced_variable(name: str) -> bool:
         是否存在该同步变量
     """
     return name in variable_bridge.shared_variables
+
+
+def get_all_accessible_variables() -> dict:
+    """获取所有可访问的变量（包括原始变量和同步变量）
+    
+    Returns:
+        所有可访问变量的字典
+    """
+    all_vars = {}
+    
+    # 添加原始YAML变量
+    try:
+        if hasattr(yaml_vars, '_variables'):
+            all_vars.update(yaml_vars._variables)
+    except Exception as e:
+        logger.warning(f"获取原始YAML变量失败: {e}")
+    
+    # 添加同步变量（会覆盖同名的原始变量）
+    all_vars.update(variable_bridge.shared_variables)
+    
+    return all_vars

{pytest_dsl-0.11.0.dist-info → pytest_dsl-0.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-dsl
-Version: 0.11.0
+Version: 0.11.1
 Summary: A DSL testing framework based on pytest
 Author: Chen Shuanglin
 License: MIT

{pytest_dsl-0.11.0.dist-info → pytest_dsl-0.11.1.dist-info}/RECORD

@@ -12,7 +12,7 @@ pytest_dsl/core/custom_keyword_manager.py,sha256=UdlGUc_mT8hIwmU7LVf4wJLG-geChwY
 pytest_dsl/core/dsl_executor.py,sha256=aEEfocFCFxNDN1puBFhQzL5fzw9eZx8BAyYJI5XSt4Y,30472
 pytest_dsl/core/dsl_executor_utils.py,sha256=cFoR2p3qQ2pb-UhkoefleK-zbuFqf0aBLh2Rlp8Ebs4,2180
 pytest_dsl/core/global_context.py,sha256=NcEcS2V61MT70tgAsGsFWQq0P3mKjtHQr1rgT3yTcyY,3535
-pytest_dsl/core/http_client.py,sha256=1AHqtM_fkXf8JrM0ljMsJwUkyt-ysjR16NoyCckHfGc,15810
+pytest_dsl/core/http_client.py,sha256=Ho1fPl23kYZzDswwAR-YCpgL5c6Oy1bWh_ieDOlgY4s,15808
 pytest_dsl/core/http_request.py,sha256=nGMlx0mFc7rDLIdp9GJ3e09OQH3ryUA56yJdRZ99dOQ,57445
 pytest_dsl/core/keyword_manager.py,sha256=hoNXHQcumnufPRUobnY0mnku4CHxSg2amwPFby4gQEs,7643
 pytest_dsl/core/lexer.py,sha256=WaLzt9IhtHiA90Fg2WGgfVztveCUhtgxzANBaEiy-F8,4347
@@ -57,17 +57,17 @@ pytest_dsl/examples/quickstart/loops.auto,sha256=ZNZ6qP636v8QMY8QRyTUBB43gWCsqHb
 pytest_dsl/keywords/__init__.py,sha256=5aiyPU_t1UiB2MEZ6M9ffOKnV1mFT_2YHxnZvyWaBNI,372
 pytest_dsl/keywords/assertion_keywords.py,sha256=obW06H_3AizsvEM_9VE2JVuwvgrNVqP1kUTDd3U1SMk,23240
 pytest_dsl/keywords/global_keywords.py,sha256=4yw5yeXoGf_4W26F39EA2Pp-mH9GiKGy2jKgFO9a_wM,2509
-pytest_dsl/keywords/http_keywords.py,sha256=B2IoWZjmAk0bQf1o5hHhHEDHpAl010PrDVA4iJ1mLk0,25605
+pytest_dsl/keywords/http_keywords.py,sha256=z2Brqj1Mkufa_PlZZNwfKuYqkgJhnjsZw-7YNnbt2N4,27302
 pytest_dsl/keywords/system_keywords.py,sha256=e65Mzyt56FYmw0vHegajLUSLeEYVI9Y-WSB1h6SKKLo,12089
 pytest_dsl/remote/__init__.py,sha256=syRSxTlTUfdAPleJnVS4MykRyEN8_SKiqlsn6SlIK8k,120
 pytest_dsl/remote/hook_manager.py,sha256=0hwRKP8yhcnfAnrrnZGVT-S0TBgo6c0A4qO5XRpvV1U,4899
-pytest_dsl/remote/keyword_client.py,sha256=doXmg2Aenx9SclKtd5bT3n-DkxGK3MnMRwn4dpdug8s,16848
-pytest_dsl/remote/keyword_server.py,sha256=7eRBHXyTC2AyXBeXMHOYLjgj570ioiAhnq4CuEnkak4,21386
-pytest_dsl/remote/variable_bridge.py,sha256=KG2xTZcUExb8kNL-rR-IPFJmYGfo7ciE4W7xzet59sw,5520
+pytest_dsl/remote/keyword_client.py,sha256=BL80MOaLroUi0v-9sLtkJ55g1R0Iw9SE1k11Ifwqx-I,17292
+pytest_dsl/remote/keyword_server.py,sha256=vGIE3Bhh461xX_u1U-Cf5nrWL2GQFYdtQdcMWfFIYgE,22320
+pytest_dsl/remote/variable_bridge.py,sha256=dv-d3Gq9ttvvrXM1fdlLtoSOPB6vRp0_GBOwX4wvcy8,7121
 pytest_dsl/templates/keywords_report.html,sha256=7x84iq6hi08nf1iQ95jZ3izcAUPx6JFm0_8xS85CYws,31241
-pytest_dsl-0.11.0.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
-pytest_dsl-0.11.0.dist-info/METADATA,sha256=Xr_eldwYrWr12X9fQMl1BN9UlqJrT0UOw9AiQoLgQC4,29642
-pytest_dsl-0.11.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytest_dsl-0.11.0.dist-info/entry_points.txt,sha256=PLOBbH02OGY1XR1JDKIZB1Em87loUvbgMRWaag-5FhY,204
-pytest_dsl-0.11.0.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
-pytest_dsl-0.11.0.dist-info/RECORD,,
+pytest_dsl-0.11.1.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
+pytest_dsl-0.11.1.dist-info/METADATA,sha256=5YIMx6SIIlzVFeeuPUhRqi0eISBdDIjpamHlptPjpIY,29642
+pytest_dsl-0.11.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytest_dsl-0.11.1.dist-info/entry_points.txt,sha256=PLOBbH02OGY1XR1JDKIZB1Em87loUvbgMRWaag-5FhY,204
+pytest_dsl-0.11.1.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
+pytest_dsl-0.11.1.dist-info/RECORD,,