def test_update_vrf_in_db(case):
clear_db()
alchemy_core.Database().create_tables()
tn = "tn0"
vrfs = ['vrf0', 'vrf1']
ori_fun = plugin_server.get_vrf_from_apic
def fail_get_vrf_from_apic(tn):
return 0
def pass_get_vrf_from_apic(tn):
return list(map(lambda x: "uni/tn-{}/ctx-{}".format(tn, x), vrfs))
pass_response = {"status_code": "200", "payload": vrfs, "message": "OK"}
fail_response = {
"status_code": "300",
"payload": [],
"message": "Could not load VRF for tenant {}".format(tn)
}
if case == "fail":
plugin_server.get_vrf_from_apic = fail_get_vrf_from_apic
response = json.loads(plugin_server.update_vrf_in_db(tn))
assert response == fail_response
else:
plugin_server.get_vrf_from_apic = pass_get_vrf_from_apic
response = json.loads(plugin_server.update_vrf_in_db(tn))
assert response == pass_response
plugin_server.get_vrf_from_apic = ori_fun
clear_db()
def test_get_polling_interval(interval):
clear_db()
dummy_db = alchemy_core.Database()
dummy_db.create_tables()
passed_response = json.dumps({
"status_code": "200",
"message": "Ok",
"payload": {
"interval": interval
}
})
failed_response = json.dumps({
"status_code": "300",
"message": "Could not get polling interval",
"payload": []
})
plugin_server.set_polling_interval(interval)
if interval != "fail":
response = plugin_server.get_polling_interval()
assert response == passed_response
clear_db()
else:
plugin_server_db_obj = plugin_server.db_obj
plugin_server.db_obj = None
response = plugin_server.get_polling_interval()
plugin_server.db_obj = plugin_server_db_obj
assert response == failed_response
clear_db()
def test_save_mapping(mapped_data):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
tenant = 'tn0'
datacenter = 'dc1'
passed_response = {
"payload": "Saved Mappings",
"status_code": "200",
"message": "OK"
}
failed_response = {
"payload": {},
"status_code": "300",
"message": "Could not save mappings to the database."
}
if mapped_data != "fail":
mapped_data = [mapped_data]
response = json.loads(
plugin_server.save_mapping(tenant, datacenter,
json.dumps(mapped_data)))
assert response == passed_response
connection = db_obj.engine.connect()
db_saved_data = db_obj.select_from_table(connection,
db_obj.MAPPING_TABLE_NAME)
connection.close()
assert check_saved_mapping(db_saved_data, mapped_data, datacenter)
else:
response = json.loads(
plugin_server.save_mapping(tenant, datacenter, {}))
assert response == failed_response
clear_db()
def test_change_agent_edit_status(case):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
if case != "":
connection = db_obj.engine.connect()
db_obj.insert_and_update(connection, db_obj.DATA_FETCH_TABLE_NAME,
[True, True])
connection.close()
connection = db_obj.engine.connect()
data = db_obj.select_from_table(connection, db_obj.DATA_FETCH_TABLE_NAME)
connection.close()
if case == "":
assert data == []
else:
assert data[0][1] is True
case = case if case != "" else True
plugin_server.change_agent_edit_status(case)
connection = db_obj.engine.connect()
data = db_obj.select_from_table(connection, db_obj.DATA_FETCH_TABLE_NAME)
connection.close()
assert data[0][1] == case
clear_db()
def test_change_agent_edit_status():
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
data = db_obj.select_from_table(connection, db_obj.DATA_FETCH_TABLE_NAME)
connection.close()
assert data == []
data_fetch.change_agent_edit_status(True)
connection = db_obj.engine.connect()
data = db_obj.select_from_table(connection, db_obj.DATA_FETCH_TABLE_NAME,
{}, ['edited'])
connection.close()
assert data[0][0] is True
data_fetch.change_agent_edit_status(False)
connection = db_obj.engine.connect()
data = db_obj.select_from_table(connection, db_obj.DATA_FETCH_TABLE_NAME,
{}, ['edited'])
connection.close()
assert data[0][0] is False
clear_db()
def test_remove_unused_servicechecks(input_data):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
agent_addr_list = input_data["agent_addr_list"]
service_checks_key = set(input_data["service_checks_key"])
connection = db_obj.engine.connect()
with connection.begin():
db_obj.insert_and_update(connection, db_obj.SERVICECHECKS_TABLE_NAME,
input_data["input"])
connection.close()
data_fetch.remove_unused_servicechecks(agent_addr_list, service_checks_key)
connection = db_obj.engine.connect()
data = db_obj.select_from_table(connection,
db_obj.SERVICECHECKS_TABLE_NAME)
connection.close()
if data:
assert list(data[0][:-3]) == input_data["output"]
else:
assert data == input_data["output"]
clear_db()
def test_set_polling_interval(interval):
clear_db()
passed_response = {
"status_code": "200",
"message": "Polling Interval Set!"
}
failed_response = {
'status_code': '300',
'message': 'Some error occurred, could not set polling interval'
}
dummy_db = alchemy_core.Database()
dummy_db.create_tables()
connection = dummy_db.engine.connect()
ls = dummy_db.select_from_table(connection, dummy_db.POLLING_TABLE_NAME)
connection.close()
assert len(ls) == 0
if interval != "fail":
response = plugin_server.set_polling_interval(interval)
assert json.loads(response) == passed_response
connection = dummy_db.engine.connect()
db_interval = dummy_db.select_from_table(connection,
dummy_db.POLLING_TABLE_NAME,
{'pkey': 'interval'},
['interval'])[0][0]
connection.close()
assert interval == db_interval
clear_db()
else:
clear_db()
response = plugin_server.set_polling_interval(interval)
assert json.loads(response) == failed_response
clear_db()
def test_remove_unused_epgs(input_data):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
tenant = input_data["tenant"]
epg_key = set(input_data["epg_key"])
connection = db_obj.engine.connect()
with connection.begin():
db_obj.insert_and_update(connection, db_obj.EPG_TABLE_NAME,
input_data["input"])
connection.close()
data_fetch.remove_unused_epgs(tenant, epg_key)
connection = db_obj.engine.connect()
data = db_obj.select_from_table(connection, db_obj.EPG_TABLE_NAME)
connection.close()
if data:
assert list(data[0][:-3]) == input_data["output"]
else:
assert data == input_data["output"]
clear_db()
def test_read_creds(case):
db_obj = alchemy_core.Database()
db_obj.create_tables()
empty_agent_response = {
'payload': [],
'status_code': '301',
'message': 'Agents not found'
}
if case == "empty_agents" or case[6] != "tn0":
response = json.loads(plugin_server.read_creds("tn0"))
assert response == empty_agent_response
def test_get_epg_alias(case):
arg = case.get("dn")
expected = case.get("expected")
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
db_obj.insert_and_update(connection, db_obj.EPG_TABLE_NAME, [
"dn", "tenant", "EPG", "BD", "contracts", "vrf", "epg_health",
"app_profile", "epg_alias"
], {"dn": arg})
connection.close()
response = plugin_server.get_epg_alias(arg)
assert response == expected
clear_db()
def test_get_agent_edit_status(case):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
with connection.begin():
db_obj.insert_and_update(connection, db_obj.DATA_FETCH_TABLE_NAME,
[True, case])
connection.close()
status = data_fetch.get_agent_edit_status()
assert status == case
def test_write_creds(case):
fail, case = case
clear_db()
failed_response = {
"status_code": "300",
"message": "Could not write the credentials.",
"payload": []
}
if case:
already_exist_response = {
"status_code":
"300",
"message":
"Agent {}:{} already exists.".format(case[0]["ip"],
case[0]["port"]),
"payload": {
"ip": case[0]["ip"],
"token": case[0]["token"],
"protocol": case[0]["protocol"],
"port": case[0]["port"]
}
}
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
if fail:
consul_utils.Consul.check_connection = check_connection_false
app_response = json.loads(
plugin_server.write_creds("tn0", json.dumps(case)))
consul_utils.Consul.check_connection = check_connection
if app_response["status_code"] == "200":
db_data = db_obj.select_from_table(connection, db_obj.LOGIN_TABLE_NAME)
assert write_creds_checker(app_response, db_data)
app_response = json.loads(
plugin_server.write_creds("tn0", json.dumps(case)))
assert already_exist_response == app_response
elif app_response["status_code"] == "301":
db_data = db_obj.select_from_table(connection, db_obj.LOGIN_TABLE_NAME)
assert write_creds_checker(app_response, db_data)
elif app_response["status_code"] == "300":
assert app_response == failed_response
connection.close()
clear_db()
def test_select_from_table(table):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
dummy = [dc[table], [i for i in dc[table]]]
dummy[1][0] = '1'
assert db_obj.insert_into_table(connection, table, dummy[0]) is True
assert db_obj.insert_into_table(connection, table, dummy[1]) is True
records = db_obj.select_from_table(connection, table)
assert len(records) == 2
for i, each in enumerate(dummy):
for j, value in enumerate(each):
assert value == records[i][j]
connection.close()
clear_db()
def test_insert_into_table(table):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
assert db_obj.insert_into_table(connection, table, dc[table]) is True
assert db_obj.insert_into_table(connection, table, dc[table]) is False
inserted_rec = db_obj.select_from_table(connection, table)
assert len(inserted_rec) == 1
for record in inserted_rec:
for index, value in enumerate(dc[table]):
assert value == record[index]
assert db_obj.insert_into_table(connection, '', dc[table]) is False
assert db_obj.insert_into_table(connection, '', []) is False
connection.close()
clear_db()
def test_get_apic_data():
input_data = get_data('get_apic_data/input.json')
output_data = get_data('get_apic_data/output.json')
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
with connection.begin():
for key, value in input_data["data"].iteritems():
for each in value:
db_obj.insert_and_update(connection, key, each)
connection.close()
tenant = input_data["tenant"]
response = plugin_server.get_apic_data(tenant)
clear_db()
assert apic_consul_data_checker(response, output_data)
def test_get_vrf_from_database(case):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
with connection.begin():
db_obj.insert_and_update(
connection, db_obj.LOGIN_TABLE_NAME,
["ip", "port", "prot", "token", "status", "dc", "tn", "vrf_dn"])
if case == "none":
db_obj.insert_and_update(
connection, db_obj.LOGIN_TABLE_NAME,
["ip", "port2", "prot", "token", "status", "dc", "tn", "-"])
connection.close()
vrfs = plugin_server.get_vrf_from_database("dc", "tn")
if case == "none":
assert vrfs == "-"
else:
assert vrfs == ['vrf_dn']
clear_db()
def test_insert_and_update(table):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
if table != 'tenant':
dummy = [dc[table], [i for i in dc[table]], [i for i in dc[table]]]
connection = db_obj.engine.connect()
for each in dummy:
assert db_obj.insert_and_update(connection, table, each,
{dc[table][0]: each[0]})
connection.close()
connection = db_obj.engine.connect()
records = db_obj.select_from_table(connection, table)
connection.close()
assert len(records) == 1
for each in records:
assert each[-2] is None
dummy[1][0] = 'new1'
dummy[2][0] = 'new2'
connection = db_obj.engine.connect()
for each in dummy:
assert db_obj.insert_and_update(connection, table, each,
{dc[table][0]: each[0]})
connection.close()
connection = db_obj.engine.connect()
records = db_obj.select_from_table(connection, table)
connection.close()
assert len(records) == 3
for each in records:
assert each[-2] is None
clear_db()
def test_update_in_table(table):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
if table != 'tenant':
assert db_obj.insert_into_table(connection, table, dc[table]) is True
assert db_obj.update_in_table(
connection, table, {}, {
dc[table][0]: 'new{}'.format(dc[table][0]),
})
records = db_obj.select_from_table(connection, table)
assert len(records) == 1
for i, each in enumerate(records):
for j in range(len(dc[table])):
if j == 0:
assert each[j] == 'new{}'.format(dc[table][j])
continue
assert each[j] == records[i][j]
connection.close()
clear_db()
def test_delete_from_table(table):
clear_db()
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
dummy = [dc[table], [i for i in dc[table]]]
dummy[1][0] = 'new{}'.format(dummy[1][0])
db_obj.insert_into_table(connection, table, dummy[0]) is True
db_obj.insert_into_table(connection, table, dummy[1]) is True
assert db_obj.delete_from_table(connection, table)
records = db_obj.select_from_table(connection, table)
assert len(records) == 0
db_obj.insert_into_table(connection, table, dummy[0]) is True
assert db_obj.delete_from_table(connection, table,
{dc[table][0]: dc[table][0]})
assert db_obj.delete_from_table(connection, "") is False
connection.close()
clear_db()
def dummy_get_vrf_specific_eps(tn, dc):
db_obj = alchemy_core.Database()
connection = db_obj.engine.connect()
eps = db_obj.select_from_table(connection, db_obj.EP_TABLE_NAME,
{'tenant': tn}, ['ip', 'dn', 'is_cep'])
return eps
def test_update_creds(case):
clear_db()
case, data = case
tenant, update_agent, dummy_data = data
agent_not_found = {
"status_code": "300",
"message": "Agents not found",
"payload": []
}
agent_already_exist = {
"status_code":
"300",
"message":
"Agent {}:{} already exists.".format(update_agent["newData"]["ip"],
update_agent["newData"]["port"]),
"payload": {
"ip": update_agent["newData"]["ip"],
"token": update_agent["newData"]["token"],
"protocol": update_agent["newData"]["protocol"],
"port": update_agent["newData"]["port"],
"vrf": update_agent["newData"]["vrf"]
}
}
connected_agent = {
"status_code": "200",
"message": "OK",
"payload": {
"status": True,
"datacenter": "-",
"protocol": update_agent["newData"]["protocol"],
"ip": update_agent["newData"]["ip"],
"token": update_agent["newData"]["token"],
"port": update_agent["newData"]["port"],
"vrf": update_agent["newData"]["vrf"]
}
}
disconnected_agent = {
"status_code": "301",
"message": "message",
"payload": {
"status": False,
"datacenter": "",
"protocol": update_agent["newData"]["protocol"],
"ip": update_agent["newData"]["ip"],
"token": update_agent["newData"]["token"],
"port": update_agent["newData"]["port"],
"vrf": update_agent["newData"]["vrf"]
}
}
exception_response = {
"status_code": "300",
"message": "Could not update the credentials.",
"payload": []
}
db_obj = alchemy_core.Database()
db_obj.create_tables()
connection = db_obj.engine.connect()
if (case != "agent list empty"):
db_obj.insert_and_update(
connection, db_obj.LOGIN_TABLE_NAME, dummy_data, {
'agent_ip': dummy_data[0],
'port': dummy_data[1],
'tenant': dummy_data[6],
'vrf_dn': dummy_data[7]
})
connection.close()
if (case == "agent list empty"):
response = plugin_server.update_creds(tenant, json.dumps(update_agent))
assert agent_not_found == json.loads(response)
elif (case == "agent already exists"):
response = plugin_server.update_creds(tenant, json.dumps(update_agent))
assert agent_already_exist == json.loads(response)
elif (case == "connected"):
response = plugin_server.update_creds(tenant, json.dumps(update_agent))
assert connected_agent == json.loads(response)
elif (case == "disconnected"):
consul_utils.Consul.check_connection = check_connection_false
response = plugin_server.update_creds(tenant, json.dumps(update_agent))
consul_utils.Consul.check_connection = check_connection
assert disconnected_agent == json.loads(response)
elif (case == "exception"):
response = plugin_server.update_creds(tenant, json.dumps(update_agent))
assert exception_response == json.loads(response)
clear_db()
