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

pytest_dsl/core/custom_keyword_manager.py

@@ -1,11 +1,8 @@
-from typing import Dict, Any, List, Optional
 import os
-import pathlib
 from pytest_dsl.core.lexer import get_lexer
 from pytest_dsl.core.parser import get_parser, Node
 from pytest_dsl.core.dsl_executor import DSLExecutor
 from pytest_dsl.core.keyword_manager import keyword_manager
-from pytest_dsl.core.context import TestContext
 
 
 class CustomKeywordManager:
@@ -127,7 +124,7 @@ class CustomKeywordManager:
             return
 
         for node in statements_node.children:
-            if node.type == 'CustomKeyword':
+            if node.type in ['CustomKeyword', 'Function']:
                 self._register_custom_keyword(node, file_path)
 
     def _register_custom_keyword(self, node: Node, file_path: str) -> None:

pytest_dsl/core/keyword_manager.py

@@ -1,13 +1,14 @@
-from typing import Dict, Any, Callable, List
+from typing import Dict, Any, Callable, List, Optional
 import functools
 import allure
 
 
 class Parameter:
-    def __init__(self, name: str, mapping: str, description: str):
+    def __init__(self, name: str, mapping: str, description: str, default: Any = None):
         self.name = name
         self.mapping = mapping
         self.description = description
+        self.default = default
 
 
 class KeywordManager:
@@ -15,8 +16,14 @@ class KeywordManager:
         self._keywords: Dict[str, Dict] = {}
         self.current_context = None
 
-    def register(self, name: str, parameters: List[Dict]):
-        """关键字注册装饰器"""
+    def register(self, name: str, parameters: List[Dict], source_info: Optional[Dict] = None):
+        """关键字注册装饰器
+        
+        Args:
+            name: 关键字名称
+            parameters: 参数列表
+            source_info: 来源信息，包含 source_type, source_name, module_name 等
+        """
         def decorator(func: Callable) -> Callable:
             @functools.wraps(func)
             def wrapper(**kwargs):
@@ -34,24 +41,94 @@ class KeywordManager:
 
             param_list = [Parameter(**p) for p in parameters]
             mapping = {p.name: p.mapping for p in param_list}
+            defaults = {p.mapping: p.default for p in param_list if p.default is not None}
             
             # 自动添加 step_name 到 mapping 中
             mapping["步骤名称"] = "step_name"
             
-            self._keywords[name] = {
+            # 构建关键字信息，包含来源信息
+            keyword_info = {
                 'func': wrapper,
                 'mapping': mapping,
-                'parameters': param_list
+                'parameters': param_list,
+                'defaults': defaults  # 存储默认值
             }
+            
+            # 添加来源信息
+            if source_info:
+                keyword_info.update(source_info)
+            else:
+                # 尝试从函数模块推断来源信息
+                keyword_info.update(self._infer_source_info(func))
+            
+            self._keywords[name] = keyword_info
             return wrapper
         return decorator
 
+    def _infer_source_info(self, func: Callable) -> Dict:
+        """从函数推断来源信息"""
+        source_info = {}
+        
+        if hasattr(func, '__module__'):
+            module_name = func.__module__
+            source_info['module_name'] = module_name
+            
+            if module_name.startswith('pytest_dsl.keywords'):
+                # 内置关键字
+                source_info['source_type'] = 'builtin'
+                source_info['source_name'] = 'pytest-dsl内置'
+            elif 'pytest_dsl' in module_name:
+                # pytest-dsl相关但不是内置的
+                source_info['source_type'] = 'internal'
+                source_info['source_name'] = 'pytest-dsl'
+            else:
+                # 第三方插件或用户自定义
+                source_info['source_type'] = 'external'
+                # 提取可能的包名
+                parts = module_name.split('.')
+                if len(parts) > 1:
+                    source_info['source_name'] = parts[0]
+                else:
+                    source_info['source_name'] = module_name
+        
+        return source_info
+
+    def register_with_source(self, name: str, parameters: List[Dict], 
+                           source_type: str, source_name: str, **kwargs):
+        """带来源信息的关键字注册装饰器
+        
+        Args:
+            name: 关键字名称
+            parameters: 参数列表
+            source_type: 来源类型 (builtin, plugin, local, remote, project_custom)
+            source_name: 来源名称 (插件名、文件路径等)
+            **kwargs: 其他来源相关信息
+        """
+        source_info = {
+            'source_type': source_type,
+            'source_name': source_name,
+            **kwargs
+        }
+        return self.register(name, parameters, source_info)
+
     def execute(self, keyword_name: str, **params: Any) -> Any:
         """执行关键字"""
         keyword_info = self._keywords.get(keyword_name)
         if not keyword_info:
             raise KeyError(f"未注册的关键字: {keyword_name}")
-        return keyword_info['func'](**params)
+        
+        # 应用默认值
+        final_params = {}
+        defaults = keyword_info.get('defaults', {})
+        
+        # 首先设置所有默认值
+        for param_key, default_value in defaults.items():
+            final_params[param_key] = default_value
+        
+        # 然后用传入的参数覆盖默认值
+        final_params.update(params)
+        
+        return keyword_info['func'](**final_params)
 
     def get_keyword_info(self, keyword_name: str) -> Dict:
         """获取关键字信息"""
@@ -69,6 +146,18 @@ class KeywordManager:
             
         return keyword_info
 
+    def get_keywords_by_source(self) -> Dict[str, List[str]]:
+        """按来源分组获取关键字"""
+        by_source = {}
+        
+        for name, info in self._keywords.items():
+            source_name = info.get('source_name', '未知来源')
+            if source_name not in by_source:
+                by_source[source_name] = []
+            by_source[source_name].append(name)
+        
+        return by_source
+
     def _log_execution(self, keyword_name: str, params: Dict, result: Any) -> None:
         """记录关键字执行结果"""
         allure.attach(
@@ -99,8 +188,9 @@ class KeywordManager:
                     description="自定义的步骤名称，用于在报告中显示"
                 ))
             for param in info['parameters']:
+                default_info = f" (默认值: {param.default})" if param.default is not None else ""
                 docs.append(
-                    f"  {param.name} ({param.mapping}): {param.description}")
+                    f"  {param.name} ({param.mapping}): {param.description}{default_info}")
             docs.append("")
         return "\n".join(docs)
 

pytest_dsl/core/plugin_discovery.py

@@ -62,7 +62,28 @@ def load_plugin_keywords(plugin_name: str) -> None:
         
         # 如果插件有register_keywords函数，调用它
         if hasattr(plugin, 'register_keywords') and callable(plugin.register_keywords):
-            plugin.register_keywords(keyword_manager)
+            # 创建一个包装的关键字管理器，自动添加来源信息
+            class PluginKeywordManager:
+                def __init__(self, original_manager, plugin_name):
+                    self.original_manager = original_manager
+                    self.plugin_name = plugin_name
+                
+                def register(self, name: str, parameters):
+                    """带插件来源信息的注册方法"""
+                    return self.original_manager.register_with_source(
+                        name, parameters, 
+                        source_type='plugin',
+                        source_name=plugin_name,
+                        module_name=plugin_name
+                    )
+                
+                def __getattr__(self, name):
+                    # 代理其他方法到原始管理器
+                    return getattr(self.original_manager, name)
+            
+            plugin_manager = PluginKeywordManager(keyword_manager, plugin_name)
+            plugin.register_keywords(plugin_manager)
+            print(f"通过register_keywords加载插件: {plugin_name}")
             return
         
         # 否则，遍历包中的所有模块
@@ -71,13 +92,29 @@ def load_plugin_keywords(plugin_name: str) -> None:
                 if not is_pkg:
                     try:
                         module = importlib.import_module(name)
+                        print(f"加载插件模块: {name}")
                         # 模块已导入，关键字装饰器会自动注册
+                        # 但我们需要在导入后更新来源信息
+                        _update_keywords_source_info(plugin_name, name)
                     except ImportError as e:
                         print(f"无法导入模块 {name}: {e}")
     except ImportError as e:
         print(f"无法导入插件 {plugin_name}: {e}")
 
 
+def _update_keywords_source_info(plugin_name: str, module_name: str):
+    """更新模块中关键字的来源信息"""
+    # 找到可能是新注册的关键字
+    for keyword_name, keyword_info in keyword_manager._keywords.items():
+        if keyword_info.get('module_name') == module_name:
+            # 更新来源信息
+            keyword_info.update({
+                'source_type': 'plugin',
+                'source_name': plugin_name,
+                'plugin_module': module_name
+            })
+
+
 def load_all_plugins() -> None:
     """
     发现并加载所有已安装的关键字插件

pytest_dsl/keywords/assertion_keywords.py

@@ -48,7 +48,8 @@ def _compare_values(actual: Any, expected: Any, operator: str = "==") -> bool:
     Args:
         actual: 实际值
         expected: 预期值
-        operator: 比较运算符 (==, !=, >, <, >=, <=, contains, not_contains, matches, and, or, not)
+        operator: 比较运算符 (==, !=, >, <, >=, <=, contains, not_contains, 
+                 matches, and, or, not)
 
     Returns:
         比较结果 (True/False)
@@ -96,8 +97,9 @@ def _compare_values(actual: Any, expected: Any, operator: str = "==") -> bool:
 
 
 @keyword_manager.register('断言', [
-    {'name': '条件', 'mapping': 'condition', 'description': '断言条件表达式，例如: "${value} == 100" 或 "1 + 1 == 2"'},
-    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息'},
+    {'name': '条件', 'mapping': 'condition', 
+     'description': '断言条件表达式，例如: "${value} == 100" 或 "1 + 1 == 2"'},
+    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息', 'default': '断言失败'},
 ])
 def assert_condition(**kwargs):
     """执行表达式断言
@@ -116,9 +118,11 @@ def assert_condition(**kwargs):
     message = kwargs.get('message', '断言失败')
     context = kwargs.get('context')
 
-    # 简单解析表达式，支持 ==, !=, >, <, >=, <=, contains, not_contains, matches, in, and, or, not
+    # 简单解析表达式，支持 ==, !=, >, <, >=, <=, contains, not_contains, 
+    # matches, in, and, or, not
     # 格式: "left_value operator right_value" 或 "boolean_expression"
-    operators = ["==", "!=", ">", "<", ">=", "<=", "contains", "not_contains", "matches", "in", "and", "or", "not"]
+    operators = ["==", "!=", ">", "<", ">=", "<=", "contains", "not_contains", 
+                 "matches", "in", "and", "or", "not"]
 
     # 先检查是否包含这些操作符
     operator_used = None
@@ -132,7 +136,8 @@ def assert_condition(**kwargs):
         try:
             # 对条件进行变量替换
             if '${' in condition:
-                condition = context.executor.variable_replacer.replace_in_string(condition)
+                condition = context.executor.variable_replacer.replace_in_string(
+                    condition)
             # 尝试直接求值
             result = eval(condition)
             if not isinstance(result, bool):
@@ -141,7 +146,8 @@ def assert_condition(**kwargs):
                 raise AssertionError(f"{message}. 布尔表达式求值为假: {condition}")
             return True
         except Exception as e:
-            raise AssertionError(f"{message}. 无法解析条件表达式: {condition}. 错误: {str(e)}")
+            raise AssertionError(
+                f"{message}. 无法解析条件表达式: {condition}. 错误: {str(e)}")
 
     # 解析左值和右值
     left_value, right_value = condition.split(f" {operator_used} ", 1)
@@ -351,8 +357,8 @@ def assert_condition(**kwargs):
     {'name': 'JSON数据', 'mapping': 'json_data', 'description': 'JSON数据（字符串或对象）'},
     {'name': 'JSONPath', 'mapping': 'jsonpath', 'description': 'JSONPath表达式'},
     {'name': '预期值', 'mapping': 'expected_value', 'description': '预期的值'},
-    {'name': '操作符', 'mapping': 'operator', 'description': '比较操作符，默认为"=="'},
-    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息'},
+    {'name': '操作符', 'mapping': 'operator', 'description': '比较操作符', 'default': '=='},
+    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息', 'default': 'JSON断言失败'},
 ])
 def assert_json(**kwargs):
     """执行JSON断言
@@ -476,7 +482,7 @@ def extract_json(**kwargs):
 @keyword_manager.register('类型断言', [
     {'name': '值', 'mapping': 'value', 'description': '要检查的值'},
     {'name': '类型', 'mapping': 'type', 'description': '预期的类型 (string, number, boolean, list, object, null)'},
-    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息'},
+    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息', 'default': '类型断言失败'},
 ])
 def assert_type(**kwargs):
     """断言值的类型
@@ -545,8 +551,8 @@ def assert_type(**kwargs):
 @keyword_manager.register('数据比较', [
     {'name': '实际值', 'mapping': 'actual', 'description': '实际值'},
     {'name': '预期值', 'mapping': 'expected', 'description': '预期值'},
-    {'name': '操作符', 'mapping': 'operator', 'description': '比较操作符，默认为"=="'},
-    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息'},
+    {'name': '操作符', 'mapping': 'operator', 'description': '比较操作符', 'default': '=='},
+    {'name': '消息', 'mapping': 'message', 'description': '断言失败时的错误消息', 'default': '数据比较失败'},
 ])
 def compare_values(**kwargs):
     """比较两个值

pytest_dsl/keywords/http_keywords.py

@@ -223,14 +223,14 @@ def _normalize_retry_config(config, assert_retry_count=None, assert_retry_interv
 
 
 @keyword_manager.register('HTTP请求', [
-    {'name': '客户端', 'mapping': 'client', 'description': '客户端名称，对应YAML变量文件中的客户端配置'},
+    {'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': '禁用客户端配置中的授权机制，默认为false'},
+    {'name': '禁用授权', 'mapping': 'disable_auth', 'description': '禁用客户端配置中的授权机制', 'default': False},
     {'name': '模板', 'mapping': 'template', 'description': '使用YAML变量文件中定义的请求模板'},
-    {'name': '断言重试次数', 'mapping': 'assert_retry_count', 'description': '断言失败时的重试次数'},
-    {'name': '断言重试间隔', 'mapping': 'assert_retry_interval', 'description': '断言重试间隔时间（秒）'}
+    {'name': '断言重试次数', 'mapping': 'assert_retry_count', 'description': '断言失败时的重试次数', 'default': 0},
+    {'name': '断言重试间隔', 'mapping': 'assert_retry_interval', 'description': '断言重试间隔时间（秒）', 'default': 1}
 ])
 def http_request(context, **kwargs):
     """执行HTTP请求

pytest_dsl/keywords/system_keywords.py

@@ -24,46 +24,54 @@ def return_result(**kwargs):
 
 
 @keyword_manager.register('等待', [
-    {'name': '秒数', 'mapping': 'seconds', 'description': '等待的秒数，可以是小数'}
+    {'name': '秒数', 'mapping': 'seconds', 
+     'description': '等待的秒数，可以是小数', 'default': 1}
 ])
 def wait_seconds(**kwargs):
-    """等待指定的秒数
+    """等待指定的时间
 
     Args:
-        seconds: 等待的秒数，可以是小数表示毫秒级等待
+        seconds: 等待的秒数，默认为1秒
     """
-    seconds = float(kwargs.get('seconds', 0))
+    seconds = float(kwargs.get('seconds', 1))
+    
     with allure.step(f"等待 {seconds} 秒"):
         time.sleep(seconds)
-    return True
+        allure.attach(
+            f"等待时间: {seconds} 秒",
+            name="等待完成",
+            attachment_type=allure.attachment_type.TEXT
+        )
 
 
 @keyword_manager.register('获取当前时间', [
-    {'name': '格式', 'mapping': 'format', 'description': '时间格式，例如 "%Y-%m-%d %H:%M:%S"，默认返回时间戳'},
-    {'name': '时区', 'mapping': 'timezone', 'description': '时区，例如 "Asia/Shanghai"，默认为本地时区'}
+    {'name': '格式', 'mapping': 'format', 
+     'description': '时间格式，例如 "%Y-%m-%d %H:%M:%S"', 'default': 'timestamp'},
+    {'name': '时区', 'mapping': 'timezone', 
+     'description': '时区，例如 "Asia/Shanghai"', 'default': 'Asia/Shanghai'}
 ])
 def get_current_time(**kwargs):
     """获取当前时间
 
     Args:
-        format: 时间格式，如果不提供则返回时间戳
-        timezone: 时区，默认为本地时区
+        format: 时间格式，如果设置为'timestamp'则返回时间戳
+        timezone: 时区，默认为Asia/Shanghai
 
     Returns:
-        str: 格式化的时间字符串或时间戳
+        str/float: 格式化的时间字符串或时间戳
     """
-    time_format = kwargs.get('format')
-    timezone = kwargs.get('timezone')
+    format_str = kwargs.get('format', 'timestamp')
+    timezone_str = kwargs.get('timezone', 'Asia/Shanghai')
 
     # 获取当前时间
-    if timezone:
+    if timezone_str and timezone_str != 'local':
         import pytz
         try:
-            tz = pytz.timezone(timezone)
+            tz = pytz.timezone(timezone_str)
             current_time = datetime.datetime.now(tz)
         except Exception as e:
             allure.attach(
-                f"时区设置异常: {str(e)}",
+                f"时区设置异常: {str(e)}，使用本地时区",
                 name="时区设置异常",
                 attachment_type=allure.attachment_type.TEXT
             )
@@ -72,34 +80,36 @@ def get_current_time(**kwargs):
         current_time = datetime.datetime.now()
 
     # 格式化时间
-    if time_format:
+    if format_str and format_str != 'timestamp':
         try:
-            result = current_time.strftime(time_format)
+            result = current_time.strftime(format_str)
         except Exception as e:
             allure.attach(
-                f"时间格式化异常: {str(e)}",
+                f"时间格式化异常: {str(e)}，返回默认格式",
                 name="时间格式化异常",
                 attachment_type=allure.attachment_type.TEXT
             )
-            result = str(current_time)
+            result = current_time.strftime('%Y-%m-%d %H:%M:%S')
     else:
         # 返回时间戳
-        result = str(int(current_time.timestamp()))
+        result = int(current_time.timestamp())
 
     return result
 
 
 @keyword_manager.register('生成随机字符串', [
-    {'name': '长度', 'mapping': 'length', 'description': '随机字符串的长度，默认为8'},
+    {'name': '长度', 'mapping': 'length', 
+     'description': '随机字符串的长度', 'default': 8},
     {'name': '类型', 'mapping': 'type',
-        'description': '字符类型：字母(letters)、数字(digits)、字母数字(alphanumeric)、全部(all)，默认为字母数字'}
+     'description': '字符类型：字母(letters)、数字(digits)、字母数字(alphanumeric)、全部(all)', 
+     'default': 'alphanumeric'}
 ])
 def generate_random_string(**kwargs):
-    """生成随机字符串
+    """生成指定长度和类型的随机字符串
 
     Args:
-        length: 随机字符串的长度
-        type: 字符类型：字母、数字、字母数字、全部
+        length: 字符串长度
+        type: 字符类型
 
     Returns:
         str: 生成的随机字符串
@@ -134,12 +144,15 @@ def generate_random_string(**kwargs):
 
 
 @keyword_manager.register('生成随机数', [
-    {'name': '最小值', 'mapping': 'min', 'description': '随机数的最小值，默认为0'},
-    {'name': '最大值', 'mapping': 'max', 'description': '随机数的最大值，默认为100'},
-    {'name': '小数位数', 'mapping': 'decimals', 'description': '小数位数，默认为0（整数）'}
+    {'name': '最小值', 'mapping': 'min', 
+     'description': '随机数的最小值', 'default': 0},
+    {'name': '最大值', 'mapping': 'max', 
+     'description': '随机数的最大值', 'default': 100},
+    {'name': '小数位数', 'mapping': 'decimals', 
+     'description': '小数位数，0表示整数', 'default': 0}
 ])
 def generate_random_number(**kwargs):
-    """生成随机数
+    """生成指定范围内的随机数
 
     Args:
         min: 随机数的最小值
@@ -172,24 +185,27 @@ 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', 'description': '操作参数1，根据操作类型不同而不同'},
-    {'name': '参数2', 'mapping': 'param2', 'description': '操作参数2，根据操作类型不同而不同'}
+    {'name': '参数1', 'mapping': 'param1', 
+     'description': '操作参数1，根据操作类型不同而不同', 'default': ''},
+    {'name': '参数2', 'mapping': 'param2', 
+     'description': '操作参数2，根据操作类型不同而不同', 'default': ''}
 ])
 def string_operation(**kwargs):
     """字符串操作
 
     Args:
-        operation: 操作类型
+        operation: 操作类型，默认为strip（去空格）
         string: 要操作的字符串
-        param1: 操作参数1
-        param2: 操作参数2
+        param1: 操作参数1，默认为空字符串
+        param2: 操作参数2，默认为空字符串
 
     Returns:
         str: 操作结果
     """
-    operation = kwargs.get('operation', '').lower()
+    operation = kwargs.get('operation', 'strip').lower()
     string = str(kwargs.get('string', ''))
     param1 = kwargs.get('param1', '')
     param2 = kwargs.get('param2', '')
@@ -204,12 +220,16 @@ def string_operation(**kwargs):
         result = string.replace(str(param1), str(param2))
     elif operation == 'split':
         # 分割字符串
-        result = string.split(str(param1))
-        if param2 and param2.isdigit():
-            # 如果提供了索引，返回指定位置的元素
-            index = int(param2)
-            if 0 <= index < len(result):
-                result = result[index]
+        if param1:  # 如果提供了分隔符
+            result = string.split(str(param1))
+            if param2 and param2.isdigit():
+                # 如果提供了索引，返回指定位置的元素
+                index = int(param2)
+                if 0 <= index < len(result):
+                    result = result[index]
+        else:
+            # 默认按空格分割
+            result = string.split()
     elif operation == 'upper':
         # 转大写
         result = string.upper()
@@ -217,19 +237,21 @@ def string_operation(**kwargs):
         # 转小写
         result = string.lower()
     elif operation == 'strip':
-        # 去空格
+        # 去空格（默认操作）
         result = string.strip()
     else:
         # 未知操作，返回原字符串
         allure.attach(
-            f"未知的字符串操作: {operation}",
+            f"未知的字符串操作: {operation}，使用默认操作strip",
             name="字符串操作错误",
             attachment_type=allure.attachment_type.TEXT
         )
+        result = string.strip()
 
     with allure.step(f"字符串操作: {operation}"):
         allure.attach(
-            f"原字符串: {string}\n操作: {operation}\n参数1: {param1}\n参数2: {param2}\n结果: {result}",
+            f"原字符串: {string}\n操作: {operation}\n参数1: {param1}\n"
+            f"参数2: {param2}\n结果: {result}",
             name="字符串操作结果",
             attachment_type=allure.attachment_type.TEXT
         )
@@ -239,7 +261,8 @@ def string_operation(**kwargs):
 
 @keyword_manager.register('日志', [
     {'name': '级别', 'mapping': 'level',
-        'description': '日志级别：DEBUG, INFO, WARNING, ERROR, CRITICAL，默认为INFO'},
+     'description': '日志级别：DEBUG, INFO, WARNING, ERROR, CRITICAL', 
+     'default': 'INFO'},
     {'name': '消息', 'mapping': 'message', 'description': '日志消息内容'}
 ])
 def log_message(**kwargs):
@@ -270,8 +293,10 @@ def log_message(**kwargs):
 
 @keyword_manager.register('执行命令', [
     {'name': '命令', 'mapping': 'command', 'description': '要执行的系统命令'},
-    {'name': '超时', 'mapping': 'timeout', 'description': '命令执行超时时间（秒），默认为60秒'},
-    {'name': '捕获输出', 'mapping': 'capture_output', 'description': '是否捕获命令输出，默认为True'}
+    {'name': '超时', 'mapping': 'timeout', 
+     'description': '命令执行超时时间（秒）', 'default': 60},
+    {'name': '捕获输出', 'mapping': 'capture_output', 
+     'description': '是否捕获命令输出', 'default': True}
 ])
 def execute_command(**kwargs):
     """执行系统命令