def get_expect_for_db(self):
if self.db_data and self.db_data[settings.EXPECT_FOR_DB]:
expect = self.db_data[settings.EXPECT_FOR_DB]
# 如果有多个参数，比如前面是sql语句，后面是期望这个sql语句返回的结果
expect_list = expect.split("|")
expect_list[0] = self.replace_randnum_for_str(expect_list[0])
db_and_sql = expect_list[0].split(">")
if len(db_and_sql) == 2:
db_name = db_and_sql[0]
sql = db_and_sql[1]
else:
db_name = settings.DEV_DB_NAME
sql = db_and_sql[0]
# 从设备上把db文件拷贝下来，传过来的需要告知是查询哪张表，如果不传给个默认
# print(settings.SQLITE_CMD.format(db_name,db_name,settings.win_ip))
# do_telnet(settings.SQLITE_CMD.format(db_name,db_name,settings.win_ip))
# 打开数据库连接
# op_db = OperationDB("sqlite", db_name)
op_db = OperationDB(settings.DB_TYPE, db_name)
expect_list[0] = op_db.search_one(sql)
if len(expect_list) == 2:
# 如果查不到的就预期空值，比如删除了的
if expect_list[1] == "None":
expect_list[1] = eval(expect_list[1])
elif "{" in expect_list[1]:
if "##" in expect_list[1]:
# 如果里面有需要替换的动态变量，才去走替换函数，提高性能，否则每次不管有没有要替换的变量，都要去递归判断每个变量是否需要替换，接口比较多的话会耗时多
expect_list[1] = self.replace_randnum(
json.loads(expect_list[1]))
else:
expect_list[1] = json.loads(expect_list[1])
if "true" in json.dumps(expect_list[1]):
expect_list[1] = self.replace_true(expect_list[1])
return expect_list
class RunMain:
_instance_lock = threading.Lock()
def __init__(self, data):
self.data = data
self.get_field()
self.op_db = OperationDB()
def __new__(cls, *args, **kwargs):
'''
实现单例模式
:param args:
:param kwargs:
:return:
'''
if not hasattr(cls, "_instance"):
with cls._instance_lock:
if not hasattr(cls, "_instance"):
cls._instance = super().__new__(cls)
return cls._instance
def get_field(self):
dc = DataConfig(self.data)
self.case_id = dc.get_case_id()
self.sql_exp = dc.get_sql_exp()
self.result = dc.get_result()
def run_main(self):
r = self.op_db.search_one(self.sql_exp)
print(
settings.BEAUTIFUL_REPORT_CONTENT.format(self.case_id,
self.sql_exp, r))
self.write_res(r)
return r
def write_res(self, res):
dc = DataConfig(self.data)
res = json.dumps(res)
para = (res, self.case_id)
sql = settings.UPDATE_RESULT_SQL
dc.write_result(sql, para)
class DependData:
def __init__(self, data):
self.db = OperationDB()
self.data = data
def get_request_data(self):
'''获取当前case的数据'''
data_config = DataConfig(self.data)
params = data_config.get_data()
return params
def get_case_id(self):
'''
获取依赖的case_id，如果有依赖多个case用 | 去分隔
:return:
'''
data_config = DataConfig(self.data)
case_ids = data_config.get_depend_case_id()
case_id_list = case_ids.split("|")
return case_id_list
def get_line_data(self, depend_case_id):
'''
获取数据库里一行数据
:return:
'''
sql = settings.LINE_DATA_SQL
return depend_case_id and self.db.search_one(sql, depend_case_id)
def get_field(self, depend_case_id):
'''
获取依赖接口的字段
:return:
'''
self.line_data = self.get_line_data(depend_case_id)
data_config = DataConfig(self.line_data)
self.url = data_config.get_url()
self.method = data_config.get_method()
self.has_cookie = data_config.has_cookie()
self.header = data_config.get_header()
self.request_param = data_config.get_param()
self.request_data = data_config.get_data()
self.request_file = data_config.get_file()
self.depend_case_id = data_config.get_depend_case_id()
self.save_value = data_config.get_save_value()
def send_depend_request(self, depend_case_id):
'''
发送依赖的接口
:return:
'''
sr = SendRequest()
oc = OperaCookie()
self.get_field(depend_case_id)
if self.depend_case_id:
data_depend = DependData(self.line_data)
self.request_data = data_depend.replace_request_data()
if isinstance(self.request_data, dict):
self.request_data = HandleListOrDict().handle_value(
self.request_data)
if self.has_cookie:
cookie = oc.get_cookie()
res = sr.send_request(self.method, self.url, self.request_data,
self.request_file, self.request_param,
self.header, cookie)
else:
res = sr.send_request(self.method, self.url, self.request_data,
self.request_file, self.request_param,
self.header)
if self.save_value:
HandleSaveValue().save_response_data(res.json(), self.save_value)
print(res.json())
return res.json()
def get_response_field(self):
'''
获取返回的依赖字段,如果有依赖多个case用 | 去分隔
:return:
'''
data_config = DataConfig(self.data)
res_fields = data_config.get_depend_response_field()
# if res_fields:
res_fields_list = res_fields.split("|")
return [res_fields.split(";")
for res_fields in res_fields_list] # ;用于分隔多个字段
def get_response_data(self):
'''
取出依赖的多个字段
:return:
'''
depend_fields_list = self.get_response_field()
depend_case_ids = self.get_case_id()
fields_list = []
for i, depend_case_id in enumerate(depend_case_ids):
response_data = self.send_depend_request(depend_case_id)
fields = []
#做判空处理，有时依赖多个接口，但并不需要所有接口的字段，用| 但是 | 前面不写内容即可
if depend_fields_list[i] and depend_fields_list[i] == ['']:
fields_list.append([''])
if depend_fields_list[i] and depend_fields_list[i] != ['']:
for depend_field in depend_fields_list[i]:
depend_field = parse(depend_field)
madle = depend_field.find(response_data)
res = [match.value for match in madle][0]
fields.append(res)
fields_list.append(fields)
return fields_list
def get_request_field(self):
'''
获取返回的请求字段
:return:
'''
data_config = DataConfig(self.data)
req_fields = data_config.get_depend_request_field()
if req_fields:
req_fields_list = req_fields.split("|")
return req_fields_list
def replace_request_data(self):
response_fields_list = self.get_response_data()
request_fields_list = self.get_request_field()
params = self.get_request_data()
for num, request_fields in enumerate(request_fields_list):
if request_fields:
if "{" in request_fields:
request_fields = json.loads(request_fields)
fields = request_fields["field"].split(";")
conn = request_fields["connection"]
else:
fields = request_fields.split(";")
conn = None
for i in range(len(fields)):
if conn:
params[fields[i]] = conn.join(
response_fields_list[num])
else:
field = fields[i].split(".")
params = self.replace_json(
params, field, response_fields_list[num][i])
print("替换后的请求数据：{}".format(str(params)))
return params
#替换json中的value,key值传入list
def replace_json(self, data, key, value):
if len(key) == 1:
data[key[0]] = value
else:
data[key[0]] = self.replace_json(data[key[0]], key[1:], value)
return data
class DataConfig:
def __init__(self, data):
self.db_data = data
self.op_db = OperationDB()
self.read_i = ReadIni()
def get_case_id(self):
return self.db_data and self.db_data[settings.CASE_ID]
def get_case_name(self):
return self.db_data and self.db_data[settings.CASE_NAME]
def get_url(self):
if self.db_data:
url = self.db_data[settings.URL]
base_url = self.read_i.get_value("base_url", "url")
#如果用例里没写base_url才加上
if base_url not in url:
url = base_url + url
return url
def get_method(self):
return self.db_data and self.db_data[settings.METHOD]
def get_header_info(self):
if self.db_data and not self.db_data[settings.HEADER_INFO]:
return settings.URL_ENCODE
return self.db_data and self.db_data[
settings.HEADER_INFO] and json.loads(
self.db_data[settings.HEADER_INFO])
def is_write(self):
header_info = self.get_header_info()
if header_info and settings.IS_WRITE in header_info:
return header_info[settings.IS_WRITE]
else:
return None
def has_cookie(self):
header_info = self.get_header_info()
if header_info and settings.COOKIE in header_info:
return header_info[settings.COOKIE]
else:
return None
def get_header(self):
header_info = self.get_header_info()
if header_info:
if not (settings.HEADER in header_info or settings.IS_WRITE
in header_info or settings.COOKIE in header_info):
header = header_info
elif settings.HEADER in header_info:
header = header_info[settings.HEADER]
if settings.TOKEN in header:
ot = OperaToken()
header[settings.TOKEN] = ot.get_token()
return header
else:
return None
def get_params(self):
return self.db_data and self.db_data[settings.PARAMS] and json.loads(
self.db_data[settings.PARAMS])
def get_data(self):
params = self.get_params()
if params:
if not (settings.PARAM in params or settings.FILE in params
or settings.DATA in params):
data = params
elif settings.DATA in params:
data = params[settings.DATA]
return data
else:
return None
def get_param(self):
params = self.get_params()
if params and settings.PARAM in params:
return params[settings.PARAM]
else:
return None
def get_file(self):
params = self.get_params()
if params and settings.FILE in params:
return json.dumps(params[settings.FILE])
else:
return None
def get_is_run(self):
return self.db_data and self.db_data[settings.IS_RUN]
def get_depend_case_id(self):
return self.db_data and self.db_data[settings.DEPEND_CASE_ID]
def get_depend_request_field(self):
return self.db_data and self.db_data[settings.DEPEND_REQUEST_FIELD]
def get_depend_response_field(self):
return self.db_data and self.db_data[settings.DEPEND_RESPONSE_FIELD]
def get_post_action(self):
if self.db_data:
post_action = self.db_data[settings.POST_ACTION]
if post_action:
post_action_list = post_action.split("|")
# for i,post_action in post_action_list:
# if "case_id" in post_action:
# post_action_list[i] = post_action.split("case_id=")[1]
return post_action_list
return None
def get_post_params(self):
if self.db_data:
post_params = self.db_data[settings.POST_PARAMS]
if post_params:
post_params_list = post_params.split("|")
for i, post_params in enumerate(post_params_list):
if "{" in post_params:
if "##" in post_params:
post_params_list[i] = self.replace_rand_param(
json.loads(post_params))
else:
post_params_list[i] = json.loads(post_params)
return post_params_list
return None
def replace_rand_param(self):
pass
def get_expext(self):
return self.db_data and self.db_data[settings.EXPECT]
def get_expect_for_db(self):
expect = self.get_expext()
if expect and "{" in expect:
expect = json.loads(expect)
if settings.EXPECT_SQL in expect:
sql = expect[settings.EXPECT_SQL]
expect = self.op_db.search_one(sql)
return expect
def get_result(self):
return self.db_data and self.db_data[settings.RESULT]
def write_result(self, sql, param):
self.op_db.sql_DML(sql, param)
def replace_rand_param(self):
pass
def get_expext(self):
return self.db_data and self.db_data[settings.EXPECT]
def get_expect_for_db(self):
expect = self.get_expext()
if expect and "{" in expect:
expect = json.loads(expect)
if settings.EXPECT_SQL in expect:
sql = expect[settings.EXPECT_SQL]
expect = self.op_db.search_one(sql)
return expect
def get_result(self):
return self.db_data and self.db_data[settings.RESULT]
def write_result(self, sql, param):
self.op_db.sql_DML(sql, param)
if __name__ == "__main__":
db = OperationDB()
sql = "select * from cases where case_id=%s"
pa = ("qingguo_001", )
data = db.search_one(sql, pa)
d = DataConfig(data)
r = d.get_header()
print(r, type(r))
class PostAct:
def __init__(self, post_action, post_params, depend_case_id, url):
self.db = OperationDB()
self.url = url
self.post_action = post_action
self.post_params = post_params
self.depend_case_id = depend_case_id
def change_base_url(self, host=None):
#如果没有传host，则从第一个用例里用正则表达式去匹配host，否则就直接用传入的host
if not host:
r = re.search(settings.URL_RE, self.url)
host = r[0]
#将host记录到ini文件中，方便后续接口使用
read_i = ReadIni()
read_i.write_data("base_url", host, "url")
def handle_post_action(self):
if self.post_action:
for i, post_act in enumerate(self.post_action):
#参数对应顺序传，否则我不知道你想传给谁
if "case_id" in post_act:
case_id = post_act.split("case_id=")[1]
self.send(case_id, post_param[i])
else:
func = getattr(self, post_act)
func(post_param[i])
#给依赖的接口所做的操作做清理
if self.depend_case_id:
data = self.get_line_data(depend_case_id)
self.get_request_data(data)
#由依赖的接口产生对象去递归调用，这里虽然叫clear什么的，但是此时他是依赖的数据了，并不是清理的
post_act_obj = PostAct(self.clear_post_action,
self.clear_post_params, self.depend_case_id,
self.url)
post_act_obj.handle_post_action()
def get_line_data(self, case_id):
'''
获取数据库里一行数据
:return:
'''
sql = settings.LINE_DATA_SQL
return case_id and self.db.search_one(sql, case_id)
def send(self, case_id, post_param):
sr = SendRequest()
clear_interface_data = self.get_line_data(case_id)
self.get_request_data(clear_interface_data)
#防止递归的时候，依赖的数据的清理动作调用的就是自身，而其实自身已经相当于做了数据清理了
if self.url != self.clear_url:
sr.send_request(method=self.clear_method,
url=self.clear_url,
data=post_param,
header=self.clear_header)
def get_request_data(self, clear_interface_data):
'''获取当前case的数据'''
data_config = DataConfig(clear_interface_data)
self.clear_url = data_config.get_url()
self.clear_method = data_config.get_method()
self.clear_header = data_config.get_header()
self.clear_post_action = data_config.get_post_action()
self.clear_post_params = data_config.get_post_params()
self.depend_case_id = data_config.get_depend_case_id()
def get_verify_code(self, key):
redis_db = OperationDB("redis")
code = redis_db.search_one(key)
read_i = ReadIni()
code = json.loads(code).get("code")
read_i.write_data(key.split(":")[0], code)
class PostAct:
def __init__(self, post_action, post_params, depend_case_id, url):
self.db = OperationDB()
self.url = url
self.post_action = post_action
self.post_params = post_params
self.depend_case_id = depend_case_id
self.logger = get_logger()
def change_base_url(self, host=None):
#如果没有传host，则从第一个用例里用正则表达式去匹配host，否则就直接用传入的host
if not host:
r = re.search(settings.URL_RE, self.url)
host = r[0]
self.logger.info(
"没有传host，从第一个用例里用正则表达式去匹配host，匹配结果是{}".format(host))
#将host记录到ini文件中，方便后续接口使用
read_i = ReadIni()
read_i.write_data("base_url", host, "url")
self.logger.info("将host记录到ini文件中，方便后续接口使用")
def get_verify_code(self, key):
redis_db = OperationDB("redis")
code = redis_db.search_one(key)
read_i = ReadIni()
code = json.loads(code).get("code")
read_i.write_data(key.split(":")[0], code)
def handle_post_action(self):
if self.post_action:
for i, post_act in enumerate(self.post_action):
#参数对应顺序传，否则我不知道你想传给谁
if "case_id" in post_act:
case_id = post_act.split("case_id=")[1]
if self.post_params:
self.send(case_id, self.post_params[i])
else:
self.send(case_id)
else:
func = getattr(self, post_act)
if self.post_params and len(self.post_action) == len(
self.post_params):
func(self.post_params[i])
else:
func()
self.logger.info("给当前接口做数据清理")
#给依赖的接口所做的操作做清理
if self.depend_case_id:
depend_case_id_list = self.depend_case_id.split("|")
for depend_case_id in depend_case_id_list:
data = self.get_line_data(depend_case_id)
self.get_request_data(data)
#由依赖的接口产生对象去递归调用，这里虽然叫clear什么的，但是此时他是依赖的数据了，并不是清理的
post_act_obj = PostAct(self.clear_post_action,
self.clear_post_params,
self.clear_depend_case_id, self.url)
post_act_obj.handle_post_action()
self.logger.info("给依赖接口做数据清理")
def get_line_data(self, case_id):
'''
获取数据库里一行数据
:return:
'''
sql = settings.LINE_DATA_SQL
return case_id and self.db.search_one(sql, case_id)
def send(self, case_id, post_param=None):
sr = SendRequest()
clear_interface_data = self.get_line_data(case_id)
self.get_request_data(clear_interface_data)
if isinstance(post_param, dict):
post_param = HandleListOrDict().handle_value(post_param)
#防止递归的时候，依赖的数据的清理动作调用的就是自身，而其实自身已经相当于做了数据清理了
# if self.url != self.clear_url:
sr.send_request(method=self.clear_method,
url=self.clear_url,
data=post_param,
header=self.clear_header)
def get_request_data(self, clear_interface_data):
'''获取当前case的数据'''
data_config = DataConfig(clear_interface_data)
self.clear_url = data_config.get_url()
self.clear_method = data_config.get_method()
self.clear_header = data_config.get_header()
self.clear_post_action = data_config.get_post_action()
self.clear_post_params = data_config.get_post_params()
self.clear_depend_case_id = data_config.get_depend_case_id()
class DependData:
def __init__(self,data):
self.db = OperationDB()
self.data = data
def get_request_data(self):
data_config = DataConfig(self.data)
params = data_config.get_data()
return params
def get_case_id(self):
'''
获取依赖的case_id
:return:
'''
data_config = DataConfig(self.data)
return data_config.get_depend_case_id()
def get_line_data(self):
'''
获取数据库里一行数据
:return:
'''
depend_case_id = self.get_case_id()
sql = settings.LINE_DATA_SQL
return depend_case_id and self.db.search_one(sql,depend_case_id)
def get_field(self):
'''
获取依赖接口的字段
:return:
'''
line_data = self.get_line_data()
data_config = DataConfig(line_data)
self.url = data_config.get_url()
self.method = data_config.get_method()
self.has_cookie = data_config.has_cookie()
self.header = data_config.get_header()
self.request_data = data_config.get_params()
def send_depend_request(self):
'''
发送依赖的接口
:return:
'''
sr = SendRequest()
oc = OperaCookie()
self.get_field()
if self.has_cookie:
cookie = oc.get_cookie()
res = sr.send_request(self.method, self.url, self.request_data, self.header, cookie)
else:
res = sr.send_request(self.method, self.url, self.request_data, self.header)
return res.json()
def get_response_field(self):
'''
获取返回的依赖字段
:return:
'''
data_config = DataConfig(self.data)
res_fields = data_config.get_depend_response_field()
return res_fields and res_fields.split(";")
def get_response_data(self):
'''
取出依赖的多个字段
:return:
'''
response_data= self.send_depend_request()
depend_fields = self.get_response_field()
fields = []
if depend_fields:
for depend_field in depend_fields:
depend_field = parse(depend_field)
madle = depend_field.find(response_data)
res = [match.value for match in madle][0]
fields.append(res)
return fields
def get_request_field(self):
'''
获取返回的请求字段
:return:
'''
data_config = DataConfig(self.data)
req_fields = data_config.get_depend_request_field()
return json.loads(req_fields)
def replace_request_data(self):
response_fields = self.get_response_data()
request_fields = self.get_request_field()
params = self.get_request_data()
if request_fields:
fields = request_fields["field"]
conn = request_fields["connection"]
if conn:
params[fields] = conn.join(response_fields)
else:
for i in range(len(fields)):
params[fields[i]] = response_fields[i]
return params
def handle_depend_data(self):
if self.get_case_id():
params = self.replace_request_data()
return params and json.dumps(params)
else:
params = self.get_request_data()
return params and json.dumps(params)
class DependData:
def __init__(self, data):
self.db = OperationDB()
self.data = data
def get_request_data(self):
'''获取当前case的数据'''
data_config = DataConfig(self.data)
params = data_config.get_data()
return params
def get_case_id(self):
'''
获取依赖的case_id，如果有依赖多个case用 | 去分隔
:return:
'''
data_config = DataConfig(self.data)
case_ids = data_config.get_depend_case_id()
case_id_list = case_ids.split("|")
return case_id_list
def get_line_data(self, depend_case_id):
'''
获取数据库里一行数据
:return:
'''
sql = settings.LINE_DATA_SQL
return depend_case_id and self.db.search_one(sql, depend_case_id)
def get_field(self, depend_case_id):
'''
获取依赖接口的字段
:return:
'''
self.line_data = self.get_line_data(depend_case_id)
data_config = DataConfig(self.line_data)
self.url = data_config.get_url()
self.method = data_config.get_method()
self.has_cookie = data_config.has_cookie()
self.header = data_config.get_header()
self.request_param = data_config.get_param()
self.request_data = data_config.get_data()
self.request_file = data_config.get_file()
self.depend_case_id = data_config.get_depend_case_id()
self.post_action = data_config.get_post_action()
self.post_params = data_config.get_post_params()
def send_depend_request(self, depend_case_id):
'''
发送依赖的接口
:return:
'''
sr = SendRequest()
oc = OperaCookie()
self.get_field(depend_case_id)
if self.depend_case_id:
data_depend = DependData(self.line_data)
self.request_data = data_depend.replace_request_data()
if self.has_cookie:
cookie = oc.get_cookie()
res = sr.send_request(self.method, self.url, self.request_data,
self.request_file, self.request_param,
self.header, cookie)
else:
res = sr.send_request(self.method, self.url, self.request_data,
self.request_file, self.request_param,
self.header)
return res.json()
def get_response_field(self):
'''
获取返回的依赖字段,如果有依赖多个case用 | 去分隔
:return:
'''
data_config = DataConfig(self.data)
res_fields = data_config.get_depend_response_field()
if res_fields:
res_fields_list = res_fields.split("|")
return [res_fields.split(";")
for res_fields in res_fields_list] # ;用于分隔多个字段
def get_response_data(self):
'''
取出依赖的多个字段
:return:
'''
depend_fields_list = self.get_response_field()
depend_case_ids = self.get_case_id()
fields_list = []
for i, depend_case_id in enumerate(depend_case_ids):
response_data = self.send_depend_request(depend_case_id)
fields = []
if depend_fields_list[i]:
for depend_field in depend_fields_list[i]:
depend_field = parse(depend_field)
madle = depend_field.find(response_data)
res = [match.value for match in madle][0]
fields.append(res)
fields_list.append(fields)
return fields_list
def get_request_field(self):
'''
获取返回的请求字段
:return:
'''
data_config = DataConfig(self.data)
req_fields = data_config.get_depend_request_field()
if req_fields:
req_fields_list = req_fields.split("|")
return [json.loads(req_fields) for req_fields in req_fields_list]
def replace_request_data(self):
response_fields_list = self.get_response_data()
request_fields_list = self.get_request_field()
params = self.get_request_data()
for num, request_fields in enumerate(request_fields_list):
if request_fields:
fields = request_fields["field"].split(";")
conn = request_fields["connection"]
for i in range(len(fields)):
if conn:
params[fields[i]] = conn.join(
response_fields_list[num])
#params[fields[i]] = response_fields_list[num][i] #fields是参数的数组，需要与返回参数的数组顺序一致
else:
field = fields[i].split(".")
params = self.replace_json(
params, field, response_fields_list[num][i])
return params
#替换json中的value,key值传入list
def replace_json(self, data, key, value):
if len(key) == 1:
data[key[0]] = value
else:
data[key[0]] = self.replace_json(data[key[0]], key[1:], value)
return data
def post_act(self, case_id, post_prams):
if self.case_id:
#获取要帮助清理的case的数据
self.get_field(case_id)
#把数据替换成我们要清理的data数据
self.request_data = post_prams
sr = SendRequest()
sr.send_request(self.method, self.url, self.request_data,
self.request_file, self.request_param, self.header)
while (self.depend_case_id):
data_depend = DependData(self.line_data)
if data_depend.post_action and self.url != data_depend.post_action:
func = getattr(data_depend, )