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, )