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_caseid(caseid1, caseid2, i):
TABLE_NAME = "cases_copy"
opera_db = OperationDB()
sql = "select case_id,post_action from {} where case_id>='{}' and case_id<='{}';".format(
TABLE_NAME, caseid1, caseid2)
data = opera_db.search_all(sql)
print(data)
for item in data:
caseid = item.get("case_id")
num = int(re.search("\d+(?=_)", caseid).group())
num1 = num + i
caseid_new = re.sub(str(num), str(num1), caseid)
post_action = item.get("post_action")
if post_action and "case_id" in post_action and (
post_action.split("=")[1] >= caseid1
and post_action.split("=")[1] <= caseid2):
num2 = int(
re.search("\d+(?=_)",
post_action.split("=")[1]).group())
num3 = num2 + i
post_action_new = re.sub(str(num2), str(num3), post_action)
else:
post_action_new = post_action
sql1 = "update {} set case_id='{}',post_action='{}' where case_id='{}';".format(
TABLE_NAME, caseid_new, post_action_new, caseid)
opera_db.sql_DML(sql1)
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 Count:
def __init__(self):
self.op_db = OperationDB()
self.chrome_result = self.get_chrome_result()
self.firefox_result = self.get_firefox_result()
self.edge_result = self.get_edge_result()
def get_chrome_result(self):
chrome_result = self.op_db.search_all(settings.GET_CHROME_RESULT)
res = [r[settings.CHROME_RESULT] for r in chrome_result]
return res
def get_firefox_result(self):
firefox_result = self.op_db.search_all(settings.GET_FIREFOX_RESULT)
res = [r[settings.FIREFOX_RESULT] for r in firefox_result]
return res
def get_edge_result(self):
edge_result = self.op_db.search_all(settings.GET_EDGE_RESULT)
res = [r[settings.EDGE_RESULT] for r in edge_result]
return res
def get_result(self):
chrome_pass = chrome_fail = firefox_pass = firefox_fail = edge_pass = edge_fail = 0
for i in self.chrome_result:
if i == "pass":
chrome_pass += 1
elif i == "fail":
chrome_fail += 1
for j in self.firefox_result:
if j == "pass":
firefox_pass += 1
elif j == "fail":
firefox_fail += 1
for k in self.edge_result:
if k == "pass":
edge_pass += 1
elif k == "fail":
edge_fail += 1
return str(chrome_pass), str(chrome_fail), str(firefox_pass), str(
firefox_fail), str(edge_pass), str(edge_fail)
class DataConfig:
def __init__(self, data):
self.db_data = data
self.op_db = OperationDB()
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_sql_exp(self):
return self.db_data and settings.EXPLAIN.format(
self.db_data[settings.SQL_EXP])
def get_result(self):
return self.db_data and self.db_data[settings.RESULT] and json.loads(
self.db_data[settings.RESULT])
def write_result(self, sql, param=None):
self.op_db.sql_DML(sql, param)
class DataConfig:
def __init__(self, data):
self.db_data = data
self.op_db = OperationDB()
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_pre_action(self):
return self.db_data and self.db_data[settings.PRE_ACTION]
def get_action(self):
return self.db_data and self.db_data[settings.ACTION]
def get_post_action(self):
return self.db_data and self.db_data[settings.POST_ACTION]
def get_params(self):
return self.db_data and self.db_data[settings.PARAMS] and json.loads(
self.db_data[settings.PARAMS])
def get_is_run(self):
return self.db_data and self.db_data[settings.IS_RUN]
def get_expext(self):
return self.db_data and self.db_data[settings.EXPECT]
def get_expect_method(self):
return self.db_data and self.db_data[settings.EXPECT_METHOD]
def get_expect_method_params(self):
return self.db_data and self.db_data[
settings.EXPECT_METHOD_PARAMS] and json.loads(
self.db_data[settings.EXPECT_METHOD_PARAMS])
def write_result(self, sql, param):
self.op_db.sql_DML(sql, param)
class Count:
def __init__(self):
self.op_db = OperationDB()
def count(self):
pass_count = fail_count = 0
result = self.op_db.search_all(settings.GET_RESULT_SQL)
for d in result:
if d.get(settings.RESULT) == "pass":
pass_count += 1
elif d.get(settings.RESULT) == "fail":
fail_count += 1
return str(pass_count), str(fail_count)
class MailReport:
def __init__(self):
self.op_db = OperationDB()
self.result = self.get_result()
def get_result(self):
result = self.op_db.search_all(settings.RESULT_SQL)
return result
def count(self):
success_count = fail_count = type_all_count = type_index_count = 0
for res in self.result:
if res[settings.RESULT]:
success_count += 1
r = json.loads(res[settings.RESULT])
if r[settings.RESULT_TYPE] == "ALL":
type_all_count += 1
elif r[settings.RESULT_TYPE] == "INDEX":
type_index_count += 1
else:
fail_count += 1
return success_count, fail_count, type_all_count, type_index_count
def get_type_case(self):
type_all_cases = [
i[settings.SQL_EXP] for i in self.result
if json.loads(i[settings.RESULT])[settings.RESULT_TYPE] == "ALL"
]
type_index_cases = [
i[settings.SQL_EXP] for i in self.result
if json.loads(i[settings.RESULT])[settings.RESULT_TYPE] == "INDEX"
]
return type_all_cases, type_index_cases
def send_result_mail(self, report_file=None):
count_tuple = self.count()
type_cases = self.get_type_case()
count = str(int(count_tuple[0]) + int(count_tuple[1]))
content = settings.EMAIL_CONTENT.format(
count, count_tuple[0], count_tuple[1], count_tuple[2],
type_cases[0], count_tuple[3], type_cases[1], report_file,
settings.DB_TYPE, settings.DB_HOST, settings.DB_USER,
settings.DB_PASSWD, settings.DB_NAME, settings.TABLE_NAME)
s = SendMail()
sub = settings.EMAIL_SUB.format(time.strftime("%Y-%m-%d %H:%M:%S"))
s.send_mail(settings.EMAIL_RECEIVER, sub, content)
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)
def __init__(self, data):
self.data = data
self.get_field()
self.op_db = OperationDB()
sys.path.append(
os.path.abspath(os.path.join(os.getcwd(), "..\\Lib\\site-packages")))
from base.browser_engine import BrowserEngine
import unittest
import ddt
import multiprocessing
from case.run_main import RunMain
from util.opera_db import OperationDB
import HTMLTestRunner
from page.login_page import LoginPage
from config import settings
from pic.opera_pics import OperaPics
from log.log_record import LogRecord
from BeautifulReport import BeautifulReport
op_db = OperationDB()
data = op_db.search_all(settings.TEST_CASE_SQL)
@ddt.ddt
class Test(unittest.TestCase):
@classmethod
def setUpClass(cls):
#清除以前的测试结果
op_db.sql_DML(settings.CLEAR_RESULT_SQL)
#cls.driver = BrowserEngine(parames).start_browser()
cls.driver = BrowserEngine("chrome").start_browser()
#lo = LoginPage(cls.driver)
#lo.login(**{"username":"******","password":11223
@ddt.data(*data)
def __init__(self, data):
self.db_data = data
self.op_db = OperationDB()
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 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 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 __init__(self):
self.op_db = OperationDB()
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_is_run(self):
return self.db_data and self.db_data[settings.IS_RUN]
def get_expext(self):
return self.db_data and self.db_data[settings.EXPECT]
def get_expect_method(self):
return self.db_data and self.db_data[settings.EXPECT_METHOD]
def get_expect_method_params(self):
return self.db_data and self.db_data[
settings.EXPECT_METHOD_PARAMS] and json.loads(
self.db_data[settings.EXPECT_METHOD_PARAMS])
def write_result(self, sql, param):
self.op_db.sql_DML(sql, param)
if __name__ == "__main__":
db = OperationDB(settings.DB_TYPE, settings.DB_USER, settings.DB_PASSWD,
settings.DB_HOST, settings.DB_PORT, settings.DB_NAME)
sql = "select * from ui_cases where case_id=%s"
pa = ("register_001", )
data = db.search_one(sql, pa)
d = DataConfig(data)
r = d.get_edge_result()
print(r)
# sql1 = "update ui_cases set result=%s where case_id=%s"
# para1 = ("pass","register_001")
# d.write_result(sql1,para1)
import unittest, ddt
from util.opera_db import OperationDB
from base.send_main import SendMain
from config import settings
from BeautifulReport.BeautifulReport import BeautifulReport
import time
op_db = OperationDB()
sql = settings.TEST_CASE_SQL
data = op_db.search_all(sql)
@ddt.ddt
class RunCase(unittest.TestCase):
@classmethod
def setUpClass(cls):
op_db.sql_DML(settings.CLEAR_RESULT_SQL)
@ddt.data(*data)
@ddt.unpack
def test01(self, *args, **kwargs):
self._testMethodDoc = kwargs[settings.CASE_NAME] #用例注释
self.is_run = kwargs[settings.IS_RUN]
if not self.is_run:
self.skipTest("不执行") #忽略测试
self.sm = SendMain(kwargs)
self.res = self.sm.run_main()
self.assertTrue(self.res)
def tearDown(self):
if self.is_run and self.res:
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
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))
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 __init__(self, data):
self.db_data = data
self.op_db = OperationDB()
self.read_i = ReadIni()
def __init__(self):
self.op_db = OperationDB()
self.chrome_result = self.get_chrome_result()
self.firefox_result = self.get_firefox_result()
self.edge_result = self.get_edge_result()
def __init__(self):
self.op_db = OperationDB()
self.result = self.get_result()
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
if "##" in url:
url = self.replace_randnum_for_str(url)
print("请求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.HEADER_JSON
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()
#header如果没有"header"的key在里面，则当他就是header
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
# 如果里面有token，则用文件里已经取到的token去替换
if settings.TOKEN in header:
ot = OperaToken()
header[settings.TOKEN] = ot.get_token()
return header
#如果有传"header"的key在里面，则取出来
if settings.HEADER in header_info:
header = header_info[settings.HEADER]
# 如果里面有token，则用文件里已经取到的token去替换
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_param(self):
params = self.get_params()
if params and settings.PARAM in params:
return json.dumps(params[settings.PARAM])
else:
return None
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]
# 如果里面有需要替换的动态变量，才去走替换函数，提高性能，否则每次不管有没有要替换的变量，都要去递归判断每个变量是否需要替换，接口比较多的话会耗时多
if "func" in json.dumps(data):
data = self.handle_value(data)
if "##" in json.dumps(data):
data = self.replace_randnum(data)
print("请求数据: " + str(data))
return data
else:
return None
def handle_value(self, data):
if isinstance(
data, dict
): #{"pass":"******","person":{"id":{"func":"rand_num"},"idcardNum":{"func":"rand_str"},"name":"Neo","IDPermission":2}}
for key, value in data.items():
if isinstance(value, list):
for num, item in enumerate(value):
value[num] = self.handle_value(item)
if isinstance(value, dict):
if "func" in value:
func = value["func"]
func = getattr(self, func)
data[key] = func()
self.read_i.write_data(key, str(data[key]))
else:
data[key] = self.handle_value(value)
return data
#获取当前时间戳
def get_timestamp(self):
self.current_time = str(int(round(time.time(), 3) * 1000))
return self.current_time
#根据时间戳、accessKey、accessSerect经由MD5 32位生成的密钥签名
def get_sign(self):
accessKey = self.read_i.get_value("data.accessKey")
accessSerect = self.read_i.get_value("data.accessSecret")
return get_des_psswd(self.current_time, accessKey, accessSerect)
def replace_randnum(self, data):
#如果一开始就是个list
if isinstance(data, list):
for n, i in enumerate(data):
data[n] = self.replace_randnum(i)
if isinstance(
data, dict
): #{"pass":"******","person":{"id":"##id","idcardNum":123,"name":"Neo","IDPermission":2}}
for key, value in data.items():
if isinstance(value, str):
#如果里面含有##则替换动态参数，从global_var.ini里查出来
if "##" in value:
value = value.split("##")[1]
data[key] = self.read_i.get_value(value)
if isinstance(value, list):
for num, item in enumerate(value):
value[num] = self.replace_randnum(item)
if isinstance(value, dict):
data[key] = self.replace_randnum(value)
return data
def replace_randnum_for_str(self, data):
if isinstance(
data, str
): # select col_1,col_2 from person_table where col_1="##id";
# 如果里面含有##则替换动态参数，从global_var.ini里查出来
p = "(?<=##).+[^_##|\"]"
if "##" in data:
# value = data.split("##")[1].split("\"")[0]
value_list = re.findall(p, data)
for value in value_list:
data = data.replace("##{}".format(value),
self.read_i.get_value(value))
return data
def rand_num(self):
return random.randint(10000001, 100000000)
def rand_str(self):
return ''.join(
random.sample(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
10))
def get_file(self):
params = self.get_params()
if params and settings.FILE in params:
# return json.dumps(params[settings.FILE])
params[settings.FILE][settings.FILE] = eval(
params[settings.FILE][settings.FILE])
return 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_save_value(self):
return self.db_data and self.db_data[settings.SAVE_VALUE]
def get_post_action(self):
if self.db_data and settings.POST_ACTION in self.db_data:
post_action = self.db_data[settings.POST_ACTION]
if post_action:
post_action_list = post_action.split("|")
return post_action_list
return None
def get_post_params(self):
if self.db_data and settings.POST_PARAMS in 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_randnum(
json.loads(post_params))
else:
post_params_list[i] = json.loads(post_params)
return post_params_list
return None
def replace_true(self, data):
if isinstance(data, dict):
for key, value in data.items():
if "true" == value:
data[key] = True
if isinstance(value, list):
for num, item in enumerate(value):
value[num] = self.replace_true(item)
if isinstance(value, dict):
data[key] = self.replace_true(value)
return data
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
# def get_expect_for_other_before(self):
# if self.db_data and self.db_data[settings.EXPECT]:
# expect = self.db_data[settings.EXPECT]
# # 如果有多个参数，比如前面是预期的接口返回结果，后面是文件是否存在（希望文件不存在的可以标注not=文件名）
# expect_list = expect.split("|")
# if len(expect_list) == 2:
# # 如果不希望文件存在呢，则在文件前面加-
# expect = expect_list[1].split("-")
# if len(expect) == 1:
# file_name = expect[0]
# else:
# file_name = expect[1]
# # n = do_telnet("ls {}\n".format(file_name))
# count = re.findall(settings.FILE_COUNT_RE,n)[-1]
# self.read_i.write_data("file_count_before",count)
def get_expect_for_other(self):
if self.db_data and self.db_data[settings.EXPECT]:
expect = self.db_data[settings.EXPECT]
# 如果有多个参数，比如前面是预期的接口返回结果，后面是文件是否存在（希望文件不存在的可以标注-）
expect_list = expect.split("|")
if "{" in expect_list[0]:
if "##" in expect_list[0]:
# 如果里面有需要替换的动态变量，才去走替换函数，提高性能，否则每次不管有没有要替换的变量，都要去递归判断每个变量是否需要替换，接口比较多的话会耗时多
expect_list[0] = self.replace_randnum(
json.loads(expect_list[0]))
else:
expect_list[0] = json.loads(expect_list[0])
if "true" in json.dumps(expect_list[0]):
expect_list[0] = self.replace_true(expect_list[0])
if len(expect_list) == 2:
expect_list[1] = self.replace_randnum_for_str(expect_list[1])
# 如果不希望文件存在呢，则在文件前面加-
expect_list[1] = expect_list[1].split("-")
print("预期结果： " + str(expect_list))
return expect_list
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 __init__(self, data):
self.db = OperationDB()
self.data = data
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, )
