def test_server_group_details(provider): """Tests server group details on UI Steps: * Get domains list from DB * Chooses one of domains * Get server groups list from DB * Chooses several server groups from list * Select each server group's details in UI, DB and MGMT * Compare selected server group UI details with CFME database and MGMT system """ domain_list = MiddlewareDomain.domains_in_db(provider=provider, strict=False) for domain in get_random_list(domain_list, ITEMS_LIMIT): server_group_list = MiddlewareServerGroup.server_groups_in_db(domain=domain, strict=False) for server_group in get_random_list(server_group_list, 1): svgr_ui = server_group.server_group(method='ui') svgr_db = server_group.server_group(method='db') svgr_mgmt = server_group.server_group(method='mgmt') assert svgr_ui, "Server Group was not found in UI" assert svgr_db, "Server Group was not found in DB" assert svgr_mgmt, "Server Group was not found in MGMT system" assert svgr_ui.name == svgr_db.name == svgr_mgmt.name, \ ("Server Group name does not match between UI:{}, DB:{}, MGMT:{}" .format(svgr_ui.name, svgr_db.name, svgr_mgmt.name)) svgr_db.validate_properties() svgr_mgmt.validate_properties()
def test_list_provider_server_deployments(provider): """Tests deployments list from current Provider for each server between UI, DB and Management system Steps: * Get servers list from UI of provider * Get deployments list for the server * Get deployments list from UI of provider, server * Get deployments list from Database of provider, server * Get deployments list from Database of provider, server * Get deployments list from Management system(Hawkular) of server * Compare size of all the list [UI, Database, Management system] """ servers = MiddlewareServer.servers(provider=provider) assert len(servers) > 0, "There is no server(s) available in UI" for server in get_random_list(servers, ITEMS_LIMIT): ui_deps = _get_deployments_set( MiddlewareDeployment.deployments(provider=provider, server=server)) db_deps = _get_deployments_set( MiddlewareDeployment.deployments_in_db(provider=provider, server=server)) mgmt_deps = _get_deployments_set( MiddlewareDeployment.deployments_in_mgmt(provider=provider, server=server)) assert ui_deps == db_deps == mgmt_deps, \ ("Lists of deployments mismatch! UI:{}, DB:{}, MGMT:{}" .format(ui_deps, db_deps, mgmt_deps))
def test_list_provider_server_groups(provider): """Tests server groups lists from current Provider between UI, DB and Management system Steps: * Get domains list from DB * Chooses one of domains * Get server groups list from UI of domain * Get server groups list from Database of domain * Get server groups list from Management system(Hawkular) * Get headers from UI * Compare headers from UI with expected headers list * Compare content of all the list [UI, Database, Management system] """ domain_list = MiddlewareDomain.domains_in_db(provider=provider) for domain in get_random_list(domain_list, 1): ui_server_groups = get_server_group_set( MiddlewareServerGroup.server_groups(domain=domain)) db_server_groups = get_server_group_set( MiddlewareServerGroup.server_groups_in_db(domain=domain)) mgmt_server_groups = get_server_group_set( MiddlewareServerGroup.server_groups_in_mgmt(domain=domain)) headers = MiddlewareServerGroup.headers(domain) headers_expected = ['Server Group Name', 'Feed', 'Domain Name', 'Profile'] assert headers == headers_expected assert ui_server_groups == db_server_groups == mgmt_server_groups, \ ("Lists of server groups mismatch! UI:{}, DB:{}, MGMT:{}" .format(ui_server_groups, db_server_groups, mgmt_server_groups))
def test_deployment_tags(provider): """Tests tags in deployment page Steps: * Select a deployment randomly from database * Run `_validate_tags` with `tags` input """ deps_db = MiddlewareDeployment.deployments_in_db(provider=provider) assert len(deps_db) > 0, "There is no deployment(s) available in UI" deployment = get_random_list(deps_db, 1)[0] validate_tags(taggable=deployment, tags=tags)
def test_datasource_tags(provider): """Tests tags in datasources page Steps: * Select a datasource randomly from database * Run `_validate_tags` with `tags` input """ ds_db = MiddlewareDatasource.datasources_in_db(provider=provider) assert len(ds_db) > 0, "There is no datasource(s) available in UI" datasource = get_random_list(ds_db, 1)[0] validate_tags(taggable=datasource, tags=tags)
def test_server_tags(provider): """Tests tags in server page Steps: * Select a server randomly from database * Run `_validate_tags` with `tags` input """ servers_db = MiddlewareServer.servers_in_db(provider=provider) assert len(servers_db) > 0, "There is no server(s) available in DB" server = get_random_list(servers_db, 1)[0] validate_tags(taggable=server, tags=tags)
def get_random_messaging(provider, load_from="db"): load_from = load_from.lower() if load_from == "ui": messagings = MiddlewareMessaging.messagings(provider=provider) elif load_from == "db": messagings = MiddlewareMessaging.messagings_in_db(provider=provider) elif load_from == "mgmt": messagings = MiddlewareMessaging.messagings_in_mgmt(provider=provider) else: raise RuntimeError("Not supported option: '{}'".format(load_from)) assert len(messagings) > 0, "There is no messaging(s) available in {}".format(load_from) return get_random_list(messagings, 1)[0]
def get_random_datasource(provider, load_from="db"): load_from = load_from.lower() if load_from == "ui": datasources = MiddlewareDatasource.datasources(provider=provider) elif load_from == "db": datasources = MiddlewareDatasource.datasources_in_db(provider=provider) elif load_from == "mgmt": datasources = MiddlewareDatasource.datasources_in_mgmt(provider=provider) else: raise RuntimeError("Not supported option: '{}'".format(load_from)) assert len(datasources) > 0, "There is no datasource(s) available in {}".format(load_from) return get_random_list(datasources, 1)[0]
def get_random_server(provider, load_from="db"): load_from = load_from.lower() if load_from == "ui": servers = MiddlewareServer.servers(provider=provider) elif load_from == "db": servers = MiddlewareServer.servers_in_db(provider=provider) elif load_from == "mgmt": servers = MiddlewareServer.servers_in_mgmt(provider=provider) assert len(servers) > 0, "There is no server(s) available in {}".format(load_from) else: raise RuntimeError("Not supported option: '{}'".format(load_from)) return get_random_list(servers, 1)[0]
def get_random_server_group(provider, load_from="db"): load_from = load_from.lower() if load_from == "ui": server_groups = MiddlewareServerGroup.server_groups(get_random_domain(provider, load_from)) elif load_from == "db": server_groups = MiddlewareServerGroup.server_groups_in_db( get_random_domain(provider, load_from)) elif load_from == "mgmt": server_groups = MiddlewareServerGroup.server_groups_in_mgmt( get_random_domain(provider, load_from)) else: raise RuntimeError("Not supported option: '{}'".format(load_from)) assert len(server_groups) > 0, "There is no server group(s) available in {}".format(load_from) return get_random_list(server_groups, 1)[0]
def test_deployment(provider): """Tests deployment details on UI Steps: * Get deployments list from UI * Select up to `ITEMS_LIMIT` deployments randomly * Compare selected deployment details with CFME database """ ui_deps = MiddlewareDeployment.deployments(provider=provider, server=get_server(provider, HAWKULAR_PRODUCT_NAME)) assert len(ui_deps) > 0, "There is no deployment(s) available in UI" for dep_ui in get_random_list(ui_deps, ITEMS_LIMIT): dep_db = dep_ui.deployment(method="db") assert dep_ui.name == dep_db.name, "deployment name does not match between UI and DB" assert dep_ui.server.name == dep_db.server.name, "deployment server name does not match between UI and DB" dep_ui.validate_properties()
def test_list_server_datasources(): """Gets servers list and tests datasources list for each server Steps: * Get servers list from UI * Get datasources list from UI of server * Get datasources list from Database of server * Compare size of all the list [UI, Database] """ servers = MiddlewareServer.servers() assert len(servers) > 0, "There is no server(s) available in UI" for server in get_random_list(servers, ITEMS_LIMIT): ui_dses = _get_datasources_set(MiddlewareDatasource.datasources(server=server)) db_dses = _get_datasources_set(MiddlewareDatasource.datasources_in_db(server=server)) assert ui_dses == db_dses, \ ("Lists of datasources mismatch! UI:{}, DB:{}".format(ui_dses, db_dses))
def test_deployment(provider): """Tests deployment details on UI Steps: * Get deployments list from UI * Select up to `ITEMS_LIMIT` deployments randomly * Compare selected deployment details with CFME database """ ui_deps = MiddlewareDeployment.deployments(provider=provider) assert len(ui_deps) > 0, "There is no deployment(s) available in UI" for dep_ui in get_random_list(ui_deps, ITEMS_LIMIT): dep_db = dep_ui.deployment(method='db') assert dep_ui.name == dep_db.name, "deployment name does not match between UI and DB" assert dep_ui.server.name == dep_db.server.name, \ "deployment server name does not match between UI and DB" dep_ui.validate_properties()
def test_list_server_datasources(): """Gets servers list and tests datasources list for each server Steps: * Get servers list from UI * Get datasources list from UI of server * Get datasources list from Database of server * Compare size of all the list [UI, Database] """ servers = MiddlewareServer.servers() assert len(servers) > 0, "There is no server(s) available in UI" for server in get_random_list(servers, ITEMS_LIMIT): ui_dses = _get_datasources_set( MiddlewareDatasource.datasources(server=server)) db_dses = _get_datasources_set( MiddlewareDatasource.datasources_in_db(server=server)) assert ui_dses == db_dses, \ ("Lists of datasources mismatch! UI:{}, DB:{}".format(ui_dses, db_dses))
def test_tags(provider): """Tests tags in server page Steps: * Select a server randomly from database * Run `validate_tags` with `tags` input """ tags = [ Tag(category=Category(display_name='Environment', single_value=True), display_name='Test'), Tag(category=Category(display_name='Location', single_value=True), display_name='New York'), Tag(category=Category(display_name='Workload', single_value=False), display_name='Application Servers'), ] servers_db = MiddlewareServer.servers_in_db(provider=provider) assert len(servers_db) > 0, "There is no server(s) available in DB" server = get_random_list(servers_db, 1)[0] server.validate_tags(tags=tags)
def test_messaging_details(provider): """Tests messaging details on UI Steps: * Get messagings list from DB * Select each messaging details in UI * Compare selected messaging UI details with CFME database """ msg_list = MiddlewareMessaging.messagings_in_db(provider=provider) for msg in get_random_list(msg_list, ITEMS_LIMIT): msg_ui = msg.messaging(method='ui') msg_db = msg.messaging(method='db') assert msg_ui, "Messaging was not found in UI" assert msg_db, "Messaging was not found in DB" assert msg_ui.name == msg_db.name, \ ("messaging name does not match between UI:{}, DB:{}" .format(msg_ui.name, msg_db.name)) msg_db.validate_properties()
def test_deployment_details(provider): """Tests deployment details on UI Steps: * Get deployments list from DB * Select up to `ITEMS_LIMIT` deployments randomly * Compare selected deployment details with CFME database and UI """ deps = MiddlewareDeployment.deployments_in_db(provider=provider, server=get_hawkular_server(provider)) assert len(deps) > 0, "There is no deployment(s) available in DB" for dep in get_random_list(deps, ITEMS_LIMIT): dep_ui = dep.deployment(method="ui") dep_db = dep.deployment(method="db") assert dep_ui, "deployment was not found in UI" assert dep_db, "deployment was not found in DB" assert dep_ui.name == dep_db.name, "deployment name does not match between UI:{}, DB:{}".format( dep_ui.name, dep_db.name ) dep_db.validate_properties()
def test_list_server_group_servers(provider): """Tests servers lists from server groups of domain and checks values between UI, DB and Management system Steps: * Get domains list from UI of provider * Chooses one of domains * Get server groups list from UI of domain * Get servers list from UI of each server group * Get servers list from Database of each server group * @TODO add support of checking in MGMT * Compare content of all the list [UI, Database] """ domain_list = MiddlewareDomain.domains(provider=provider) for domain in get_random_list(domain_list, 1): server_groups = MiddlewareServerGroup.server_groups(domain=domain) for server_group in server_groups: ui_servers = get_servers_set(MiddlewareServer.servers(server_group=server_group)) db_servers = get_servers_set(MiddlewareServer.servers_in_db(server_group=server_group)) assert ui_servers == db_servers, "Lists of servers mismatch! UI:{}, DB:{}".format(ui_servers, db_servers)
def test_server_details(provider): """Tests server details on UI Steps: * Get servers list from UI * Select each server details in UI * Compare selected server UI details with CFME database and MGMT system """ server_list = MiddlewareServer.servers(provider=provider) for server in get_random_list(server_list, 1): srv_ui = server.server(method='ui') srv_db = server.server(method='db') srv_mgmt = srv_ui.server(method='mgmt') assert srv_ui, "Server was not found in UI" assert srv_db, "Server was not found in DB" assert srv_mgmt, "Server was not found in MGMT system" assert srv_ui.name == srv_db.name == srv_mgmt.name, \ ("server name does not match between UI:{}, DB:{}, MGMT:{}" .format(srv_ui.name, srv_db.name, srv_mgmt.name)) srv_db.validate_properties() srv_mgmt.validate_properties()
def test_datasource_details(provider): """Tests datasource details on UI Steps: * Get datasources list from UI * Select each datasource details in UI * Compare selected datasource UI details with CFME database and MGMT system """ ds_list = MiddlewareDatasource.datasources(provider=provider) for ds in get_random_list(ds_list, ITEMS_LIMIT): ds_ui = ds.datasource(method='ui') ds_db = ds.datasource(method='db') ds_mgmt = ds_ui.datasource(method='mgmt') assert ds_ui, "Datasource was not found in UI" assert ds_db, "Datasource was not found in DB" assert ds_mgmt, "Datasource was not found in MGMT system" assert ds_ui.name == ds_db.name == ds_mgmt.name, \ ("datasource name does not match between UI:{}, DB:{}, MGMT:{}" .format(ds_ui.name, ds_db.name, ds_mgmt.name)) ds_db.validate_properties() ds_mgmt.validate_properties()
def test_domain_details(provider): """Tests domain details on UI Steps: * Get domains list from UI * Select each domain details in UI * Compare selected domain UI details with CFME database and MGMT system """ domain_list = MiddlewareDomain.domains(provider=provider) for domain in get_random_list(domain_list, 1): dmn_ui = domain.domain(method='ui') dmn_db = domain.domain(method='db') dmn_mgmt = domain.domain(method='mgmt') assert dmn_ui, "Domain was not found in UI" assert dmn_db, "Domain was not found in DB" assert dmn_mgmt, "Domain was not found in MGMT system" assert dmn_ui.name == dmn_db.name == dmn_mgmt.name, \ ("domain name does not match between UI:{}, DB:{}, MGMT:{}" .format(dmn_ui.name, dmn_db.name, dmn_mgmt.name)) dmn_db.validate_properties() dmn_mgmt.validate_properties()
def get_random_server_group(provider): server_groups = MiddlewareServerGroup.server_groups(get_random_domain(provider)) assert len(server_groups) > 0, "There is no server_groups(s) available in UI" return get_random_list(server_groups, 1)[0]
def get_random_domain(provider): domains = MiddlewareDomain.domains(provider=provider) assert len(domains) > 0, "There is no domains(s) available in UI" return get_random_list(domains, 1)[0]
def get_random_server(provider): servers = MiddlewareServer.servers(provider=provider) assert len(servers) > 0, "There is no server(s) available in UI" return get_random_list(servers, 1)[0]
def get_random_messaging(provider): messagings = MiddlewareMessaging.messagings_in_db(provider=provider, strict=False) assert len(messagings) > 0, "There is no messaging(s) available in DB" return get_random_list(messagings, 1)[0]
def get_random_datasource(provider): datasources = MiddlewareDatasource.datasources_in_db(provider=provider, strict=False) assert len(datasources) > 0, "There is no datasource(s) available in DB" return get_random_list(datasources, 1)[0]
def get_random_deployment(provider): deployments = MiddlewareDeployment.deployments_in_db(provider=provider, strict=False) assert len(deployments) > 0, "There is no deployment(s) available in DB" return get_random_list(deployments, 1)[0]
def get_random_server_group(provider): server_groups = MiddlewareServerGroup.server_groups_in_db(get_random_domain(provider), strict=False) assert len(server_groups) > 0, "There is no server_groups(s) available in DB" return get_random_list(server_groups, 1)[0]
def get_random_domain(provider): domains = MiddlewareDomain.domains_in_db(provider=provider, strict=False) assert len(domains) > 0, "There is no domains(s) available in DB" return get_random_list(domains, 1)[0]
def get_random_server(provider): servers = MiddlewareServer.servers_in_db(provider=provider, strict=False) assert len(servers) > 0, "There is no server(s) available in DB" return get_random_list(servers, 1)[0]
def get_random_datasource(provider): datasources = MiddlewareDatasource.datasources(provider=provider) assert len(datasources) > 0, "There is no datasource(s) available in UI" return get_random_list(datasources, 1)[0]
def get_random_messaging(provider): messagings = MiddlewareMessaging.messagings(provider=provider) assert len(messagings) > 0, "There is no messaging(s) available in UI" return get_random_list(messagings, 1)[0]
def _get_random_server(provider): servers = MiddlewareServer.servers(provider=provider) assert len(servers) > 0, "There is no server(s) available in UI" return get_random_list(servers, 1)[0]