def run_onetime(
self,
interfacename,
casename,
config_data,
expect_data,
):
'''
path = os.path.dirname(os.getcwd())
parpath = os.path.dirname(path)
yamlname = parpath + '/Config/interface/' + '%s/%s.yaml' % (interfacename, interfacename)
config_data = Yaml.YAML().read_yaml(yamlname)'''
try:
start = time.clock()
if config_data['protocol'].lower() == 'http':
res = Http.http_runner(interfacename, casename)
end = time.clock()
Log.LOG(interfacename + '->' + casename).log_result(
'Http has get the response data using %s' %
str(end - start))
logcache = '%s--->%s: Http has get the response data using %s\n' % (
interfacename, casename, str(end - start))
(judge, error_key,
result) = self.r.assert_runner(res, expect_data)
return judge, error_key, logcache, res, round((end - start),
2), result
elif config_data['protocol'].lower() == 'https':
res = Https.https_runner(interfacename, casename)
end = time.clock()
Log.LOG(interfacename + '->' + casename).log_result(
'Https has get the response data using %s' %
str(end - start))
logcache = '%s--->%s: Http has get the response data using %s\n' % (
interfacename, casename, str(end - start))
(judge, error_key,
result) = self.r.assert_runner(res, expect_data)
return judge, error_key, logcache, res, round((end - start),
2), result
elif config_data['protocol'].lower() == 'hessian':
res = Hessian.hessian_runner(interfacename, casename)
end = time.clock()
Log.LOG(interfacename + '->' + casename).log_result(
'Hessian has get the response data using %s' %
str(end - start))
logcache = '%s--->%s: Http has get the response data using %s\n' % (
interfacename, casename, str(end - start))
(judge, error_key,
result) = self.r.assert_runnerhessian(res, expect_data)
return judge, error_key, logcache, res, round((end - start),
2), result
else:
HandleException.Exception().syntaxerror(
'The interface type is not exist! ')
except Exception, e:
HandleException.Exception().exception(e)
def http_request(self, header=None, method=None):
global cookie
res = None
if header == "form":
res = self.request_data(url=getattr(get_data, "url"),
method=method,
cookie=cookie,
data=getattr(get_data, "data"),
header=getattr(get_data, "Header_form"))
elif header == "json":
res = self.request_json(url=getattr(get_data, "url"),
method=method,
cookie=cookie,
data=getattr(get_data, "data"),
header=getattr(get_data, "Header_json"))
elif header == "text":
res = self.request_data(url=getattr(get_data, "url"),
method=method,
cookie=cookie,
data=getattr(get_data, "data"),
header=getattr(get_data, "Header_text"))
elif header == "file":
data = getattr(get_data, "data")
file_path = os.path.join(
Readconfig().get_path('test_data', 'test_data', 0), data[1])
if len(data) == 2:
files = {data[0]: (data[1], open(file_path, 'rb'))}
m = MultipartEncoder(
files, boundary='------WebKitFormBoundaryPDylsMEaQhk1XpIh')
res = self.request_data(
url=getattr(get_data, "url"),
method=method,
cookie=cookie,
data=m,
header={'Content-Type': m.content_type})
elif len(data) == 3:
files = {data[0]: (data[1], open(file_path, 'rb'), data[2])}
m = MultipartEncoder(
files, boundary='------WebKitFormBoundaryPDylsMEaQhk1XpIh')
res = self.request_data(
url=getattr(get_data, "url"),
method=method,
cookie=cookie,
data=m,
header={'Content-Type': m.content_type})
else:
Log().error("入参数据不正确")
else:
Log().error("没有定义该请求方法")
if res.cookies: # 更新cookie
cookie = res.cookies
return res
def sql_assertion(self, case_list=None): # 执行SQL获取数据并断言
temporary_data = {}
result = None
try:
sql_data = eval(getattr(get_data, "sql"))
variable_data = getattr(get_data, 'variable_data')
Log().info("SQL语句{}".format(sql_data))
i = 0
j = -1
for sql_value in sql_data: # 遍历SQL语句
i = i + 1
if type(sql_value) is dict: # 判断是否为字典类型数据
for key in sql_value.keys(): # 遍历SQL语句
sql = self.get_data(sql_value[key]) # 执行SQL
variable_data[key] = str(
sql) # 将SQL语句返回结果存入变量池variable_data
temporary_data[str(i)] = str(
sql) # 将SQL语句返回结果存入sql_data
Log().info("SQL查询结果{}".format(sql))
setattr(get_data, "variable_data",
variable_data) # 反射变量池
else:
sql_assertion = eval(getattr(get_data,
"sql_assertion")) # 获取断言
j = j + 1
sql = self.get_data(sql_value) # 执行SQL
Log().info("SQL查询结果{}".format(sql))
if sql is not None: # SQL断言
try:
unittest.TestCase().assertIn(
sql_assertion[j], str(sql))
result = "pass"
Log().info("SQL断言正确")
except AssertionError as e:
result = "fail"
Log().error("SQL断言错误{}".format(e))
raise e
finally:
temporary_data[str(i)] = str(
sql) # 将SQL语句返回结果存入sql_data
else:
try:
unittest.TestCase().assertEqual(
sql_assertion[j], 'None')
result = "pass"
Log().info("SQL断言正确")
except AssertionError as e:
result = "fail"
Log().error("SQL断言错误{}".format(e))
raise e
finally:
temporary_data[str(i)] = str(
sql) # 将SQL语句返回结果存入sql_data
return temporary_data
except Exception as e:
Log().error("SQL执行错误")
raise e
finally:
case_list.extend([temporary_data, result])
def Testcase(self,
url=None,
data=None,
assertion=None,
regular=None,
sql=None,
sql_assertion=None,
case_id=None,
header=None,
method=None,
sheet_name=None,
case_list=None):
Log().info("执行的用例{}".format(case_id))
# s数据初始化
Data_Init().data_init(url=url,
data=data,
assertion=assertion,
regular=regular,
sql=sql,
sql_assertion=sql_assertion)
# 发送HTTP请求
res = Http_Request().http_request(header=header, method=method)
response_data = res.text
# 断言
if assertion is not None:
Response_Assertion().assertion(response_data=response_data,
case_id=case_id,
case_list=case_list,
sheet_name=sheet_name)
# 正则匹配
if regular is not None:
Regular().regular(response_data)
# 执行sql
if sql is not None:
Read_Mysql().sql_assertion(case_list=case_list)
def regular(self, res_request):
variable_data = getattr(get_data, 'variable_data')
try:
for regular_value in eval(getattr(get_data,
"regular")): # 遍历正则匹配数据
for key in regular_value.keys():
if type(regular_value[key]) is str:
self.get_regular(
regular_value[key],
json.loads(res_request)) # 调用字典列表拆解获取唯一结果
variable_data[key] = str(
getattr(get_data, "regular_value")) # 将正则返回结果存入变量中
Log().info("正则获取到的变量{}".format(
getattr(get_data, "regular_value")))
setattr(get_data, "variable_data",
variable_data) # 反射变量
elif type(regular_value[key]) is list:
data = regular_value[key]
self.get_key(data[0], json.loads(res_request), data[1])
variable_data[key] = str(
getattr(get_data, "regular_value")) # 将正则返回结果存入变量中
Log().info("正则获取到的变量{}".format(
getattr(get_data, "regular_value")))
setattr(get_data, "variable_data",
variable_data) # 反射变量
if type(getattr(get_data, "regular_value")) is list:
list_data = getattr(get_data, "regular_value")
setattr(get_data, "variable_data",
list_data[0]) # 反射变量
variable_data[key] = str(
getattr(get_data, "regular_value"))
elif type(getattr(get_data, "regular_value")) is str:
if (getattr(get_data, "regular_value")[0] == "["
and getattr(get_data, "regular_value")
[len(getattr(get_data, "regular_value")) - 1]
== "]"):
setattr(
get_data, "regular_value",
eval(getattr(get_data,
"regular_value"))[0])
variable_data[key] = str(
getattr(get_data, "regular_value"))
Log().info("正则获取到的变量{}".format(
getattr(get_data, "regular_value")))
except Exception as e:
Log().error("正则执行失败{}".format(e))
raise e
def all_case(self, interfacename):
try:
start = time.clock()
'''path = os.path.dirname(os.getcwd())
parpath = os.path.dirname(path)
dirname = parpath + '/TestCase/Function/' + interfacename'''
casename = HandleDB.HandleDB().db_readcase(interfacename)
end = time.clock()
Log.LOG(interfacename).log_result(
'The case of %s has built using %s' %
(interfacename, str(end - start)))
Log.LOG(interfacename).log_result('The caselist is:\n %s' %
str(casename))
return casename
except Exception, e:
HandleException.Exception().exception(
'all_case raise exception:\n' + e)
def http_req(self):
# 不同method请求发送,返回请求结果集
try:
if self.method.lower() == 'get':
r = requests.Session()
r.keep_alive = False
self.req = r.get(url=self.host, params=self.params, headers=self.headers, data=self.data, cookies=self.cookie)
r.close()
self.req.close()
return self.req
elif self.method.lower() == 'post':
r = requests.Session()
r.keep_alive = False
self.req = r.post(url=self.host, params=self.params, headers=self.headers, data=self.data, cookies=self.cookie)
r.close()
self.req.close()
return self.req
elif self.method.lower() == 'put':
r = requests.Session()
r.keep_alive = False
self.req = r.put(url=self.host, params=self.params, headers=self.headers, data=self.data, cookies=self.cookie)
r.close()
self.req.close()
return self.req
elif self.method.lower() == 'patch':
r = requests.Session()
r.keep_alive = False
self.req = r.patch(url=self.host, params=self.params, headers=self.headers, data=self.data,
cookies=self.cookie)
r.close()
self.req.close()
return self.req
elif self.method.lower() == 'delete':
r = requests.Session()
r.keep_alive = False
self.req = r.delete(url=self.host, params=self.params, headers=self.headers, data=self.data,
cookies=self.cookie)
r.close()
self.req.close()
return self.req
else:
Log.LOG(self.host).log_info('The method of Http Request is invalid!')
return None
except Exception, e:
Log.LOG(self.host).log_error(e)
def print_responsedata(self):
s = '----------------response start----------------'
s = s + '\n' + 'The data of response:' + '\n' + 'The return status:' + str(self.result['req_status'])
s = s + '\n' + 'The return headers:' + str(self.result['req_headers'])
s = s + '\n' + 'The return content:' + str(self.result['req_content'])
s = s + '\n' + 'The return cookies: ' + str(self.result['req_cookie'])
s = s + '\n' + 'The return token: ' + str(self.result['req_token'])
s = s + '\n' + '----------------response end----------------'
Log.LOG().log_info(s)
def __init__(self):
global host, port, user, password, sender, receiver, title
host = localReadCongig.get_email("mail_host")
port = localReadCongig.get_email("mail_port")
user = localReadCongig.get_email('mail_user')
password = localReadCongig.get_email('mail_pass')
sender = localReadCongig.get_email('sender')
title = localReadCongig.get_email('subject')
self.value = localReadCongig.get_email('receiver')
self.receiver = []
#获取收件人列表
for n in str(self.value).split("/"):
self.receiver.append(n)
#定义邮件的subject
date = datetime.now().strftime('%Y-%m-%d')
self.subject = title + "" + date
self.msg = MIMEMultipart('mixed')
self.log = Log()
self.logger = self.log.get_logger()
def request_data(self,
url=None,
method=None,
cookie=None,
data=None,
header=None): # 封装data请求
Log().info(
"请求的入参url:{}...method:{}...cookie:{}...data:{}...header:{}".format(
url, method, cookie, data, header))
try:
el = requests.request(method=method,
url=url,
data=data,
cookies=cookie,
headers=header,
verify="False")
except Exception as e:
Log().error("{}请求方式有误：{}".format(method, e))
raise e
return el
def print_inputdata(self, inputdata, http_data, interfacename, casename):
# 打印入参数据
s = '\n' + '----------------http request start----------------' + '\n' + 'The request host:' + str(inputdata['host'])
s = s + '\n' + 'The request headers:' + str(inputdata['headers'])
if http_data['data'] != None:
s = s + '\n' + 'The request body:' + str(inputdata['data'])
s = s + '\n' + 'The request params:' + str(inputdata['params'])
s = s + '\n' + 'The request method:' + str(inputdata['method'])
s = s + '\n' + 'The request cookie:' + str(inputdata['cookie'])
s = s + '\n' + '----------------request end----------------'
Log.LOG(interfacename + '->' + casename + '-->' + inputdata['host']).log_info(s)
def assertion(self, data, expected):
result = []
com_flag = True
for i in expected: # 校验接口返回,返回结果是一个以True或False的列表
for k, v in i.items():
if k == "eq":
Log.logger(
"Equal Assert!!! Expected_value =Actual_value ... ")
flag = self.eq_assert(data, v)
result.append(flag)
elif k == "co":
Log.logger(
"Contain Assert!!! Actual_value contains Expected_value ... "
)
flag = self.co_assert(data, v)
result.append(flag)
elif k == "nq":
Log.logger(
"Not Equal Assert!!! Expected_value !=Actual_value ... "
)
flag = self.nq_assert(data, v)
result.append(flag)
for i in result: # 对断言列表进行校验,只要含有Flase测试结果就为False
if i == False:
com_flag = False
break
return com_flag
def assertion(self,
response_data=None,
case_id=None,
sheet_name=None,
case_list=None):
result = None
case_dict = {}
case_response = {}
assertion = getattr(get_data, "assertion")
try:
unittest.TestCase().assertIn(str(assertion), response_data)
result = "pass"
Log().info("断言正确")
except AssertionError as e:
result = "fail"
Log().error("断言错误{}".format(e))
raise e
finally:
case_list.extend([result, response_data])
case_dict[str(int(case_id) + 2)] = case_list
case_response[sheet_name] = case_dict
get_data.response.append(case_response)
def set_var(self, path, di, res):
for k, v in di.items():
if "headers" in v:
headers = res.headers
temp = v.split('.')
for j in range(1, len(temp)):
str = temp[j]
text = headers[str]
elif "body" in v:
body = res.text
if isinstance(body, dict): # 判断是否为字典
pass
else:
body = json.loads(body) # Json字符串转换成字典
temp = v.split('.')
for j in range(1, len(temp)):
str = temp[j]
text = body[str]
di[k] = text
var.update(di)
Log.logger("Global Var:" + json.dumps(var))
# print("设定全局变量"+var)
return var
def read_inputdata(self, interfacename, casename):
try:
path = os.path.dirname(os.getcwd())
parpath = os.path.dirname(path)
# 获取接口配置数据
config_data = self.get_configdata(interfacename)
case_data = config_data
# 从case中取参数
'''filename = parpath + '/TestCase/Function/' + '%s/%s.txt' % (interfacename, casename)
with open(filename, 'r')as f:
para_data = f.read()
# 对case里取出的string流处理
para_data = TransCode.TransCode().transcode(para_data)'''
para_data = HandleDB.HandleDB().db_readcaseinfo(casename)
Log.LOG(interfacename + '--->' + casename).log_result('para_data: %s\n'%para_data)
case_data['params'] = para_data
return case_data
except Exception,e:
HandleException.Exception().exception('read_inputdata raise exception:\n'+ e)
def data_init(self,
url=None,
data=None,
assertion=None,
regular=None,
sql=None,
sql_assertion=None):
try:
variable_data = getattr(get_data, "variable_data")
setattr(get_data, "sql", sql)
setattr(get_data, "sql_assertion", sql_assertion)
setattr(get_data, "assertion", assertion)
setattr(get_data, "regular", regular)
setattr(get_data, "url", url)
setattr(get_data, "data", data)
if getattr(get_data, "sql_assertion") is not None: # 替换变量
self.str_data(variable_data=variable_data,
variable_name="sql_assertion")
if getattr(get_data, "sql") is not None: # 替换变量
self.list_data(variable_data=variable_data,
variable_name="sql")
if getattr(get_data, "assertion") is not None: # 替换变量
self.str_data(variable_data=variable_data,
variable_name="assertion")
if getattr(get_data, "regular") is not None: # 替换变量
self.list_data(variable_data=variable_data,
variable_name="regular")
if getattr(get_data, "url") is not None: # 替换变量
self.str_data(variable_data=variable_data, variable_name="url")
if getattr(get_data, "data") is not None: # 替换变量
self.str_data(variable_data=variable_data,
variable_name="data")
if (getattr(get_data, "data")[0] == "[" and getattr(
get_data,
"data")[len(getattr(get_data, "data")) - 1] == "]"
) or (getattr(get_data, "data")[0] == "{" and getattr(
get_data, "data")[len(getattr(get_data, "data")) - 1]
== "}"):
setattr(get_data, "data", eval(getattr(get_data, "data")))
except Exception as e:
Log().error("数据初始化失败")
raise e
def test_api(self, name, method, url, headers, params, expected, export):
allure.dynamic.title("请求接口:{i}".format(i=url)) # 设定用例标题
allure.dynamic.description("用例描述:{i}".format(i=name)) # 设定用例描述
# com_flag = True # 设置默认的断言结果
headers = obj.get_var(headers) # 判断请求头中是否有变量,有的话需获取变量值
Log.logger("Request Headers:"+str(headers))
params = obj.get_var(params) # 判断请求消息体中是否有变量,有的话需获取变量值
Log.logger("Request Body:"+str(params))
if method == "GET":
data = Base.base_request(url=url, method=method, headers=headers, params=params)
elif method == "POST":
data = Base.base_request(url=url, method=method, headers=headers, data=params)
Log.logger("Response Headers:" + str(data.headers))
Log.logger("Response Body:" + str(data.text))
if export == "NULL": # 接口返回是否需要输出变量供其他接口使用
pass
else:
obj.set_var(path, export, data)
com_flag = Assert.assertion(data,expected)
assert data.status_code == 200, "Test Failed!!!"
assert com_flag, "Test Failed!!!"
class RunAll:
log = Log()
logger = log.get_logger()
email = Email()
def test_run(self):
try:
self.logger.info("********接口测试开始********")
start = time.clock()
data = CreateTest.test_main()
errorlist = data[0]
totalcase = data[1] - 1
errorcouting = len(errorlist)
self.email.send_email(totalcase, errorcouting, errorlist)
end = time.clock()
self.logger.info("********接口测试结束********")
self.logger.info("接口自动化脚本运行时间：%.03f seconds" % (end - start))
except Exception as ex:
self.logger.error(str(ex))
def handler(event, context):
try:
# get odata settings
Debugging=!!!!
odataDoman = ParameterStoreHelper.get_value_from_ssm_parameter_store("/{env}/aws_c4c/employee_publisher/{ver}/odata_doman".format(env=environment, ver=version))
odataUserName = ParameterStoreHelper.get_value_from_ssm_parameter_store("/{env}/aws_c4c/employee_publisher/{ver}/odata_userName".format(env=environment, ver=version))
odataPassword = ParameterStoreHelper.get_value_from_ssm_parameter_store("/{env}/aws_c4c/employee_publisher/{ver}/odata_password".format(env=environment, ver=version), True)
odataUrlFormat = ParameterStoreHelper.get_value_from_ssm_parameter_store("/{env}/aws_c4c/employee_publisher/{ver}/odata_urlFormat".format(env=environment, ver=version))
for record in event['Records']:
try:
payload = json.loads(record['body'])
# request c4c for the details
result = requests.get(url=odataUrlFormat.format(domain=odataDoman, objectId=payload["data"]["root-entity-id"]), headers=odataHeaders, auth=(odataUserName, odataPassword))
if(result.status_code != 200):
raise Exception(result)
jsonResult = result.json()
record_to_publish = {
"ObjectID: jsonResult['d']['results']['ObjectID'],
"EmployeeID": jsonResult['d']['results']['EmployeeID'],
"BusinessPartnerID": jsonResult['d']['results']['BusinessPartnerID'],
"FirstName": jsonResult['d']['results']['FirstName'],
"MiddleName": jsonResult['d']['results']['MiddleName'],
"LastName": jsonResult['d']['results']['LastName'],
"Email": jsonResult['d']['results']['Email'],
"CountryCode": jsonResult['d']['results']['CountryCode'],
"CountryCodeText": jsonResult['d']['results']['CountryCodeText'],
"UserLockedIndicator": str(jsonResult['d']['results']['UserLockedIndicator']),
"TeamID": getattr(jsonResult['d']['results'], 'TeamID', ''),
"TeamName": getattr(jsonResult['d']['results'], 'TeamName', ''),
"UserAvailableIndicator": str(getattr(jsonResult['d']['results'], 'UserAvailableIndicator', '')),
"SupportedCountries": getattr(jsonResult['d']['results'], 'SupportedCountries', ''),
"SupportedLanguages": getattr(jsonResult['d']['results'], 'SupportedLanguages', ''),
}
# publish to Employee Queue
result = sqsClient.send_message(
QueueUrl=queueUrl,
MessageBody=json.dumps(record_to_publish, ensure_ascii=False).encode('utf-8').decode(),
MessageAttributes={
'countryCode': {
'DataType': 'String',
'StringValue': jsonResult['d']['results']['CountryCode']
},
'eventSource': {
'DataType': 'String',
'StringValue': eventSource
},
'correlationId': {
'DataType': 'String',
'StringValue': payload['event-id'] or str(uuid.uuid4())
}
})
DataLogger.info(Log(
message="Published employee record",
correlation_id=payload['event-id'] or str(uuid.uuid4()),
invoked_component="{env}-c4c-employee-event-publisher-{ver}".format(env=environment, ver=version),
invoker_agent="{env}-c4c-employee-event-queue-{ver}".format(env=environment, ver=version),
target_idp_application="{env}-c4c-employee-queue-{ver}".format(env=environment, ver=version),
processing_stage="employee-publisher-created",
request_payload=json.dumps(payload),
response_details=json.dumps(result),
invocation_timestamp=str(invocation_timestamp),
original_source_app=eventSource))
except Exception as error:
DataLogger.info(Log(
message="Error publishing employee record",
error=str(error),
correlation_id=payload['event-id'] or str(uuid.uuid4()),
invoked_component="{env}-c4c-employee-event-publisher-{ver}".format(env=environment, ver=version),
invoker_agent="{env}-c4c-employee-event-queue-{ver}".format(env=environment, ver=version),
target_idp_application="{env}-c4c-employee-queue-{ver}".format(env=environment, ver=version),
processing_stage="employee-publisher-created",
request_payload=json.dumps(payload),
invocation_timestamp=str(invocation_timestamp),
original_source_app=eventSource))
raise Exception(error)
return LambdaResponse.ok_response()
except Exception as error:
DataLogger.info(Log(
message="Error publishing employee record",
error=str(error),
invoked_component="{env}-c4c-employee-event-publisher-{ver}".format(env=environment, ver=version),
invoker_agent="{env}-c4c-employee-event-queue-{ver}".format(env=environment, ver=version),
target_idp_application="{env}-c4c-employee-queue-{ver}".format(env=environment, ver=version),
processing_stage="employee-publisher-created",
invocation_timestamp=str(invocation_timestamp),
original_source_app=eventSource))
raise Exception(error)
def test_svs_02(self, test_item):
log = Log()
# 获取域名[host]
test_host = Read_Config('Svs', 'host').readconfig()
# 拼接接口地址
url = 'https://' + test_host + test_item['path']
if test_item['status'] == 0:
res = Request('Svs').post_requests(url, test_item['data'])
print(res.json())
log.debug('正在执行第{0}条case:"标题为{1}"'.format(test_item['id'],
test_item['dec']))
code = res.status_code
# 对比接口状态码实际结果与预期结果
test_code = self.assertEqual(code, 200)
if test_code == None:
pass
else:
log.error('【状态码错误!!】执行第{0}条case:标题为"{1}"'.format(
test_item['id'], test_item['dec']))
print("当前错误码为" + str(code))
res = res.json()['code']
# 提取接口响应内容进行比较
test_result = self.assertEqual(res,
test_item['expectd_body']['code'])
if test_result == None:
log.info('【测试通过!!】执行第{0}条case:标题为"{1}"'.format(
test_item['id'], test_item['dec']))
else:
log.error('【测试失败!!】执行第{0}条case:标题为"{1}"'.format(
test_item['id'], test_item['dec']) + '失败。')
print("当前接口返回的信息为：" + str(res))
else:
# Log打印接口状态未开启
log.warning('未执行第{0}条case:"标题为{1}"'.format(
test_item['id'], test_item['dec']) + '未开启状态')
pass
def systemerror(self, s):
try:
raise SystemError
except SystemError:
Log.LOG('System Error').log_error(s)
def syntaxerror(self, s):
try:
raise SyntaxError
except SyntaxError:
Log.LOG('Syntax Error').log_error(s)
def exception(self, e):
# 打印代码内部错误
Log.LOG('Program error').log_error(e)
def transcode(self, strobject):
result = chardet.detect(strobject)
coding = result.get('encoding')
Log.LOG('case coding type').log_result(coding)
new = strobject.decode('GBK').encode('UTF-8')
return new
# -*- coding: UTF-8 -*-
from appium import webdriver
from Common.Log import Log
# from sshtunnel import SSHTunnelForwarder
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import string, random
import traceback
import pymysql
import datetime
import time
import allure
import os
logger = Log(logger="BasePage").getlog()
class BasePage:
def __init__(self, driver):
self.driver = driver
#等待元素可见
def wait_eleVisible(self, locator, times=20, poll_frequency=0.5, doc=""):
try:
#开始等待时间
star = datetime.datetime.now()
# return WebDriverWait(self.driver,times,poll_frequency).until(EC.visibility_of_element_located(locator))
WebDriverWait(self.driver, times, poll_frequency).until(
EC.presence_of_element_located(locator))
# 结束等待的时间
#encoding = utf-8 from Common.ParseExcel import ParseExcel from Config.VarConfig import * from Common.Log import Log from Common.request import * from Common.HandleJson import * from Common.HandleResult import * from Common.ModifyJson import * from Common.login import * import time import traceback import unittest # 创建解析Excel对象 excelObj = ParseExcel() # 将Excel数据文件加载到内存 excelObj.loadWorkBook(dataFilePath) log = Log()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Created by hubiao on 2017/5/17
from __future__ import unicode_literals
from functools import wraps
from Common.Log import Log
log = Log()
log.set_logger()
def CaseAssertion(attempt=3):
'''
用例装饰器
:param attempt: 重试次数
:return:
'''
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
att = 0
while att < attempt:
try:
log.i('--> %s', func.__name__)
ret = func(*args, **kwargs)
log.i('<-- %s, %s\n',func.__name__,'Success')
return ret
except AssertionError as e:
log.e('AssertionError, %s', e)
log.e('<-- %s, %s, %s\n',func.__name__,'AssertionError','Fail')
raise AssertionError(e)
except Exception as e:
log.e('Exception, %s', e)
class CreateTest:
#将测试数据设置为类对象
table = ReadTestcase.open_excel()
nrows = ReadTestcase.get_nrows(table)
id = ReadTestcase.get_id(table, nrows)
name = ReadTestcase.get_name(table, nrows)
url = ReadTestcase.get_url(table, nrows)
method = ReadTestcase.get_method(table, nrows)
data = ReadTestcase.get_data(table, nrows)
pattern = ReadTestcase.get_pattern(table, nrows)
#初始化日志信息
log = Log()
logger = log.get_logger()
reportpath = log.get_report_path()
#统计失败用例的编号
failcaseID = []
errorcouting = []
#定义报告的信息类别
successmsg = '测试通过'
failmsg = '测试失败，查看日志获取详情。'
@classmethod
# 接口函数
def test_api(self, url, method, data):
global response
try:
#还要添加判断，连接成功才往下走
if method == 'POST':
req = requests.post(url=url, data=json.loads(data))
self.response = req.json()
if method == 'GET':
req = requests.get(url=url, params=json.loads(data))
self.response = req.json()
return self.response
except Exception as ex:
self.logger.error(str(ex))
@classmethod
# 正则表达式，判断测试结果
# def test_result(self,response, pa): # pa对应Excel中的pattern列
# try:
# match = re.findall(pa, str(response), re.S)
# if match:
# self.report = self.successmsg
# self.report_log = '用例编号：%s ，' \
# '用例名称：%s，' \
# '测试通过！' % (self.id, self.name)
# self.logger.info(self.report_log)
# else:
# self.report = self.failmsg
# self.report_log = '用例编号：%s，' \
# '用例名称：%s，' \
# '测试失败：实际响应数据与用例不符，' \
# '实际响应数据：%s，'\
# '用例数据：%s'% (self.id, self.name, response, self.pattern)
# self.logger.info(self.report_log)
# except AttributeError:
# self.report = self.errormsg
# self.logger.error(self.report)
# return self.report
#@classmethod
# 获取用例执行的时间
def test_time(cls):
nowtime = datetime.datetime.now()
testtime = nowtime.strftime('%Y-%m-%d %H:%M:%S')
return testtime
@classmethod
# 获取本次测试报告的名称
def test_report(cls):
nowtime = datetime.datetime.now()
reporttime = nowtime.strftime('%Y-%m-%d-%H')
reportname = reporttime + '.html'
return reportname
@classmethod
# 主执行程序
def test_main(self):
global testresults
xml = minidom.Document()
xml.appendChild(xml.createComment("测试报告"))
caselist = xml.createElement("caselist")
xml.appendChild(caselist)
# 读取测试用例Excel的数据
for i in range(1, self.nrows):
testid = self.id[i]
testname = self.name[i]
testurl = self.url[i]
testmethod = self.method[i]
testdata = self.data[i]
testpattern = self.pattern[i]
# 执行测试
StartupTeardown.startup()
testresults = CreateTest.test_api(testurl, testmethod, testdata)
try:
match = re.findall(str(testpattern), str(testresults), re.S)
if match:
report = self.successmsg
report_log = '用例编号：%s ，' \
'用例名称：%s \n' \
'测试通过！' % (self.id[i], self.name[i])
self.logger.info(report_log)
else:
report = self.failmsg
report_log = '用例编号：%s，' \
'用例名称：%s\n' \
'测试失败：实际响应数据与用例不符 \n' \
'实际响应数据：%s \n' \
'用例数据：%s' % (self.id[i], self.name[i], testresults, self.pattern[i])
self.logger.info(report_log)
except Exception as ex:
self.logger.error(str(ex))
# 执行结束
StartupTeardown.teardown()
# 生成xml文件
# 输入用例ID
case = xml.createElement("case")
case.setAttribute("id", testid)
# 输入用例名称
name = xml.createElement("name")
name.appendChild(xml.createTextNode(testname))
# 输入接口类型
method = xml.createElement("method")
method.appendChild(xml.createTextNode(testmethod))
# 输入用例测试结果
result = xml.createElement("result")
result.appendChild(xml.createTextNode(report))
# 输入用例执行时间
time = xml.createElement("time")
time.appendChild(xml.createTextNode(CreateTest.test_time()))
case.appendChild(name)
case.appendChild(method)
case.appendChild(result)
case.appendChild(time)
caselist.appendChild(case)
# xml文件生成结束
#统计失败的用例ID和name
if report == self.failmsg:
self.failcaseID.append(testid)
self.errorcouting = self.failcaseID
# 生成测试报告文件,放到日志文件的同一路径下
filename = io.open(self.reportpath, 'w+', encoding='utf-8')
xml.writexml(writer=filename,
indent='\t',
newl='\n',
addindent='\t',
encoding='utf-8')
filename.close()
return (self.errorcouting, self.nrows)
'''
封装WEBUI自动化的公用方法
'''
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.wait import WebDriverWait
from Common.Chrome_Options import Options
from Common.Log import Log
from time import sleep
from Common.ExecuteResult import RESULT_LIST
log = Log().logger
# 创建浏览器对象
def open_browser(browser):
try:
# 将传入的browser参数进行格式化，首字母大写，其余小写
browser = browser.capitalize()
if browser == 'Chrome':
# 实例化对象
driver = webdriver.Chrome(options=Options().options_conf())
else:
# python反射机制，browser == Chrome时相当于webdriver.Chrome()
driver = getattr(webdriver, browser)()
log.info('{}浏览器启动中...'.format(browser))
except Exception as error:
log.info('{0}浏览器启动异常，默认启动Chrome浏览器，异常信息：{1}'.format(browser, error))
driver = webdriver.Chrome(options=Options().options_conf())
return driver
def eq_assert(self, data, expected):
expected = expected
if expected[0] == "code":
Log.logger("Expected_value: {a}".format(a=expected[1]))
Log.logger("Actual_value: {a}".format(a=data.status_code))
if data.status_code == expected[1]:
return True
else:
return False
if "headers" in expected[0]:
headers = data.headers
temp = expected[0].split('.')
for i in range(1, len(temp)):
str = temp[i]
text = headers[str]
Log.logger("Expected_value: {a}".format(a=expected[1]))
Log.logger("Actual_value: {a}".format(a=text))
if text == expected[1]:
return True
else:
return False
if "body" in expected[0]:
body = data.text
# if (type(body).__name__=='dict'): # 判断是否为字典
if isinstance(body, dict): # 判断是否为字典
pass
else:
body = json.loads(body) # 字符串转换成字典
temp = expected[0].split('.')
for i in range(1, len(temp)):
str = temp[i]
text = body[str]
Log.logger("Expected_value: {a}".format(a=expected[1]))
Log.logger("Actual_value: {a}".format(a=text))
if text == expected[1]:
return True
else:
return False
