pytest-dsl 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

pytest_dsl/core/http_request.py

@@ -13,7 +13,7 @@ from pytest_dsl.core.http_client import http_client_manager
 
 # 定义支持的比较操作符
 COMPARISON_OPERATORS = {
-    "eq", "neq", "lt", "lte", "gt", "gte", "in", "not_in"
+    "eq", "neq", "lt", "lte", "gt", "gte", "in", "not_in", "matches"
 }
 
 # 定义支持的断言类型
@@ -397,14 +397,14 @@ class HTTPRequest:
                         if extractor_type in ["jsonpath", "body", "header"]:
                             # 当提取器是jsonpath/body/header时，将contains当作断言类型处理
                             assertion_type = assertion[1]
-                            compare_operator = "eq"  # 默认操作符
+                            compare_operator = assertion[1]  # 匹配操作符和断言类型
                         else:
                             # 否则当作操作符处理
                             assertion_type = "value"
                             compare_operator = assertion[1]
                     else:
                         assertion_type = "value"  # 标记为值比较
-                        compare_operator = assertion[1]  # 比较操作符
+                        compare_operator = assertion[1]
                     
                     expected_value = assertion[2]  # 预期值
                 else:
@@ -421,12 +421,12 @@ class HTTPRequest:
                         # 特殊处理类型断言，它确实需要一个值但在这种格式中没有提供
                         if assertion_type == "type":
                             raise ValueError(f"断言类型 'type' 需要预期值(string/number/boolean/array/object/null)，但未提供: {assertion}")
-                        # 如果是不需要值的断言类型，则允许这种格式
+                        # 断言类型作为操作符
                         expected_value = None
-                        compare_operator = "eq"  # 默认比较操作符
+                        compare_operator = assertion_type  # 使用断言类型作为操作符
                     else:
                         expected_value = None
-                        compare_operator = "eq"  # 默认比较操作符
+                        compare_operator = assertion_type  # 存在性断言的操作符就是断言类型本身
             elif len(assertion) == 4:  # 带操作符的断言 ["jsonpath", "$.id", "eq", 1] 或特殊断言 ["jsonpath", "$.type", "type", "string"]
                 extraction_path = assertion[1]
                 
@@ -449,11 +449,11 @@ class HTTPRequest:
                         # 对于长度断言，总是需要有比较操作符和期望值
                         if len(assertion) < 4:
                             raise ValueError(f"长度断言需要提供预期值: {assertion}")
-                        compare_operator = "eq"  # 在这种4元素格式中，使用默认比较操作符eq
+                        compare_operator = "eq"  # 默认使用相等比较
                         expected_value = assertion[3]  # 预期长度值
                     else:
                         # 对于其他特殊断言，使用第四个元素作为期望值
-                        compare_operator = "eq"  # 默认比较操作符
+                        compare_operator = assertion_type  # 使用断言类型作为操作符
                         expected_value = assertion[3]
             else:  # 5个参数，例如 ["jsonpath", "$", "length", "eq", 10]
                 extraction_path = assertion[1]
@@ -647,15 +647,34 @@ class HTTPRequest:
         
         # 执行完所有断言后，如果有失败的断言，抛出异常
         if failed_assertions:
-            if len(failed_assertions) == 1:
-                # 只有一个断言失败时，直接使用该断言的错误消息
-                raise AssertionError(failed_assertions[0][1])
-            else:
-                # 多个断言失败时，汇总所有错误
-                error_summary = f"多个断言失败 ({len(failed_assertions)}/{len(process_asserts)}):\n"
-                for idx, (assertion_idx, error_msg) in enumerate(failed_assertions, 1):
-                    error_summary += f"\n{idx}. 断言 #{assertion_idx+1}: {error_msg.split('断言失败')[0].strip()}"
-                raise AssertionError(error_summary)
+            # 检查是否只收集失败而不抛出异常（由重试机制设置）
+            collect_only = self.config.get('_collect_failed_assertions_only', False)
+            
+            if not collect_only:
+                if len(failed_assertions) == 1:
+                    # 只有一个断言失败时，直接使用该断言的错误消息
+                    raise AssertionError(failed_assertions[0][1])
+                else:
+                    # 多个断言失败时，汇总所有错误
+                    error_summary = f"多个断言失败 ({len(failed_assertions)}/{len(process_asserts)}):\n"
+                    for idx, (assertion_idx, error_msg) in enumerate(failed_assertions, 1):
+                        # 从错误消息中提取关键部分
+                        if "[" in error_msg and "]" in error_msg:
+                            # 尝试提取提取器类型
+                            extractor_type = error_msg.split("[", 1)[1].split("]")[0] if "[" in error_msg else "未知"
+                        else:
+                            extractor_type = "未知"
+                        
+                        # 生成简短的断言标题
+                        assertion_title = f"断言 #{assertion_idx+1} [{extractor_type}]"
+                        
+                        # 添加分隔线使错误更容易辨别
+                        error_summary += f"\n{'-' * 30}\n{idx}. {assertion_title}:\n{'-' * 30}\n{error_msg}"
+                    
+                    # 添加底部分隔线
+                    error_summary += f"\n{'-' * 50}"
+                    
+                    raise AssertionError(error_summary)
         
         # 返回断言结果和需要重试的断言
         return assert_results, failed_retryable_assertions
@@ -716,15 +735,24 @@ class HTTPRequest:
             elif extractor_type == "status":
                 return self.response.status_code
             elif extractor_type == "body":
-                return self.response.text
+                if isinstance(self.response.text, str):
+                    return self.response.text
+                return str(self.response.text)
             elif extractor_type == "response_time":
                 return self.response.elapsed.total_seconds() * 1000
             else:
                 raise ValueError(f"不支持的提取器类型: {extractor_type}")
         except Exception as e:
+            # 记录提取错误
+            error_message = f"提取值失败({extractor_type}, {extraction_path}): {type(e).__name__}: {str(e)}"
+            allure.attach(
+                error_message,
+                name=f"提取错误: {extractor_type}",
+                attachment_type=allure.attachment_type.TEXT
+            )
             if default_value is not None:
                 return default_value
-            raise ValueError(f"提取值失败({extractor_type}, {extraction_path}): {str(e)}")
+            raise ValueError(error_message)
     
     def _extract_jsonpath(self, path: str, default_value: Any = None) -> Any:
         """使用JSONPath从JSON响应提取值
@@ -907,13 +935,87 @@ class HTTPRequest:
                     attachment_type=allure.attachment_type.TEXT
                 )
         
+        # 记录断言参数
+        allure.attach(
+            f"断言类型: {assertion_type}\n"
+            f"比较操作符: {operator}\n"
+            f"实际值: {actual_value} ({type(actual_value).__name__})\n"
+            f"期望值: {expected_value} ({type(expected_value).__name__ if expected_value is not None else 'None'})",
+            name="断言参数",
+            attachment_type=allure.attachment_type.TEXT
+        )
+        
         # 基于断言类型执行断言
         if assertion_type == "value":
             # 直接使用操作符进行比较
             return self._compare_values(actual_value, expected_value, operator)
+        # 特殊断言类型 - 这些类型的操作符与断言类型匹配
+        elif assertion_type in ["contains", "not_contains", "startswith", "endswith", "matches", "schema"]:
+            # 直接使用断言类型作为方法处理，实现特殊断言逻辑
+            if assertion_type == "contains":
+                # contains断言总是检查actual是否包含expected
+                if isinstance(actual_value, str):
+                    return str(expected_value) in actual_value
+                elif isinstance(actual_value, (list, tuple, dict)):
+                    return expected_value in actual_value
+                return False
+            elif assertion_type == "not_contains":
+                # not_contains断言总是检查actual是否不包含expected
+                if isinstance(actual_value, str):
+                    return str(expected_value) not in actual_value
+                elif isinstance(actual_value, (list, tuple, dict)):
+                    return expected_value not in actual_value
+                return True
+            elif assertion_type == "startswith":
+                return isinstance(actual_value, str) and actual_value.startswith(str(expected_value))
+            elif assertion_type == "endswith":
+                return isinstance(actual_value, str) and actual_value.endswith(str(expected_value))
+            elif assertion_type == "matches":
+                if not isinstance(actual_value, str):
+                    actual_value = str(actual_value) if actual_value is not None else ""
+                try:
+                    import re
+                    pattern = str(expected_value)
+                    match_result = bool(re.search(pattern, actual_value))
+                    # 记录匹配结果
+                    allure.attach(
+                        f"正则表达式匹配结果: {'成功' if match_result else '失败'}\n"
+                        f"模式: {pattern}\n"
+                        f"目标字符串: {actual_value}",
+                        name="正则表达式匹配",
+                        attachment_type=allure.attachment_type.TEXT
+                    )
+                    return match_result
+                except Exception as e:
+                    # 记录正则表达式匹配错误
+                    allure.attach(
+                        f"正则表达式匹配失败: {type(e).__name__}: {str(e)}\n"
+                        f"模式: {expected_value}\n"
+                        f"目标字符串: {actual_value}",
+                        name="正则表达式错误",
+                        attachment_type=allure.attachment_type.TEXT
+                    )
+                    return False
+            elif assertion_type == "schema":
+                try:
+                    from jsonschema import validate
+                    validate(instance=actual_value, schema=expected_value)
+                    return True
+                except Exception as e:
+                    # 记录JSON Schema验证错误
+                    allure.attach(
+                        f"JSON Schema验证失败: {type(e).__name__}: {str(e)}\n"
+                        f"Schema: {expected_value}\n"
+                        f"实例: {actual_value}",
+                        name="Schema验证错误",
+                        attachment_type=allure.attachment_type.TEXT
+                    )
+                    return False
         elif assertion_type == "length":
             # 长度比较
-            return self._compare_values(actual_value, expected_value, operator)
+            # 使用实际的比较操作符进行比较，默认使用eq
+            effective_operator = "eq" if operator == "length" else operator
+            return self._compare_values(actual_value, expected_value, effective_operator)
         elif assertion_type == "exists":
             return actual_value is not None
         elif assertion_type == "not_exists":
@@ -932,40 +1034,6 @@ class HTTPRequest:
             elif expected_value == "null":
                 return actual_value is None
             return False
-        elif assertion_type == "contains":
-            # contains断言总是检查actual是否包含expected
-            if isinstance(actual_value, str):
-                return str(expected_value) in actual_value
-            elif isinstance(actual_value, (list, tuple, dict)):
-                return expected_value in actual_value
-            return False
-        elif assertion_type == "not_contains":
-            # not_contains断言总是检查actual是否不包含expected
-            if isinstance(actual_value, str):
-                return str(expected_value) not in actual_value
-            elif isinstance(actual_value, (list, tuple, dict)):
-                return expected_value not in actual_value
-            return True
-        elif assertion_type == "startswith":
-            return isinstance(actual_value, str) and actual_value.startswith(str(expected_value))
-        elif assertion_type == "endswith":
-            return isinstance(actual_value, str) and actual_value.endswith(str(expected_value))
-        elif assertion_type == "matches":
-            if not isinstance(actual_value, str):
-                return False
-            try:
-                import re
-                pattern = str(expected_value)
-                return bool(re.search(pattern, actual_value))
-            except:
-                return False
-        elif assertion_type == "schema":
-            try:
-                from jsonschema import validate
-                validate(instance=actual_value, schema=expected_value)
-                return True
-            except:
-                return False
         else:
             raise ValueError(f"不支持的断言类型: {assertion_type}")
             
@@ -998,6 +1066,47 @@ class HTTPRequest:
         elif operator == "not_in":
             # not_in操作符检查actual是否不在expected列表中
             return actual_value not in expected_value
+        elif operator == "contains":
+            # contains操作符检查actual是否包含expected
+            if isinstance(actual_value, str):
+                return str(expected_value) in actual_value
+            elif isinstance(actual_value, (list, tuple, dict)):
+                return expected_value in actual_value
+            return False
+        elif operator == "not_contains":
+            # not_contains操作符检查actual是否不包含expected
+            if isinstance(actual_value, str):
+                return str(expected_value) not in actual_value
+            elif isinstance(actual_value, (list, tuple, dict)):
+                return expected_value not in actual_value
+            return True
+        elif operator == "matches":
+            # matches操作符使用正则表达式进行匹配
+            if not isinstance(actual_value, str):
+                actual_value = str(actual_value) if actual_value is not None else ""
+            try:
+                import re
+                pattern = str(expected_value)
+                match_result = bool(re.search(pattern, actual_value))
+                # 记录匹配结果
+                allure.attach(
+                    f"正则表达式匹配结果: {'成功' if match_result else '失败'}\n"
+                    f"模式: {pattern}\n"
+                    f"目标字符串: {actual_value}",
+                    name="正则表达式匹配",
+                    attachment_type=allure.attachment_type.TEXT
+                )
+                return match_result
+            except Exception as e:
+                # 记录正则表达式匹配错误
+                allure.attach(
+                    f"正则表达式匹配失败: {type(e).__name__}: {str(e)}\n"
+                    f"模式: {expected_value}\n"
+                    f"目标字符串: {actual_value}",
+                    name="正则表达式错误",
+                    attachment_type=allure.attachment_type.TEXT
+                )
+                return False
         else:
             raise ValueError(f"不支持的比较操作符: {operator}")
     

pytest_dsl/core/lexer.py

@@ -9,7 +9,10 @@ reserved = {
     'range': 'RANGE',
     'using': 'USING',  # Add new keyword for data-driven testing
     'True': 'TRUE',    # 添加布尔值支持
-    'False': 'FALSE'   # 添加布尔值支持
+    'False': 'FALSE',   # 添加布尔值支持
+    'return': 'RETURN',  # 添加return关键字支持
+    'else': 'ELSE',   # 添加else关键字支持
+    'if': 'IF'  # 添加if关键字支持
 }
 
 # token 名称列表
@@ -33,6 +36,18 @@ tokens = [
     'DATE_KEYWORD',
     'TEARDOWN_KEYWORD',
     'DATA_KEYWORD',  # Add new token for @data keyword
+    'KEYWORD_KEYWORD',  # 添加@keyword关键字
+    'IMPORT_KEYWORD',   # 添加@import关键字
+    'GT',        # 大于 >
+    'LT',        # 小于 <
+    'GE',        # 大于等于 >=
+    'LE',        # 小于等于 <=
+    'EQ',        # 等于 ==
+    'NE',        # 不等于 !=
+    'PLUS',      # 加法 +
+    'MINUS',     # 减法 -
+    'TIMES',     # 乘法 *
+    'DIVIDE',    # 除法 /
 ] + list(reserved.values())
 
 # 正则表达式定义 token
@@ -43,6 +58,16 @@ t_RBRACKET = r'\]'
 t_COLON = r':'
 t_COMMA = r','
 t_EQUALS = r'='
+t_GT = r'>'
+t_LT = r'<'
+t_GE = r'>='
+t_LE = r'<='
+t_EQ = r'=='
+t_NE = r'!='
+t_PLUS = r'\+'
+t_MINUS = r'-'
+t_TIMES = r'\*'
+t_DIVIDE = r'/'
 
 # 增加PLACEHOLDER规则，匹配 ${变量名} 格式
 t_PLACEHOLDER = r'\$\{[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*\}'
@@ -106,6 +131,16 @@ def t_DATA_KEYWORD(t):
     return t
 
 
+def t_KEYWORD_KEYWORD(t):
+    r'@keyword'
+    return t
+
+
+def t_IMPORT_KEYWORD(t):
+    r'@import'
+    return t
+
+
 def t_NUMBER(t):
     r'\d+'
     t.value = int(t.value)

pytest_dsl/core/parser.py

@@ -12,23 +12,44 @@ class Node:
 # 定义优先级和结合性
 precedence = (
     ('left', 'COMMA'),
+    ('left', 'GT', 'LT', 'GE', 'LE', 'EQ', 'NE'),  # 比较运算符优先级
+    ('left', 'PLUS', 'MINUS'),  # 加减运算符优先级
+    ('left', 'TIMES', 'DIVIDE'),  # 乘除运算符优先级
     ('right', 'EQUALS'),
 )
 
 
 def p_start(p):
     '''start : metadata statements teardown
-             | metadata statements'''
+             | metadata statements
+             | statements teardown
+             | statements'''
 
     if len(p) == 4:
         p[0] = Node('Start', [p[1], p[2], p[3]])
+    elif len(p) == 3:
+        # 判断第二个元素是teardown还是statements
+        if p[2].type == 'Teardown':
+            p[0] = Node('Start', [Node('Metadata', []), p[1], p[2]])
+        else:
+            p[0] = Node('Start', [p[1], p[2]])
     else:
-        p[0] = Node('Start', [p[1], p[2]])
+        # 没有metadata和teardown
+        p[0] = Node('Start', [Node('Metadata', []), p[1]])
 
 
 def p_metadata(p):
-    '''metadata : metadata_items'''
-    p[0] = Node('Metadata', p[1])
+    '''metadata : metadata_items
+                | empty'''
+    if p[1]:
+        p[0] = Node('Metadata', p[1])
+    else:
+        p[0] = Node('Metadata', [])
+
+
+def p_empty(p):
+    '''empty :'''
+    p[0] = None
 
 
 def p_metadata_items(p):
@@ -46,13 +67,16 @@ def p_metadata_item(p):
                     | TAGS_KEYWORD COLON LBRACKET tags RBRACKET
                     | AUTHOR_KEYWORD COLON metadata_value
                     | DATE_KEYWORD COLON DATE
-                    | DATA_KEYWORD COLON data_source'''
+                    | DATA_KEYWORD COLON data_source
+                    | IMPORT_KEYWORD COLON STRING'''
     if p[1] == '@tags':
         p[0] = Node(p[1], value=p[4])
     elif p[1] == '@data':
         # 对于数据驱动测试，将数据源信息存储在节点中
         data_info = p[3]  # 这是一个包含 file 和 format 的字典
         p[0] = Node(p[1], value=data_info, children=None)
+    elif p[1] == '@import':
+        p[0] = Node(p[1], value=p[3])
     else:
         p[0] = Node(p[1], value=p[3])
 
@@ -90,7 +114,10 @@ def p_statements(p):
 def p_statement(p):
     '''statement : assignment
                 | keyword_call
-                | loop'''
+                | loop
+                | custom_keyword
+                | return_statement
+                | if_statement'''
     p[0] = p[1]
 
 
@@ -104,13 +131,31 @@ def p_assignment(p):
 
 
 def p_expression(p):
-    '''expression : NUMBER
-                  | STRING
-                  | PLACEHOLDER
-                  | ID
-                  | boolean_expr
-                  | list_expr'''
-    p[0] = Node('Expression', value=p[1])
+    '''expression : expr_atom
+                  | comparison_expr
+                  | arithmetic_expr'''
+    # 如果是比较表达式或其他复合表达式，则已经是一个Node对象
+    if isinstance(p[1], Node):
+        p[0] = p[1]
+    else:
+        p[0] = Node('Expression', value=p[1])
+
+
+def p_expr_atom(p):
+    '''expr_atom : NUMBER
+                 | STRING
+                 | PLACEHOLDER
+                 | ID
+                 | boolean_expr
+                 | list_expr
+                 | LPAREN expression RPAREN'''
+    if p[1] == '(':
+        # 处理括号表达式，直接返回括号内的表达式节点
+        p[0] = p[2]
+    elif isinstance(p[1], Node):
+        p[0] = p[1]
+    else:
+        p[0] = Node('Expression', value=p[1])
 
 
 def p_boolean_expr(p):
@@ -185,6 +230,103 @@ def p_data_source(p):
     p[0] = {'file': p[1], 'format': p[3]}
 
 
+def p_custom_keyword(p):
+    '''custom_keyword : KEYWORD_KEYWORD ID LPAREN param_definitions RPAREN DO statements END'''
+    p[0] = Node('CustomKeyword', [p[4], p[7]], p[2])
+
+
+def p_param_definitions(p):
+    '''param_definitions : param_def_list
+                        | '''
+    if len(p) == 2:
+        p[0] = p[1]
+    else:
+        p[0] = []
+
+
+def p_param_def_list(p):
+    '''param_def_list : param_def COMMA param_def_list
+                     | param_def'''
+    if len(p) == 4:
+        p[0] = [p[1]] + p[3]
+    else:
+        p[0] = [p[1]]
+
+
+def p_param_def(p):
+    '''param_def : ID EQUALS STRING
+                | ID EQUALS NUMBER
+                | ID'''
+    if len(p) == 4:
+        p[0] = Node('ParameterDef', [Node('Expression', value=p[3])], p[1])
+    else:
+        p[0] = Node('ParameterDef', [], p[1])
+
+
+def p_return_statement(p):
+    '''return_statement : RETURN expression'''
+    p[0] = Node('Return', [p[2]])
+
+
+def p_if_statement(p):
+    '''if_statement : IF expression DO statements END
+                   | IF expression DO statements ELSE statements END'''
+    if len(p) == 6:
+        p[0] = Node('IfStatement', [p[2], p[4]], None)
+    else:
+        p[0] = Node('IfStatement', [p[2], p[4], p[6]], None)
+
+
+def p_comparison_expr(p):
+    '''comparison_expr : expr_atom GT expr_atom
+                      | expr_atom LT expr_atom
+                      | expr_atom GE expr_atom
+                      | expr_atom LE expr_atom
+                      | expr_atom EQ expr_atom
+                      | expr_atom NE expr_atom'''
+    
+    # 根据规则索引判断使用的是哪个操作符
+    if p.slice[2].type == 'GT':
+        operator = '>'
+    elif p.slice[2].type == 'LT':
+        operator = '<'
+    elif p.slice[2].type == 'GE':
+        operator = '>='
+    elif p.slice[2].type == 'LE':
+        operator = '<='
+    elif p.slice[2].type == 'EQ':
+        operator = '=='
+    elif p.slice[2].type == 'NE':
+        operator = '!='
+    else:
+        print(f"警告: 无法识别的操作符类型 {p.slice[2].type}")
+        operator = None
+    
+    p[0] = Node('ComparisonExpr', [p[1], p[3]], operator)
+
+
+def p_arithmetic_expr(p):
+    '''arithmetic_expr : expression PLUS expression
+                       | expression MINUS expression
+                       | expression TIMES expression
+                       | expression DIVIDE expression'''
+    
+    # 根据规则索引判断使用的是哪个操作符
+    if p.slice[2].type == 'PLUS':
+        operator = '+'
+    elif p.slice[2].type == 'MINUS':
+        operator = '-'
+    elif p.slice[2].type == 'TIMES':
+        operator = '*'
+    elif p.slice[2].type == 'DIVIDE':
+        operator = '/'
+    else:
+        print(f"警告: 无法识别的操作符类型 {p.slice[2].type}")
+        operator = None
+    
+    p[0] = Node('ArithmeticExpr', [p[1], p[3]], operator)
+
+
 def p_error(p):
     if p:
         print(