WebsocketTest 1.0.0__py3-none-any.whl

WebsocketTest-1.0.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.1
+Name: WebsocketTest
+Version: 1.0.0
+Summary: websocket api autotest
+Author: chencheng
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: allure-python-commons==2.13.5
+Requires-Dist: numpy==2.2.4
+Requires-Dist: pandas==2.2.3
+Requires-Dist: pytest==8.2.2
+Requires-Dist: PyYAML==6.0.2
+Requires-Dist: websockets==12.0
+
+# WebSocket 接口自动化测试工具 (WS_API_TEST)
+
+#### 介绍
+
+这是一个基于 WebSocket 协议的接口自动化测试工具。它可以用于自动化测试 WebSocket 接口，确保接口的稳定性和可靠性。
+
+#### 系统要求
+
+**Python 3.10+**：确保你的系统上已经安装了 Python 3.10（推荐使用最新稳定版）。
+**项目依赖**：项目需要一些第三方库，可以通过 requirements.txt 文件安装。
+
+#### 安装步骤
+
+**1.安装 Python：**
+确保你的系统上已经安装了 Python 3.10 或更高版本。你可以从 [Python 官方网站 ](https://www.python.org/downloads/?spm=5176.28103460.0.0.40f75d27PnqPkU)下载并安装。
+**2.克隆项目：**
+使用 Git 克隆项目到你的本地机器。
+
+```
+git clone https://code.iflytek.com/ZNQC_AUTO_AI/python_scripts.git
+cd python_scripts
+git checkout WS_API_TEST
+```
+
+**3.安装项目依赖：**
+使用 pip 安装项目所需的依赖库。
+
+```
+pip install -r requirements.txt
+```
+**4.运行项目：**
+你可以通过以下两种方式之一来运行项目：
+
+* **使用命令行**：
+  在命令行中运行以下命令：
+
+```
+python run_tests.py --env uat --app 3d7d3ea4  --service gateway_5.4 --project vwa
+```
+
+* **使用批处理脚本**：
+  双击 run_tests.bat 文件来运行项目。
+
+#### 项目结构
+├─allure_report
+├─allure_results
+├─build
+├─common
+├─config
+├─data
+├─dist
+├─logs
+├─testcase
+
+* **文件说明**:
+**allure_report**：存放 Allure 生成的 HTML 报告，用于展示测试结果。
+**allure_results**：存放 Allure 生成的测试结果数据文件，如 result-12345.xml。
+**build**：存放构建过程中生成的临时文件
+**common**：存放通用的工具类
+**config**：存放环境配置文件
+**data**：存放测试数据文件
+**dist**：存放最终发布的测试包
+**logs**：存放运行日志文件
+**testcase**：存放测试用例脚本

WebsocketTest-1.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+caseScript/Aqua.py,sha256=zr1mURYGikzzJDsx2lwdH9m_ENlJzH3vDvepsfwhfdg,7405
+caseScript/Gateway.py,sha256=D_oVhhKGFA3FdFblg_YmUj2HhlPNI3kht9LqHnSuNZA,11723
+caseScript/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+common/Assertion.py,sha256=xMesYiZY6FSf7_Zf6BIXGl9a2Prx-blRYGK2zKQy81M,5215
+common/WSBaseApi.py,sha256=-zDpMsaF4ugVKUpzDwbs6l9DBvlh2uw1oJGY64fk6fY,3982
+common/WebSocketApi.py,sha256=JpgX1qAA8skh_t9hLDmgEx6KugewF284u2cjrQkbLnI,2743
+common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+common/assertUtils.py,sha256=xJvjm0QDIxUHIZm96-2sKkDUWzPQHaOJB9x9eSLlIoU,4699
+common/logger.py,sha256=B7jjPd5miAYorveHUEGW8xKxUNlJzKlVug0rKWRK3p0,783
+common/utils.py,sha256=5NrU_cXzpzTYSI38LZe4IjJe3HxNB64rtrXZcf3Vixs,8706
+testcase/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testcase/test_all.py,sha256=mdfivt5vmfcn_4LZVcQ1KTH0n69gKxd_Id-DCapGlu4,198
+WebsocketTest-1.0.0.dist-info/METADATA,sha256=hvOrTxBDRTSSsRwEBzdiXqf1wOvCMgc1tx-kPUCG5Ik,2378
+WebsocketTest-1.0.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+WebsocketTest-1.0.0.dist-info/entry_points.txt,sha256=IHzfkbidO-zy6nSbDStRwp2Qa0C6zHgD8M1Tq_ik9rA,195
+WebsocketTest-1.0.0.dist-info/top_level.txt,sha256=KmqByBRxmIHZiIEEGQnX5_C3urP-43-6TCFUhM3aMKk,27
+WebsocketTest-1.0.0.dist-info/RECORD,,

WebsocketTest-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

WebsocketTest-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+har2case = pastor.cli:main_har2case_alias
+locusts = pastor.ext.locust:main_locusts
+pastor = pastor.cli:main
+pmake = pastor.cli:main_make_alias
+prun = pastor.cli:main_prun_alias

WebsocketTest-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+caseScript
+common
+testcase

caseScript/Aqua.py

@@ -0,0 +1,165 @@
+
+from common.utils import *
+from urllib.parse import quote_plus 
+from common import WSBaseApi
+from common.WSBaseApi import WSBaseApi
+
+
+
+
+class ApiTestRunner(WSBaseApi):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.answer_text = ""
+    def build_params(self):
+        """准备请求参数"""  
+        return {
+            "header": {
+                "appid": self.appId,
+                "scene": self.scene,
+                "sid": self.sid or generate_random_string(), # 奥迪sid为空时，不会自生成
+                "uid": self.uid,
+                "usrid": ""
+            },
+            "parameter": {
+                "custom": {
+                    "custom_data": {
+                        "SessionParams": {
+                            "isLog": "true",
+                            "app_id": "",
+                            "attachparams": {
+                                "iat_params": {
+                                    "compress": "raw",
+                                    "da": "0",
+                                    "domain": "aiui-automotiveknife",
+                                    "dwa": "wpgs",
+                                    "encoding": "utf8",
+                                    "eos": "600",
+                                    "format": "json",
+                                    "isFar": "0",
+                                    "opt": "2",
+                                    "ufsa": "1",
+                                    "vgap": "200",
+                                    "accent": self.accent,
+                                    "language": self.language
+                                },
+                                "nlp_params": {
+                                    "llmEnv": "test",
+                                    "ovs_cluster":"AUDI",
+                                    "city": "合肥",
+                                    "compress": "raw",
+                                    "encoding": "utf8",
+                                    "format": "json",
+                                    "devid": "",
+                                    "news": {
+                                        "pageNo": 1,
+                                        "pageSize": 20
+                                    },
+                                    "flight": {
+                                        "pageNo": 1,
+                                        "pageSize": 20
+                                    },
+                                    "ovs_version": {
+                                        "weather": "3.5"
+                                    },
+                                    "user_defined_params": {},
+                                    "weather_airquality": "true",
+                                    "mapU": {
+                                        "pageNo": 1,
+                                        "pageSize": 20
+                                    },
+                                    "deviceId": self.deviceId,
+                                    "userId": self.userId,
+                                    "asp_did": self.asp_did,
+                                    "vWtoken": self.token,
+                                    "car_identity": self.car_identity,
+                                    "theme": "standard",
+                                    "vin": self.vin,
+                                    "interactive_mode": "fullDuplex",
+                                    "did": self.did,
+                                    "smarthome": {
+                                        "jd": {
+                                            "newSession": "true",
+                                            "sessionId": "123456789",
+                                            "userId": "9adbd42d-618f-4752-ad6d-9cb382079e25"
+                                        }
+                                    },
+                                    "train": {
+                                        "pageNo": 1,
+                                        "pageSize": 20
+                                    }
+                                },
+                                "tts_params": {
+                                    "bit_depth": "16",
+                                    "channels": "1",
+                                    "encoding": "speex-wb",
+                                    "frame_size": "0",
+                                    "sample_rate": "16000"
+                                }
+                            },
+                            "aue": "speex-wb",
+                            "bit_depth": "16",
+                            "channels": "1",
+                            "city_pd": "",
+                            "client_ip": "112.132.223.243",
+                            "dtype": "text",
+                            "frame_size": "0",
+                            "msc.lat": "31.837463",
+                            "msc.lng": "117.17",
+                            "pers_param": self.pers_param,
+                            "sample_rate": "16000",
+                            "scene": self.scene,
+                            "stmid": "0",
+                            "uid": self.uid,
+                            "debug": self.debug,
+                            "debugx": self.debugx,
+                            "category": self.category
+                        },
+                        "UserParams": encode_base64(self.UserParams),
+                        "UserData": quote_plus(self.UserData)
+                    }
+                }
+            },
+            "payload": {
+                "text": {
+                    "compress": "raw",
+                    "encoding": "utf8",
+                    "format": "plain",
+                    "plainText": self.plainText,
+                    "status": 3
+                }
+            }
+        }
+    async def handle_v1_chain(self, ws):
+        """
+        处理5.0链路逻辑：
+        - 根据接收到的消息执行不同的操作
+        - 当'action'为'started'时，读取文件并发送数据块
+        - 发送结束标识
+        - 当'action'为'result'且'sub'为'stream_tpp'时，返回内容
+        """
+        while True:
+            _msg = await ws.recv()
+            # print(_msg)
+            try:
+                msg = json.loads(_msg)
+                code = safe_get(msg, ["header","code"])
+                if code != 0:
+                    logging.error(f'请求错误: {code}, {msg}')
+                    break
+                else:
+                    answer = safe_get(msg, ["payload","results","text","intent","answer"])
+                    answerText = safe_get(answer, ["text"])
+                    if answerText:
+                        self.answer_text += answerText
+                    if msg['header']['status']=="2" or msg['header']['status']=="3":  # 返回结果接收完成
+                        if self.answer_text:
+                            answer["text"] = self.answer_text     
+                        self.response = msg
+                        return
+                        
+            except Exception as e:
+                logging.error(f"error in handle_v1_chain :{e}")
+                break
+ 
+    

caseScript/Gateway.py

@@ -0,0 +1,264 @@
+
+from wsgiref.handlers import format_date_time
+import asyncio
+from time import mktime
+import hashlib
+import hmac,time
+from urllib.parse import urlencode, urlparse
+import uuid
+from common.utils import *
+from common.WSBaseApi import WSBaseApi
+from pathlib import Path
+
+class ApiTestRunner(WSBaseApi):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.text_path = Path.cwd().resolve().joinpath("data/audio",f"{self.text}.pcm")
+    def generate_v2_auth_headers(self):
+        """为v2 5.4链路生成授权头"""
+        url_host = urlparse(self.url).netloc
+        date = format_date_time(mktime(datetime.now().timetuple()))
+        authorization_headers = f"host: {url_host}\ndate: {date}\nGET /v2/autoCar HTTP/1.1"
+        signature_sha = hmac.new(self.apiSecret.encode('utf-8'), authorization_headers.encode('utf-8'),
+                                digestmod=hashlib.sha256).digest()
+        authorization_signature = encode_base64(signature_sha,input_encoding='bytes')
+        authorization = f'api_key="{self.apiKey}", algorithm="hmac-sha256", headers="host date request-line", signature="{authorization_signature}"'
+        return {
+                "host": url_host,
+                "date": date,
+                "authorization": encode_base64(authorization),
+                "appid": self.appId
+            }
+    def generate_v1_auth_headers(self):
+        
+        """为5.0链路生成参数"""
+        param_iat = self.build_params()
+        cur_time = int(time.time())
+        param = json.dumps(param_iat, ensure_ascii=False)
+        param_base64 = encode_base64(param)
+        check_sum_pre = self.apiKey + str(cur_time) + param_base64
+        checksum = hashlib.md5(check_sum_pre.encode("utf-8")).hexdigest()
+        return {
+                "appid": self.appId,
+                "checksum": checksum,
+                "param": param_base64,
+                "curtime": str(cur_time),
+                "signtype": "md5"
+            }
+    def assemble_ws_auth_url(self,  chain=None):
+        if chain:
+            # v2 5.4链路
+            params = self.generate_v2_auth_headers()
+        else:
+            # 默认5.0链路
+            params = self.generate_v1_auth_headers()
+
+        return f"{self.url}?{urlencode(params)}"
+    # @exception_decorator
+    async def handle_v2_chain(self, ws):
+        """
+        处理v2 5.4链路逻辑：
+        - 接收消息并解析
+        - 检查返回码是否为0（成功）
+        - 如果状态为1，则解码并返回特定的文本内容
+        - 如果状态为2，则结束循环
+        """
+        while True:
+            try:
+                msg = await ws.recv()
+                # print(msg)
+                response_data = json.loads(msg)
+                # code 返回码，0表示成功，其它表示异常
+                if response_data["header"]["code"] == 0:
+                    # status 整个结果的状态，0-会话起始结果，1-中间结果，2-最终结果
+                    if "status" in response_data["header"]:
+                        status = response_data["header"]["status"]
+                        if status == 1 and "cbm_semantic" in response_data["payload"]:
+                            semantic_bs64 = response_data["payload"]["cbm_semantic"]["text"]
+                            semantic_str = base64.b64decode(semantic_bs64.encode('utf-8')).decode('utf-8')
+                            self.response = json.loads(semantic_str)
+                            return
+                        elif status == 2:
+                            break
+                else:
+                    logging.error(f"返回结果错误：{response_data['header']['message']}")
+                    break
+            except Exception as e:
+                logging.error(f"Error in processing message: {e}")
+                break
+    # @exception_decorator
+    async def handle_v1_chain(self, ws):
+        """
+        处理5.0链路逻辑：
+        - 根据接收到的消息执行不同的操作
+        - 当'action'为'started'时，读取文件并发送数据块
+        - 发送结束标识
+        - 当'action'为'result'且'sub'为'stream_tpp'时，返回内容
+        """
+
+        while True:
+            _msg = await ws.recv()
+            # print(_msg)
+            try:
+                msg = json.loads(_msg)
+                if msg['action'] == "started":
+                    with open(self.text_path, 'rb') as file:
+                        for chunk in iter(lambda: file.read(1280), b''):
+                            await ws.send(chunk)
+                            await asyncio.sleep(0.04)  # 使用asyncio.sleep避免阻塞事件循环
+                    await ws.send("--end--".encode("utf-8"))
+                elif msg['action'] == "result":
+                    data = msg['data']
+                    if data.get('sub') == "stream_tpp" or data.get('sub') == "tpp":
+                        self.response = json.loads(data['content'])
+                        return
+            except Exception as e:
+                logging.error(f"error in handle_v1_chain :{e}")
+                break
+   
+    def build_params(self,chain=None):
+        if chain:  #5.4链路参数
+            _textParams = {
+                "sparkEnv": self.sparkEnv,
+                "userId": self.userId,
+                "user_data": "", 
+                "attachparams": str({"nlp_params": {"vWtoken": self.token, "aiui45_intv_mode": 2, "aqua_route": "vwa"}}), # 不能传递字典，需要传str
+                "scene": self.scene,
+                "debugx": "true",
+                "debug": "true"
+            }
+            # # 序列化 textParams
+            textParams = json.dumps(_textParams, ensure_ascii=False)
+            def get_audio():
+                with open(self.text_path, "rb") as file:
+                    content = file.read()
+                    return encode_base64(content,input_encoding='bytes')
+        
+
+            return {
+                    "header": {
+                        "app_id": self.appId,
+                        "uid": "efeafe5e-82d6-4922-9770-f7aaabf97548",
+                        "stmid": "sid1111",
+                        "status": 3,
+                        "scene": self.scene
+                    },
+                    "parameter": {
+                        "nlp": {
+                            "sub_scene": "cbm_v47",
+                            "new_session": False,
+                            "nlp": {
+                                "encoding": "utf8",
+                                "compress": "raw",
+                                "format": "json"
+                            }
+                        }
+                    },
+                    "payload": {
+                        "cbm_semantic": {
+                            "compress": "raw",
+                            "format": "plain",
+                            "text": encode_base64(textParams),
+                            "encoding": "utf8",
+                            "status": 3
+                        },
+                        "audio": {
+                            "audio": get_audio(),
+                            "status": 2,
+                            "encoding": "raw",
+                            "sample_rate": 16000,
+                            "channels": 1,
+                            "bit_depth": 16,
+                            "frame_size": 0
+                        }
+                    }
+                }
+        else: #5.0链路参数
+            def get_auth_id():
+                """
+                生成基于系统MAC地址的唯一身份验证ID。
+                
+                返回:
+                    str: 唯一的身份验证ID。
+                """
+                # 获取系统MAC地址的整数表示，并转换为12位的十六进制字符串
+                mac = uuid.UUID(int=uuid.getnode()).hex[-12:]
+                
+                # 将MAC地址按照标准格式（使用冒号分隔）重新组合
+                formatted_mac = ":".join([mac[e:e + 2] for e in range(0, 11, 2)])
+                
+                # 对格式化后的MAC地址进行MD5哈希处理，并返回其十六进制表示
+                auth_id = hashlib.md5(formatted_mac.encode("utf-8")).hexdigest()
+                return auth_id
+            trs_params = {}
+            iat_params = {
+                        "accent": "mandarin",
+                        "language": self.language,
+                        "domain": "aiui-automotiveknife",
+                        "eos": "600",
+                        "evl": "0",
+                        "isFar": "0",
+                        "svl": "50",
+                        "vgap": "400"
+                    }
+            
+            nlp_params = {
+                        "devid": "LG8-LGA26.08.2420010196",
+                        "city": "合肥市",
+                        "user_defined_params": {},
+                        "weather_airquality": "true",
+                        "deviceId": "LG8-LGA26.08.2420010196",
+                        "userId": "69b85a13-1434-408b-872f-1632c587dbc4",
+                        "asp_did": "LG8-LGA26.08.2420010196",
+                        "vWtoken": self.token,
+                        "car_identity": "MP24",
+                        "theme": "standard",
+                        "vin": "HVWJA1ER5R1203864",
+                        "interactive_mode": "fullDuplex",
+                        "did": "VW_HU_ICAS3_LG8-LGA26.08.2420010196_v2.0.1_v0.0.1"
+                    }
+            attach_params = {
+                            "trs_params": json.dumps(trs_params, ensure_ascii=False),
+                            "iat_params": json.dumps(iat_params, ensure_ascii=False),
+                            "nlp_params": json.dumps(nlp_params, ensure_ascii=False)
+                        }
+            return {
+                    "auth_id": get_auth_id(),
+                    "ver_type": "websocket",
+                    "data_type": "audio",
+                    "scene": "main",
+                    "lat": "31.704187",
+                    "lng": "117.239833",
+                    "attach_params": json.dumps(attach_params, ensure_ascii=False),
+                    "userparams": "eyJjbGVhbl9oaXN0b3J5Ijoib2ZmIiwic2tpcCI6Im5vdF9za2lwIn0=",
+                    "interact_mode": "continuous",
+                    "text_query": "tpp",
+                    "sample_rate": "16000",
+                    "aue": "raw",
+                    "speex_size": "60",
+                    "dwa": "wpgs",
+                    "result_level": "complete",
+                    "debugx": "True",
+                    "debug": "true",
+                    "close_delay": "100"
+                }
+    
+    @exception_decorator
+    def run(self):
+        extra_headers = {'Authorization': self.token}
+        # 使用split函数分割URL，并找到包含"v2"的部分
+        parts = self.url.split('/')
+        # "v2"正好位于倒数第二个位置, v2走5.4链路,v1走5.0链路
+        version = "v2" if len(parts) > 2 and parts[-2] == 'v2' else None
+        # 根据版本选择正确的assemble_ws_auth_url方法参数
+        self.url = self.assemble_ws_auth_url(version)
+        # 构建frame，对于v2版本添加额外参数
+        if version:
+            self.request = self.build_params(version)
+        # WebSocket连接与消息发送
+        asyncio.run(self.WebSocketApi(
+            extra_headers,
+            version
+        ))
+
+

common/Assertion.py

@@ -0,0 +1,105 @@
+
+from datetime import datetime, timedelta,date
+from common.assertUtils import *
+import pytest
+
+
+def iAssert(response, keys_values_str):
+    """
+    断言JSON响应中的键值对是否符合预期。
+
+    :param response: JSON响应作为字典。
+    :param keys_values_str: 键值对字符串，用逗号或顿号分隔。
+    :return: 包含断言结果的字典。
+    """
+    # 处理输入字符串，提取键和值。
+    key_value_map = get_key_value(keys_values_str, delimiter='\n', pair_delimiter='=',opt="not in")
+
+    for key,value in key_value_map.items():
+        expected_value = value
+        actual_value = str(get_value(response, key))
+        msg = f"【{key}】 expected【{expected_value}】, but got 【{actual_value}】"
+        if expected_value == '1no1' or expected_value is None:
+            # 对于期望值为 '1no1' 或 None 的情况，仅检查键是否存在。
+            assert has_key(response, key),  f"key:{key}  is not exist, check path!" 
+        else:
+            # 需要校验值的情况。
+            if expected_value.startswith('*') and expected_value.endswith('*'):
+                assert re.search(expected_value[1:-1], actual_value),  msg
+            elif expected_value.endswith('*'):
+                assert re.match(expected_value[:-1], actual_value), msg
+            elif expected_value.startswith('*'):
+                assert re.search(expected_value[1:], actual_value), msg
+            elif isinstance(expected_value, dict):
+                assert actual_value != expected_value, msg
+            elif expected_value.startswith('eval_'):
+                except_value = expected_value[5:]
+                assert str(eval(except_value)) == actual_value, msg
+            elif expected_value.startswith('in('):
+                # 处理以 in 开头的情况。or:a in(1||2||3)
+                expected_value_list = expected_value[3:-1].split('||')
+                assert actual_value in expected_value_list, msg 
+            elif expected_value.startswith('language_'):
+                # 检测文本 language 
+                assert check_text_language(actual_value) == expected_value[9:], msg
+            else:
+                assert actual_value == expected_value, msg
+
+
+def urlAssert(req, res, query_info):
+    """
+    比较请求和响应参数。
+    :param req: 请求数据
+    :param res: 响应数据
+    :param query_info: 查询信息字符串
+    :return: 响应数据对象
+    """
+    query_info_dic = get_key_value(query_info, delimiter='\n', pair_delimiter=':')
+    url_path = query_info_dic["queryPath"]
+    res_url = get_Urlparam_dic(get_value(res, url_path), json_fields = ['pers_param', 'user_defined_params'])
+    req_res_keys_str = query_info_dic["queryCondit"]
+    req_res_keys = get_key_value(req_res_keys_str)
+    for req_key,res_key in req_res_keys.items():
+        req_val = get_value(req,req_key.strip(), decode_funcs={"parameter.custom.custom_data.UserParams": decode_base64,"parameter.custom.custom_data.UserData": url_decode})
+        res_val = get_value(res_url,res_key.strip())
+        assert req_val == res_val, f"【请求参数: {req_key}】与【响应参数: {res_key}】 的值对比不一致，\n请求值为: 【{req_val}】\n响应值为:【{res_val}】"
+    return res_url
+
+def arrayAssert(response_json, query_info):
+    """
+    path对应数据是数组, 根据多个条件查找数组中匹配的元素。
+    """
+    query_info_dic = get_key_value(query_info, delimiter='\n', pair_delimiter=':')
+    query_condit = query_info_dic["queryCondit"]
+    query_path = query_info_dic["queryPath"]
+
+    # 解析 查询条件，将其转换为字典形式
+    condit_dit = get_key_value(query_condit, delimiter=',', pair_delimiter='=')
+
+    try:
+        # 获取返回消息中path对应的JSON 数据
+        path_json = get_value(response_json, query_path)
+    except KeyError as e:
+        raise ValueError(f'{e}')
+
+    # 查找所有匹配项
+    index_list = list(find_matching_index(path_json, condit_dit))
+
+    if not index_list:
+        raise ValueError(f'未找到符合条件的元素：【{query_condit}】')
+    else:
+        # 假设我们只关心第一个匹配项
+        return path_json[int(index_list[0])]
+
+def Assert(request,response, case_suite):
+        """执行断言"""
+        if case_suite["UniversalAssert"]:  #通用断言，key=value
+            iAssert(response, case_suite['UniversalAssert'])
+
+        if case_suite["ArrayAssert"]: #数组断言，value=[{...},{...},{...},...],给出条件，找到匹配的{...},再在{...}中执行通用断言 key=value
+            iAssert(arrayAssert(response, case_suite['ArrayAssert']), case_suite['ArrayAssert'])
+            
+        if case_suite["URLAssert"]:  #url查询参数断言，某些resquest key(a.b.c=xx）会传给res url,作为res_url的查询参数(http://...?c=xx)，断言value(a.b.c)=value(cc)
+            _res = urlAssert(request, response, case_suite['URLAssert'])
+            if get_key_value(case_suite['URLAssert'], delimiter='\n', pair_delimiter='=',opt="not in"):
+                iAssert(_res, case_suite['URLAssert'])

common/WSBaseApi.py

@@ -0,0 +1,109 @@
+import websockets
+from functools import cached_property
+import asyncio
+from common.utils import *
+import allure
+from pathlib import Path
+from common.Assertion import Assert
+import pytest
+import traceback
+class WSBaseApi:
+    def __init__(self, **kwargs):
+        self.request = {}
+        self.response = {}
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+    async def WebSocketApi(self, extra_headers=None, chain=None):
+        """
+        建立WebSocket连接，根据提供的参数发送初始帧，并根据链路版本处理后续消息
+        - 如果chain为v2，则调用handle_v2_chain处理消息
+        - 否则，默认调用handle_v1_chain处理消息
+        """
+        async with websockets.connect(self.url, extra_headers=extra_headers) as ws:
+            await ws.send(json.dumps(self.request, ensure_ascii=False))
+            await self.handle_v2_chain(ws) if chain == "v2" else await self.handle_v1_chain(ws)
+    @exception_decorator
+    def run(self):
+        self.request = self.build_params()
+        # WebSocket连接与消息发送
+        asyncio.run(self.WebSocketApi())
+
+
+
+class BaseApiTest:
+    # 定义需要子类实现的属性
+    TEST_TYPE = "API自动化测试"  # 默认值，可被子类覆盖
+    CASE_PATH = Path.cwd().resolve().joinpath("data/case_data.xlsx")
+
+    @cached_property
+    def API_TEST_RUNNER_CLASS(self):
+        """动态加载对应的测试运行器类（自动缓存）"""
+        class_prefix = self.__class__.__name__[4:]  # TestGateway -> Gateway
+        module_path = f"caseScript.{class_prefix}"
+        
+        try:
+            module = __import__(module_path, fromlist=['ApiTestRunner'])
+            return module.ApiTestRunner
+        except ImportError as e:
+            raise ImportError(
+                f"无法加载 {module_path}.ApiTestRunner，"
+                "请检查模块路径和类命名是否符合规范"
+            ) from e
+
+    @pytest.mark.parametrize('case_suite', gen_case_suite(CASE_PATH))
+    def test_api(self, case_suite, setup_env):
+        """测试用例执行模板"""
+        try:
+            # 1. 合并参数
+            params = merge_dicts(case_suite, setup_env)
+            
+            # 2. 执行测试
+            runner = self.API_TEST_RUNNER_CLASS(**params)
+            runner.run()
+            
+            # 3. 记录报告
+            self._record_allure_report(runner)
+            
+            # 4. 执行断言
+            self._execute_assertions(runner, case_suite)
+            
+        except Exception as e:
+            self._record_error(e)
+            raise
+    
+    def _record_allure_report(self, runner):
+        """记录Allure测试报告"""
+        allure.dynamic.epic(
+            f"【{runner.env_name}】"
+            f"【{runner.project}】"
+            f"【{runner.service}】"
+            f"{self.TEST_TYPE}"
+        )
+        allure.dynamic.story(runner.appId)
+        allure.attach(runner.url, 'URL', allure.attachment_type.URI_LIST)
+        allure.attach(
+            f"{convert_to_json(runner.request)}", 
+            'API请求', 
+            allure.attachment_type.JSON
+        )
+        allure.attach(
+            f"{convert_to_json(runner.response)}", 
+            'API响应', 
+            allure.attachment_type.JSON
+        )
+    def _execute_assertions(self, runner, case_suite):
+        """执行断言逻辑"""
+        with allure.step(f'【断言】{runner.number}_{runner.casename}'):
+            Assert(runner.request, runner.response, case_suite)
+    def _record_error(self, error):
+        """记录测试错误信息"""
+        allure.attach(
+            str(error),
+            '异常信息',
+            allure.attachment_type.TEXT
+        )
+        allure.attach(
+            traceback.format_exc(),
+            '异常堆栈',
+            allure.attachment_type.TEXT
+        )

common/WebSocketApi.py

@@ -0,0 +1,73 @@
+import _thread as thread
+import logging
+import websocket  # 使用websocket_client
+from common.utils import *
+
+class WebSocketApi:
+    def __init__(self, url, request):
+        self.url = url
+        self.request = request
+        self.answer_text = ""
+        self.errcode = ""
+        self.response = {}
+        self.ws = None
+        
+    def on_error(self, ws, error):
+        """处理WebSocket错误"""
+        logging.error(f"### error: {error}")
+        self.errcode = str(error)
+        self.ws.close()
+
+    def on_close(self, ws, close_status_code, close_msg):
+        """处理WebSocket关闭"""
+        logging.info(f"### ws closed with status {close_status_code} and message {close_msg}")
+
+    def on_open(self, ws):
+        """处理WebSocket连接建立"""
+        thread.start_new_thread(self.run, (ws,))
+
+    def run(self, ws, *args):
+        """发送请求"""
+        ws.send(self.request)
+
+    def on_message(self, ws, message: str):
+        """处理WebSocket消息"""
+        try:
+            msg = json.loads(message)
+            code = safe_get(msg, ["header","code"])
+            if code != 0:
+                logging.error(f'请求错误: {code}, {msg}')
+                err_msg = safe_get(msg, ["header","message"])
+                self.errcode = f"{code}, error msg: {err_msg}"
+                self.ws.close()
+            else:
+                answer = safe_get(msg, ["payload","results","text","intent","answer"])
+                answerText = safe_get(answer, ["text"])
+                if answerText:
+                    self.answer_text += answerText
+                if msg['header']['status']=="2" or msg['header']['status']=="3":  # 返回结果接收完成
+                    if self.answer_text:
+                        answer["text"] = self.answer_text     
+                    self.response = msg
+                    self.ws.close()
+        except json.JSONDecodeError as e:
+            logging.error(f"JSON解码错误: {e}")
+            self.errcode = f"JSON解码错误: {e}"
+            self.ws.close()
+
+    def start(self):
+        """启动WebSocket客户端"""
+        websocket.enableTrace(False)
+        self.ws = websocket.WebSocketApp(self.url,
+                                        on_open=self.on_open,
+                                        on_error=self.on_error,
+                                        on_message=self.on_message,
+                                        on_close=self.on_close)
+        self.ws.run_forever()
+
+
+def main(Spark_url, request: str):
+    """主函数，启动WebSocket客户端并返回响应"""
+    client = WebSocketApi(Spark_url, request)
+    client.start()
+    return client.response

common/assertUtils.py

@@ -0,0 +1,132 @@
+import re
+from common.utils import *
+from typing import Literal
+
+def get_value(data, path, decode_funcs=None):
+    """
+    获取嵌套字典中的值。
+    
+    :param data: 嵌套字典
+    :param path: 字典路径，用点号分隔
+    :param decode_funcs: 一个字典，键是路径，值是解码函数
+    :return: 路径对应的值, 如果路径不存在则返回None
+    """
+    keys = path.split('.')
+    current = data
+    for key in keys:
+        if isinstance(current, dict) and key in current:
+            current = current[key]
+        else:
+            return None
+    # 特殊处理某些路径的值
+    if decode_funcs and path in decode_funcs:
+        return decode_funcs[path](current)
+    else:
+        return current
+
+def get_key_value(input_str, delimiter=',，', pair_delimiter='=',opt: Literal["in", "not in"]="in"):
+    """
+    解析键值对字符串，返回指定数据格式。
+    
+    :param input_str: 键值对字符串
+    :param delimiter: 键值对之间的分隔符，默认为逗号
+    :param pair_delimiter: 键和值之间的分隔符，默认为等号
+    :return: 键和值
+    """
+    def should_include(part):
+        """根据 opt 判断是否包含该部分"""
+        if opt == "in":
+            return pair_delimiter in part
+        elif opt == "not in":
+            return ":" not in part
+        else:
+            raise ValueError(f"Invalid operation: {opt}")
+
+    # 解析字符串并根据 opt 进行过滤
+    key_value_map = {part.split(pair_delimiter)[0].strip():part.strip().split(pair_delimiter)[1].strip() for part in re.split(rf'[{delimiter}]', input_str) if should_include(part)}
+    return key_value_map
+
+
+def get_Urlparam_dic(urlstr, json_fields=None):
+    """
+    将URL查询字符串解析为字典，并处理特定字段的JSON解码。
+    
+    :param urlstr: 完整的URL字符串
+    :param json_fields: 需要进行JSON解码的字段列表
+    :return: 解析后的字典
+    """
+    if json_fields is None:
+        json_fields = []
+    # 如果URL中没有查询字符串，直接返回空字典
+    if '?' not in urlstr:
+        return {}
+    
+    # 分离URL和查询字符串
+    _, _params = urlstr.split('?', 1)
+    
+    # 解析查询字符串为键值对
+    params = urllib.parse.parse_qs(_params)
+    # 解码值并构建字典,values[0]取第一个值（假设每个键只有一个值）
+    obj = {key: url_decode(values[0]) if values else None for key, values in params.items()}
+    def decode_json_field(field, value):
+        """
+        尝试将字段值解析为JSON对象。
+        
+        :param field: 字段名
+        :param value: 字段值
+        :return: 解析后的JSON对象或原始值
+        """
+        if value is None:
+            return None
+        
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError as e:
+            print(f"JSON解码错误: {e}")
+            print(f"字段 '{field}' 的值为: {value}")
+            return None
+    # 解析特定字段为JSON对象
+    for field in json_fields:
+        if field in obj:
+            obj[field] = decode_json_field(field, obj[field])
+    
+    return obj
+    
+
+def has_key(obj, key_path):
+    """
+    检查一个对象中是否存在指定的键路径。
+
+    :param obj: 要检查的对象。
+    :param key_path: 键路径，用点号分隔。
+    :return: 如果路径存在则返回True, 否则返回False。
+    """
+    current_obj = obj
+    keys = key_path.split('.')
+    for key in keys:
+            if key in current_obj:
+                current_obj = current_obj[key] 
+            else:
+                return False
+    return True
+
+
+def find_matching_index(data, conditions, current_path=""):
+    """
+    递归查找匹配所有条件的数据index。
+    只有当项是字典或列表时才进一步递归
+    """
+    if isinstance(data, list):
+        for index, item in enumerate(data):
+            if isinstance(item, (dict, list)): 
+                new_path = f"{current_path}[{index}]"
+                yield from find_matching_index(item, conditions, new_path)
+    elif isinstance(data, dict):
+        if all([str(get_value(data,key)) == value for key, value in conditions.items()]):
+            index = re.search(r'\[(\d+)\]', current_path).group(1)
+            yield index
+        else:
+            for key, value in data.items():
+                new_path = f"{current_path}.{key}" if current_path else key
+                if isinstance(value, (dict, list)):
+                    yield from find_matching_index(value, conditions, new_path)

common/logger.py

@@ -0,0 +1,27 @@
+import os
+import logging
+from datetime import datetime
+
+def configure_logging():
+    # 指定日志文件夹路径
+    log_dir = 'logs'
+    
+    # 创建日志文件夹（如果它不存在）
+    os.makedirs(log_dir, exist_ok=True)
+    
+    # 获取今天的日期，用于日志文件名
+    today_date = datetime.now().date()
+    
+    # 配置日志记录
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s.%(msecs)03d - %(levelname)s - %(name)s - %(message)s',
+        datefmt='%H:%M:%S',
+        handlers=[
+            logging.StreamHandler(),  # 输出到控制台
+            logging.FileHandler(f'{log_dir}/{today_date}.log')  # 输出到文件
+        ]
+    )
+
+# 调用函数以配置日志记录
+configure_logging()

common/utils.py

@@ -0,0 +1,244 @@
+import  base64, json,os
+import pandas as pd
+import inspect,urllib
+import random
+import string
+from datetime import datetime
+import email.utils
+from functools import wraps
+from common.logger import *
+from typing import Optional, Union, Literal
+import numpy as np
+def get_rfc1123_time():
+        # 获取当前UTC时间
+        now = datetime.utcnow()
+        # 将时间格式化为RFC1123格式
+        rfc1123_time = email.utils.format_datetime(now)
+        return rfc1123_time
+
+def generate_random_string(length=32):
+    """
+    生成指定长度的随机字符串，该字符串可以从包含小写字母、数字以及'@'符号的字符集中随机选择。
+    
+    Args:
+        length (int): 生成字符串的长度，默认为32。
+    
+    Returns:
+        str: 生成的随机字符串。
+    """
+    if length < 1:
+        raise ValueError("Length must be at least 1.")
+    
+    # 定义字符池：包含小写字母、数字和 '@' 符号
+    chars = string.ascii_lowercase + string.digits + "@"
+    
+    # 从字符池中随机选择指定数量的字符
+    random_chars = random.choices(chars, k=length)
+    
+    return ''.join(random_chars)
+
+def decode_unicode_escape(data):
+    """
+    递归地遍历字典或列表，将所有字符串值中的Unicode转义序列解码为原始字符。
+    
+    Args:
+        data (dict or list): 包含Unicode转义序列的JSON对象（字典或列表）。
+    
+    Returns:
+        dict or list: 解码后的JSON对象，其中所有字符串值已被正确解码。
+    """
+    if isinstance(data, dict):
+        return {key: decode_unicode_escape(value) for key, value in data.items()}
+    elif isinstance(data, list):
+        return [decode_unicode_escape(element) for element in data]
+    elif isinstance(data, str):
+        try:
+            # 使用 json.loads 来解析包含转义字符的字符串
+            return json.loads(f'"{data}"')
+        except json.JSONDecodeError:
+            # 如果字符串不是有效的JSON字符串，则直接返回原字符串
+            return data
+    else:
+        # 对于其他类型的数据，直接返回它们
+        return data
+
+def convert_to_json(data):
+    """
+    将包含Unicode转义序列的JSON数据解码，并返回JSON格式的字符串。
+    
+    Args:
+        data (dict or list): 包含Unicode转义序列的JSON对象（字典或列表）。
+    
+    Returns:
+        str: 解码并格式化后的JSON字符串。
+    """
+    decoded_data = decode_unicode_escape(data)
+    return json.dumps(decoded_data, ensure_ascii=False, indent=4)
+    
+def encode_base64(
+    s: Optional[Union[str, bytes]],
+    *,
+    input_encoding: Literal['auto', 'str', 'bytes'] = 'auto',
+    output_encoding: str = 'utf-8'
+) -> Optional[str]:
+    """将字符串或字节数据编码为 Base64 格式
+    
+    Args:
+        s: 要编码的输入数据，可以是字符串或字节，None 直接返回 None
+        input_encoding: 输入处理模式：
+            'auto' - 自动检测类型（默认）
+            'str' - 强制作为字符串处理
+            'bytes' - 强制作为字节处理
+        output_encoding: 输出结果的编码格式（默认utf-8）
+    
+    Returns:
+        Base64 编码后的字符串，如果输入为 None 则返回 None
+    
+    Raises:
+        TypeError: 输入类型不符合要求
+        ValueError: 编码失败或模式参数无效
+    """
+    if s is None:
+        return None
+
+    # 输入类型处理
+    try:
+        if input_encoding == 'str':
+            data = s.encode('utf-8') if isinstance(s, str) else s
+        elif input_encoding == 'bytes':
+            data = s if isinstance(s, bytes) else str(s).encode('utf-8')
+        elif input_encoding == 'auto':
+            data = s.encode('utf-8') if isinstance(s, str) else s
+        else:
+            raise ValueError(f"Invalid input_encoding: {input_encoding}")
+    except (AttributeError, UnicodeError) as e:
+        raise ValueError(f"Input encoding failed: {str(e)}") from e
+
+    if not isinstance(data, bytes):
+        raise TypeError(f"Expected bytes or string, got {type(s).__name__}")
+
+    # Base64 编码
+    try:
+        return base64.b64encode(data).decode(output_encoding)
+    except UnicodeError as e:
+        raise ValueError(f"Output decoding failed: {str(e)}") from e
+def decode_base64(s):
+    """将 Base64 编码的字符串解码回原始字符串"""
+    return base64.b64decode(s.encode('utf-8')).decode('utf-8') if s is not None else None
+
+def url_decode(str_):
+    """
+    解码URL编码的字符串。
+    
+    :param str_: URL编码的字符串
+    :return: 解码后的字符串
+    """
+    return urllib.parse.unquote_plus(str_)  if str_ else None
+
+def check_text_language(text):
+    """
+    检查文本是纯中文、纯英文还是中文加英文。
+    
+    :param text: 需要检查的文本
+    :return: 文本的语言类型 ('纯中文', '纯英文', '中文+英文', '其他')
+    """
+    has_chinese = any('\u4e00' <= char <= '\u9fff' for char in text)
+    has_english = any('a' <= char <= 'z' or 'A' <= char <= 'Z' for char in text)
+
+    if has_chinese and has_english:
+        return "中文+英文"
+    elif has_chinese:
+        return "纯中文"
+    elif has_english:
+        return "纯英文"
+    else:
+        return "其他"
+    
+def safe_get(data, keys, default=""):
+    """ 安全地从嵌套字典中获取值 """
+    for key in keys:
+        try:
+            data = data[key]
+        except (KeyError, TypeError):
+            return default
+    return data
+
+def append_msg_to_excel(file_path, **kwargs):
+    try:
+        # 检查文件是否存在
+        if not os.path.exists(file_path):
+            # 如果文件不存在，创建一个新的 DataFrame 并保存为 Excel 文件
+            existing_df = pd.DataFrame()
+        else:
+            # 读取现有数据
+            existing_df = pd.read_excel(file_path)
+
+        # 动态构建 new_data 字典
+        new_data = {**kwargs}
+
+        # 将新数据转换为 DataFrame
+        new_df = pd.DataFrame([new_data])
+
+        # 追加新数据到现有数据
+        updated_df = pd.concat([existing_df, new_df], ignore_index=True)
+
+        # 写回 Excel 文件
+        updated_df.to_excel(file_path, index=False)
+    except Exception as e:
+        # 获取当前文件名和方法名
+        current_file = inspect.getfile(inspect.currentframe())
+        current_function = inspect.currentframe().f_code.co_name
+        print(f"An error occurred in file '{current_file}' and function '{current_function}': {e}")
+
+def read_excel(file_path):
+    df = pd.read_excel(file_path, header=0, dtype={'debug': str,'debugX': str})
+    # 如果确实需要空字符串，先转换类型
+    pd.set_option('future.no_silent_downcasting', True)
+    df = df.astype(object).fillna("")  # 转换为object类型
+    data_dict = df.to_dict(orient='records')
+    return data_dict
+
+def exception_decorator(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            # 直接使用被装饰函数的名字
+            function_name = func.__name__
+            file_name = os.path.basename(func.__code__.co_filename)  # 提取文件名
+            # 打印异常和函数名
+            logging.error( f"异常发生在文件 [{file_name}] 的函数 [{function_name}] 中: {str(e)}",
+                exc_info=True  # 自动追加堆栈信息
+                )
+            # 可选择再次抛出异常或进行其他处理
+            raise
+    return wrapper
+def merge_dicts(a: dict, b: dict) -> dict:
+    """合并两个字典，重复key时优先取a中非空的值
+    
+    Args:
+        a: 优先字典（保留其非空值）
+        b: 后备字典（当a中的值为空时使用）
+    
+    Returns:
+        合并后的新字典
+    """
+    return {
+        # 遍历所有key（a和b的key取并集）
+        k: 
+            # 如果key在a中 且 a的value不是空值 → 取a的值
+            a.get(k) if k in a and a.get(k) not in (None, "") 
+            # 否则 → 取b的值（可能为None）
+            else b.get(k)
+        # 获取a和b的所有key的并集（避免用a|b需要Python 3.9+）
+        for k in set(a) | set(b)
+    }
+
+def gen_case_suite(file_path):
+    # 生成测试用例套件
+    data_dict = read_excel(file_path)
+    case_suite = []
+    for case in data_dict:
+        case_suite.append(case)
+    return case_suite

testcase/test_all.py

@@ -0,0 +1,10 @@
+# 具体测试类实现
+from common.WSBaseApi import BaseApiTest
+import pytest
+
+@pytest.mark.gateway
+class TestGateway(BaseApiTest):pass
+
+
+@pytest.mark.aqua
+class TestAqua(BaseApiTest):pass