CloudApiRequest 1.0.0__py3-none-any.whl

cloud/CloudAPIRequest.py

@@ -0,0 +1,426 @@
+"""
+cloud接口测试核心类
+"""
+import json
+import os
+import time
+from urllib.parse import urlparse
+
+import pytest
+import allure
+import jsonpath
+from requests_toolbelt import MultipartEncoder
+from cloud.CloudLogUtil import log
+from cloud.CloudRequestUtil import CloudHttpClient
+from cloud.CloudSignUtil import CloudSignUtil
+from cloud.CloudYamlUtil import CloudReadYaml, CloudPlaceholderYaml
+from cloud.CloudApiConfig import config
+
+
+class CloudAPIRequest:
+    """
+    cloud接口测试核心类
+    """
+
+    def __init__(self, commonCase=None):
+        """
+        :param commonCase: 公共用例文件
+        """
+        self.commonCase = commonCase
+        # 延迟初始化配置，避免循环导入
+        self._config = None
+        self.baseUrl = None
+        self.token = None
+        self.globalBean = None
+        self.assertFail = 'stop'
+        self.tenv = 'base'
+    
+    def _get_config(self):
+        """延迟获取配置实例"""
+        if self._config is None:
+            from cloud import config
+            self._config = config
+            # 正确获取配置值，而不是property对象
+            self.baseUrl = str(config._baseUrl) if hasattr(config, '_baseUrl') and config._baseUrl else None
+            self.token = str(config._token) if hasattr(config, '_token') and config._token else None
+            self.globalBean = config
+            self.assertFail = str(config._assertFail) if hasattr(config, '_assertFail') and config._assertFail else 'stop'
+            self.tenv = str(config._tEnv) if hasattr(config, '_tEnv') and config._tEnv else 'base'
+        return self._config
+
+    def doRequest(self, file, bean):
+        """
+        执行API请求测试
+        """
+        requestParameter = None
+        dataSaveBean = bean
+        yaml = CloudReadYaml(file).load_yaml()
+        yamlId = yaml.get('id')
+        yamlName = yaml.get('name')
+        yamlTestcase = yaml.get('testcases')
+        
+        log.info(f"开始执行测试用例name: {yamlName}, id: {yamlId}")
+        config_instance = self._get_config()
+        clientSession = config_instance.Session
+        
+        for testcase in yamlTestcase:
+            with allure.step(testcase.get('name')):
+                if testcase.get('skip'):
+                    log.info(f"用例: {testcase.get('name')}跳过")
+                    continue
+                    
+                sleeps = testcase.get('sleep')
+                if sleeps:
+                    time.sleep(int(sleeps))
+                    log.info(f"当前用例: {testcase.get('name')}执行前等待{sleeps}秒")
+                
+                # 处理公共用例
+                config_instance = self._get_config()
+                if testcase.get('kind') and testcase.get('kind').lower() == 'common' and hasattr(config_instance, '_commonTestCasePath') and config_instance._commonTestCasePath is not None:
+                    testcase = self.getCommonTestCase(testcase, config_instance._commonTestCasePath, testcase.get('id'))
+                elif testcase.get('kind') and testcase.get('kind').lower() == 'common' and (not hasattr(config_instance, '_commonTestCasePath') or config_instance._commonTestCasePath is None):
+                    log.error(f"commonPath路径未配置,请检查配置文件")
+                    raise Exception(f"commonPath路径未配置,请检查配置文件")
+                
+                # 参数替换
+                if testcase.get('requestType') is None:
+                    requestType = 'json'
+                else:
+                    requestType = testcase.get('requestType')
+                repParameter = self.replaceParameterAttr(dataSaveBean, testcase.get('parameter'), requestType)
+                repApi = self.replaceParameterAttr(dataSaveBean, testcase.get('api'))
+                headers = self.replaceParameterAttr(dataSaveBean, testcase.get('headers'))
+                
+                # 鉴权处理
+                requestParameter, requestUrl, authHeaders = self.authType(testcase.get('authType'), repApi, testcase.get('method'), repParameter)
+                
+                # 请求类型处理
+                dataRequestParameter, jsonRequestParameter, paramsData, ModelData, requestType = self.requestType(requestType, requestParameter)
+                
+                # 合并请求头
+                if headers:
+                    headers.update(authHeaders)
+                else:
+                    headers = authHeaders
+                
+                # 执行请求
+                log.info(f"开始请求地址: {requestUrl}")
+                log.info(f"开始请求方式: {testcase.get('method')}")
+                
+                if dataRequestParameter is not None and requestType.lower() in ['form-data', 'form-file']:
+                    headers['Content-Type'] = dataRequestParameter.content_type
+                
+                if testcase.get('stream_check'):
+                    response = self.handle_stream_response(clientSession, testcase.get('method'), requestUrl, dataRequestParameter, jsonRequestParameter, paramsData, ModelData, headers)
+                else:
+                    response = clientSession.request(method=testcase.get('method'), url=requestUrl, data=dataRequestParameter, json=jsonRequestParameter, params=paramsData, files=ModelData, headers=headers)
+                
+                # 记录响应
+                try:
+                    log.info(f"当前用例response: {json.dumps(response.json(), indent=4, ensure_ascii=False)}")
+                except:
+                    log.info(f"当前用例response: {response.text}")
+                
+                # 处理断言
+                if testcase.get('assertFail'):
+                    failtype = testcase.get('assertFail')
+                else:
+                    failtype = self.assertFail
+                self.assertType(testcase.get('assert'), response, dataSaveBean, failtype)
+                
+                # 保存数据
+                try:
+                    self.addAttrSaveBean(dataSaveBean, self.globalBean, testcase.get('saveData'), response.json())
+                except:
+                    self.addAttrSaveBean(dataSaveBean, self.globalBean, testcase.get('saveData'), response.text)
+        
+        return clientSession
+
+    def assertType(self, assertType, response, bean, failType):
+        """
+        处理断言
+        """
+        if assertType is None:
+            log.info(f"断言为空,跳过断言")
+            return None
+        
+        for ass in assertType:
+            key = list(ass.keys())[0]
+            log.info(f"开始判断{key}断言: {ass.get(key)}")
+            
+            if 'status_code' in ass:
+                if ass.get('status_code'):
+                    self.assertChoose(str(response.status_code) == str(ass.get('status_code')), 
+                                   f"status_code断言失败: {ass.get('status_code')}  ,response结果: {response.status_code}", failType)
+                    continue
+            
+            jsonpathResults = jsonpath.jsonpath(response.json(), ass.get(key)[0])
+            if jsonpathResults is False and 'not_found' not in ass:
+                self.assertChoose(1 > 2, f"提取{ass.get(key)[0]}失败，断言失败", failType)
+                continue
+            
+
+            
+            if 'eq' in ass:
+                expectedResults = CloudPlaceholderYaml(attrObj=bean, reString=ass.get('eq')[1]).replace().replaced_str
+                assResults = str(expectedResults) in [str(item) for item in jsonpathResults]
+                self.assertChoose(assResults is True, f"eq断言失败: {jsonpathResults} 不等于 {expectedResults}", failType)
+            elif 'sge' in ass:
+                expectedResults = CloudPlaceholderYaml(attrObj=bean, reString=ass.get('sge')[1]).replace().replaced_str
+                self.assertChoose(len(jsonpathResults) >= int(expectedResults), f"sge断言失败: {jsonpathResults} 小于 {expectedResults}", failType)
+            elif 'nn' in ass:
+                self.assertChoose(jsonpathResults is not None, f"not none断言失败: {ass.get('nn')[0]}", failType)
+            elif 'none' in ass:
+                self.assertChoose(jsonpathResults is True, f"none断言失败: {ass.get('none')[0]}", failType)
+            elif 'not_found' in ass:
+                self.assertChoose(jsonpathResults is False, f"not_found断言失败,字段存在", failType)
+            elif 'in' in ass:
+                expectedResults = CloudPlaceholderYaml(attrObj=bean, reString=ass.get('in')[1]).replace().replaced_str
+                self.assertChoose(str(expectedResults) in str(jsonpathResults), f"断言in失败: {expectedResults} 不在 {jsonpathResults} 内", failType)
+            elif 'len' in ass:
+                expectedResults = CloudPlaceholderYaml(attrObj=bean, reString=ass.get('in')[1]).replace().replaced_str
+                jsonpathResults_len = len(jsonpathResults[0])
+                self.assertChoose(jsonpathResults_len == int(expectedResults), f"断言len失败: {jsonpathResults_len} 长度不等于 {expectedResults}", failType)
+
+    def addAttrSaveBean(self, bean, globalBean, data: list, response):
+        """
+        保存响应数据到Bean
+        """
+        if data is None:
+            return
+        for d in data:
+            if 'json' in d:
+                jsonPath = d.get('json')[1]
+                value = jsonpath.jsonpath(response, jsonPath)
+                if value is False:
+                    value = None
+                
+                saveBean = bean
+                if d.get('json').__len__() == 3 and d.get('json')[2].lower() == 'global':
+                    saveBean = globalBean
+                
+                key_parts = d.get('json')[0].split(':')
+                d.get('json')[0] = key_parts[0]
+                
+                if value is not None and len(value) > 1:
+                    setattr(saveBean, d.get('json')[0], list(value))
+                elif value is not None and len(value) == 1:
+                    if len(key_parts) > 1 and key_parts[1].lower() == 'str':
+                        value[0] = str(value[0])
+                    setattr(saveBean, d.get('json')[0], value[0])
+
+    def replaceParameterAttr(self, bean, parameter, requestType='json'):
+        """
+        替换参数中的占位符
+        """
+        if parameter is None:
+            return None
+        
+        # 获取配置实例
+        config_instance = self._get_config()
+        
+        if requestType.lower() == 'json-text':
+            repParameter = CloudPlaceholderYaml(yaml_str=parameter, attrObj=bean, methObj=config_instance.methObj).replace().textLoad()
+        else:
+            repParameter = CloudPlaceholderYaml(yaml_str=parameter, attrObj=bean, methObj=config_instance.methObj).replace().jsonLoad()
+        
+        return repParameter
+
+    def requestType(self, requestType, data):
+        """
+        处理请求类型
+        """
+        jsonRequestParameter = None
+        dataRequestParameter = None
+        paramsData = None
+        ModelData = None
+        
+        if isinstance(data, dict) and data.get('MIME'):
+            MIME = data.get('MIME')
+        else:
+            MIME = 'application/octet-stream'
+            
+        if requestType is None:
+            jsonRequestParameter = data
+        elif requestType.lower() in ["json", "json-text"]:
+            jsonRequestParameter = data
+        elif requestType.lower() == "form-data":
+            dataRequestParameter = MultipartEncoder(fields=data)
+        elif requestType.lower() == "form-model":
+            filename = data['filename']
+            file_name = data[filename].split('\\')
+            data[filename] = (file_name[-1], open(data[filename], 'rb'), MIME)
+            for k, v in data.items():
+                if type(v) == dict:
+                    data[k] = (None, json.dumps(data[k]))
+            ModelData = data
+        elif requestType.lower() == "form-file":
+            filename = data['filename']
+            data[filename] = (os.path.basename(data[filename]), open(data[filename], 'rb'), MIME)
+            dataRequestParameter = MultipartEncoder(fields=data)
+        elif requestType == "PARAMS":
+            paramsData = data
+        elif requestType == "DATA":
+            dataRequestParameter = data
+        else:
+            log.error("请求方式不支持")
+            
+        return dataRequestParameter, jsonRequestParameter, paramsData, ModelData, requestType
+
+    def authType(self, authType, url, method, parameter):
+        """
+        处理鉴权方式
+        """
+        if self.baseUrl is None or self.isValidUrl(url):
+            requestUrl = url
+        else:
+            requestUrl = self.baseUrl + url
+        requestParameter = None
+        authHeaders = {}
+        
+        if authType == "SIGN":
+            # 云服务MD5签名鉴权
+            config_instance = self._get_config()
+            # 从config中获取企业ID
+            enterprise_id = config_instance._enterpriseId if hasattr(config_instance, '_enterpriseId') else None
+            if not enterprise_id:
+                log.error("企业ID未配置，请在环境配置中设置enterpriseId")
+                raise ValueError("企业ID未配置，请在环境配置中设置enterpriseId")
+            
+            if method.upper() == "GET":
+                # GET请求：将签名参数添加到URL参数中
+                # 添加默认的validateType参数
+                if parameter is None:
+                    parameter = {}
+                if 'validateType' not in parameter:
+                    parameter['validateType'] = config_instance._validateType if hasattr(config_instance, '_validateType') else '2'  # 从配置中获取验证类型
+                
+                signed_params = CloudSignUtil.generate_params_with_signature(
+                    enterprise_id=enterprise_id,
+                    token=config_instance._token if hasattr(config_instance, '_token') else None,
+                    additional_params=parameter
+                )
+                # 构建带签名的URL
+                from urllib.parse import urlencode
+                query_string = urlencode(signed_params)
+                if '?' in requestUrl:
+                    requestUrl += '&' + query_string
+                else:
+                    requestUrl += '?' + query_string
+                requestParameter = None
+                log.info(f"GET请求URL: {requestUrl}")
+            else:
+                # POST/PUT/PATCH请求：签名信息放在请求头中
+                authHeaders = CloudSignUtil.generate_headers(
+                    method=method,
+                    url=requestUrl,
+                    params=None,
+                    enterprise_id=enterprise_id,
+                    token=config_instance._token if hasattr(config_instance, '_token') else None,
+                    body=parameter
+                )
+                requestParameter = parameter
+            
+            return requestParameter, requestUrl, authHeaders
+        elif authType == "COOKIE" or authType is None:
+            requestParameter = parameter
+            return requestParameter, requestUrl, authHeaders
+        else:
+            log.error("鉴权方式不支持")
+        return requestParameter, requestUrl, authHeaders
+
+    def getCommonTestCase(self, testcase, commonFile, caseId):
+        """
+        获取公共测试用例
+        """
+        if self.commonCase is None:
+            commonFile = commonFile
+        else:
+            commonFile = os.path.join(commonFile.split('common')[0], f'common/{self.commonCase}')
+        
+        yaml = CloudReadYaml(commonFile).load_yaml()
+        commonCase = yaml.get('testcases')
+        
+        for case in commonCase:
+            if case.get('id') == caseId:
+                case['assert'] = [item for item in (case.get('assert') or []) + (testcase.get('assert') or []) if item is not None]
+                case['saveData'] = [item for item in (case.get('saveData') or []) + (testcase.get('saveData') or []) if item is not None]
+                return case
+        
+        raise ValueError("Case with id {} not found".format(caseId))
+
+    def assertChoose(self, ass, tips, type):
+        """
+        断言选择器
+        """
+        if type == 'stop':
+            assert ass, tips
+        elif type == 'continue':
+            pytest.assume(ass, tips)
+
+    def isValidUrl(self, url):
+        """
+        验证URL是否有效
+        """
+        try:
+            result = urlparse(url)
+            return all([result.scheme, result.netloc])
+        except ValueError:
+            return False
+
+    def handle_stream_response(self, clientSession, method, url, data, json_data, params, files, headers):
+        """
+        处理流式响应
+        """
+        try:
+            response_dict = {}
+            answer_count = 0
+            complete_message = ""
+
+            with clientSession.request(
+                    method=method,
+                    url=url,
+                    data=data,
+                    json=json_data,
+                    params=params,
+                    files=files,
+                    headers=headers,
+                    stream=True
+            ) as response:
+                for chunk in response.iter_lines():
+                    if chunk:
+                        data = chunk.decode('utf-8')
+                        if data.startswith('data: '):
+                            try:
+                                json_str = data[6:]
+                                if json_str.strip() == '[DONE]':
+                                    if complete_message:
+                                        response_dict["complete_message"] = complete_message
+                                    continue
+
+                                json_data = json.loads(json_str)
+
+                                if 'answer' in json_data:
+                                    answer_count += 1
+                                    key = f"answer{answer_count}"
+                                    response_dict[key] = json_data
+
+                                    answer_content = json_data.get('answer', '')
+                                    if isinstance(answer_content, list):
+                                        answer_content = ''.join(str(item) for item in answer_content)
+                                    elif not isinstance(answer_content, str):
+                                        answer_content = str(answer_content)
+
+                                    complete_message += answer_content
+
+                            except json.JSONDecodeError as e:
+                                log.error(f"JSON解析错误: {e}")
+                                continue
+
+                response.json = lambda: response_dict
+                response._content = json.dumps(response_dict).encode()
+                return response
+
+        except Exception as e:
+            log.error(f"流式处理错误: {e}")
+            raise 

cloud/CloudApiConfig.py

@@ -0,0 +1,311 @@
+from faker import Faker
+import string
+import time
+import random
+import datetime
+import pytz
+import hashlib
+import base64
+import hmac
+import json
+from urllib.parse import urlencode, urlparse
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+
+from cloud.CloudRequestUtil import CloudHttpClient
+
+
+class CloudTimes:
+    def __init__(self, dt=None, tz=pytz.timezone('Asia/Shanghai')):
+        """
+        初始化时间工具类
+
+        :param dt: datetime对象，默认使用当前时间
+        :param tz: 时区，默认使用本地时区
+        """
+        self.tz = tz
+        self.dt = dt or datetime.datetime.now(self.tz)
+
+    def to_datetime(self):
+        """
+        返回datetime对象
+
+        :return: datetime对象
+        """
+        return self.dt
+
+    def to_str(self, fmt='%Y-%m-%dT%H:%M:%SZ'):
+        """
+        将datetime对象转换为指定格式的字符串
+
+        :param fmt: 时间格式，默认为'%Y-%m-%d %H:%M:%S'
+        :return: 格式化后的时间字符串
+        """
+        return self.dt.strftime(fmt)
+
+
+class CloudDataGenerator:
+    """
+    生成中文数据的工具类
+    """
+
+    def __init__(self):
+        self.fake = Faker(locale='zh_CN')
+
+    def generate_name(self):
+        """
+        生成中文姓名，返回字符串。
+        """
+        return self.fake.name()
+
+    def generate_address(self):
+        """
+        生成中文地址，返回字符串。
+        """
+        return self.fake.address()
+
+    def generate_phone_number(self):
+        """
+        生成中文手机号，返回字符串。
+        """
+        return self.fake.phone_number()
+
+    def generate_id_number(self):
+        """
+        生成中文身份证号码，返回字符串。
+        """
+        return self.fake.ssn()
+
+    def random_number(self, digits=4):
+        """
+        生成一个4位随机整数并转换为字符串类型
+        如果生成的整数不足4位，则在左侧用0进行填充
+        """
+        digits = int(digits)
+        return "{:04d}".format(self.fake.random_number(digits=digits))
+
+    def get_cloud_password(self):
+        """
+        获取初始化的SK 加密后的密码
+        :return:
+        """
+        # 这里不能直接引用config，因为config类还没有定义
+        # 在实际使用时，会通过实例方法调用
+        return "default_cloud_password"
+
+    @staticmethod
+    def start_of_day():
+        """
+        获取当前时间开始时间戳：eg：2023-06-01 00:00:00
+        """
+        now = datetime.datetime.now()
+        return datetime.datetime(now.year, now.month, now.day)
+
+    @staticmethod
+    def end_of_day():
+        """
+        获取当前时间开始时间戳：eg：2023-06-01 23:59:59
+        """
+        return CloudDataGenerator.start_of_day() + datetime.timedelta(days=1) - datetime.timedelta(seconds=1)
+
+    def start_of_day_s(self):
+        """
+        获取当前时间开始时间戳：eg：1685548800  秒级
+        """
+        return int(time.mktime(CloudDataGenerator.start_of_day().timetuple()))
+
+    def end_of_day_s(self):
+        """
+        获取当前时间结束时间戳：eg：1685635199 秒级
+        """
+        return int(time.mktime(CloudDataGenerator.end_of_day().timetuple()))
+
+    def random_externalId(self):
+        """
+        生成唯一性数据，crm用于 外部企业客户id
+        """
+        num = str(random.randint(1000, 9999))
+        src_uppercase = string.ascii_uppercase  # string_大写字母
+        src_lowercase = string.ascii_lowercase  # string_小写字母
+        chrs = random.sample(src_lowercase + src_uppercase, 3)
+        for i in chrs:
+            num += i
+        return num
+    
+    def encryptPassword(self, plain_text='Aa112233'):
+        """
+        加密 - 使用默认密钥
+        """
+        # 使用默认密钥进行加密
+        password = "default_encryption_key"
+        # 设置随机数生成器的种子
+        secure_random = hashlib.sha1(password.encode()).digest()
+        # 创建对称加密密钥生成器
+        kgen = hashlib.sha1(secure_random).digest()[:16]
+        # 创建密码器并初始化
+        cipher = AES.new(kgen, AES.MODE_ECB)
+        # 加密明文（使用PKCS7填充）
+        padded_plain_text = pad(plain_text.encode(), AES.block_size)
+        encrypted_bytes = cipher.encrypt(padded_plain_text)
+        # 将加密结果转换为16进制字符串
+        encrypted_text = base64.b16encode(encrypted_bytes).decode().lower()
+        return encrypted_text
+
+    def decrypt(self, encrypted_text, password):
+        """
+        # 解密
+        """
+        # 设置随机数生成器的种子
+        secure_random = hashlib.sha1(password.encode()).digest()
+        # 创建对称加密密钥生成器
+        kgen = hashlib.sha1(secure_random).digest()[:16]
+        # 创建密码器并初始化
+        cipher = AES.new(kgen, AES.MODE_ECB)
+        # 解密密文（parseHexStr2Byte方法为将16进制字符串转为二进制字节数组）
+        encrypted_bytes = base64.b16decode(encrypted_text)
+        decrypted_bytes = cipher.decrypt(encrypted_bytes)
+        decrypted_text = unpad(decrypted_bytes, AES.block_size).decode()
+        return decrypted_text
+
+    def generate_cloud_signature(self, method, url, params, access_key_id, access_key_secret):
+        """
+        生成云服务签名
+        """
+        # 获取当前时间戳
+        timestamp = int(time.time())
+        
+        # 构建签名字符串
+        # 1. 请求方法
+        string_to_sign = method.upper() + "\n"
+        
+        # 2. 请求路径
+        parsed_url = urlparse(url)
+        string_to_sign += parsed_url.path + "\n"
+        
+        # 3. 查询参数（按字典序排序）
+        if params:
+            sorted_params = sorted(params.items())
+            query_string = "&".join([f"{k}={v}" for k, v in sorted_params])
+            string_to_sign += query_string + "\n"
+        else:
+            string_to_sign += "\n"
+        
+        # 4. 时间戳
+        string_to_sign += str(timestamp)
+        
+        # 使用HMAC-SHA256进行签名
+        signature = hmac.new(
+            access_key_secret.encode('utf-8'),
+            string_to_sign.encode('utf-8'),
+            hashlib.sha256
+        ).hexdigest()
+        
+        # 构建Authorization头
+        auth_header = f"Cloud {access_key_id}:{signature}"
+        
+        return auth_header, timestamp
+
+
+class config:
+    """
+    配置文件
+    """
+
+    def __init__(self, baseUrl=None, token=None, CloudPassword=None, 
+                 commonTestCasePath=None, methObj=None, Session: CloudHttpClient = CloudHttpClient(), 
+                 assertFail='stop', tEnv='base', enterpriseId=None, validateType='2'):
+        """
+        初始化配置文件
+        """
+        self._baseUrl = baseUrl
+        self._token = token
+        self._enterpriseId = enterpriseId
+        self._validateType = validateType
+        # 加密后的密码
+        self._CloudPassword = CloudPassword
+        self._commonTestCasePath = commonTestCasePath
+        self._methObj = methObj
+        self._assertFail = assertFail
+        self._tEnv = tEnv
+        # 构建全局session
+        self._Session = Session
+
+    @property
+    def Session(self):
+        return self._Session
+
+    @Session.setter
+    def Session(self, value):
+        self._Session = value
+
+    @property
+    def methObj(self):
+        return self._methObj
+
+    @methObj.setter
+    def methObj(self, value):
+        self._methObj = value
+
+    @property
+    def CloudPassword(self):
+        return self._CloudPassword
+
+    @CloudPassword.setter
+    def CloudPassword(self, value):
+        self._CloudPassword = value
+
+    @property
+    def commonTestCasePath(self):
+        return self._commonTestCasePath
+
+    @commonTestCasePath.setter
+    def commonTestCasePath(self, value):
+        self._commonTestCasePath = value
+
+    @property
+    def baseUrl(self):
+        return self._baseUrl
+
+    @baseUrl.setter
+    def baseUrl(self, value):
+        self._baseUrl = value
+
+    @property
+    def assertFail(self):
+        return self._assertFail
+
+    @assertFail.setter
+    def assertFail(self, value):
+        self._assertFail = value
+
+    @property
+    def enterpriseId(self):
+        return self._enterpriseId
+
+    @enterpriseId.setter
+    def enterpriseId(self, value):
+        self._enterpriseId = value
+
+    @property
+    def tEnv(self):
+        return self._tEnv
+
+    @tEnv.setter
+    def tEnv(self, value):
+        self._tEnv = value
+
+    @property
+    def validateType(self):
+        return self._validateType
+
+    @validateType.setter
+    def validateType(self, value):
+        self._validateType = value
+
+    @property
+    def token(self):
+        return self._token
+
+    @token.setter
+    def token(self, value):
+        self._token = value 

cloud/CloudLogUtil.py

@@ -0,0 +1,36 @@
+import logging
+import time
+
+"""
+cloud日志工具类:
+    定义日志输出
+"""
+
+
+class CloudLogConfig:
+
+    @staticmethod
+    def logger_set():
+        # 第一步：创建一个日志收集器
+        log = logging.getLogger()
+
+        # 第二步：设置收集器收集的等级
+        log.setLevel(logging.INFO)
+
+        # 第三步：设置输出渠道以及输出渠道的等级
+        curTime = time.strftime("%Y-%m-%d %H-%M-%S", time.localtime())
+        
+        sh = logging.StreamHandler()
+        sh.setLevel(logging.INFO)
+        log.addHandler(sh)
+        
+        # 创建一个输出格式对象
+        formats = '%(thread)d: %(asctime)s -- [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s'
+        form = logging.Formatter(formats)
+        # 将输出格式添加到输出渠道
+        sh.setFormatter(form)
+
+        return log
+
+
+log = CloudLogConfig.logger_set() 

cloud/CloudRequestUtil.py

@@ -0,0 +1,107 @@
+import jsonpath
+import requests
+from urllib.parse import urlparse
+from requests import Session
+
+
+class CloudHttpClient:
+    """
+    对 requests 库进行简单封装的类，可以方便地进行 HTTP 请求和处理响应。
+    """
+
+    def __init__(self, base_url=None):
+        """
+        初始化方法，接受一个基础URL参数，并创建一个Session对象
+        :param base_url: str 基础URL，例如 https://api.cloud.com
+        """
+        if base_url is not None:
+            self.base_url = base_url
+
+        self.session: Session = requests.Session()
+
+    def request(self, method, url, **kwargs):
+        """
+        发送HTTP请求，并返回响应对象
+        :param method: str 请求方法，例如 GET、POST、PUT等
+        :param url: str 请求URL，会和base_url拼接成完整的URL
+        :param kwargs: dict 其他requests.request方法支持的参数
+        :return: requests.Response 响应对象
+        """
+        response = self.session.request(method, url, **kwargs)
+        # 判断请求url 是否包含 openapi_login  用于处理 单点登录到系统后进行系统的接口请求鉴权处理
+        # if 'openapi_login' in url:
+        #     # 需要请求接口 获取 Tsessionid
+        #     # 先从url 中解析出请求域名
+        #     parsed_url = urlparse(url)
+        #     domain = parsed_url.scheme + '://' + parsed_url.netloc
+        #     # 进行接口请求 拿到响应
+        #     personalResponse = self.session.request(method='GET', url=domain + '/api/personal/info/get')
+        #     # 拿响应的$.result.authToken
+        #     authToken = jsonpath.jsonpath(personalResponse.json(), '$.result.authToken')[0]
+        #     # 后续的请求头上都需要带上 Tsessionid
+        #     self.session.headers.update({'Tsessionid': authToken})
+        
+        # 处理HTTP错误
+        http_error_msg = None
+        if 400 <= response.status_code < 500:
+            http_error_msg = (
+                f"{response.status_code} 客户端错误 Error: {response.text} for url: {response.url}"
+            )
+        elif 500 <= response.status_code < 600:
+            http_error_msg = (
+                f"{response.status_code} 服务端错误 Error: {response.text} for url: {response.url}"
+            )
+
+        return response
+
+    def get(self, url, params=None, **kwargs):
+        """
+        发送GET请求，并返回响应对象
+        :param url: str 请求URL，会和base_url拼接成完整的URL
+        :param params: dict 查询参数，会被转换为?key=value&key=value的形式拼接到URL后面
+        :param kwargs: dict 其他requests.get方法支持的参数
+        :return: requests.Response 响应对象
+        """
+        return self.request('GET', url, params=params, **kwargs)
+
+    def post(self, url, json=None, data=None, **kwargs):
+        """
+        发送POST请求，并返回响应对象
+        :param url: str 请求URL，会和base_url拼接成完整的URL
+        :param data: dict 请求体参数，以表单形式提交
+        :param json: dict 请求体参数，以JSON格式提交
+        :param kwargs: dict 其他requests.post方法支持的参数
+        :return: requests.Response 响应对象
+        """
+        return self.request('POST', url, data=data, json=json, **kwargs)
+
+    def put(self, url, json=None, data=None, **kwargs):
+        """
+        发送PUT请求，并返回响应对象
+        :param url: str 请求URL，会和base_url拼接成完整的URL
+        :param data: dict 请求体参数，以表单形式提交
+        :param json: dict 请求体参数，以JSON格式提交
+        :param kwargs: dict 其他requests.put方法支持的参数
+        :return: requests.Response 响应对象
+        """
+        return self.request('PUT', url, data=data, json=json, **kwargs)
+
+    def delete(self, url, **kwargs):
+        """
+        发送DELETE请求，并返回响应对象
+        :param url: str 请求URL，会和base_url拼接成完整的URL
+        :param kwargs: dict 其他requests.delete方法支持的参数
+        :return: requests.Response 响应对象
+        """
+        return self.request('DELETE', url, **kwargs)
+
+    def patch(self, url, json=None, data=None, **kwargs):
+        """
+        发送PATCH请求，并返回响应对象
+        :param url: str 请求URL，会和base_url拼接成完整的URL
+        :param data: dict 请求体参数，以表单形式提交
+        :param json: dict 请求体参数，以JSON格式提交
+        :param kwargs: dict 其他requests.patch方法支持的参数
+        :return: requests.Response 响应对象
+        """
+        return self.request('PATCH', url, data=data, json=json, **kwargs) 

cloud/CloudSignUtil.py

@@ -0,0 +1,117 @@
+import hashlib
+import json
+import time
+from urllib.parse import urlparse
+
+from cloud.CloudLogUtil import log
+
+
+class CloudSignUtil:
+    """
+    cloud签名工具类 - 基于MD5的签名算法
+    鉴权方式：MD5({enterpriseId}+{timestamp}+{token})
+    """
+    
+    @staticmethod
+    def generate_md5_signature(enterprise_id, timestamp, token):
+        """
+        生成MD5签名
+        :param enterprise_id: 企业ID
+        :param timestamp: 时间戳
+        :param token: 访问token
+        :return: 32位小写MD5签名
+        """
+        # 构建签名字符串：{enterpriseId}+{timestamp}+{token}
+        sign_string = f"{enterprise_id}{timestamp}{token}"
+        log.info(f"签名字符串: {sign_string}")
+        
+        # 生成MD5签名
+        signature = hashlib.md5(sign_string.encode('utf-8')).hexdigest()
+        log.info(f"生成的MD5签名: {signature}")
+        
+        return signature
+    
+    @staticmethod
+    def generate_headers(method, url, params, enterprise_id, token, body=None):
+        """
+        生成云服务请求头 - 基于MD5签名
+        :param method: 请求方法
+        :param url: 请求URL
+        :param params: 查询参数
+        :param enterprise_id: 企业ID
+        :param token: 访问token
+        :param body: 请求体（用于POST/PUT请求）
+        :return: 请求头字典
+        """
+        # 获取当前时间戳（秒级）
+        timestamp = int(time.time())
+        
+        # 生成MD5签名
+        signature = CloudSignUtil.generate_md5_signature(enterprise_id, timestamp, token)
+        
+        # 构建请求头
+        headers = {
+            'Authorization': f"Cloud {token}:{signature}",
+            'X-Timestamp': str(timestamp),
+            'Content-Type': 'application/json',
+            'User-Agent': 'CloudAPISDK/1.0'
+        }
+        
+        # 添加企业ID到请求头（如果需要）
+        headers['X-Enterprise-Id'] = str(enterprise_id)
+        
+        log.info(f"生成的请求头: {headers}")
+        
+        return headers
+    
+    @staticmethod
+    def generate_params_with_signature(enterprise_id, token, additional_params=None):
+        """
+        生成带签名的请求参数
+        :param enterprise_id: 企业ID
+        :param token: 访问token
+        :param additional_params: 额外参数
+        :return: 包含签名的参数字典
+        """
+        # 获取当前时间戳（秒级）
+        timestamp = int(time.time())
+        
+        # 生成MD5签名
+        signature = CloudSignUtil.generate_md5_signature(enterprise_id, timestamp, token)
+        
+        # 构建基础参数
+        params = {
+            'enterpriseId': enterprise_id,
+            'timestamp': timestamp,
+            'sign': signature
+        }
+        
+        # 添加额外参数
+        if additional_params:
+            params.update(additional_params)
+        
+        log.info(f"生成的请求参数: {params}")
+        
+        return params
+    
+    @staticmethod
+    def validate_signature(enterprise_id, timestamp, token, received_signature):
+        """
+        验证签名
+        :param enterprise_id: 企业ID
+        :param timestamp: 时间戳
+        :param token: 访问token
+        :param received_signature: 接收到的签名
+        :return: 验证结果
+        """
+        # 生成期望的签名
+        expected_signature = CloudSignUtil.generate_md5_signature(enterprise_id, timestamp, token)
+        
+        # 比较签名
+        is_valid = expected_signature == received_signature
+        
+        log.info(f"签名验证结果: {is_valid}")
+        log.info(f"期望签名: {expected_signature}")
+        log.info(f"接收签名: {received_signature}")
+        
+        return is_valid 

cloud/CloudYamlUtil.py

@@ -0,0 +1,197 @@
+import re
+import yaml
+import json
+from cloud.CloudLogUtil import log
+from cloud.CloudApiConfig import config
+
+
+class CloudPlaceholderYaml:
+    """
+    用于替换yaml文件中的占位符
+    """
+
+    def __init__(self, yaml_str=None, reString=None, attrObj=config, methObj=None, gloObj=config):
+        if yaml_str:
+            self.yaml_str = json.dumps(yaml_str)
+        else:
+            self.yaml_str = str(reString)
+
+        self.attrObj = attrObj
+        
+        # 修复methObj的初始化逻辑
+        if methObj is not None:
+            self.methObj = methObj
+        elif hasattr(config, 'methObj') and config.methObj is not None:
+            self.methObj = config.methObj
+        else:
+            # 如果都没有，创建一个默认的CloudDataGenerator实例
+            from cloud.CloudApiConfig import CloudDataGenerator
+            self.methObj = CloudDataGenerator()
+            log.warning("methObj未配置，使用默认的CloudDataGenerator实例")
+        
+        self.gloObj = gloObj
+
+    def replace(self):
+        # 定义正则表达式模式
+        # 用于匹配 ${attr} 和 #{method} 这样的占位符
+        # $() #() 如果不匹配则报错
+        pattern_attr = re.compile(r'\$\{(\w+)\}')
+        pattern_method = re.compile(r'\#\{(.*?)\}')
+        pattern_glo = re.compile(r'\$\$\{(\w+)\}')
+
+        # 定义全局替换函数
+        def replace_glo(match):
+            # 获取占位符中的属性名
+            attr_name = match.group(1)
+            # 如果对象中有该属性，则返回该属性的值
+            if hasattr(self.gloObj, attr_name):
+                # 获取属性的值
+                attr_value = getattr(self.gloObj, attr_name)
+                # 如果属性的值是字符串，则返回该字符串
+                if isinstance(attr_value, str):
+                    return str(attr_value)
+                # 如果属性的值是可调用对象，则返回方法名
+                elif callable(attr_value):
+                    return match.group(0)
+                # 如果属性的值是字典，则返回该字典的字符串表示
+                elif isinstance(attr_value, dict):
+                    return str(attr_value)
+                # 如果属性的值是列表，则返回该列表的字符串表示
+                elif isinstance(attr_value, list):
+                    return str(",".join(str(x) for x in attr_value))
+                # 否则，返回属性的值（将其转换为字符串）
+                else:
+                    return str(attr_value)
+            # 否则返回原字符串
+            return match.group(0)
+
+        # 定义替换函数
+        def replace_attr(match):
+            # 获取占位符中的属性名
+            attr_name = match.group(1)
+            # 如果对象中有该属性，则返回该属性的值
+            if hasattr(self.attrObj, attr_name):
+                # 获取属性的值
+                attr_value = getattr(self.attrObj, attr_name)
+                # 如果属性的值是字符串，则返回该字符串
+                if isinstance(attr_value, str):
+                    return str(attr_value)
+                # 如果属性的值是可调用对象，则返回方法名
+                elif callable(attr_value):
+                    return match.group(0)
+                # 如果属性的值是字典，则返回该字典的字符串表示
+                elif isinstance(attr_value, dict):
+                    return str(attr_value)
+                # 如果属性的值是列表，则返回该列表的字符串表示
+                elif isinstance(attr_value, list):
+                    return str(",".join(str(x) for x in attr_value))
+                # 否则，返回属性的值（将其转换为字符串）
+                else:
+                    return str(attr_value)
+            # 否则返回原字符串
+            return match.group(0)
+
+        # 定义替换函数
+        def replace_method(match):
+            # 获取占位符中的方法名
+            method_name = match.group(1)
+            args = None
+            if '(' in match.group(1):
+                # 获取占位符中的方法名
+                method_name = match.group(1).split('(')[0]
+                # 获取参数列表
+                args_str = match.group(1).split('(')[1][:-1]
+                args = [arg.strip() for arg in args_str.split(',')]
+
+            # 如果对象中有该方法，并且该方法是可调用的，则返回该方法的返回值
+            if hasattr(self.methObj, method_name):
+                # 获取方法
+                method = getattr(self.methObj, method_name)
+                # 如果方法是可调用对象，则调用该方法并返回其返回值的字符串表示
+                if callable(method):
+                    try:
+                        if args:
+                            method_value = method(*args)
+                        else:
+                            method_value = method()
+                        if isinstance(method_value, str):
+                            return str(method_value)
+                        else:
+                            return str(method_value)
+                    except Exception as e:
+                        log.error(f"调用方法 {method_name} 时出错: {e}")
+                        return match.group(0)
+                # 否则，返回方法的字符串表示
+                else:
+                    return str(method)
+            else:
+                log.warning(f"方法 {method_name} 在 methObj 中不存在，methObj类型: {type(self.methObj)}")
+                log.warning(f"methObj 可用方法: {[attr for attr in dir(self.methObj) if not attr.startswith('_')]}")
+            # 否则返回原字符串
+            return match.group(0)
+
+        # 判断是否有需要替换的再进行替换
+        log.info(f"开始替换str中的占位符: {self.yaml_str}")
+        log.info(f"使用的methObj: {type(self.methObj)}")
+        # 先进行全局替换
+        replaced_str = pattern_glo.sub(replace_glo, self.yaml_str)
+        # 替换占位符中的属性
+        replaced_str = pattern_attr.sub(replace_attr, replaced_str)
+        # 替换占位符中的方法
+        replaced_str = pattern_method.sub(replace_method, replaced_str)
+        self.replaced_str = replaced_str
+        log.info("替换后的str内容为：{}".format(replaced_str))
+        return self
+
+    def jsonLoad(self):
+        # 把replaced_str中的"[]"替换为[]  "{}"替换为{}   "'"替换为"/""  'None换为 null'
+        replaced_str = self.replaced_str.replace('"[', '[').replace(']"', ']').replace('"{', '{').replace('}"', '}').replace("'", "\"").replace('None','null')
+        try:
+            replaced_str = json.loads(replaced_str)
+            log.info("替换后jsonLoad的str内容为：{}".format(replaced_str))
+            return replaced_str
+        except:
+            log.info(f'*************替换失败-YAML,请检查格式{replaced_str}******************')
+
+    def textLoad(self):
+        return json.loads(self.replaced_str)
+
+
+class CloudReadYaml:
+    """
+    用于读取yaml文件的工具类
+    """
+
+    def __init__(self, yaml_file):
+        self.yaml_file = yaml_file
+
+    def load_yaml(self):
+        """
+        读取yaml文件，并返回其中的数据
+        :return: dict
+        """
+        with open(self.yaml_file, encoding='utf-8') as f:
+            data = yaml.safe_load(f)
+        return data if data is not None else {}  # 如果data为None，则返回空字典
+
+    def get(self, key, default=None):
+        """
+        获取yaml文件中的数据
+        :param key: 数据的键
+        :param default: 如果获取失败，则返回该默认值
+        :return: dict
+        """
+        # 读取yaml文件
+        data = self.load_yaml()
+        # 获取数据
+        return data.get(key, default) if data is not None else default
+
+    def get_all(self):
+        """
+        获取yaml文件中的所有数据
+        :return: dict
+        """
+        # 读取yaml文件
+        data = self.load_yaml()
+        # 如果data为None，则返回空字典
+        return data if data is not None else {} 

cloud/__init__.py

@@ -0,0 +1,9 @@
+from cloud.CloudAPIRequest import CloudAPIRequest
+from cloud.CloudApiConfig import config, CloudDataGenerator
+from cloud.CloudRequestUtil import CloudHttpClient
+
+# 创建config实例
+config = config()
+# 初始化配置实例
+config.methObj = CloudDataGenerator()
+config.Session = CloudHttpClient() 

cloud/cli.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Cloud API SDK 命令行工具
+"""
+
+import argparse
+import sys
+import os
+from cloud_api_sdk import config, CloudAPIRequest
+
+
+def main():
+    """
+    主函数
+    """
+    parser = argparse.ArgumentParser(description='Cloud API SDK 测试工具')
+    parser.add_argument('testcase', help='测试用例文件路径')
+    parser.add_argument('--base-url', help='基础URL')
+    parser.add_argument('--access-key-id', help='访问密钥ID')
+    parser.add_argument('--access-key-secret', help='访问密钥Secret')
+    parser.add_argument('--cloud-password', help='云服务密码')
+    parser.add_argument('--env', default='test', help='运行环境')
+    parser.add_argument('--common-path', help='公共用例路径')
+    parser.add_argument('--assert-fail', default='stop', choices=['stop', 'continue'], help='断言失败处理模式')
+    
+    args = parser.parse_args()
+    
+    # 配置环境
+    if args.base_url:
+        config.baseUrl = args.base_url
+    if args.access_key_id:
+        config.accessKeyId = args.access_key_id
+    if args.access_key_secret:
+        config.accessKeySecret = args.access_key_secret
+    if args.cloud_password:
+        config.CloudPassword = args.cloud_password
+    if args.common_path:
+        config.commonTestCasePath = args.common_path
+    config.assertFail = args.assert_fail
+    config.tEnv = args.env
+    
+    # 检查测试用例文件是否存在
+    if not os.path.exists(args.testcase):
+        print(f"错误: 测试用例文件 {args.testcase} 不存在")
+        sys.exit(1)
+    
+    # 执行测试
+    try:
+        class TestRunner:
+            pass
+        
+        test_runner = TestRunner()
+        CloudAPIRequest().doRequest(args.testcase, test_runner)
+        print("测试执行完成")
+    except Exception as e:
+        print(f"测试执行失败: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main() 

cloudapirequest-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+ 
+Copyright (c) [2025] [天润-测试]
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cloudapirequest-1.0.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: CloudApiRequest
+Version: 1.0.0
+Summary: 天润cloud接口测试库
+Home-page: https://www.ti-net.com.cn/
+Author: 天润-测试
+Author-email: wangwd@ti-net.com.cn
+License: MIT
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: Faker==18.4.0
+Requires-Dist: jsonpath==0.82
+Requires-Dist: pytz==2023.3
+Requires-Dist: PyYAML==6.0
+Requires-Dist: requests==2.28.2
+Requires-Dist: allure-pytest==2.13.2
+Requires-Dist: allure-python-commons==2.13.2
+Requires-Dist: requests-toolbelt==1.0.0
+Requires-Dist: pycryptodome==3.17
+Requires-Dist: pytest-assume==2.4.3
+

cloudapirequest-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+cloud/CloudAPIRequest.py,sha256=bji5WJJ4UQPO7EhQ2IsFMAOcG1aHtxjRU-0zwzNek2U,19441
+cloud/CloudApiConfig.py,sha256=6mF-guPi92UyjE0o7pXVd5cZKZAJHmohv16CvziVkGs,9138
+cloud/CloudLogUtil.py,sha256=EXnU6QXFxl_npCcJgQvhtlG8uR57NmbOovFjVMHPOpQ,935
+cloud/CloudRequestUtil.py,sha256=bsbI74p1iu4weXbDKqwhXvH1KwezvxYXdrXBMc9L3sE,4827
+cloud/CloudSignUtil.py,sha256=3D2etwvk1LYRE3GzoU6qXfTIM4FhEFjmT-i458Q2uCA,3849
+cloud/CloudYamlUtil.py,sha256=_WmtzLOBznwYNY02JOQxOB3B8WvgJONk-PV7grw2C_U,8392
+cloud/__init__.py,sha256=RgNAN_vKhCHnwcBy0hc1ttrr5x58bO_u6TNICZDSfFw,306
+cloud/cli.py,sha256=VId1s29djJu7QrkXJc2je4fRV030vqD3nwuI23AN8Ig,1986
+cloudapirequest-1.0.0.dist-info/LICENSE,sha256=hMjjUYpALQY0E8hzysmZszKwYy2mt8tUvAFQfIIbwV4,1099
+cloudapirequest-1.0.0.dist-info/METADATA,sha256=3uFgDtx9S2odQlKmBxEKJULLQKq-rxcix41RpnET33I,608
+cloudapirequest-1.0.0.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+cloudapirequest-1.0.0.dist-info/top_level.txt,sha256=lBiHHi76sKOBY-DmE0iDypxZxv-TTCnvHeiFleC_PuA,6
+cloudapirequest-1.0.0.dist-info/RECORD,,

cloudapirequest-1.0.0.dist-info/WHEEL

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

cloudapirequest-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cloud