class Login(object):
"""
登录
"""
log = Log()
request = request.RunMethod()
def __init__(self):
self.yaml_data = ReadFile().read_yaml('yaml_path')['lxk']
self.header = self.yaml_data['headers']
self.url = self.yaml_data['url']
self.lxk_c_url = self.yaml_data['c_login']['url']
self.lxk_c_method = self.yaml_data['c_login']['method']
self.lxk_c_param = self.yaml_data['c_login']['param']
def lxk_c_login(self, project, mobile):
"""
蓝薪卡C端登录
:param project:
:param mobile:
:return:
"""
try:
if project == 'lxk_c':
self.lxk_c_param['mobile'] = mobile
result = self.request.run_main(self.lxk_c_method,
self.url + self.lxk_c_url,
self.header, self.lxk_c_param)
elif project == 'lxk_a':
pass
elif project == 'lxk_b':
pass
return result
except Exception as e:
self.log.error('登录报错{}'.format(e))
class RunMethod(object):
"""
request
"""
log = Log()
urllib3.disable_warnings()
def post_main(self,url,data,header,file=None):
"""
post请求
:param url:
:param data:
:param header:
:param file:
:return:
"""
res=None
if file!=None:
res=requests.post(url=url,json=data,headers=header,verify=False)
else:
res = requests.post(url=url, json=data,headers=header, files=file, verify=False)
return res.json()
def get_main(self,url,header,param=None):
"""
get请求
:param url:
:param header:
:param param:
:return:
"""
res=None
if param!=None:
res=requests.get(url=url,headers=header,verify=False)
else:
res = requests.get(url=url, headers=header, json=param,verify=False)
return res.json()
def run_main(self,method,url,header,data=None,file=None):
"""
被调用主request
:param method:
:param url:
:param header:
:param data:
:param file:
:return:
"""
try:
res=None
if method=='post' or method=='POST' or method=='Post':
res=self.post_main(url,data,header,file=None)
elif method=='get' or method=='GET' or method=='Get':
res=self.get_main(url,header,param=None)
else:
return "request传参错误"
return res
except Exception as e:
self.log.error("请求方法报错{}".farmat(e))
class ReadFile(object):
log = Log()
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
def __init__(self):
self.excel_path = os.path.join(
os.path.dirname(os.path.dirname(__file__)), 'config/testcase.xls')
self.yaml_path = os.path.join(
os.path.dirname(os.path.dirname(__file__)), 'config/test.yaml')
self.sql_yaml_path = os.path.join(
os.path.dirname(os.path.dirname(__file__)), 'config/sql.yaml')
def read_yaml(self, path_type):
"""
读yaml文件
:return:
"""
try:
if path_type == 'yaml_path':
file_path = self.yaml_path
elif path_type == 'sql_yaml_path':
file_path = self.sql_yaml_path
with open(file_path, 'r', encoding='utf-8') as f:
return yaml.load(f.read())
except Exception as e:
self.log.error("读yaml文件报错{}".format(e))
def read_excel(self, sheet_name, function, casename=None):
"""
读取excel
:param sheet_name:
:param function:
:return:
"""
try:
book = xlrd.open_workbook(self.excel_path)
sheet = book.sheet_by_name(sheet_name)
param = []
for i in range(0, sheet.nrows):
if casename == None:
if sheet.row_values(i)[0] == function and sheet.row_values(
i)[3] == 1:
param.append(sheet.row_values(i))
else:
if sheet.row_values(i)[0] == function and sheet.row_values(
i)[1] == casename and sheet.row_values(i)[3] == 1:
param.append(sheet.row_values(i))
return param
except Exception as e:
self.log.error("读取excel报错{}".format(e))
import jwt
from common import crypto
from common.logs import Log
from oauth.token import client_request
from common.config import Config
cnf = Config()
log = Log()
public_key = cnf.access_token_secret
# Assymmetric encrypted generator: validating generator with RSA public key in PEM or SSH format
def validate_ae_token(e_token, audience_id):
try:
jwt_token = crypto.reverse_token(e_token)
return jwt.decode(jwt_token,
key=public_key,
audience=audience_id,
issuer=cnf.token_issuer,
algorithms=[cnf.ae_algorithm])
except jwt.ExpiredSignatureError as e:
log.debug("Expired jwt generator : " + jwt_token)
log.debug(e)
raise Exception('Unauthorized')
except jwt.InvalidIssuerError as e:
log.debug("The issuer claim is incorrect for the generator : " +
jwt_token)
log.debug(e)
raise Exception('Unauthorized')
except jwt.InvalidAudienceError as e:
log.debug("The audience claim is incorrect for the generator : " +
from common.logs import Log
from oauth.auth import authenticator
from util import response
from common.config import Config
log = Log()
cnf = Config()
def refresh_handler(event, context):
refreshToken = event["body"]["refresh_token"]
client_id = event["headers"]["client_id"]
client_request_data = event["client_request_data"]
return response.build(
authenticator.refresh(refresh_token=refreshToken,
client_id=client_id,
client_request_data=client_request_data))
if __name__ == "__main__":
event = {
"refresh_token":
"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiIxMjM0NSIsImlzcyI6ImFiYy5jb20iLCJ0b2tlbl91c2UiOiJyZWZyZXNoIiwianRpIjoic2FqOUlybGpvcjF6ayIsImV4cCI6MTUwOTEzMTUwOCwiaWF0IjoxNTA2NTM5NTA4LCJzY29wZSI6eyJhY2Nlc3MiOnsiL2dyYW50IjpbIlBPU1QiXSwiL2V2ZW50IjpbIlBBVENIIiwiR0VUIl19LCJncmFudF9hY2Nlc3MiOlsidXBkYXRlLWV2ZW50IiwiZ3JhbnQtYWNjZXNzIiwiZ2V0LWV2ZW50Il19LCJyb2xsIjpbIkFETUlOIl0sInN1YiI6ImJpam95LnBhdWxAdG90aGVuZXcuY29tIn0.gupFbJtlWd50xu8aVm7rgrjeXMWH2Zz7LnIFxaJGiVU",
"client_id": cnf.client_id,
"client_request_data": {
"todo": "TODO"
}
}
log.info(refresh_handler(event, None))
class ExecSql(object):
"""
执行sql语句类
"""
log = Log()
_instance=None
def __new__(cls,*args,**kwargs):
if cls._instance is None:
cls._instance=super().__new__(cls)
return cls._instance
def __init__(self):
"""
初始化mysql配置
:param platform_name:
"""
#self.sql_conf = self._get_sql_conf(platform_name)
self.sql_conf=None
def _get_sql_conf(self, project):
"""
获取mysql配置
:param platform_name:
:return:
"""
try:
return ReadFile().read_yaml('yaml_path')[project]['mysql']
except:
self.log.error("找不到对应项目：{0}".format(project))
def connect_db(self):
"""
连接mysql
:return:
"""
host = self.sql_conf['host']
user = self.sql_conf['user']
pwd = self.sql_conf['pwd']
test_db = self.sql_conf['test_db']
try:
self.conn = pymysql.connect(host=host, user=user, password=pwd, db=test_db, port=3306, charset="utf8")
except Exception as e:
self.log.error("连接mysql失败：{0}".format(e))
def get_cursor(self):
"""
获取游标
:return:
"""
self.cursor=self.conn.cursor()
return self.cursor
def exec_sql(self,project,sql_type,sql):
"""
执行sql语句
:param sql_type:
:param sql:
:return:
"""
self.sql_conf = self._get_sql_conf(project)
try:
if sql_type == 'select_one':
self.connect_db()
cursor = self.get_cursor()
cursor.execute(sql)
result = cursor.fetchone()
elif sql_type == 'select_list':
self.connect_db()
cursor = self.get_cursor()
cursor.execute(sql)
result = cursor.fetchall()
elif sql_type == 'update' or sql_type == 'del' or sql_type == 'insert':
self.connect_db()
result = self.get_cursor().execute(sql)
self.conn.commit()
self.cursor.close()
self.conn.close()
return result
except Exception as e:
self.log.error("执行sql语句报错：{0}".format(e))
class Assertion(object):
log = Log()
sql_values_list = []
response_values = []
def __init__(self):
self.test = ExecSql().exec_sql
def get_sql_data(self, project, sql_type, sql):
'''
查询sql数据组合list
:param project:
:param sql_type:
:param sql:
:return:
'''
try:
sql_values = self.test(project, sql_type, sql)
for i in sql_values:
for j in i:
self.sql_values_list.append(j)
except Exception as e:
self.log.error("查询sql数据组合list报错{}".format(e))
def get_response_data(self, response_data, keys=[]):
'''
获取接口响应数据组合list
:param response_data:
:param keys:
:return:
'''
try:
if isinstance(response_data, list):
for value in response_data:
if isinstance(value, list) or isinstance(value, dict):
self.get_response_data(value, keys)
elif isinstance(response_data, dict):
for i, j in sorted(response_data.items()):
if i in keys:
self.response_values.append(j)
else:
self.get_response_data(j, keys)
else:
pass
except Exception as e:
self.log.error("获取接口响应数据组合list报错{}".format(e))
def asser(self,
function,
casename,
expect,
response_data,
assert_type=None):
'''
断言
:param assert_type:
:param expect:
:param response_data:
:return:
'''
try:
if assert_type == 'type1':
assert self.sql_values_list == self.response_values
self.log.info("查询sql数据组合list为{}".format(self.sql_values_list))
self.log.info("接口响应数据组合list为{}".format(self.response_values))
assert eval(expect)['code'] == response_data['code']
assert eval(expect)['msg'] == response_data['msg']
self.log.info("{}——{}【PASS】".format(function, casename))
except Exception as e:
self.log.error("{}——{}【PASS】{}".format(function, casename, e))
import traceback
from oauth.token.validator import authorizer
from common.config import Config
from common.logs import Log
log = Log()
cnf = Config()
def validation_handler(event, context):
def success_message_builder(data):
statusCode = 200
successMessage = {
"code": statusCode,
"data": data,
"app_name": cnf.app_name,
"request_id": cnf.request_id
}
return {"statusCode":statusCode, "body": str(successMessage)}
@staticmethod
def bad_request_error_message(message):
statusCode = 400
errorObject = {
"code": statusCode,
"error_type": "BadRequest",
"app_name": cnf.app_name,
"request_id": cnf.request_id,
"message": message
}
return {"statusCode": statusCode, "body": str(errorObject)}
