from flask.testing import FlaskClient
from tests.test_base import check_blueprints
from werkzeug.datastructures import ImmutableMultiDict
from eNMS.functions import fetch_all
netmiko_ping = ImmutableMultiDict([
("name", "netmiko_ping"),
("waiting_time", "0"),
("devices", "1"),
("devices", "2"),
("description", ""),
("vendor", ""),
("operating_system", ""),
("content_type", "simple"),
("content", "ping 1.1.1.1"),
("netmiko_type", "show_commands"),
("driver", "cisco_xr_ssh"),
("global_delay_factor", "1.0"),
])
file_transfer_service = ImmutableMultiDict([
("name", "test"),
("waiting_time", "0"),
("devices", "1"),
("devices", "2"),
("description", ""),
("vendor", ""),
("operating_system", ""),
("driver", "cisco_ios"),
("source_file", "path/to/source"),
args.model_name,
useGPU,
Environment,
gpuNum=gpuNum)
while True:
data = dataQueue.get()
nnetResult = nnet(data)
resQueue.put(nnetResult)
if __name__ == "__main__":
# ---------processing state
data = ImmutableMultiDict([
('state',
'[8, 10, 36, 3, 4, 12, 27, 34, 53, 9, 5, 0, 46, 13, 19, 11, 30,\
2, 18, 52, 15, 41, 22, 21, 47, 1, 35, 44, 7, 17, 16, 31, 37, 24,\
48, 29, 45, 14, 6, 25, 40, 39, 42, 28, 33, 26, 23, 38, 43, 49, 50,\
20, 32, 51]')
])
data = ImmutableMultiDict([(
'state',
'51, 32, 26, 30, 4, 3, 2, 19, 36, 9, 39, 29, 28, 13, 14, 38, 5, 45, 27, 16, 44, 21, 22, 46, 8, 52, 42, 15, 50, 47, 23, 31, 34, 6, 48, 11, 35, 41, 24, 10, 40, 37, 17, 7, 0, 20, 43, 33, 25, 49, 1, 18, 12, 53'
)])
data = data.to_dict()
arr = []
data['state'] = ast.literal_eval(data['state'])
print(data['state'])
for i in data['state']:
arr.append(int(i))
def test_connect_true_and_customer_id(self):
""" Test connect customer to account (true) and if correct customer id. """
imd = ImmutableMultiDict([('account', '2'), ('person', 'and')])
self.assertTrue(self.bank.connect(imd))
self.assertTrue("and" in self.bank.accounts[1].holders)
self.assertIn("and", self.bank.accounts[1].holders)
def test_query_list_deserialize_items():
schema = EnumQueryStringListSchema()
result = schema.load(ImmutableMultiDict([("foo_ids", "A,B")]), )
assert_that(result.data["foo_ids"], is_(equal_to([TestEnum.A,
TestEnum.B])))
from conftest import path_scripts
from os.path import join
from tasks.models import Task
from test_base import check_blueprints
from test_objects import create_from_file
from test_scripts import netmiko_ping, napalm_jinja2_script
from werkzeug.datastructures import ImmutableMultiDict
instant_task = ImmutableMultiDict([
('name', 'instant_task'),
('scripts', 'napalm_subif'),
('scripts', 'netmiko_ping'),
('start_date', ''),
('end_date', ''),
('frequency', ''),
('script', '')
])
scheduled_task = ImmutableMultiDict([
('name', 'scheduled_task'),
('scripts', 'napalm_subif'),
('scripts', 'netmiko_ping'),
('start_date', '30/03/2018 19:10:13'),
('end_date', '06/04/2018 19:10:13'),
('frequency', '3600'),
('script', '')
])
@check_blueprints('/views', '/tasks')
def updatesettings():
try:
something = request.form
imd = ImmutableMultiDict(something)
newdict = helpers.convert(imd)
# Query the first set of settings, could query custom settings for individual users
settings = Setting.query.filter_by(_id=1).first()
# Make sure we're updating the settings instead of overwriting them
if 'threatcrowd' in newdict.keys():
settings.threatcrowd = 'on'
else:
settings.threatcrowd = 'off'
if 'ptinfo' in newdict.keys() and newdict['ptkey'] is not '':
settings.ptinfo = 'on'
else:
settings.ptinfo = 'off'
if 'cuckoo' in newdict.keys():
settings.cuckoo = 'on'
else:
settings.cuckoo = 'off'
if 'vtinfo' in newdict.keys() and newdict['apikey'] is not '':
settings.vtinfo = 'on'
else:
settings.vtinfo = 'off'
if 'vtfile' in newdict.keys() and newdict['apikey'] is not '':
settings.vtfile = 'on'
else:
settings.vtfile = 'off'
if 'circlinfo' in newdict.keys() and newdict['circlusername'] is not '':
settings.circlinfo = 'on'
else:
settings.circlinfo = 'off'
if 'circlssl' in newdict.keys() and newdict['circlusername'] is not '':
settings.circlssl = 'on'
else:
settings.circlssl = 'off'
if 'whoisinfo' in newdict.keys():
settings.whoisinfo = 'on'
else:
settings.whoisinfo = 'off'
if 'farsightinfo' in newdict.keys() and newdict['farsightkey'] is not '':
settings.farsightinfo = 'on'
else:
settings.farsightinfo = 'off'
if 'shodaninfo' in newdict.keys() and newdict['shodankey'] is not '':
settings.shodaninfo = 'on'
else:
settings.shodaninfo = 'off'
if 'odnsinfo' in newdict.keys() and newdict['odnskey'] is not '':
settings.odnsinfo = 'on'
else:
settings.odnsinfo = 'off'
settings.farsightkey = newdict['farsightkey']
settings.apikey = newdict['apikey']
settings.odnskey = newdict['odnskey']
settings.httpproxy = newdict['httpproxy']
settings.httpsproxy = newdict['httpsproxy']
settings.cuckoohost = newdict['cuckoohost']
settings.cuckooapiport = newdict['cuckooapiport']
settings.circlusername = newdict['circlusername']
settings.circlpassword = newdict['circlpassword']
settings.ptkey = newdict['ptkey']
settings.shodankey = newdict['shodankey']
db_session.commit()
settings = Setting.query.first()
return render_template('settings.html', records=settings)
except Exception as e:
return render_template('error.html', error=e)
def hakem_kayit_kurum_disi(self):
"""Kurum dışı hakem kayıt için post methodunu karşılayan view"""
form = request.get_json()['kurum_disi']
imd = ImmutableMultiDict([(element['name'], element['value'])
for element in form])
kurum_disi_form = KurumDisiHakemKayitForm(imd)
if kurum_disi_form.validate():
try:
harici_hakem_ekli_mi = DB.session.query(Person).filter(
Person.birincil_eposta ==
kurum_disi_form.email.data).first()
if harici_hakem_ekli_mi:
return jsonify(
status="error",
error_message=
"İlgili eposta adresi başka bir kişi tarafından "
"kullanılmaktadır. Lütfen başka bir eposta "
"adresiyle tekrar deneyiniz!"), 500
user = User()
user.username = kurum_disi_form.email.data
user.password = random_pw()
user.email = kurum_disi_form.email.data
DB.session.add(user)
DB.session.flush()
person = Person()
person.ad = kurum_disi_form.ad.data
person.soyad = kurum_disi_form.soyad.data
person.birincil_eposta = kurum_disi_form.email.data
person.user_id = user.id
DB.session.add(person)
DB.session.flush()
hakem = Hakem()
hakem.unvan = kurum_disi_form.unvan.data
if kurum_disi_form.universitede_gorev_almayan.data:
hakem.kurum = kurum_disi_form.kurum.data
hakem.daire = kurum_disi_form.daire.data
hakem.birim = kurum_disi_form.birim.data
else:
hakem.universite_id = kurum_disi_form.universite.data
hakem.fakulte_id = kurum_disi_form.fakulte.data
hakem.bolum_id = kurum_disi_form.bolum.data
hakem.hakem_turu = kurum_disi_form.hakem_turu.data
hakem.person_id = person.id
hakem.kurum_ici = False
DB.session.add(hakem)
DB.session.commit()
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Kurum dışı hakem eklenirken bir hata oluştu."
"Hata: {}".format(exc))
return jsonify(status="error"), 500
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"person_hakem_yap").type_index,
"nesne":
'Hakem',
"nesne_id":
hakem.id,
"etkilenen_nesne":
"Person",
"etkilenen_nesne_id":
person.id,
"ekstra_mesaj":
"{} adlı kullanıcı, {} {} adlı kurum dışı hakem olarak ekledi "
.format(current_user.username, person.ad, person.soyad)
}
signal_sender(**signal_payload)
return jsonify(status="success")
return jsonify(status="error",
error_message="Lütfen formu eksiksiz doldurunuz!"), 400
from tasks.models import Task
from test_base import check_blueprints
from test_objects import create_from_file
from werkzeug.datastructures import ImmutableMultiDict
getters_once_dict = ImmutableMultiDict([
('name', 'getters_once'),
('getters', 'get_arp_table'),
('getters', 'get_interfaces_counters'),
('getters', 'get_interfaces'),
('getters', 'get_lldp_neighbors'),
('scheduled_date', ''),
('frequency', ''),
('script_type', 'napalm_getters')
])
getters_recurrent = ImmutableMultiDict([
('name', 'testzdqdqd'),
('getters', 'get_network_instances'),
('getters', 'get_ntp_peers'),
('getters', 'get_bgp_config'),
('getters', 'get_bgp_neighbors'),
('scheduled_date', '15/03/2020 20:47:15'),
('frequency', '160'),
('script_type', 'napalm_getters')
])
@check_blueprints('/', '/views/', '/tasks/')
def test_getters(user_client):
create_from_file(user_client, 'europe.xls')
def upload_file(toktok):
TOK = toktok
if pp.token_test(TOK) == False:
return 'Invalid token'
if request.method != 'POST':
return "Invalid. Submit a text file"
file = request.files['file']
# Gathers all the data
try:
dictdata = ImmutableMultiDict(request.form).to_dict(flat='')
app = str(dictdata["app"][0].lower())
# Gets the list of topics/subtopics
Tops = [j for j in dictdata.keys() if j != "app"]
# Each topic will be defined by Topic: subtopics
# Subtopics are separated by commas
TST = {} # Topics structure
for one_top in Tops:
TST[one_top] = [zz for zz in dictdata[one_top][0].upper().split(',') if zz != '']
except:
return "INVALID, not all data has been provided"
# If no app is provided, it will assume BOINC
try:
if (app != "boinc2docker") and (app != "adtdp"):
return "INVALID app"
except:
app = "boinc2docker"
# Avoids empty files and non-text files
if file.filename == '':
return 'No file submitted'
if file.filename.split('.')[-1] != 'txt':
return "File type invalid, only text files are acccepted"
# Randomizes the file name to avoid matches
new_filename = pp.random_file_name()
file.save(os.path.join(UPLOAD_FOLDER, new_filename))
# Gets the image names
# Although uncommon, users can write multiple commands in a single file
Im_Names = []
with open(UPLOAD_FOLDER+'/'+new_filename, 'r') as comfil:
for line in comfil:
LL = line.replace('\n', '')
if len(line.split(' ')) == 1:
continue
Im_Names.append(line.split(' ')[0])
# Adds the token at the end of the file
with open(UPLOAD_FOLDER+'/'+new_filename, 'a') as nod:
nod.write('\n'+str(TOK))
AA = ''
if app == "boinc2docker":
# Adds the topic to database
for an_image in Im_Names:
AA += cus.complete_tag_work(an_image, TST, jobsub=len(Im_Names))
shutil.move(UPLOAD_FOLDER+'/'+new_filename, FINAL_FOLDER+'/'+new_filename)
if app == "adtdp":
shutil.move(UPLOAD_FOLDER+'/'+new_filename, ADTDP_FOLDER+'/'+new_filename)
return "File submitted for processing\n"+AA
from werkzeug.datastructures import ImmutableMultiDict
valid = ImmutableMultiDict([
('token', 'rYI1FoMqUAysp62UPsv7Y8ph'), ('team_id', 'T75THHT8X'),
('team_domain', 'metaswitchgrads2017'), ('channel_id', 'G7Q3BSXMF'),
('channel_name', 'privategroup'), ('user_id', 'U756R3LAX'),
('user_name', 'alex.lloyd'), ('command', '/points'),
('text', '<@U749REFCZ|toby.birkett> 10'),
('response_url',
'https://hooks.slack.com/commands/T75THHT8X/275391498660/70WjzObOKXDyWJ9TDW0APYtU'
),
('trigger_id',
'275488945861.243935605303.5e963f4b8de7de5db26c6c4ea092d892')
])
def test_mail_notifier_return_correct_status(self):
data = ImmutableMultiDict([('body-plain', 'test')])
response = self.client.post('/mail-notifier',
data=data,
follow_redirects=True)
self.assertEquals(response.data, 'OK')
def define_link(subtype, source, destination, name):
return ImmutableMultiDict([('name', name), ('description', 'description'),
('location', 'Los Angeles'),
('vendor', 'Juniper'), ('type', subtype),
('source', source),
('destination', destination), ('add_link', '')])
@check_blueprints('', '/objects', '/views')
def test_link_deletion(user_client):
create_from_file(user_client, 'europe.xls')
for link in links:
user_client.post('/objects/delete/link/' + link)
assert len(Node.query.all()) == 33
assert len(Link.query.all()) == 38
## Object filtering
filter1 = ImmutableMultiDict([
('name', 'filter1'),
('node_location', 'france|spain'),
('node_location_regex', 'y'),
('link_name', 'link[1|2].'),
('link_name_regex', 'y'),
])
filter2 = ImmutableMultiDict([
('name', 'filter2'),
('node_location', 'france'),
('link_name', 'l.*k\\S3'),
('link_name_regex', 'y'),
])
@check_blueprints('', '/objects', '/views')
def test_object_filtering(user_client):
create_from_file(user_client, 'europe.xls')
def authenticated_request_token(orgtok, temptok):
if request.method != 'POST':
return 'Invalid, no data provided'
all_org_keys = [
r_org.hmget(x.decode('UTF-8'), 'Organization Token')[0].decode('UTF-8')
for x in r_org.keys()
]
if orgtok not in all_org_keys:
return 'Organization key invalid, access denied'
if r_temp.get(temptok) is None:
return 'Temporary token not valid or expired, access denied'
dictdata = ImmutableMultiDict(request.form).to_dict(flat='')
try:
NAME = str(dictdata['name'][0])
LAST_NAME = str(dictdata['last_name'][0])
EMAIL = str(dictdata['email'][0])
ALLOCATION = str(dictdata['allocation'][0])
except:
return 'Invalid request, not all data is provided'
# Finds the organization's name and updates it with the result
all_orgs = [x.decode('UTF-8') for x in r_org.keys()]
for otok, org in zip(all_org_keys, all_orgs):
if otok == orgtok:
user_org = org
maxalloc = r_org.hget(user_org, 'Data Plan').decode('UTF-8')
if float(ALLOCATION) > float(maxalloc):
return 'Invalid: User requested allocation is larger than organization allows'
# Creates a final token for the user
SEQ = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
user_tok = ''
for qq in range(0, 14):
user_tok += random.choice(SEQ)
# Replaces single quotes by double quotes
Org_Users_Data = json.loads(
r_org.hget(user_org,
'Users').decode('UTF-8').replace('\"', 'UHJKNM').replace(
'\'', '\"').replace('UHJKLM', '\''))
Org_Users_Data[user_tok] = {
'name': NAME,
'last name': LAST_NAME,
'email': EMAIL,
'allocation': ALLOCATION
}
r_org.hset(user_org, 'Users', Org_Users_Data)
r_temp.delete(temptok)
r_org.hincrby(user_org, 'No. Users', 1)
# Adds the token to the token file
with open("/root/project/html/user/token_data/Tokens.txt", "a") as tokfile:
tokfile.write(NAME + " " + LAST_NAME + ", " + user_tok + ", " + EMAIL +
'\n')
# Adds the allocation details
r_alloc.set(user_tok, ALLOCATION)
return 'User has been added, your new token is: ' + user_tok
from werkzeug.datastructures import ImmutableMultiDict
from eNMS.tasks.models import Task
from tests.test_base import check_blueprints
from tests.test_objects import create_from_file
instant_task = ImmutableMultiDict([('name', 'instant_task'),
('waiting_time', '0'), ('nodes', '8'),
('nodes', '9'), ('start_date', ''),
('end_date', ''), ('frequency', ''),
('job', '2'), ('run_immediately', 'y')])
scheduled_task = ImmutableMultiDict([('name', 'scheduled_task'),
('waiting_time', '0'), ('nodes', '8'),
('nodes', '9'),
('start_date', '30/03/2018 19:10:13'),
('end_date', '06/04/2018 19:10:13'),
('frequency', '3600'), ('job', '2'),
('run_immediately', 'y')])
@check_blueprints('/views', '/tasks')
def test_netmiko_napalm_config(user_client):
create_from_file(user_client, 'europe.xls')
user_client.post('tasks/scheduler', data=instant_task)
assert len(Task.query.all()) == 1
user_client.post('tasks/scheduler', data=scheduled_task)
assert len(Task.query.all()) == 2
def test_validate_input_correct_input(self):
request_args = ImmutableMultiDict([('name', 'aldous huxley')])
response = books_helper.validate_input(request_args)
self.assertTrue(response is None, msg="Couldn't handle name parameter")
def newobject():
try:
something = request.form
imd = ImmutableMultiDict(something)
records = helpers.convert(imd)
# Import indicators from Cuckoo for the selected analysis task
if 'type' in records and 'cuckoo' in records['type']:
host_data, dns_data, sha1, firstseen = cuckoo.report_data(records['cuckoo_task_id'])
if host_data and dns_data and sha1 and firstseen:
# Import IP Indicators from Cuckoo Task
for ip in host_data:
ind = Indicator.query.filter_by(object=ip).first()
if ind is None:
indicator = Indicator(ip.strip(), 'IPv4', firstseen, '', 'Infrastructure', records['campaign'],
'Low', '', records['tags'], '')
db_session.add(indicator)
db_session.commit()
# Import Domain Indicators from Cuckoo Task
for dns in dns_data:
ind = Indicator.query.filter_by(object=dns['request']).first()
if ind is None:
indicator = Indicator(dns['request'], 'Domain', firstseen, '', 'Infrastructure',
records['campaign'], 'Low', '', records['tags'], '')
db_session.add(indicator)
db_session.commit()
# Import File/Hash Indicators from Cuckoo Task
ind = Indicator.query.filter_by(object=sha1).first()
if ind is None:
indicator = Indicator(sha1, 'Hash', firstseen, '', 'Capability',
records['campaign'], 'Low', '', records['tags'], '')
db_session.add(indicator)
db_session.commit()
# Redirect to Dashboard after successful import
return redirect(url_for('home'))
else:
errormessage = 'Task is not a file analysis'
return redirect(url_for('import_indicators'))
if 'inputtype' in records:
# Makes sure if you submit an IPv4 indicator, it's an actual IP
# address.
ipregex = re.match(
r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', records['inputobject'])
# Convert the inputobject of IP or Domain to a list for Bulk Add functionality.
records['inputobject'] = records['inputobject'].split(',')
for newobject in records['inputobject']:
if records['inputtype'] == "IPv4":
if ipregex:
object = Indicator.query.filter_by(object=newobject).first()
if object is None:
ipv4_indicator = Indicator(newobject.strip(), records['inputtype'],
records['inputfirstseen'], records['inputlastseen'],
records['diamondmodel'], records['inputcampaign'],
records['confidence'], records['comments'], records['tags'], None)
db_session.add(ipv4_indicator)
db_session.commit()
network = Indicator.query.filter(Indicator.type.in_(
('IPv4', 'IPv6', 'Domain', 'Network'))).all()
else:
errormessage = "Entry already exists in database."
return render_template('newobject.html', errormessage=errormessage,
inputtype=records['inputtype'], inputobject=newobject,
inputfirstseen=records['inputfirstseen'],
inputlastseen=records['inputlastseen'],
inputcampaign=records['inputcampaign'],
comments=records['comments'],
diamondmodel=records['diamondmodel'],
tags=records['tags'])
else:
errormessage = "Not a valid IP Address."
newobject = ', '.join(records['inputobject'])
return render_template('newobject.html', errormessage=errormessage,
inputtype=records['inputtype'],
inputobject=records, inputfirstseen=records['inputfirstseen'],
inputlastseen=records['inputlastseen'],
confidence=records['confidence'], inputcampaign=records['inputcampaign'],
comments=records['comments'], diamondmodel=records['diamondmodel'],
tags=records['tags'])
else:
object = Indicator.query.filter_by(object=newobject).first()
if object is None:
indicator = Indicator(newobject.strip(), records['inputtype'], records['inputfirstseen'],
records['inputlastseen'], records['diamondmodel'], records['inputcampaign'],
records['confidence'], records['comments'], records['tags'], None)
db_session.add(indicator)
db_session.commit()
else:
errormessage = "Entry already exists in database."
return render_template('newobject.html', errormessage=errormessage,
inputtype=records['inputtype'], inputobject=newobject,
inputfirstseen=records['inputfirstseen'],
inputlastseen=records['inputlastseen'],
inputcampaign=records['inputcampaign'],
comments=records['comments'],
diamondmodel=records['diamondmodel'],
tags=records['tags'])
# TODO: Change 'network' to 'object' in HTML templates to standardize on verbiage
if records['inputtype'] == "IPv4" or records['inputtype'] == "Domain" or records['inputtype'] == "Network"\
or records['inputtype'] == "IPv6":
network = Indicator.query.filter(Indicator.type.in_(('IPv4', 'IPv6', 'Domain', 'Network'))).all()
return render_template('networks.html', network=network)
elif records['diamondmodel'] == "Victim":
victims = Indicator.query.filter(Indicator.diamondmodel == ('Victim')).all()
return render_template('victims.html', network=victims)
elif records['inputtype'] == "Hash":
files = Indicator.query.filter(Indicator.type == ('Hash')).all()
return render_template('files.html', network=files)
else:
threatactors = Indicator.query.filter(Indicator.type == ('Threat Actors')).all()
return render_template('threatactors.html', network=threatactors)
except Exception as e:
return render_template('error.html', error=e)
def test_validate_input_wrong_input(self):
request_args = ImmutableMultiDict([])
response = books_helper.validate_input(request_args)
self.assertTrue(response.status_code == 400,
msg="Couldn't handle empty name parameter")
def hakem_kayit_kurum_ici(self):
"""Kurum içi hakem kayıt için post methodunu karşılayan view"""
form = request.get_json()['kurum_ici']
imd = ImmutableMultiDict([(element['name'], element['value'])
for element in form])
kurum_ici_form = KurumIciHakemKayitForm(imd)
if kurum_ici_form.validate():
personel_id = kurum_ici_form.personel_sec.data
hakem_kayitli_mi = DB.session.query(Hakem).filter_by(
personel_id=personel_id).first()
if not hakem_kayitli_mi:
hakem = Hakem()
personel = DB.session.query(Personel).filter_by(
id=personel_id).first()
hakem.unvan = personel.unvan
hakem.universite_id = personel.birim
hakem.fakulte_id = personel.birim
hakem.personel_id = personel_id
hakem.person_id = personel.person_id
hakem.bolum_id = personel.birim
hakem.hakem_turu = kurum_ici_form.kurum_ici_hakem_turu.data
hakem.kurum_ici = True
try:
DB.session.add(hakem)
DB.session.commit()
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Kurum içi hakem eklenirken bir hata "
"oluştu."
"Hata: {}".format(exc))
return jsonify(status="error"), 500
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"personel_hakem_yap").type_index,
"nesne":
'Hakem',
"nesne_id":
hakem.id,
"etkilenen_nesne":
"Personel",
"etkilenen_nesne_id":
personel.id,
"ekstra_mesaj":
"{} adlı kullanıcı, {} {} adlı personeli hakem olarak ekledi "
.format(current_user.username, personel.person.ad,
personel.person.soyad)
}
signal_sender(**signal_payload)
return jsonify(status="success")
return jsonify(
status="error",
error_message="Personel hakem olarak kayıtlı.!"), 500
return jsonify(status="error",
error_message="Lütfen formu eksiksiz doldurunuz.!"), 400
from tests.test_base import check_blueprints
from werkzeug.datastructures import ImmutableMultiDict
# test the creation of configuration script (netmiko / napalm)
# test the creation of file transfer script (netmiko via SCP)
# test the creation of ansible script
## Netmiko configuration
netmiko_ping = ImmutableMultiDict([
('name', 'netmiko_ping'),
('waiting_time', '0'),
('description', ''),
('vendor', ''),
('operating_system', ''),
('content_type', 'simple'),
('create_script', 'netmiko_config'),
('content', 'ping 1.1.1.1'),
('netmiko_type', 'show_commands'),
('driver', 'cisco_xr_ssh'),
('global_delay_factor', '1.0'),
])
template = '''
{% for interface, properties in subinterfaces.items() %}
interface FastEthernet0/0.{{ interface }}
description {{ properties.aire }}
encapsulation dot1Q {{ properties.dot1Q }}
ip address {{ properties.address }} 255.255.255.248
no ip redirects
ip ospf cost {{ properties.cost }}
def hakem_edit_post(self, hakem_id):
"""Hakem duzenleme"""
hakem = DB.session.query(Hakem).filter(Hakem.id == hakem_id).one()
if hakem.kurum_ici:
form = request.get_json()['kurum_ici']
imd = ImmutableMultiDict([(element['name'], element['value'])
for element in form])
kurum_ici_form = KurumIciHakemKayitForm(imd)
if kurum_ici_form.validate():
personel_id = kurum_ici_form.personel_sec.data
hakem_ekli_mi = DB.session.query(Hakem).filter_by(
personel_id=personel_id).first()
if hakem_ekli_mi:
return jsonify(
status="error",
error_message=
"Seçilen personel kurumiçi hakem olarak kayıtlı.!"
), 500
personel = DB.session.query(Personel).filter_by(
id=personel_id).first()
hakem.unvan = personel.unvan
hakem.universite_id = personel.birim
hakem.fakulte_id = personel.birim
hakem.personel_id = personel_id
hakem.person_id = personel.person_id
hakem.bolum_id = personel.birim
hakem.hakem_turu = kurum_ici_form.kurum_ici_hakem_turu.data
hakem.person_id = personel.person_id
try:
DB.session.commit()
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Kurum içi hakem eklenirken bir hata "
"oluştu.Hata: {}".format(exc))
return jsonify(status="error"), 500
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"personel_hakem_yap").type_index,
"nesne":
'Hakem',
"nesne_id":
hakem.id,
"etkilenen_nesne":
"Personel",
"etkilenen_nesne_id":
personel.id,
"ekstra_mesaj":
"{} adlı kullanıcı, {} {} adlı personeli {} idli hakem yerine hakem olarak ekledi "
.format(current_user.username, personel.person.ad,
personel.person.soyad, hakem.id)
}
signal_sender(**signal_payload)
return jsonify(status="success")
return jsonify(
status="error",
error_message="Lütfen formu eksiksiz doldurunuz.!"), 400
else:
form = request.get_json()['kurum_disi']
imd = ImmutableMultiDict([(element['name'], element['value'])
for element in form])
kurum_disi_form = KurumDisiHakemKayitForm(imd)
if kurum_disi_form.validate():
try:
hakem = DB.session.query(Hakem).filter(
Hakem.id == hakem_id).one()
person = DB.session.query(Person).filter(
Person.id == hakem.person_id).one()
person.ad = kurum_disi_form.ad.data
person.soyad = kurum_disi_form.soyad.data
person.birincil_eposta = kurum_disi_form.email.data
hakem.unvan = kurum_disi_form.unvan.data
hakem.hakem_turu = kurum_disi_form.hakem_turu.data
if kurum_disi_form.universitede_gorev_almayan.data:
hakem.kurum = kurum_disi_form.kurum.data
hakem.daire = kurum_disi_form.daire.data
hakem.birim = kurum_disi_form.birim.data
hakem.universite_id = None
hakem.fakulte_id = None
hakem.bolum_id = None
else:
hakem.kurum = None
hakem.daire = None
hakem.birim = None
hakem.universite_id = kurum_disi_form.universite.data
hakem.fakulte_id = kurum_disi_form.fakulte.data
hakem.bolum_id = kurum_disi_form.bolum.data
DB.session.commit()
except Exception as exc:
DB.session.rollback()
CustomErrorHandler.error_handler(
hata="Kurum dışı hakem eklenirken bir hata oluştu."
"Hata: {}".format(exc))
return jsonify(status="error"), 500
signal_payload = {
"message_type":
USER_ACTIVITY_MESSAGES.get("bap").get(
"person_hakem_yap").type_index,
"nesne":
'Hakem',
"nesne_id":
hakem.id,
"etkilenen_nesne":
"Person",
"etkilenen_nesne_id":
person.id,
"ekstra_mesaj":
"{} adlı kullanıcı, {} {} adlı kurum dışı hakem bilgilerini güncelledi."
.format(current_user.username, person.ad, person.soyad)
}
signal_sender(**signal_payload)
return jsonify(status="success")
return jsonify(
status="error",
error_message="Lütfen formu eksiksiz doldurunuz!"), 400
put('http://127.0.0.1:5000/rest/object/node', data=dumps(updated_node))
response = get('http://127.0.0.1:5000/rest/object/node/router10',
headers={'Accept': 'application/json'})
assert loads(response.content) == updated_response
assert len(Node.query.all()) == 1
# DELETE: delete an object
delete('http://127.0.0.1:5000/rest/object/node/router10',
headers={'Accept': 'application/json'})
assert len(Node.query.all()) == 0
post_script = ImmutableMultiDict([('name', 'create_router10'),
('description', 'POST creation'),
('call_type', 'POST'),
('url',
'http://127.0.0.1:5000/rest/object/node'),
('payload', dumps(node)), ('username', ''),
('password', ''),
('content', '.*15.5(\\d)M.*'),
('content_regex', 'y')])
post_script_task = ImmutableMultiDict([('name', 'task_create_router'),
('waiting_time', '0'), ('job', '4'),
('start_date', ''), ('end_date', ''),
('frequency', ''),
('run_immediately', 'y')])
delete_script = ImmutableMultiDict([
('name', 'delete_router10'), ('description', 'DELETE'),
('call_type', 'DELETE'),
('url', 'http://127.0.0.1:5000/rest/object/node/router10'),
def __init__(self, **kwargs):
# Flask `request.args` has type of ImmutableMultiDict
# Need to use that here so that request.args.getlist will work
self.args = ImmutableMultiDict(kwargs)
@pytest.mark.parametrize(
'context',
[
# querystring
{
'path': '/foo?name=steve&name=Loria&nums=4&nums=2'
},
# form
{
'path':
'/foo',
'method':
'POST',
'data':
ImmutableMultiDict([('name', 'steve'), ('name', 'Loria'),
('nums', 4), ('nums', 2)])
},
])
def test_parse_multiple(context, testapp):
multargs = {'name': Arg(multiple=True), 'nums': Arg(int, multiple=True)}
with testapp.test_request_context(**context):
args = parser.parse(multargs)
assert args['name'] == ['steve', 'Loria']
assert args['nums'] == [4, 2]
def test_parse_multiple_arg_with_single_value(testapp):
multargs = {'name': Arg(multiple=True)}
with testapp.test_request_context('/foo?name=steve'):
args = parser.parse(multargs)
assert args['name'] == ['steve']
'c17': 4,
'c23': 2,
'c29': 4,
'c35': 2,
'c6': 5,
'c12': 2,
'c18': 3,
'c24': 1,
'c30': 3,
'c36': 1
}
decision = []
form = ImmutableMultiDict([('c10', ''), ('c19', ''), ('c28', ''), ('c37', ''),
('c46', ''), ('c55', ''), ('c73', ''), ('c2', ''),
('c20', ''), ('c38', ''), ('c47', ''), ('c56', ''),
('c65', ''), ('c74', ''), ('c3', ''), ('c12', ''),
('c30', ''), ('c48', ''), ('c57', ''), ('c66', ''),
('c75', ''), ('c4', ''), ('c13', ''), ('c22', ''),
('c31', ''), ('c40', ''), ('c49', ''), ('c58', ''),
('c67', ''), ('c76', ''), ('c5', ''), ('c23', ''),
('c32', ''), ('c41', ''), ('c50', ''), ('c59', ''),
('c68', ''), ('c6', ''), ('c15', ''), ('c24', ''),
('c33', ''), ('c42', ''), ('c51', ''), ('c60', ''),
('c78', ''), ('c16', ''), ('c25', ''), ('c34', ''),
('c43', ''), ('c52', ''), ('c70', ''), ('c79', ''),
('c17', ''), ('c26', ''), ('c35', ''), ('c44', ''),
('c53', ''), ('c62', ''), ('c71', ''), ('c9', ''),
('c27', ''), ('c36', ''), ('c54', ''), ('c72', ''),
('c81', '')])
def get(self, req_data):
form = MonitorHeartbeatForm(ImmutableMultiDict(req_data))
if not form.validate():
raise Status400(form.errors)
get_data = es_heart.get_record(
settings.opt['ELASTICSEARCH']['HEARTINDEX'], **form.data)
if len(get_data['dlist']) == 0:
return {
'result': 0,
'message': 'success',
'interval': 0,
'instance': [],
'trace_list': [],
}
# 检查时间断点
sorted_data = sorted(get_data['dlist'],
cmp=lambda x, y: cmp(x['time'], y['time']))
mseconds = form.data['duration'] * 1000
ret_data = []
s_flag, count_flag = 0, 0.0
interval = get_data['interval']
sorted_len = len(sorted_data)
last_flag = False
while count_flag <= mseconds:
now = form.data['starttime'] + datetime.timedelta(
seconds=count_flag / 1000)
s_flag_time = sorted_data[s_flag]['time']
delay_len = len(sorted_data[s_flag]['delay_list'])
delta = sorted_data[s_flag]['interval'] * delay_len / 100
time_flag = datetime.datetime.strptime(
s_flag_time,
'%Y-%m-%d %H:%M:%S') - datetime.timedelta(seconds=delta * 0.1)
# logger.debug('xxxxxxxxxxxxxxxxxxxxxxxxxxx')
# logger.debug('{0} --- {1} --- {2}'format(s_flag_time, sorted_data[s_flag]['interval'], delay_len))
# logger.debug('{0} --- {1}'.format(now, time_flag))
# logger.debug('{0} --- {1} --- {2}'.format(count_flag, mseconds, len(ret_data)))
# logger.debug('xxxxxxxxxxxxxxxxxxxxxxxxxxx')
if time_flag < now:
if s_flag == sorted_len - 1 and last_flag is True:
ret_data.append({
'loss_rate': '-',
'delay': '-',
})
count_flag = count_flag + interval
else:
tmp_time = datetime.datetime.strptime(
s_flag_time, '%Y-%m-%d %H:%M:%S') - now
tmp_len = tmp_time.seconds * 1000 / sorted_data[s_flag][
'interval']
for j in range(tmp_len):
if sorted_data[s_flag]['delay_list'][j] == 0:
sorted_data[s_flag]['delay_list'][j] = get_data[
'delay_top']
ret_data.append({
'loss_rate':
sorted_data[s_flag]['loss_rate'],
'delay':
sorted_data[s_flag]['delay_list'][j]
})
for jj in range(
(sorted_data[s_flag]['interval'] - interval) /
interval):
ret_data.append({
'loss_rate': '-',
'delay': '-',
})
s_flag = s_flag + 1
if s_flag == sorted_len:
last_flag = True
s_flag = s_flag - 1
count_flag = count_flag + tmp_len * sorted_data[s_flag][
'interval']
elif time_flag == now:
for j in sorted_data[s_flag]['delay_list']:
if j == 0:
j = get_data['delay_top']
ret_data.append({
'loss_rate':
sorted_data[s_flag]['loss_rate'],
'delay':
j
})
for jj in range(
(sorted_data[s_flag]['interval'] - interval) /
interval):
ret_data.append({
'loss_rate': '-',
'delay': '-',
})
s_flag = s_flag + 1
if s_flag == sorted_len:
last_flag = True
s_flag = s_flag - 1
count_flag = count_flag + delta * 100
else:
ret_data.append({
'loss_rate': '-',
'delay': '-',
})
count_flag = count_flag + interval
# 新增主动检测匹配功能
start_time = form.data['starttime']
stop_time = start_time + datetime.timedelta(
seconds=form.data['duration'])
trace_time = es_trace.get_record(
settings.opt['ELASTICSEARCH']['TRACEINDEX'],
userid=form.data['user_id'],
appid=form.data['appid'],
starttime=start_time,
stoptime=stop_time,
)
trace_list = [{
'pos':
MonitorHeartbeatHandler.pos_from_time(
datetime.datetime.strptime(t, '%Y-%m-%d %H:%M:%S'), start_time,
interval),
'timestamp':
t
} for t in trace_time['checktimes']]
return {
'result': 0,
'message': 'success',
'interval': interval,
'instance': ret_data,
'trace_list': trace_list,
}
def test_if_http_routing__data_contained_in_request_form(self):
with mock_odoo_request(self.env, data=self.data):
assert request.httprequest.form == ImmutableMultiDict(self.data)
assert not request.httprequest.data
@check_blueprints('', '/objects', '/views')
def test_link_deletion(user_client):
create_from_file(user_client, 'europe.xls')
for link_name in links:
link = fetch(Link, name=link_name)
user_client.post(f'/objects/delete/link/{link.id}')
assert len(Device.query.all()) == 60
assert len(Link.query.all()) == 42
pool1 = ImmutableMultiDict([
('name', 'pool1'),
('device_location', 'france|spain'),
('device_location_regex', 'y'),
('link_name', 'link[1|2].'),
('link_name_regex', 'y'),
])
pool2 = ImmutableMultiDict([
('name', 'pool2'),
('device_location', 'france'),
('link_name', 'l.*k\\S3'),
('link_name_regex', 'y'),
])
@check_blueprints('', '/objects', '/views')
def test_pool_management(user_client):
create_from_file(user_client, 'europe.xls')
def test_connect_false(self):
""" Test connect existing customer to account as holder (false). """
imd = ImmutableMultiDict([('account', '2'), ('person', 'mar')])
self.assertFalse(self.bank.connect(imd))
self.assertTrue("mar" in self.bank.accounts[1].holders)
self.assertIn("mar", self.bank.accounts[1].holders)
def test_analysis(self):
import_name = self.generated_directory + '/generated_routes.py'
md_gen = imp.load_source('generated_routes', import_name)
for res in self.test_res:
v_uri = {}
v_args = ImmutableMultiDict([])
v_data = ''
v_mimetype = 'text/plain'
if res.get('validation') != [] and res.get('validation') != None:
for x in res['validation']:
if x['source'] == 'get_param':
if x['validation']['example'] == None:
self.output.append((
'INFO',
'GET Parameter ' + x['validation']['name'] +
' of resource ' + res['name'] +
' does not have an example defined for testing'
))
else:
d_items = []
for y in v_args:
d_items.append((y, v_args[y]))
d_items.append((x['validation']['name'],
x['validation']['example']))
v_args = ImmutableMultiDict(d_items)
elif x['source'] == 'uri_param':
if x['validation']['example'] == None:
self.output.append((
'INFO',
'URI Parameter ' + x['validation']['name'] +
' of resource ' + res['name'] +
' does not have an example defined for testing'
))
else:
v_uri[x['validation']
['name']] = x['validation']['example']
elif x['source'] == 'body':
for y in x['validation']:
v_mimetype = y['mime-type']
if y['example'] == None:
self.output.append((
'INFO',
'BODY with schema ' + y['mime-type'] +
' of resource ' + res['name'] +
' does not have an example defined for testing'
))
else:
v_data = y['example']
mr = Mock_Request(v_uri, v_args, v_data, v_mimetype)
tested_class = eval('md_gen.' + res['name'] + '(mr)')
result = tested_class.validate_params_handler()
if result.value == '' and result.code == 200 and result.proceed == True:
self.output.append(
('INFO', 'Test of ' + res['name'] + ': SUCCESS'))
else:
self.output.append(
('WARN', 'Test of ' + res['name'] + ': FAIL'))
return self.dump_output()
