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

pytest_dsl/cli.py

@@ -64,8 +64,12 @@ def parse_args():
         )
         list_parser.add_argument(
             '--format', choices=['text', 'json'],
-            default='text',
-            help='输出格式：text(默认) 或 json'
+            default='json',
+            help='输出格式：json(默认) 或 text'
+        )
+        list_parser.add_argument(
+            '--output', '-o', type=str, default=None,
+            help='输出文件路径（仅对 json 格式有效，默认为 keywords.json）'
         )
         list_parser.add_argument(
             '--filter', type=str, default=None,
@@ -88,7 +92,10 @@ def parse_args():
         if '--list-keywords' in argv:
             parser.add_argument('--list-keywords', action='store_true')
             parser.add_argument(
-                '--format', choices=['text', 'json'], default='text'
+                '--format', choices=['text', 'json'], default='json'
+            )
+            parser.add_argument(
+                '--output', '-o', type=str, default=None
             )
             parser.add_argument('--filter', type=str, default=None)
             parser.add_argument(
@@ -178,13 +185,22 @@ def format_keyword_info_text(keyword_name, keyword_info, show_category=True):
             param_name = getattr(param, 'name', str(param))
             param_mapping = getattr(param, 'mapping', '')
             param_desc = getattr(param, 'description', '')
+            param_default = getattr(param, 'default', None)
 
+            # 构建参数描述
+            param_info = []
             if param_mapping and param_mapping != param_name:
-                lines.append(
-                    f"    {param_name} ({param_mapping}): {param_desc}"
-                )
+                param_info.append(f"{param_name} ({param_mapping})")
             else:
-                lines.append(f"    {param_name}: {param_desc}")
+                param_info.append(param_name)
+            
+            param_info.append(f": {param_desc}")
+            
+            # 添加默认值信息
+            if param_default is not None:
+                param_info.append(f" (默认值: {param_default})")
+            
+            lines.append(f"    {''.join(param_info)}")
     else:
         lines.append("  参数: 无")
 
@@ -221,6 +237,12 @@ def format_keyword_info_json(keyword_name, keyword_info):
             'mapping': getattr(param, 'mapping', ''),
             'description': getattr(param, 'description', '')
         }
+        
+        # 添加默认值信息
+        param_default = getattr(param, 'default', None)
+        if param_default is not None:
+            param_data['default'] = param_default
+        
         keyword_data['parameters'].append(param_data)
 
     # 函数文档
@@ -231,8 +253,8 @@ def format_keyword_info_json(keyword_name, keyword_info):
     return keyword_data
 
 
-def list_keywords(output_format='text', name_filter=None,
-                  category_filter='all'):
+def list_keywords(output_format='json', name_filter=None,
+                  category_filter='all', output_file=None):
     """罗列所有关键字信息"""
     import json
 
@@ -319,7 +341,25 @@ def list_keywords(output_format='text', name_filter=None,
             keyword_data = format_keyword_info_json(name, info)
             keywords_data['keywords'].append(keyword_data)
 
-        print(json.dumps(keywords_data, ensure_ascii=False, indent=2))
+        json_output = json.dumps(keywords_data, ensure_ascii=False, indent=2)
+        
+        # 确定输出文件名
+        if output_file is None:
+            output_file = 'keywords.json'
+        
+        # 写入到文件
+        try:
+            with open(output_file, 'w', encoding='utf-8') as f:
+                f.write(json_output)
+            print(f"关键字信息已保存到文件: {output_file}")
+            print(f"共 {total_count} 个关键字")
+            for cat, count in category_counts.items():
+                cat_names = {'builtin': '内置', 'custom': '自定义', 'remote': '远程'}
+                print(f"  {cat_names.get(cat, cat)}: {count} 个")
+        except Exception as e:
+            print(f"保存文件失败: {e}")
+            # 如果写入文件失败，则回退到打印
+            print(json_output)
 
 
 def load_yaml_variables(args):
@@ -433,16 +473,19 @@ def main():
         list_keywords(
             output_format=args.format,
             name_filter=args.filter,
-            category_filter=args.category
+            category_filter=args.category,
+            output_file=args.output
         )
     elif args.command == 'run':
         run_dsl_tests(args)
     elif args.command == 'list-keywords-compat':
         # 向后兼容：旧的--list-keywords格式
+        output_file = getattr(args, 'output', None)
         list_keywords(
             output_format=args.format,
             name_filter=args.filter,
-            category_filter=args.category
+            category_filter=args.category,
+            output_file=output_file
         )
     elif args.command == 'run-compat':
         # 向后兼容：默认执行DSL测试
@@ -458,8 +501,12 @@ def main_list_keywords():
     parser = argparse.ArgumentParser(description='查看pytest-dsl可用关键字列表')
     parser.add_argument(
         '--format', choices=['text', 'json'],
-        default='text',
-        help='输出格式：text(默认) 或 json'
+        default='json',
+        help='输出格式：json(默认) 或 text'
+    )
+    parser.add_argument(
+        '--output', '-o', type=str, default=None,
+        help='输出文件路径（仅对 json 格式有效，默认为 keywords.json）'
     )
     parser.add_argument(
         '--filter', type=str, default=None,
@@ -477,7 +524,8 @@ def main_list_keywords():
     list_keywords(
         output_format=args.format,
         name_filter=args.filter,
-        category_filter=args.category
+        category_filter=args.category,
+        output_file=args.output
     )
 
 

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:
@@ -34,6 +35,7 @@ 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"
@@ -41,7 +43,8 @@ class KeywordManager:
             self._keywords[name] = {
                 'func': wrapper,
                 'mapping': mapping,
-                'parameters': param_list
+                'parameters': param_list,
+                'defaults': defaults  # 存储默认值
             }
             return wrapper
         return decorator
@@ -51,7 +54,19 @@ class KeywordManager:
         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:
         """获取关键字信息"""
@@ -99,8 +114,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/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):
     """执行系统命令

pytest_dsl/remote/keyword_client.py

@@ -56,30 +56,51 @@ class RemoteKeywordClient:
         try:
             param_names = self.server.get_keyword_arguments(name)
             doc = self.server.get_keyword_documentation(name)
-
-            print(f"注册远程关键字: {name}, 参数: {param_names}")
+            
+            # 尝试获取参数详细信息（包括默认值）
+            param_details = []
+            try:
+                param_details = self.server.get_keyword_parameter_details(name)
+            except Exception as e:
+                print(f"获取关键字 {name} 的参数详细信息失败，使用基本信息: {e}")
+                # 如果新方法不可用，使用旧的方式
+                for param_name in param_names:
+                    param_details.append({
+                        'name': param_name,
+                        'mapping': param_name,
+                        'description': f'远程关键字参数: {param_name}',
+                        'default': None
+                    })
+
+            print(f"注册远程关键字: {name}, 参数详情: {param_details}")
 
             # 创建参数列表
             parameters = []
             param_mapping = {}  # 为每个关键字创建参数映射
 
-            for param_name in param_names:
+            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_default = param_detail.get('default')
+                
                 # 确保参数名称正确映射
-                # 这里我们保持原始参数名称，但在执行时会进行正确映射
                 parameters.append({
                     'name': param_name,
-                    'mapping': param_name,  # 保持原始参数名称
-                    'description': f'远程关键字参数: {param_name}'
+                    'mapping': param_mapping_name,
+                    'description': param_desc,
+                    'default': param_default  # 添加默认值支持
                 })
                 # 添加到参数映射
-                param_mapping[param_name] = param_name
+                param_mapping[param_name] = param_mapping_name
 
             # 添加步骤名称参数，这是所有关键字都应该有的
             if not any(p['name'] == '步骤名称' for p in parameters):
                 parameters.append({
                     'name': '步骤名称',
                     'mapping': 'step_name',
-                    'description': '自定义的步骤名称，用于在报告中显示'
+                    'description': '自定义的步骤名称，用于在报告中显示',
+                    'default': None
                 })
                 param_mapping['步骤名称'] = 'step_name'
 
@@ -93,6 +114,7 @@ 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},  # 添加默认值支持
                 'remote': True,  # 标记为远程关键字
                 'alias': self.alias,
                 'original_name': name
@@ -101,7 +123,8 @@ class RemoteKeywordClient:
             # 缓存关键字信息
             self.keyword_cache[name] = {
                 'parameters': param_names,  # 注意这里只缓存原始参数，不包括步骤名称
-                'doc': doc
+                'doc': doc,
+                'param_details': param_details  # 缓存详细参数信息
             }
 
             # 保存参数映射

pytest_dsl/remote/keyword_server.py

@@ -141,6 +141,7 @@ class RemoteKeywordServer:
         self.server.register_function(self.get_keyword_names)
         self.server.register_function(self.run_keyword)
         self.server.register_function(self.get_keyword_arguments)
+        self.server.register_function(self.get_keyword_parameter_details)
         self.server.register_function(self.get_keyword_documentation)
         self.server.register_function(self.authenticate)
 
@@ -289,6 +290,30 @@ class RemoteKeywordServer:
 
         return [param.name for param in keyword_info['parameters']]
 
+    def get_keyword_parameter_details(self, name):
+        """获取关键字的参数详细信息，包括默认值
+        
+        Args:
+            name: 关键字名称
+            
+        Returns:
+            list: 参数详细信息列表，每个元素包含name, mapping, description, default
+        """
+        keyword_info = keyword_manager.get_keyword_info(name)
+        if not keyword_info:
+            return []
+
+        param_details = []
+        for param in keyword_info['parameters']:
+            param_details.append({
+                'name': param.name,
+                'mapping': param.mapping,
+                'description': param.description,
+                'default': param.default
+            })
+        
+        return param_details
+
     def get_keyword_documentation(self, name):
         """获取关键字的文档信息"""
         keyword_info = keyword_manager.get_keyword_info(name)

{pytest_dsl-0.9.1.dist-info → pytest_dsl-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-dsl
-Version: 0.9.1
+Version: 0.10.0
 Summary: A DSL testing framework based on pytest
 Author: Chen Shuanglin
 License: MIT
@@ -42,11 +42,12 @@ pytest-dsl是一个革命性的关键字驱动测试框架，基于pytest构建
 ## ✨ 核心特性
 
 - 🎯 **门槛上手低** - 自然语言风格，只需少量编程基础
-- 🔧 **高度可扩展** - 轻松创建自定义关键字
+- 🔧 **高度可扩展** - 轻松创建自定义关键字，支持参数默认值
 - 🌐 **分布式执行** - 支持远程关键字调用
 - 🔄 **无缝集成** - 完美兼容pytest生态
 - 📊 **丰富报告** - 集成Allure测试报告
 - 🛡️ **企业级** - 支持变量管理、环境隔离
+- ⚡ **智能简化** - 参数默认值让DSL更加简洁易读
 
 ## 🚀 5分钟快速开始
 
@@ -850,17 +851,19 @@ def database_query(**kwargs):
 
 @keyword_manager.register('发送邮件', [
     {'name': '收件人', 'mapping': 'to_email', 'description': '收件人邮箱'},
-    {'name': '主题', 'mapping': 'subject', 'description': '邮件主题'},
-    {'name': '内容', 'mapping': 'content', 'description': '邮件内容'}
+    {'name': '主题', 'mapping': 'subject', 'description': '邮件主题', 'default': '测试邮件'},
+    {'name': '内容', 'mapping': 'content', 'description': '邮件内容', 'default': '这是一封测试邮件'},
+    {'name': '优先级', 'mapping': 'priority', 'description': '邮件优先级', 'default': 'normal'}
 ])
 def send_email(**kwargs):
     """发送邮件通知"""
     to_email = kwargs.get('to_email')
-    subject = kwargs.get('subject')
-    content = kwargs.get('content')
+    subject = kwargs.get('subject', '测试邮件')
+    content = kwargs.get('content', '这是一封测试邮件')
+    priority = kwargs.get('priority', 'normal')
 
     # 实现邮件发送逻辑
-    print(f"发送邮件到 {to_email}: {subject}")
+    print(f"发送邮件到 {to_email}: {subject} (优先级: {priority})")
 
     return True
 ```
@@ -874,10 +877,71 @@ def send_email(**kwargs):
 users = [数据库查询], 查询语句: "SELECT * FROM users WHERE active = 1"
 [打印], 内容: "查询到 ${len(users)} 个活跃用户"
 
-# 发送测试报告邮件
-[发送邮件], 收件人: "admin@example.com", 主题: "测试报告", 内容: "测试已完成"
+# 发送测试报告邮件 - 使用默认值
+[发送邮件], 收件人: "admin@example.com"  # 主题和内容使用默认值
+
+# 发送自定义邮件 - 覆盖默认值
+[发送邮件], 收件人: "dev@example.com", 主题: "部署完成", 内容: "系统已成功部署到生产环境"
+```
+
+### 5. 参数默认值功能 🆕
+
+pytest-dsl 现在支持为关键字参数设置默认值，让DSL编写更加简洁：
+
+#### 定义带默认值的关键字
+
+```python
+from pytest_dsl.core.keyword_manager import keyword_manager
+
+@keyword_manager.register('HTTP请求', [
+    {'name': '地址', 'mapping': 'url', 'description': '请求地址'},
+    {'name': '方法', 'mapping': 'method', 'description': 'HTTP方法', 'default': 'GET'},
+    {'name': '超时', 'mapping': 'timeout', 'description': '超时时间（秒）', 'default': 30},
+    {'name': '重试次数', 'mapping': 'retries', 'description': '重试次数', 'default': 3},
+    {'name': '验证SSL', 'mapping': 'verify_ssl', 'description': '是否验证SSL证书', 'default': True}
+])
+def http_request(**kwargs):
+    """HTTP请求关键字，支持默认值"""
+    url = kwargs.get('url')
+    method = kwargs.get('method', 'GET')  # 默认值也会自动应用
+    timeout = kwargs.get('timeout', 30)
+    retries = kwargs.get('retries', 3)
+    verify_ssl = kwargs.get('verify_ssl', True)
+    
+    # 执行HTTP请求逻辑
+    return {"status": "success", "method": method, "url": url}
 ```
 
+#### 在DSL中使用默认值
+
+```python
+@name: "默认值功能演示"
+
+# 只传递必需参数，其他使用默认值
+response1 = [HTTP请求], 地址: "https://api.example.com/users"
+# 等价于：方法: "GET", 超时: 30, 重试次数: 3, 验证SSL: True
+
+# 部分覆盖默认值
+response2 = [HTTP请求], 地址: "https://api.example.com/users", 方法: "POST", 超时: 60
+# 只覆盖方法和超时，重试次数和SSL验证仍使用默认值
+
+# 内置关键字也支持默认值
+random_num = [生成随机数]  # 使用默认范围 0-100，整数
+custom_num = [生成随机数], 最大值: 50  # 只修改最大值，其他保持默认
+
+# 生成随机字符串
+default_string = [生成随机字符串]  # 长度8，字母数字混合
+custom_string = [生成随机字符串], 长度: 12, 类型: "letters"  # 自定义长度和类型
+```
+
+#### 默认值的优势
+
+- **🎯 简化调用** - 只需传递关键参数，常用配置自动应用
+- **🔧 灵活覆盖** - 可选择性地覆盖任何默认值
+- **📖 提高可读性** - DSL更加简洁，重点突出
+- **🛡️ 减少错误** - 避免重复配置常用参数
+- **🌐 远程支持** - 远程关键字也完整支持默认值功能
+
 #### 支持远程模式的关键字
 
 ```python
@@ -1037,20 +1101,6 @@ CMD ["pytest-dsl", "tests/", "--yaml-vars", "config/prod.yaml"]
 - **集成测试** - 跨系统测试协调
 - **性能测试** - 结合其他工具进行性能测试
 
-## 🤝 贡献与支持
-
-我们欢迎您的贡献和反馈！
-
-- 🐛 [报告问题](https://github.com/your-repo/pytest-dsl/issues)
-- 💡 [功能建议](https://github.com/your-repo/pytest-dsl/discussions)
-- 🔧 [提交PR](https://github.com/your-repo/pytest-dsl/pulls)
-
-## 📄 许可证
-
-MIT License - 详见 [LICENSE](LICENSE) 文件
-
----
-
 ## 📋 示例验证
 
 本README.md中的大部分示例都已经过验证，确保可以正常运行。验证示例位于 `examples/readme_validation/` 目录中。
@@ -1086,3 +1136,18 @@ pytest-dsl api_basic.dsl
 ---
 
 🚀 **开始使用pytest-dsl，让测试自动化变得简单而强大！**
+
+
+## 🤝 贡献与支持
+
+我们欢迎您的贡献和反馈！
+
+- 🐛 [报告问题](https://github.com/felix-1991/pytest-dsl/issues)
+- 💡 [功能建议](https://github.com/felix-1991/pytest-dsl/discussions)
+- 🔧 [提交PR](https://github.com/felix-1991/pytest-dsl/pulls)
+
+## 📄 许可证
+
+MIT License - 详见 [LICENSE](LICENSE) 文件
+
+---

{pytest_dsl-0.9.1.dist-info → pytest_dsl-0.10.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pytest_dsl/__init__.py,sha256=FzwXGvmuvMhRBKxvCdh1h-yJ2wUOnDxcTbU4Nt5fHn8,301
-pytest_dsl/cli.py,sha256=x3zSHJqAGUNPUsJfhFRzVVwRE0zM02Lcr2bx_V8v4YA,15806
+pytest_dsl/cli.py,sha256=1lsjCkfRk-goGoi4E37FjFTGrg74idyB1ktV2J1F2IM,17763
 pytest_dsl/conftest_adapter.py,sha256=cevEb0oEZKTZfUrGe1-CmkFByxKhUtjuurBJP7kpLc0,149
 pytest_dsl/main_adapter.py,sha256=pUIPN_EzY3JCDlYK7yF_OeLDVqni8vtG15G7gVzPJXg,181
 pytest_dsl/plugin.py,sha256=MEQcdK0xdxwxCxPEDLNHX_kGF9Jc7bNxlNi4mx588DU,1190
@@ -14,7 +14,7 @@ pytest_dsl/core/dsl_executor_utils.py,sha256=cFoR2p3qQ2pb-UhkoefleK-zbuFqf0aBLh2
 pytest_dsl/core/global_context.py,sha256=NcEcS2V61MT70tgAsGsFWQq0P3mKjtHQr1rgT3yTcyY,3535
 pytest_dsl/core/http_client.py,sha256=1AHqtM_fkXf8JrM0ljMsJwUkyt-ysjR16NoyCckHfGc,15810
 pytest_dsl/core/http_request.py,sha256=nGMlx0mFc7rDLIdp9GJ3e09OQH3ryUA56yJdRZ99dOQ,57445
-pytest_dsl/core/keyword_manager.py,sha256=FtPsXlI7PxvVQMJfDN_nQYvRhkag5twvaHXjELQsCEo,4068
+pytest_dsl/core/keyword_manager.py,sha256=vm78au2s8waWD7k2sxltkOhJNgEJOGccDBTr8fgN3eU,4773
 pytest_dsl/core/lexer.py,sha256=WaLzt9IhtHiA90Fg2WGgfVztveCUhtgxzANBaEiy-F8,4347
 pytest_dsl/core/parser.py,sha256=xxy6yC6NdwHxln200aIuaWWN3w44uI8kkNlw8PTVpYI,11855
 pytest_dsl/core/parsetab.py,sha256=aN-2RRTr3MSbMyfe-9zOj_t96Xu84avE29GWqH6nqmg,31472
@@ -55,18 +55,18 @@ pytest_dsl/examples/quickstart/api_basics.auto,sha256=SrDRBASqy5ZMXnmfczuKNCXoTi
 pytest_dsl/examples/quickstart/assertions.auto,sha256=FWrwod3L8oxuKCnA-lnVO2fzs5bZsXWaVqd6zehKrzw,859
 pytest_dsl/examples/quickstart/loops.auto,sha256=ZNZ6qP636v8QMY8QRyTUBB43gWCsqHbpPQw2RqamvOk,516
 pytest_dsl/keywords/__init__.py,sha256=5aiyPU_t1UiB2MEZ6M9ffOKnV1mFT_2YHxnZvyWaBNI,372
-pytest_dsl/keywords/assertion_keywords.py,sha256=WOCGP7WX2wZ6mQPDGmi38LWdG2NaThHoNU54xc8VpxI,23027
+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=DY1SvUgOziN6Ga-QgE0q4XFd2qGGwvbv1B_k2gTdPLw,25554
-pytest_dsl/keywords/system_keywords.py,sha256=n_jRrMvSv2v6Pm_amokfyLNVOLYP7CFWbBE3_dlO7h4,11299
+pytest_dsl/keywords/http_keywords.py,sha256=B2IoWZjmAk0bQf1o5hHhHEDHpAl010PrDVA4iJ1mLk0,25605
+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=Zem86qW6TudPAiiqU8wAFQeCoBl5urPRiAhFDPkAGgQ,15618
-pytest_dsl/remote/keyword_server.py,sha256=5nKLUIqgAVJoLL2t2dHaJb9S95z4K3UusSMEBylU6X4,20549
+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-0.9.1.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
-pytest_dsl-0.9.1.dist-info/METADATA,sha256=tmPXjA1YZtuduO_Fus6vujf1vMOYxx3L2n7c7ZV4oyc,26712
-pytest_dsl-0.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytest_dsl-0.9.1.dist-info/entry_points.txt,sha256=PLOBbH02OGY1XR1JDKIZB1Em87loUvbgMRWaag-5FhY,204
-pytest_dsl-0.9.1.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
-pytest_dsl-0.9.1.dist-info/RECORD,,
+pytest_dsl-0.10.0.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
+pytest_dsl-0.10.0.dist-info/METADATA,sha256=wzdKD6pqnD0Xj4xP2GlWg5R0r5JewGH2hk7-rHTadZs,29613
+pytest_dsl-0.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytest_dsl-0.10.0.dist-info/entry_points.txt,sha256=PLOBbH02OGY1XR1JDKIZB1Em87loUvbgMRWaag-5FhY,204
+pytest_dsl-0.10.0.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
+pytest_dsl-0.10.0.dist-info/RECORD,,