def sql(step):
result = {}
element = step['element']
_sql = e.get(element)[1]
logger.info('SQL: %s' % repr(_sql))
# 获取连接参数
value = e.get(step['page'] + '-' + 'config')[1]
arg = data_format(value)
if step['page'] not in g.db.keys():
g.db[step['page']] = DB(arg)
if _sql.lower().startswith('select'):
row = g.db[step['page']].fetchone(_sql)
logger.info('SQL result: %s' % repr(row))
if not row:
raise Exception('*** Fetch None ***')
elif _sql.lower().startswith('db.'):
_sql_ = _sql.split('.', 2)
collection = _sql_[1]
sql = _sql_[2]
row = g.db[step['page']].mongo(collection, sql)
if sql.startswith('find'):
result = row
logger.info('keys result: %s' % repr(result))
else:
g.db[step['page']].execute(_sql)
if _sql.lower().startswith('select'):
text = _sql[6:].split('FROM')[0].split('from')[0].strip()
keys = dedup(text).split(',')
for i, k in enumerate(keys):
keys[i] = k.split(' ')[-1]
result = dict(zip(keys, row))
logger.info('keys result: %s' % repr(result))
data = step['data']
if not data:
data = step['expected']
if data:
for key in data:
sv, pv = data[key], result[key]
logger.info('key: %s, expect: %s, real: %s' %
(repr(key), repr(sv), repr(pv)))
compare(sv, pv)
output = step['output']
if output:
_output = {}
for key in output:
_output[key] = result[output[key]]
g.var[key] = result[output[key]]
logger.info('output: %s' % repr(_output))
def sql(step):
element = step['element']
el, _sql = e.get(element)
logger.info('SQL: %s' % repr(_sql))
# 获取连接参数
el, value = e.get(step['page'] + '-' + 'config')
arg = data_format(value)
if step['page'] not in g.db.keys():
g.db[step['page']] = DB(arg)
if _sql.lower().startswith('select'):
row = g.db[step['page']].fetchone(_sql)
logger.info('SQL result: %s' % repr(row))
if not row:
raise Exception('*** Fetch None ***')
else:
g.db[step['page']].execute(_sql)
result = {}
if _sql.lower().startswith('select'):
keys = _sql[6:].split('FROM')[0].split('from')[0].strip().split(',')
for i, k in enumerate(keys):
keys[i] = k.split(' ')[-1]
result = dict(zip(keys, row))
logger.info('keys result: %s' % repr(result))
data = step['data']
if not data:
data = step['expected']
if data:
for key in data:
logger.info('key: %s, expect: %s, real: %s' %
(repr(key), repr(data[key]), repr(result[key])))
if data[key].startswith('*'):
assert data[key][1:] in result[key]
else:
assert data[key] == result[key]
output = step['output']
if output:
logger.info('output: %s' % repr(output))
for key in output:
g.var[key] = result[output[key]]
def execute(step):
# 先执行赋值操作
data = step['data']
for k, v in data.items():
g.var[k] = v
from sweetest.testcase import TestCase
element = step['element']
times = 1
_element = element.split('*')
# snippet 执行失败是否退出标准
flag = True
if element[-1] == '*':
flag = False
if len(_element) >= 2:
element = _element[0]
times = int(_element[1])
steps = []
if element != '变量赋值':
for t in range(times):
if t > 0:
_data = data_format(str(step['_data']))
replace_dict(_data)
for k, v in _data.items():
g.var[k] = v
testcase = deepcopy(g.snippet[element])
tc = TestCase(testcase)
tc.run()
for s in testcase['steps']:
s['no'] = str(t + 1) + '-' + str(s['no'])
steps += testcase['steps']
if testcase['result'] != 'Pass':
if flag:
return steps
return steps
def sql(step):
response = {}
element = step['element']
_sql = e.get(element)[1]
logger.info('SQL: %s' % repr(_sql))
# 获取连接参数
value = e.get(step['page'] + '-' + 'config')[1]
arg = data_format(value)
if step['page'] not in g.db.keys():
g.db[step['page']] = DB(arg)
if _sql.lower().startswith('select'):
row = g.db[step['page']].fetchone(_sql)
logger.info('SQL response: %s' % repr(row))
if not row:
raise Exception('*** Fetch None ***')
elif _sql.lower().startswith('db.'):
_sql_ = _sql.split('.', 2)
collection = _sql_[1]
sql = _sql_[2]
response = g.db[step['page']].mongo(collection, sql)
if response:
logger.info('find result: %s' % repr(response))
else:
g.db[step['page']].execute(_sql)
if _sql.lower().startswith('select'):
text = _sql[6:].split('FROM')[0].split('from')[0].strip()
keys = dedup(text).split(',')
for i, k in enumerate(keys):
keys[i] = k.split(' ')[-1]
response = dict(zip(keys, row))
logger.info('select result: %s' % repr(response))
expected = step['data']
if not expected:
expected = step['expected']
if 'json' in expected:
expected['json'] = json2dict(expected.get('json', '{}'))
result = check(expected.pop('json'), response['json'])
logger.info('json check result: %s' % result)
if result['code'] != 0:
raise Exception(f'json | EXPECTED:{repr(expected["json"])}, REAL:{repr(response["json"])}, RESULT: {result}')
elif result['var']:
var = dict(var, **result['var'])
g.var = dict(g.var, **result['var'])
logger.info('json var: %s' % (repr(result['var'])))
if expected:
for key in expected:
sv, pv = expected[key], response[key]
logger.info('key: %s, expect: %s, real: %s' %
(repr(key), repr(sv), repr(pv)))
compare(sv, pv)
output = step['output']
if output:
_output = {}
for k, v in output.items():
if k == 'json':
sub = json2dict(output.get('json', '{}'))
result = check(sub, response['json'])
# logger.info('Compare json result: %s' % result)
var = dict(var, **result['var'])
g.var = dict(g.var, **result['var'])
logger.info('json var: %s' % (repr(result['var'])))
else:
_output[k] = response[v]
g.var[k] = response[v]
logger.info('output: %s' % repr(_output))
def execute(step):
# 先处理循环结束条件
condition = ''
for k in ('循环结束条件', 'condition', '#break'):
if step['data'].get(k):
condition = step['data'].get(k)
del step['data'][k]
if condition.lower() in ('成功', 'success'):
condition = 'success'
elif condition.lower() in ('失败', 'failure'):
condition = 'failure'
# 执行赋值操作
data = step['data']
for k, v in data.items():
g.var[k] = v
from sweetest.testcase import TestCase
element = step['element']
times = 1
_element = element.split('*')
# snippet 执行失败是否退出标志
flag = True
if element[-1] == '*':
flag = False
if len(_element) >= 2:
element = _element[0]
if _element[1].upper() == 'N':
times = 999
else:
times = int(_element[1])
# 初始化测试片段执行结果
result = 'success'
steps = []
if step['page'] in ('用例片段', 'SNIPPET'):
g.var['_last_'] = False
for t in range(times):
if t > 0:
_data = data_format(str(step['_data']))
replace_dict(_data)
for k, v in _data.items():
g.var[k] = v
testcase = deepcopy(g.snippet[element])
tc = TestCase(testcase)
tc.run()
for s in testcase['steps']:
s['no'] = str(step['no']) + '*' + \
str(t + 1) + '-' + str(s['no'])
steps += testcase['steps']
# 用例片段执行失败时
if testcase['result'] != 'success':
result = testcase['result']
# 循环退出条件为失败，则直接返回，返回结果是 success
if condition == 'failure':
return 'success', testcase['steps']
# 如果没有结束条件，且直接退出标志位为真，则返回结果
if not condition and flag:
return result, steps
# 用例片段执行成功时
else:
# 如果循环退出条件是成功，则直接返回，返回结果是 success
if condition == 'success':
return 'success', testcase['steps']
if g.var['_last_']:
g.var['_last_'] = False
break
# 执行结束，还没有触发循环退出条件，则返回结果为 failure
if condition:
return 'failure', testcase['steps']
elif step['page'] in ('用例组合', 'CASESET'):
caseset = element
for t in range(times):
if t > 0:
_data = data_format(str(step['_data']))
replace_dict(_data)
for k, v in _data.items():
g.var[k] = v
for testcase in g.caseset[caseset]:
testcase = deepcopy(testcase)
testcase['flag'] = ''
g.ts.run_testcase(testcase)
g.casesets.append(testcase)
# if testcase['result'] != 'success':
# result = testcase['result']
return result, steps
def execute(step):
# 先处理循环结束条件
condition = ''
for k in ('循环结束条件', 'condition'):
if step['data'].get(k):
condition = step['data'].get(k)
del step['data'][k]
if condition.lower() in ('成功', 'success'):
condition = 'success'
elif condition.lower() in ('失败', 'failure'):
condition = 'failure'
# 执行赋值操作
data = step['data']
for k, v in data.items():
g.var[k] = v
from sweetest.testcase import TestCase
element = step['element']
times = 1
_element = element.split('*')
# snippet 执行失败是否退出标志
flag = True
if element[-1] == '*':
flag = False
if len(_element) >= 2:
element = _element[0]
times = int(_element[1])
# 初始化测试片段执行结果
result = 'success'
steps = []
if element != '变量赋值':
for t in range(times):
if t > 0:
_data = data_format(str(step['_data']))
replace_dict(_data)
for k, v in _data.items():
g.var[k] = v
testcase = deepcopy(g.snippet[element])
tc = TestCase(testcase)
tc.run()
for s in testcase['steps']:
s['no'] = str(step['no']) + '*' + \
str(t + 1) + '-' + str(s['no'])
steps += testcase['steps']
# 用例片段执行失败时
if testcase['result'] != 'success':
result = testcase['result']
# 循环退出条件为失败，则直接返回，返回结果是 success
if condition == 'failure':
return 'success', testcase['steps']
# 如果没有结束条件，且失败直接退出标志位真，则返回结果
if not condition and flag:
return result, steps
# 用例片段执行成功时
else:
# 如果循环退出条件是成功，则直接返回，返回结果是 success
if condition == 'success':
return 'success', testcase['steps']
# 执行结束，还没有触发循环退出条件，则返回结果为 failure
if condition:
return 'failure', testcase['steps']
return result, steps
def execute(step):
# 先处理循环结束条件
condition = ''
for k in ('循环结束条件', 'condition'):
if step['data'].get(k):
condition = step['data'].get(k)
del step['data'][k]
if condition.lower() in ('成功', 'pass'):
condition = 'Pass'
elif condition.lower() in ('失败', 'fail'):
condition = 'Fail'
# 执行赋值操作
data = step['data']
for k, v in data.items():
if '|' in v:
g.var[k] = v.split('|')
else:
g.var[k] = v
from sweetest.testcase import TestCase
element = step['element']
times = 1
_element = element.split('*')
# snippet 执行失败是否退出标志
flag = True
if element[-1] == '*':
flag = False
# date_loop=False #按照数据循环执行用例片段
if len(_element) >= 2:
element = _element[0]
try:
times = int(_element[1])
except ValueError:
# 处理用例片段按值循环
newdata_dic = step['data']
for k, v in newdata_dic.items():
n = len(v) if isinstance(v, list) else 0
if n > times:
times = n
break
# 初始化测试片段执行结果
result = 'Pass'
steps = []
# if element != '变量赋值':
for t in range(times):
if t > 0:
_data = data_format(str(step['_data']))
replace_dict(_data)
for k, v in _data.items():
g.var[k] = v
testcase = deepcopy(g.snippet[element])
# if date_loop:
# for step in testcase['steps']
# step['element'] = replace(step['element'])
# testcase['step']['data']=newdata_dic
# testcase['step']['data'][list_key]=newdata_dic[list_key][t]
tc = TestCase(testcase)
tc.run()
for s in testcase['steps']:
s['no'] = str(step['no']) + '*' + str(t + 1) + '-' + str(s['no'])
steps += testcase['steps']
# 用例片段执行失败时
if testcase['result'] != 'Pass':
result = testcase['result']
# 循环退出条件为失败，则直接返回，返回结果是 Pass
if condition == 'Fail':
return 'Pass', testcase['steps']
# 如果没有结束条件，且失败直接退出标志位真，则返回结果
if not condition and flag:
return result, steps
# 用例片段执行成功时
else:
# 如果循环退出条件是成功，则直接返回，返回结果是 Pass
if condition == 'Pass':
return 'Pass', testcase['steps']
# 执行结束，还没有触发循环退出条件，则返回结果为 Fail
if condition:
return 'Fail', testcase['steps']
return result, steps
def sql(step):
element = step['element']
el, _sql = e.get(element)
logger.info('SQL: %s' % repr(_sql))
# 获取连接参数
el, value = e.get(step['page'] + '-' + 'config')
arg = data_format(value)
if step['page'] not in g.db.keys():
g.db[step['page']] = DB(arg)
if _sql.lower().startswith('select'):
row = g.db[step['page']].fetchone(_sql)
logger.info('SQL result: %s' % repr(row))
if not row:
raise Exception('*** Fetch None ***')
else:
g.db[step['page']].execute(_sql)
result = {}
if _sql.lower().startswith('select'):
keys = _sql[6:].split('FROM')[0].split('from')[0].strip().split(',')
for i, k in enumerate(keys):
keys[i] = k.split(' ')[-1]
result = dict(zip(keys, row))
logger.info('keys result: %s' % repr(result))
data = step['data']
if not data:
data = step['expected']
if data:
for key in data:
sv, pv = data[key], result[key]
logger.info('key: %s, expect: %s, real: %s' %
(repr(key), repr(sv), repr(pv)))
compare(sv, pv)
# if isinstance(sv, str):
#
# if sv.startswith('#'):
# assert sv[1:] != str(pv)
#
# assert isinstance(pv, str)
#
# if sv.startswith('*'):
# assert sv[1:] in pv
#
# elif sv.startswith('^'):
# assert pv.startswith(sv[1:])
#
# elif sv.startswith('$'):
# assert pv.endswith(sv[1:])
#
# elif sv.startswith('\\'):
# sv = sv[1:]
#
# assert sv == pv
#
# elif isinstance(sv, int):
# assert isinstance(pv, int)
# assert sv == pv
#
# elif isinstance(sv, float):
# assert absisinstance(pv, float)
# assert sv == pv
#
# else:
# assert sv == pv
output = step['output']
if output:
logger.info('output: %s' % repr(output))
for key in output:
g.var[key] = result[output[key]]
