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