def main():
"""Call when data_collector starts."""
# Setup the configuration and mongo connection
Config.init_logging(log)
mongo = Mongo.connect(log, Config.MONGO_URI)
# Populate database with known berths if not already there
if mongo is not None and "BERTHS" not in mongo.collections():
log.info("Loading known berths into database")
with open("./berths.json") as berths_file:
berths_data = json.load(berths_file)
for key, set_data in berths_data.items():
mongo.update("BERTHS", {"NAME": key}, {"$set": set_data})
# Setup the STOMP national rail data feed collector and connect
feeds = []
if Config.COLLECTOR_PPM:
feeds.append(Feeds.PPM)
if Config.COLLECTOR_TD:
feeds.append(Feeds.TD)
if Config.COLLECTOR_TM:
feeds.append(Feeds.TM)
collector = STOMPCollector(
mongo,
feeds,
Config.COLLECTOR_ATTEMPTS,
Config.COLLECTOR_NR_USER,
Config.COLLECTOR_NR_PASS,
)
collector.start()
# Infinite loop
while 1:
time.sleep(30)
def main():
"""Call when graph_generator starts."""
# Setup signal handlers
signal.signal(signal.SIGINT, exit_handler)
signal.signal(signal.SIGTERM, exit_handler)
# Setup the configuration and mongo connection
Config.init_logging(log)
mongo = Mongo.connect(log, Config.MONGO_URI)
if mongo is None:
raise ConnectionError
# Create the graph generator
gen = GraphGenerator(
log,
mongo,
Config.GENERATOR_K,
Config.GENERATOR_ITER,
Config.GENERATOR_CUT_D,
Config.GENERATOR_SCALE,
Config.GENERATOR_DELTA_B,
Config.GENERATOR_DELTA_T,
)
# Run the graph generator in a loop, run every GRAPH_UPDATE_RATE seconds
while 1:
gen.run()
time.sleep(Config.GENERATOR_RATE)
def create_dash(server):
"""Create the Dash instance for this application.
Args:
server (flask.Flask): flask application
Returns:
dash.Dash: dash application
"""
app = Dash(
name=__package__,
server=server,
suppress_callback_exceptions=True,
external_stylesheets=[dbc.themes.LUX],
)
# Initialise logging
Config.init_logging(app.logger)
server.logger.removeHandler(app.logger.handlers[0])
# Initialise the mongo database
app.mongo = Mongo.connect(app.logger, app.server.config["MONGO_URI"])
# Update the Flask config a default "TITLE" and then with any new Dash
# configuration parameters that might have been updated so that we can
# access Dash config easily from anywhere in the project with Flask's
# 'current_app'
server.config.setdefault("TITLE", "Dash")
# Set the app name
app.title = "thetrains"
return app
class Service:
def __init__(self):
self.db = Mongo()
def execute(self, commands):
'''
getattr
:param commands:
:return:
'''
print('commands的值是', commands)
# 关键字库进行实例化
element = None
kw = KeyWord() # 对象
for command in commands:
element = getattr(kw, command['command'])(element,
command['parameter'])
# 加个等待，代码更稳定
time.sleep(3)
kw.base_quit_driver()
def save(self, data):
'''
保存功能
:return:
'''
data.setdefault('_id', get_case_id())
return self.db.insert('automation', 'cases', data)
class Service:
def __init__(self):
self.db = Mongo()
def execute(self, commands):
# 给el一个初始值
try:
element = None
kw = KeyWord()
# func = getattr(kw,函数的名字(command对应的命令))
for command in commands:
element = getattr(kw, command['command'])(element, command['parameter'])
# 需要加一个等待，否则代码运行的快，页面上有些操作可能不能顺利完成
time.sleep(3)
kw.base_quit_driver()
# 运行结果是成功还是失败
return True
except:
return False
def save(self,data):
data.setdefault('_id',get_case_id())
return self.db.insert('automation', 'cases', data)
def trigger(self,data):
'''
1.查询数据库 commands
2.execute这个函数
'''
filter = {'_id':data.get('id')}
cases = self.db.search('automation','cases', filter)
for case in cases:
result = self.execute(case['commands'])
report = {
'_id':get_case_id(),
'case_id':case['_id'],
'case_name':case['casename'],
'result':result
}
self.db.insert('automation', 'report', report)
def __init__(self):
self.mongo = Mongo()
def __init__(self):
# 实例化mongo数据的对象
self.db = Mongo()
class Service:
def __init__(self):
# 实例化mongo数据的对象
self.db = Mongo()
# 发起请求，获取响应
def make_request(self, data):
'''
主要把前端收集过来的数据进行处理，然后发起请求，把响应返回给前端
核心函数：requests.request()
:param data: 前端传递过来的数据
:return: response 响应返回去
'''
# 获取method
method = data.get('method')
# 获取url的值
url = data.get('url')
# 收集参数，cookies，...
kwargs = {}
# 对header做校验
if 'header' in data and data.get('header') != {
'': ''
} and data.get('header'):
kwargs['headers'] = data['header']
# 对params做校验
if 'params' in data and data.get('params') != {
'': ''
} and data.get('params'):
kwargs['params'] = data['params']
# 对data做校验
if 'data' in data and data.get('data') != {
'': ''
} and data.get('data'):
kwargs['data'] = data['data']
# 对json做校验--参数数据结构 字典
if data.get('json'):
kwargs['json'] = json.loads(data['json'])
print('kwargs的值是', kwargs)
response = requests.request(method, url, **kwargs)
# 如果响应值是字符串的，那么resp.json()就会报错，.text进行解析
try:
content = response.json()
except:
content = response.text
data['response'] = {
'code': response.status_code, # 获取状态码
'json': content # 获取json数据
}
print('发送请求之后的data数据是', data)
# requests.request()
return data
def save_cases(self, data):
'''
把前端收集到的data数据保存到数据库中,insert
:param data:
:return: insert_id
'''
case_id = get_case_id()
# 把_id放到data数据中
data.setdefault('_id', case_id)
# 把data数据插入到mongo数据库中
id = self.db.insert('interface', 'cases', data)
return id
def make_assert(self, data):
'''
{
"code": "0",
"data": {
"brand": "testfan",
"price": "804",
"skuId": 1,
"skuName": "ptest-1",
"stock": 367
},
"message": "success"
}
usage:
表达式 预期值
data.brand testfan
data.cross_list.0.name 联谊路--绿溪路
做比较的时候：反射 运行结果=getattr(对象，method)(参数1，参数2)
解析表达式
:param data:
:return:
'''
# 实例化一个做比较的对象
compare = Compare()
# 获取各个参数，并解析表达式
for expr in data['assert']:
# 预期值
expect = expr['expected']
# 预期条件
condition = expr['condition']
# 来源
source = expr['source']
# 对状态码进行断言
if source == 'code':
# tmp 代表的 实际的值
tmp = str(data['response']['code'])
else: # 隐藏的含义对body进行断言
# 实际运行的响应体内容是什么？
tmp = data['response']['json']
for item in expr['expression'].split('.'):
print('item的值是{},数据类型是{}'.format(item, type(item)))
# try:
# # 能走通 证明关键字就是字符串
# tmp=tmp[item]
# except:
# # 报错的话，证明这个item是个列表的索引值
# tmp = tmp[int(item)]
if isinstance(item, str):
tmp = tmp[item]
elif isinstance(item, int):
tmp = tmp[int(item)]
# 实际结果跟预期结果做比较，获取最终的值
result = getattr(compare, condition)(tmp, expect)
# 把我们的result的结果放到expr这个表达式中
expr.setdefault('result', result)
return data
def team_and_project(self, data):
'''
找出variable里面出现的所有的team和project
去重
:param data:
:return: menu {'产品部':[project1,project2..],'质量部':[,,]}
'''
menu = {}
# 把所有的数据都需要返回过来
filter = {'page': 0, 'limit': 0}
results = self.db.search('variable', 'variable', filter)
for result in results:
# 判断一下team这个键是否在result这个字典中，如果不在就追加字典
if result['team'] not in menu:
menu.setdefault(result['team'], [result['project']])
# key in dict dict【key】追加project
else:
menu[result['team']].append(result['project'])
# todo 键是唯一 team 但是project是列表，需要去重
for team in menu:
# 取出所有值，然后去重 之前值=去重之后的值
menu[team] = list(set(menu[team]))
print('menu的值是', menu)
return menu
# 替换变量
def replace_variable(self, data):
'''
对变量进行解析
变量的使用：{ip}
:param data:
:return: 解析之后的data数据
'''
# 过滤条件，然后把所有的变量和值查询出来
filter = {'team': data.get('team'), 'project': data.get('project')}
results = self.db.search('variable', 'variable', filter) #[{},{}]
print('results的值是', results)
# 把data里面包含的数据提取出来，然后把这些数据跟results的进行比对，解析
if 'url' in data:
# {pinter_ip} / pinter / com / getSku
# todo
data['url'] = derivation(data['url'], results)
if 'header' in data:
for key in data['header']:
data['header'][key] = derivation(data['header'][key], results)
if 'params' in data:
for key in data['params']:
data['params'][key] = derivation(data['params'][key], results)
if 'data' in data:
for key in data['data']:
data['data'][key] = derivation(data['data'][key], results)
return data
def interface_list(self, data):
'''
接口列表页面提供数据来源
:return:
'''
data = self.db.search('interface', 'cases', data)
return data
def delete(self, data):
'''
实现删除功能
:param data:
:return:
'''
id_list = data.get('id_list')
filter = {'_id': id_list}
count = self.db.delete('interface', 'cases', filter)
return count
def interface_search(self, data):
'''
编辑页面提供id接口的查询
:param data:
:return:
'''
filter = {'_id': data.get('id')}
data = self.db.search('interface', 'cases', filter)
return data
def interface_update(self, data):
'''
对接口的数据进行更新
:param data:
:return:
'''
update_id = self.db.update('interface', 'cases',
{'_id': data.get('id')}, data)
return update_id
def save_suite(self, data):
'''
把套件内容保存到interface-suite表中
:return:
'''
data.setdefault('_id', get_case_id())
result = self.db.insert('interface', 'suite', data)
return result
def suite_list(self, data):
'''
套件页面给table表格提供数据的接口
:param data:
:return:
'''
print('suite_list的data值是{}'.format(data))
result = self.db.search('interface', 'suite', data)
return result
def suite_delete(self, data):
'''
套件删除
:param data:
:return:
'''
filter = {'_id': data.get('id')}
result = self.db.delete('interface', 'suite', filter)
return result
def trigger(self, data):
'''
实现套件的运行
:param data:
:return:
'''
print('data的值是{}'.format(data))
filter = {'_id': data.get("id")}
# 通过filter查询到套件的信息
suite = self.db.search('interface', 'suite', filter)
print('suite的值是{}'.format(suite))
if not suite:
return filter['_id']
# 定义一个变量，result->insert report表中的信息
result = {
'_id': get_case_id(),
'team': suite[0]['team'],
'project': suite[0]['project'],
# 包含case+response的详细信息
'result': []
}
for case_id in suite[0]["cases"]:
# 通过case_id去cases这个表中查询详细的接口信息
case = self.db.search('interface', 'cases', {'_id': case_id})
print('case的值是{}'.format(case))
# 调用一个运行接口用例的方法
case = self.run(case[0])
#todo 想把case放到report这个表中
result['result'].append(case)
# 把result保存到report表中
self.db.insert('interface', 'report', result)
# 返回一个报告的id值
return result['_id']
def __init__(self):
self.db = Mongo()
g.data = []
class Service:
def __init__(self):
self.db = Mongo()
g.data = []
def make_request(self, data):
'''
发起请求，获取响应
:param data: 获取的参数值
:return: 响应值
'''
method = data.get('method')
url = data.get('url')
kwargs = {}
# 对http请求头信息做校验
if 'header' in data and data.get('header') != {
'': ''
} and data.get('header'):
kwargs['header'] = data['header']
# 对http的参数做校验
if 'params' in data and data.get('params'):
kwargs['params'] = data['params']
if 'form_data' in data and data.get('form_data'):
kwargs['data'] = data['form_data']
if 'json_data' in data and data.get('json_data'):
kwargs['json'] = data['json_data']
response = requests.request(method=method, url=url, **kwargs)
# print(response)
# print(response.status_code)
# print(response.json())
# return response.json()
data['response'] = {
'code': response.status_code,
'json': response.json()
}
return data
@staticmethod
def make_assert(data):
compare = Compare()
for expr in data['assert']:
# 预期值
expect = expr['expected']
# 获取条件
func = expr['condition']
if expr['source'] == 'code':
# 实际结果
tmp = str(data['response']['code'])
else:
# 响应-保存到一个便令tmp
tmp = data['response']['json']
# 对响应体对判断，开始进行分隔符处理 字符串->列表
for item in expr['expression'].split('.'):
# 如果报错 就证明 item是int值索引
try:
tmp = tmp[item]
except:
tmp = tmp[int(item)]
# print(tmp)
# 取数据结束->断言处理 真假 反射 def eqls(self,actual,expected):
result = getattr(compare, func)(tmp, expect)
#把断言结果放在data里面，然后在传给前端。
expr.setdefault('result', result)
return data
# 替换变量
def execute_snippet(self, data):
'''
执行关键字函数的代码，得到返回值，替换掉参数当中的关键字
:param data:
:return:
'''
# 查库，把关键字表当中的信息查询出来
results = self.db.search('variable', 'keyword', {})
# 对传进来的参数进行一个处理：首先判断有没有关键字参数，有的做一个替换
result = evaluation(data['params'], results)
data['params']['sign'] = result
return data
def replace_variable(self, data):
'''
:param data:
:return:
'''
filter = {'team': data.get('team'), 'project': data.get('project')}
# 列表-想拓展这个列表 extend([])
results = self.db.search('variable', 'variable', filter)
# todo 把那个提取出来的参数对应的值，从这个位置加入到变量库当中
results.extend(g.data)
if 'url' in data:
data['url'] = derivation(data['url'], results)
if 'header' in data:
for key in data['header']:
data['header'][key] = derivation(data['header'][key], results)
if 'params' in data:
for key in data['params']:
data['params'][key] = derivation(data['params'][key], results)
return data
def extract_parameter(self, data):
'''
:param data:
:return:
'''
# 'extract': [{'expression': 'data.adcode', 'expected': 'sid'}]
print(data)
if 'extract' not in data or not data['extract']:
return data
for extract in data['extract']:
expr = extract['expression']
# name=sid 值是多少？？？
name = extract['expected']
tmp = data['response']['json']
for item in expr.split('.'):
try:
tmp = tmp[int(item)]
except:
# name的值就是tmp 320583
# {'name':name,'value':tmp}
# [{'name':name,'value':tmp}]
# 2.sid = 320583 应在存在哪里 flask中 g 接口 请求 响应
# 发起请求g产生，请求完成（获取响应）g就会销毁 g的数据格式是字典
# 1.如何在请求之前替换第二个接口的参数
tmp = tmp[item]
g.data.append({'name': name, 'value': tmp})
return data
# 核心
def run(self, data):
'''
统一运行接口用例的方法，你以后对请求有什么特殊函数方法的添加，
直接写在这里面就可以了
:param data:
:return:
'''
data = self.replace_variable(data)
data = self.execute_snippet(data)
data = self.make_request(data)
data = self.make_assert(data)
data = self.extract_parameter(data)
return data
def save_cases(self, data):
'''
:param data:
:return:
'''
# 构造_id 原则-唯一的，不重复
case_id = get_case_id()
# 然后_id放到data里面去
data.setdefault('_id', case_id)
# 把data数据保存到数据库
id = self.db.insert('interface', 'cases', data)
return id
def interface_team_and_project(self):
'''
查库:查的是哪一个库，哪一个表
返回的数据结构data {'team1':[project1,project1],'team2':[project1,project2...]}
:return:
'''
menu = {}
# 把有的数据都给我返回过来
filter = {'page': 0, 'limit': 0}
results = self.db.search('variable', 'variable', filter)
# print(results)
# 遍历results，然后构造最终我们想要的data数据
for result in results:
if result['team'] not in menu:
menu.setdefault(result['team'], [result['project']])
else:
menu[result['team']].append(result['project'])
# set 循环遍历menu里面的key，然后去重他的值
for team in menu:
# 修改值 之前的值=去重之后的值
menu[team] = list(set(menu[team]))
return menu
def interface_list(self, data):
'''
:return:
'''
data = self.db.search('interface', 'cases', data)
return data
def interface_delete(self, data):
'''
:param data:
:return:
'''
count, id_list = 0, data.get('id_list')
for id in id_list:
filter = {'_id': id}
result = self.db.delete('interface', 'cases', filter)
count += result
return count
def interface_search(self, data):
'''
:param data:
:return:
'''
filter = {'_id': data.get('id')}
data = self.db.search('interface', 'cases', filter)
return data
def interface_update(self, data):
'''
:param data:
:return:
'''
filter = {'_id': data.get('id')}
data = self.db.update('interface', 'cases', filter, data)
return data
def save_suite(self, data):
'''
:return:
'''
data.setdefault('_id', get_case_id())
result = self.db.insert('interface', 'suite', data)
return result
def suite_list(self, data):
'''
:param data:
:return:
'''
result = self.db.search('interface', 'suite', data)
return result
def suite_delete(self, data):
'''
:param data:
:return:
'''
count, id_list = 0, data.get('id_list')
for id in id_list:
filter = {'_id': id}
result = self.db.delete('interface', 'suite', filter)
count += result
return count
def trigger(self, data):
'''
:param data:
:return:
'''
filter = {'_id': data.get('id')}
# suite是列表
suite = self.db.search('interface', 'suite', filter)
print('suite的值是', suite)
if not suite:
return filter['_id']
# 为了把运行接口放在report这个库里面,所以在这个位置定义一个储存数据的容器
result = {
'_id': get_case_id(),
'team': suite[0]['team'],
'project': suite[0]['project'],
'result': []
}
for case_id in suite[0]['cases']:
# case是列表
case = self.db.search('interface', 'cases', {'_id': case_id})
# 调用一个运行接口用例的方法
case = self.run(case[0])
result['result'].append(case)
self.db.insert('interface', 'report', result)
return result['_id']
def __init__(self):
self.db = Mongo()