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

pytest_dsl/keywords/system_keywords.py

@@ -185,7 +185,8 @@ def generate_random_number(**kwargs):
 
 @keyword_manager.register('字符串操作', [
     {'name': '操作', 'mapping': 'operation',
-     'description': '操作类型：拼接(concat)、替换(replace)、分割(split)、大写(upper)、小写(lower)、去空格(strip)', 
+     'description': '操作类型：拼接(concat)、替换(replace)、分割(split)、'
+                   '大写(upper)、小写(lower)、去空格(strip)', 
      'default': 'strip'},
     {'name': '字符串', 'mapping': 'string', 'description': '要操作的字符串'},
     {'name': '参数1', 'mapping': 'param1', 
@@ -366,3 +367,421 @@ def execute_command(**kwargs):
                 'stdout': '',
                 'stderr': str(e)
             }
+
+
+@keyword_manager.register('求和', [
+    {'name': '数据', 'mapping': 'data', 'description': '要求和的数字列表或可迭代对象'},
+    {'name': '起始值', 'mapping': 'start', 'description': '求和的起始值', 'default': 0}
+])
+def sum_values(**kwargs):
+    """计算数字列表的总和
+
+    Args:
+        data: 要求和的数字列表
+        start: 求和的起始值，默认为0
+
+    Returns:
+        数字总和
+    """
+    data = kwargs.get('data', [])
+    start = kwargs.get('start', 0)
+
+    # 确保data是可迭代的
+    if not hasattr(data, '__iter__') or isinstance(data, str):
+        raise ValueError("数据必须是可迭代的数字列表")
+
+    try:
+        result = sum(data, start)
+        
+        with allure.step(f"求和计算: 数据长度={len(data)}, 起始值={start}"):
+            allure.attach(
+                f"输入数据: {data}\n起始值: {start}\n结果: {result}",
+                name="求和结果",
+                attachment_type=allure.attachment_type.TEXT
+            )
+        
+        return result
+    except Exception as e:
+        allure.attach(
+            f"求和计算失败: {str(e)}",
+            name="求和错误",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        raise
+
+
+@keyword_manager.register('获取长度', [
+    {'name': '对象', 'mapping': 'obj', 'description': '要获取长度的对象（字符串、列表、字典等）'}
+])
+def get_length(**kwargs):
+    """获取对象的长度
+
+    Args:
+        obj: 要获取长度的对象
+
+    Returns:
+        int: 对象的长度
+    """
+    obj = kwargs.get('obj')
+    
+    if obj is None:
+        return 0
+
+    try:
+        result = len(obj)
+        
+        with allure.step(f"获取长度: 对象类型={type(obj).__name__}"):
+            allure.attach(
+                f"对象: {obj}\n类型: {type(obj).__name__}\n长度: {result}",
+                name="长度计算结果",
+                attachment_type=allure.attachment_type.TEXT
+            )
+        
+        return result
+    except Exception as e:
+        allure.attach(
+            f"获取长度失败: {str(e)}",
+            name="长度计算错误",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        raise
+
+
+@keyword_manager.register('获取最大值', [
+    {'name': '数据', 'mapping': 'data', 'description': '要比较的数据列表或多个参数'},
+    {'name': '默认值', 'mapping': 'default', 
+     'description': '当数据为空时的默认值', 'default': None}
+])
+def get_max_value(**kwargs):
+    """获取最大值
+
+    Args:
+        data: 要比较的数据
+        default: 当数据为空时的默认值
+
+    Returns:
+        最大值
+    """
+    data = kwargs.get('data')
+    default = kwargs.get('default')
+    
+    if data is None:
+        if default is not None:
+            return default
+        raise ValueError("数据不能为空")
+
+    try:
+        # 如果data不是可迭代的，将其转换为列表
+        if not hasattr(data, '__iter__') or isinstance(data, str):
+            data = [data]
+        
+        if len(data) == 0:
+            if default is not None:
+                return default
+            raise ValueError("数据列表为空")
+        
+        result = max(data)
+        
+        with allure.step(f"获取最大值: 数据长度={len(data)}"):
+            allure.attach(
+                f"输入数据: {data}\n最大值: {result}",
+                name="最大值计算结果",
+                attachment_type=allure.attachment_type.TEXT
+            )
+        
+        return result
+    except Exception as e:
+        allure.attach(
+            f"获取最大值失败: {str(e)}",
+            name="最大值计算错误",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        raise
+
+
+@keyword_manager.register('获取最小值', [
+    {'name': '数据', 'mapping': 'data', 'description': '要比较的数据列表或多个参数'},
+    {'name': '默认值', 'mapping': 'default', 
+     'description': '当数据为空时的默认值', 'default': None}
+])
+def get_min_value(**kwargs):
+    """获取最小值
+
+    Args:
+        data: 要比较的数据
+        default: 当数据为空时的默认值
+
+    Returns:
+        最小值
+    """
+    data = kwargs.get('data')
+    default = kwargs.get('default')
+    
+    if data is None:
+        if default is not None:
+            return default
+        raise ValueError("数据不能为空")
+
+    try:
+        # 如果data不是可迭代的，将其转换为列表
+        if not hasattr(data, '__iter__') or isinstance(data, str):
+            data = [data]
+        
+        if len(data) == 0:
+            if default is not None:
+                return default
+            raise ValueError("数据列表为空")
+        
+        result = min(data)
+        
+        with allure.step(f"获取最小值: 数据长度={len(data)}"):
+            allure.attach(
+                f"输入数据: {data}\n最小值: {result}",
+                name="最小值计算结果",
+                attachment_type=allure.attachment_type.TEXT
+            )
+        
+        return result
+    except Exception as e:
+        allure.attach(
+            f"获取最小值失败: {str(e)}",
+            name="最小值计算错误",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        raise
+
+
+@keyword_manager.register('绝对值', [
+    {'name': '数值', 'mapping': 'number', 'description': '要计算绝对值的数字'}
+])
+def get_absolute_value(**kwargs):
+    """计算数字的绝对值
+
+    Args:
+        number: 要计算绝对值的数字
+
+    Returns:
+        数字的绝对值
+    """
+    number = kwargs.get('number')
+    
+    if number is None:
+        raise ValueError("数值不能为空")
+
+    try:
+        result = abs(number)
+        
+        with allure.step(f"计算绝对值: {number}"):
+            allure.attach(
+                f"输入数值: {number}\n绝对值: {result}",
+                name="绝对值计算结果",
+                attachment_type=allure.attachment_type.TEXT
+            )
+        
+        return result
+    except Exception as e:
+        allure.attach(
+            f"计算绝对值失败: {str(e)}",
+            name="绝对值计算错误",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        raise
+
+
+@keyword_manager.register('四舍五入', [
+    {'name': '数值', 'mapping': 'number', 'description': '要四舍五入的数字'},
+    {'name': '小数位数', 'mapping': 'ndigits', 
+     'description': '保留的小数位数', 'default': 0}
+])
+def round_number(**kwargs):
+    """对数字进行四舍五入
+
+    Args:
+        number: 要四舍五入的数字
+        ndigits: 保留的小数位数，默认为0（整数）
+
+    Returns:
+        四舍五入后的数字
+    """
+    number = kwargs.get('number')
+    ndigits = kwargs.get('ndigits', 0)
+    
+    if number is None:
+        raise ValueError("数值不能为空")
+
+    try:
+        if ndigits == 0:
+            result = round(number)
+        else:
+            result = round(number, int(ndigits))
+        
+        with allure.step(f"四舍五入: {number} -> {ndigits}位小数"):
+            allure.attach(
+                f"输入数值: {number}\n小数位数: {ndigits}\n结果: {result}",
+                name="四舍五入结果",
+                attachment_type=allure.attachment_type.TEXT
+            )
+        
+        return result
+    except Exception as e:
+        allure.attach(
+            f"四舍五入失败: {str(e)}",
+            name="四舍五入错误",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        raise
+
+
+@keyword_manager.register('转换为字符串', [
+    {'name': '值', 'mapping': 'value', 'description': '要转换为字符串的值'}
+])
+def convert_to_string(**kwargs):
+    """将值转换为字符串
+
+    Args:
+        value: 要转换的值
+
+    Returns:
+        str: 转换后的字符串
+    """
+    value = kwargs.get('value')
+    
+    try:
+        result = str(value)
+        
+        with allure.step(f"转换为字符串: {type(value).__name__} -> str"):
+            allure.attach(
+                f"原始值: {value}\n原始类型: {type(value).__name__}\n"
+                f"转换结果: {result}\n结果类型: {type(result).__name__}",
+                name="字符串转换结果",
+                attachment_type=allure.attachment_type.TEXT
+            )
+        
+        return result
+    except Exception as e:
+        allure.attach(
+            f"转换为字符串失败: {str(e)}",
+            name="字符串转换错误",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        raise
+
+
+@keyword_manager.register('转换为整数', [
+    {'name': '值', 'mapping': 'value', 'description': '要转换为整数的值'},
+    {'name': '进制', 'mapping': 'base', 
+     'description': '数字进制（当值为字符串时）', 'default': 10}
+])
+def convert_to_integer(**kwargs):
+    """将值转换为整数
+
+    Args:
+        value: 要转换的值
+        base: 数字进制（当值为字符串时），默认为10
+
+    Returns:
+        int: 转换后的整数
+    """
+    value = kwargs.get('value')
+    base = kwargs.get('base', 10)
+    
+    if value is None:
+        raise ValueError("值不能为空")
+
+    try:
+        # 如果指定了非10进制，将值转换为字符串再进行进制转换
+        if int(base) != 10:
+            value_str = str(value)
+            result = int(value_str, int(base))
+        else:
+            result = int(value)
+        
+        with allure.step(f"转换为整数: {type(value).__name__} -> int"):
+            allure.attach(
+                f"原始值: {value}\n原始类型: {type(value).__name__}\n"
+                f"进制: {base}\n转换结果: {result}\n结果类型: {type(result).__name__}",
+                name="整数转换结果",
+                attachment_type=allure.attachment_type.TEXT
+            )
+        
+        return result
+    except Exception as e:
+        allure.attach(
+            f"转换为整数失败: {str(e)}",
+            name="整数转换错误",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        raise
+
+
+@keyword_manager.register('转换为浮点数', [
+    {'name': '值', 'mapping': 'value', 'description': '要转换为浮点数的值'}
+])
+def convert_to_float(**kwargs):
+    """将值转换为浮点数
+
+    Args:
+        value: 要转换的值
+
+    Returns:
+        float: 转换后的浮点数
+    """
+    value = kwargs.get('value')
+    
+    if value is None:
+        raise ValueError("值不能为空")
+
+    try:
+        result = float(value)
+        
+        with allure.step(f"转换为浮点数: {type(value).__name__} -> float"):
+            allure.attach(
+                f"原始值: {value}\n原始类型: {type(value).__name__}\n"
+                f"转换结果: {result}\n结果类型: {type(result).__name__}",
+                name="浮点数转换结果",
+                attachment_type=allure.attachment_type.TEXT
+            )
+        
+        return result
+    except Exception as e:
+        allure.attach(
+            f"转换为浮点数失败: {str(e)}",
+            name="浮点数转换错误",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        raise
+
+
+@keyword_manager.register('转换为布尔值', [
+    {'name': '值', 'mapping': 'value', 'description': '要转换为布尔值的值'}
+])
+def convert_to_boolean(**kwargs):
+    """将值转换为布尔值
+
+    Args:
+        value: 要转换的值
+
+    Returns:
+        bool: 转换后的布尔值
+    """
+    value = kwargs.get('value')
+    
+    try:
+        result = bool(value)
+        
+        with allure.step(f"转换为布尔值: {type(value).__name__} -> bool"):
+            allure.attach(
+                f"原始值: {value}\n原始类型: {type(value).__name__}\n"
+                f"转换结果: {result}\n结果类型: {type(result).__name__}",
+                name="布尔值转换结果",
+                attachment_type=allure.attachment_type.TEXT
+            )
+        
+        return result
+    except Exception as e:
+        allure.attach(
+            f"转换为布尔值失败: {str(e)}",
+            name="布尔值转换错误",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        raise

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 {