iflow-mcp_galaxyxieyu_api-auto-test 0.1.0__py3-none-any.whl

atf/core/login_handler.py

@@ -0,0 +1,60 @@
+# @time:    2024-09-20
+# @author:  xiaoqq
+
+from atf.core.config_manager import ConfigManager
+from atf.auth import Auth
+from atf.core.globals import Globals
+from atf.core.log_manager import log
+
+class LoginHandler:
+	"""
+	用于处理项目登录的管理类，提供登录判断和登录操作。
+	"""
+
+	def __init__(self):
+		self.config_manager = ConfigManager()
+
+	def login_if_needed(self, project_name, project_config, env):
+		"""
+		判断项目是否需要登录，如果需要则进行登录
+		:param project_name: 项目名称
+		:param project_config: 项目配置
+		:param env: 环境名称
+		:return: 登录成功返回 token，失败返回 None
+		"""
+		if project_config and project_config.get('is_need_login'):
+			auth_class = Auth()
+			# 获取 auth_class 中指定名称的方法，如果找不到该方法（例如 project_name_login），则使用默认的 login 方法。
+			login_function = getattr(auth_class, f'{project_name}_login', auth_class.login)
+			log.info(f"正在登录 {project_name}, 登录参数为：{project_config['login']}")
+			try:
+				token = login_function(project_name, project_config['login'], env)
+				log.info(f"{project_name} 登录成功并获取到 token: {token}。")
+				return token
+			except Exception as e:
+				log.error(f"{project_name} 登录失败：{e}")
+				return None
+		return None
+
+	def check_and_login_project(self, project_name, env):
+		"""
+		检查并登录指定项目，如果 Globals 中没有 token，则执行登录操作
+		:param project_name: 项目名称
+		:param env: 环境名称
+		"""
+		project_info = Globals.get(project_name)
+		if project_info is None or not project_info.get("token"):
+			project_env_config = self.config_manager.get_project_env_config(project_name, env)
+			if project_env_config is not None:
+				log.info(f"project_name, project_env_config, env：{project_name}, {project_env_config}, {env}")
+				token = self.login_if_needed(project_name, project_env_config.get(project_name), env)
+				if token:
+					# 将 token 存入全局变量
+					Globals.update(project_name, "token", token)
+					# log.info(f"{project_name} 登录成功并获取 token。")
+				else:
+					log.error(f"{project_name} 登录失败。")
+			else:
+				log.warning(f"未找到项目 {project_name} 的配置，跳过登录。")
+		else:
+			log.info(f"{project_name} 已经登录，跳过登录操作。")

atf/core/request_handler.py

@@ -0,0 +1,189 @@
+# @time:    2024-08-01
+# @author:  xiaoqq
+
+import json
+import time
+import requests
+from atf.core.log_manager import log
+
+
+class SSEResponse:
+    """SSE 响应封装"""
+    def __init__(self, events, raw_lines, status_code):
+        self.events = events          # 解析后的事件列表
+        self.raw_lines = raw_lines    # 原始行数据
+        self.status_code = status_code
+        self.event_count = len(events)
+
+    def get_event(self, index):
+        """获取指定索引的事件"""
+        return self.events[index] if 0 <= index < len(self.events) else None
+
+    def get_all_data(self, field=None):
+        """获取所有事件的 data，可选提取特定字段"""
+        if field:
+            return [e.get('data', {}).get(field) for e in self.events if isinstance(e.get('data'), dict)]
+        return [e.get('data') for e in self.events]
+
+    def find_event(self, **kwargs):
+        """查找匹配条件的事件"""
+        for event in self.events:
+            match = True
+            for key, value in kwargs.items():
+                if key == 'data_contains':
+                    if value not in str(event.get('data', '')):
+                        match = False
+                elif key == 'event_type':
+                    if event.get('event') != value:
+                        match = False
+                else:
+                    if event.get(key) != value:
+                        match = False
+            if match:
+                return event
+        return None
+
+    def contains(self, text):
+        """检查是否包含指定文本"""
+        return any(text in str(e.get('data', '')) for e in self.events)
+
+
+class RequestHandler:
+    @staticmethod
+    def send_request(method, url, headers=None, data=None, params=None, files=None, timeout=10):
+        log.info(f"正在发送 {method} 请求至 {url} ，headers={headers}, data={data}, params={params}, files={files}")
+
+        if method.lower() == 'get':
+            _params = params
+            if not _params:
+                _params = data
+            response = requests.get(url, headers=headers, params=_params, timeout=timeout)
+        elif method.lower() == 'post':
+            if files:
+                response = requests.post(url, headers=headers, files=files, timeout=timeout)
+            elif headers and 'Content-Type' in headers and headers['Content-Type'] == 'application/x-www-form-urlencoded':
+                response = requests.post(url, headers=headers, data=data, timeout=timeout)
+            else:
+                response = requests.post(url, headers=headers, json=data, timeout=timeout)
+        elif method.lower() in ['put', 'delete']:
+            response = requests.request(method, url, headers=headers, json=data, timeout=timeout)
+        else:
+            log.error(f"不支持的方法: {method}")
+            raise ValueError(f"不支持的方法: {method}")
+
+        try:
+            response_json = response.json()
+            response_json['_status_code'] = response.status_code  # 添加状态码到响应中
+            log.info("返回参数：{}".format(response_json))
+            return response_json
+        except ValueError:
+            log.error("非JSON响应：{}".format(response.text))
+            response.raise_for_status()
+
+        if not response.ok:
+            log.error("请求失败：状态码 {}".format(response.status_code))
+            response.raise_for_status()
+
+    @staticmethod
+    def send_sse_request(method, url, headers=None, data=None, params=None,
+                         timeout=60, max_events=None, stop_on=None):
+        """
+        发送 SSE 流式请求
+        :param method: 请求方法
+        :param url: 请求地址
+        :param headers: 请求头
+        :param data: 请求体
+        :param params: 查询参数
+        :param timeout: 超时时间（秒）
+        :param max_events: 最大事件数，达到后停止
+        :param stop_on: 停止条件，如 {"data_contains": "[DONE]"} 或 {"event_type": "done"}
+        :return: SSEResponse 对象
+        """
+        headers = headers or {}
+        headers.setdefault('Accept', 'text/event-stream')
+
+        log.info(f"正在发送 SSE {method} 请求至 {url}, timeout={timeout}, max_events={max_events}, stop_on={stop_on}")
+
+        events = []
+        raw_lines = []
+        current_event = {}
+
+        try:
+            with requests.request(
+                method=method,
+                url=url,
+                headers=headers,
+                json=data if method.upper() != 'GET' else None,
+                params=params if method.upper() == 'GET' else None,
+                stream=True,
+                timeout=timeout
+            ) as resp:
+                status_code = resp.status_code
+                start_time = time.time()
+
+                for line in resp.iter_lines(decode_unicode=True):
+                    # 超时检查
+                    if time.time() - start_time > timeout:
+                        log.info(f"SSE 请求超时，已收集 {len(events)} 个事件")
+                        break
+
+                    if line:
+                        raw_lines.append(line)
+
+                        if line.startswith('event:'):
+                            current_event['event'] = line[6:].strip()
+                        elif line.startswith('data:'):
+                            data_str = line[5:].strip()
+                            # 尝试解析 JSON
+                            try:
+                                current_event['data'] = json.loads(data_str)
+                            except json.JSONDecodeError:
+                                current_event['data'] = data_str
+                        elif line.startswith('id:'):
+                            current_event['id'] = line[3:].strip()
+                        elif line.startswith('retry:'):
+                            current_event['retry'] = int(line[6:].strip())
+                    else:
+                        # 空行表示事件结束
+                        if current_event:
+                            events.append(current_event)
+                            log.debug(f"收到 SSE 事件: {current_event}")
+
+                            # 检查停止条件
+                            if stop_on:
+                                should_stop = True
+                                for key, value in stop_on.items():
+                                    if key == 'data_contains':
+                                        if value not in str(current_event.get('data', '')):
+                                            should_stop = False
+                                    elif key == 'event_type':
+                                        if current_event.get('event') != value:
+                                            should_stop = False
+                                    else:
+                                        if current_event.get(key) != value:
+                                            should_stop = False
+                                if should_stop:
+                                    log.info(f"满足停止条件 {stop_on}，停止接收")
+                                    break
+
+                            # 检查最大事件数
+                            if max_events and len(events) >= max_events:
+                                log.info(f"达到最大事件数 {max_events}，停止接收")
+                                break
+
+                            current_event = {}
+
+                # 处理最后一个未完成的事件
+                if current_event:
+                    events.append(current_event)
+
+        except requests.exceptions.Timeout:
+            log.warning(f"SSE 请求超时，已收集 {len(events)} 个事件")
+            status_code = 0
+        except Exception as e:
+            log.error(f"SSE 请求异常: {e}")
+            raise
+
+        sse_response = SSEResponse(events, raw_lines, status_code)
+        log.info(f"SSE 请求完成，共收到 {sse_response.event_count} 个事件")
+        return sse_response

atf/core/variable_resolver.py

@@ -0,0 +1,212 @@
+# @time:    2024-08-23
+# @author:  xiaoqq
+
+import re
+import importlib
+from types import ModuleType
+from typing import Any, Dict, Union
+from atf.core.log_manager import log
+
+class VariableResolver:
+	"""
+	解析YAML文件中的变量表达式'{{ *** }}'，根据变量表达式调用工具函数、获取全局、会话变量的值。
+	1. 先判断变量中是否有"()"，如{{ tools.demo_func(a=2, b=1) }}，有则调用 atf.utils.helpers.py 中的函数，并传入参数；
+	2. 再判断是否存在“.”，有则再判断测试用例局部变量session_vars中是否存在“.”前面第一个字符串，如果是则获取
+	3. 如果不是则从全局变量获取
+	4. 如果变量表达式以Global或GLOBAL开头，则直接从全局变量获取
+	"""
+	def __init__(self, session_vars: Dict[str, Any], global_vars: Dict[str, Any]):
+		self.session_vars = session_vars
+		self.global_vars = global_vars
+
+	def resolve_variable(self, expression: str) -> Any:
+		"""解析 {{ }} 表达式并返回其值"""
+		expression = expression.strip()
+
+		# 如果是函数调用形式
+		if '(' in expression and ')' in expression:
+			return self._resolve_function(expression)
+		# 如果是多层次的变量引用形式
+		elif '.' in expression or '[' in expression:
+			return self._resolve_dot_expression(expression)
+		else:
+			raise ValueError(f"Unsupported expression format: {expression}")
+
+	def _resolve_function(self, expression: str) -> Any:
+		"""处理函数调用形式的表达式"""
+		# 提取模块名和函数名
+		module_name, func_call = expression.split('.', 1)
+		module = self._import_module(module_name)
+
+		# 提取函数名和参数
+		func_name, args_str = re.match(r"(\w+)\((.*)\)", func_call).groups()
+		func = getattr(module, func_name)
+
+		# 解析参数
+		args = self._parse_function_args(args_str)
+
+		# 调用函数并返回结果
+		return func(**args)
+
+	def _import_module(self, module_name: str) -> ModuleType:
+		"""导入模块"""
+		try:
+			return importlib.import_module(f'atf.utils.{module_name}')
+		except ImportError as e:
+			raise ImportError(f"Module {module_name} not found in atf.utils. Error: {e}")
+
+	def _parse_function_args(self, args_str: str) -> Dict[str, Any]:
+		"""解析函数参数"""
+		return eval(f"dict({args_str})")
+
+	def _resolve_dot_expression(self, expression: str) -> Any:
+		"""处理以 '.' 分隔的变量引用形式"""
+		keys = re.split(r'\.|\[|\]', expression)
+		keys = [key for key in keys if key]  # 去掉空字符串
+		
+		root_key = keys[0]
+		
+		# 通过Global 或 GLOBAL 指定从全局变量获取，如{{Global.data.id}}
+		use_global = root_key in ['Global', 'GLOBAL']
+		
+		if use_global:
+			root_key = keys[1]
+			value = self.global_vars[root_key]
+		elif root_key in self.session_vars:
+			value = self.session_vars[root_key]
+		elif root_key in self.global_vars:
+			value = self.global_vars[root_key]
+		else:
+			log.error(f"{root_key} not found in session_vars or global_vars")
+			raise ValueError(f"{root_key} not found in session_vars or global_vars")
+		
+		for key in keys[1:]:
+			if key.isdigit():  # 检查key是否为索引
+				value = value[int(key)]
+			else:
+				try:
+					value = value[key]
+				except KeyError:
+					log.error(f"Key '{key}' not found in {value}")
+					raise ValueError(f"Key '{key}' not found in {value}")
+
+		return value
+
+	def process_value(self, value: Union[str, Dict, list]) -> Any:
+		"""递归处理字典、列表或字符串中的 {{ }} 表达式"""
+		if isinstance(value, str) and '{{' in value and '}}' in value:
+			return self._process_string(value)
+		elif isinstance(value, dict):
+			return {k: self.process_value(v) for k, v in value.items()}
+		elif isinstance(value, list):
+			return [self.process_value(item) for item in value]
+		else:
+			return value
+	
+	def _process_string(self, value: str) -> any:
+		"""解析字符串中的 {{ }} 表达式并替换"""
+		# pattern = r'\{\{\s*(.*?)\s*\}\}'
+		pattern = r'\{\{(.*?)}\}'
+		matches = re.findall(pattern, value)
+		
+		for match in matches:
+			match_stripped = match.strip()  # 去除表达式两侧的空格
+			# 检查是否以Global/GLOBAL开头
+			if match_stripped.startswith(('Global.', 'GLOBAL.')):
+				resolved_value = self._resolve_dot_expression(match_stripped)
+			else:
+				resolved_value = self.resolve_variable(match_stripped)
+			
+			# resolved_value = self.resolve_variable(match_stripped)
+			
+			# 确定表达式的原始格式，并替换
+			original_format = f'{{{{ {match_stripped} }}}}'
+			if match.startswith(' ') and match.endswith(' '):
+				new_format = original_format
+			elif match.startswith(' '):
+				new_format = f'{{{{ {match_stripped}}}}}'
+			elif match.endswith(' '):
+				new_format = f'{{{{{match_stripped} }}}}'
+			else:
+				new_format = f'{{{{{match_stripped}}}}}'
+				
+			# 如果解析出的值不是字符串，且原始表达式不是整个字符串，则保留原始类型
+			if isinstance(resolved_value, (int, float, bool)) and value == new_format:
+				return resolved_value
+			# 否则，将其转换为字符串并替换掉原始表达式
+			value = value.replace(new_format, str(resolved_value))
+		
+		return value
+
+	def process_data(self, data: Any) -> Any:
+		"""处理 YAML 数据并替换所有 {{ }} 表达式"""
+		data_str = str(data)
+		if '{{' in data_str:
+			# log.info(f"开始解析并获取变量：{data}")
+			log.info(f"开始解析并获取变量")
+			return self.process_value(data)
+		return data
+
+if __name__ == '__main__':
+	# 示例用法
+	session_vars = {
+		'step1': {
+			'data': {
+				'id': 123,
+				'orderNo': 1020240906142034235893,
+				'items': [
+					{'id': 'item_0'},
+					{'id': 'item_1'}
+				]
+			}
+		}
+	}
+	
+	global_vars = {
+		'merchant': {
+			'token': 'xyz-token'
+		}
+	}
+	
+	url = '/api/endpoint1/{{ tools.demo_get_id() }}'
+	
+	headers = {
+		'Content-Type': 'application/json',
+		'Authorization': '{{ merchant.token }}'
+	}
+	
+	data = {
+		'param1': '{{ step1.data.id }}',
+		'param2': {
+			'p_param': {
+				'p_p_param1': '{{tools.demo_func(a=3, b=1, c=3) }}',
+				'p_p_param2': '{{ tools.demo_func()}}',
+				'p_p_param3': 333,
+				'p_p_param4': ['/goods/detail/{{tools.demo_get_id()}}', "sss"],
+				'p_p_param5': '{{step1.data.items[1].id}}'
+			}
+		}
+	}
+	asserts = [
+		{
+			"type": "equal",
+			"field": "code",
+			"expected": 0
+		},
+		{
+			"type": "equal",
+			"field": "message",
+			"expected": "success"
+		},
+		{
+			"type": "equal",
+			"field": "data.orderNo",
+			"expected": "{{step1.data.orderNo}}"
+		}
+	]
+	
+	resolver = VariableResolver(session_vars, global_vars)
+	print(resolver.process_data(url))
+	print(resolver.process_data(headers))
+	print(resolver.process_data(data))
+	print(resolver.process_data(asserts))

atf/handlers/__init__.py

@@ -0,0 +1,10 @@
+# 处理器模块
+from .teardown_handler import TeardownHandler
+from .report_generator import ReportGenerator
+from .notification_handler import NotificationHandler
+
+__all__ = [
+    'TeardownHandler',
+    'ReportGenerator',
+    'NotificationHandler',
+]

atf/handlers/notification_handler.py

@@ -0,0 +1,101 @@
+# @time:    2024-08-27
+# @author:  xiaoqq
+
+from dingtalkchatbot.chatbot import DingtalkChatbot
+from atf.core.log_manager import log
+
+
+def set_color_and_size(text, color, size='14px'):
+	colors = {
+		"green": "#00CC00",  # 成功
+		"blue": "#0000FF",  # 信息
+		"yellow": "#FFCC00",  # 跳过
+		"red": "#FF0000",  # 失败/错误
+		"black": "#000000"  # 普通文本
+	}
+	# 使用 style 属性控制字体大小和加粗
+	return f'<font color="{colors.get(color, "#000000")}" style="font-size:{size}; font-weight:bold;">{text}</font>'
+
+
+def format_field(label, value, color='black', size='14px', icon=None):
+	"""
+	格式化消息字段，支持颜色、字体大小和图标
+	"""
+	label = set_color_and_size(label, color, size)
+	if icon:
+		return f"{icon} {label}: {value}"
+	return f"{label}: {value}"
+
+
+class NotificationHandler:
+	"""
+	钉钉消息发送
+	"""
+	
+	def __init__(self, webhook, secret, project=None):
+		self.ding = DingtalkChatbot(webhook=webhook, secret=secret)
+		self.project = project
+	
+	def _build_message(self, conclusion, total, passed, failed, error, skipped, start_time, duration):
+		"""
+		构建消息文本
+		"""
+		# 消息标题，字体加粗且字号更大
+		header = "<strong><font size='24px'>📢 接口自动化测试监控通知</font></strong>"
+		
+		# 信息字段及其样式
+		items = [
+			('测试结果', conclusion, 'green' if conclusion == '执行通过' else 'red', '16px'),
+			('开始时间', start_time, 'black', '14px'),
+			('执行时长', f'{duration:.2f} 秒', 'black', '14px'),
+			('用例总数', total, 'blue', '14px'),
+			('成功用例', passed, 'green', '14px'),
+			('失败用例', failed, 'red', '14px'),
+			('错误用例', error, 'red', '14px'),
+			('跳过用例', skipped, 'yellow', '14px')
+		]
+		
+		# 定义 Unicode Emoji 图标
+		icons = {
+			'测试结果': '📝',
+			'开始时间': '⏰',
+			'执行时长': '⏱️',
+			'用例总数': '📊',
+			'成功用例': '✅',
+			'失败用例': '❌',
+			'错误用例': '💥',
+			'跳过用例': '⚠️'
+		}
+		
+		# 使用优化后的样式和图标构建消息体
+		lines = [format_field(item[0], item[1], item[2], item[3], icon=icons.get(item[0])) for item in items]
+		text = "\n\n".join(lines)
+		return f"{header}\n\n{text}"
+	
+	def send_markdown_msg(self, conclusion, total, passed, failed, error, skipped, start_time, duration):
+		"""
+		发送测试用例执行结果
+		"""
+		# 构建钉钉消息内容
+		text = self._build_message(conclusion, total, passed, failed, error, skipped, start_time, duration)
+		title = "【接口自动化测试通知】"
+		try:
+			log.info("钉钉机器人正在发送结果......")
+			self.ding.send_markdown(title=title, text=text, is_at_all=True)
+			log.info("测试结果已发送至钉钉群")
+		except Exception as e:
+			log.error("钉钉机器人发送消息失败：%s", e)
+			
+if __name__ == '__main__':
+	webhook = "https://oapi.dingtalk.com/robot/send?access_token=your_dingtalk_access_token"
+	secret = "your_secret"
+	NotificationHandler(webhook, secret).send_markdown_msg(
+		conclusion="执行通过",
+		total = 100,
+		passed = 95,
+		failed = 2,
+		error = 3,
+		skipped = 0,
+		start_time = "2024-9-14 11:44:43",
+		duration = 1000.22
+	)