def test_import_all_nix_system(core_session, cleanup_accounts, cleanup_resources): """ Test case: C279397 :param core_session: Centrify session """ # datframe to store systems with unique name in csv import template # dataframe to store systems in csv import template # datframe to store systems with unique name in csv import template system_list = cleanup_resources[0] accounts_list = cleanup_accounts[0] dataframe = pd.read_csv('Assets\\serverimport.csv') server_list = dataframe['Name'] for server in server_list: dataframe = dataframe.replace(server, f'{server}{guid()}') temp_server_csv = f"Assets\\serverimport{guid()}.csv" dataframe.to_csv(temp_server_csv, encoding='utf-8', index=False) # API call with server import template result, success = ResourceManager.bulk_import_system(core_session, temp_server_csv) assert success, f"failed to add systems, return result is: {result}" logger.info('bulk import successful') server = RedrockController.get_accounts(core_session) for row in server: if row['User'].__contains__("Administrator"): accounts_list.append(row["ID"]) server = RedrockController.get_computers(core_session) for row in server: if row['Name'].__contains__("host"): system_list.append(row["ID"]) if os.path.exists(temp_server_csv): os.remove(temp_server_csv) else: pass
def test_bulk_account_delete_job_fails_due_to_invalid_request_missing_secret( clean_bulk_delete_systems_and_accounts, core_session, simulate_failure, list_of_created_systems): batch = ResourceManager.add_multiple_systems_with_accounts( core_session, 1, 1, list_of_created_systems) all_systems, all_accounts = DataManipulation.aggregate_lists_in_dict_values( [batch]) some_set_name = "ApiSet" + guid() success, set_id = SetsManager.create_manual_collection( core_session, some_set_name, "VaultAccount", None) assert success, "Did not create collection" SetsManager.update_members_collection(core_session, 'add', list(all_accounts), 'VaultAccount', set_id) params = Util.scrub_dict({ 'Ids': list(all_accounts), 'SaveToSecrets': simulate_failure, 'SecretName': "Bulk Account Delete", 'SetQuery': "", 'SkipIfHasAppsOrServices': simulate_failure }) if simulate_failure: request = core_session.apirequest(EndPoints.ACCOUNT_MULTI_DELETE, params) request_json = request.json() result, success = request_json['Result'], request_json['success'] ResourceManager.wait_for_job_state_succeeded(core_session, result) assert simulate_failure == success, f"Query success was unexpected value, with message {result}" else: request = core_session.apirequest(EndPoints.ACCOUNT_MULTI_DELETE, params) request_json = request.json() result, success = request_json['Result'], request_json['success'] ResourceManager.wait_for_job_state_succeeded(core_session, result) assert not simulate_failure == success, f"Query success was unexpected value, with message {result}" total_account = RedrockController.get_accounts(core_session) SetsManager.delete_collection(core_session, set_id) list_account = [] for get_account in total_account: if get_account['ID'] == all_accounts: list_account.append(get_account['ID']) assert 0 == len( list_account ), "Number of remaining added accounts was unexpected number"
def test_add_system_discovery(core_session, ad_discovery_profile, pas_ad_discovery_config, core_value, delete_discovered_system): """ Test Case: Add System (C1555) :param core_session: Authenticated Centrify Session :param ad_discovery_profile: Fixture to create AD profile for system discovery :param pas_ad_discovery_config: fixture to read yaml file to create profile :param core_value: fixture to read core.yaml :param delete_discovered_system: fixture for cleanup before and after discovery """ config_profile = pas_ad_discovery_config profile_data = config_profile['ad_profile_data'][0] domain_details = config_profile['domains'] domain_name = [] domain_id_list = [] for domains in domain_details: domain_name.append(domains['Name']) for domain in domain_name: domain_id = RedrockController.get_id_from_name(core_session, domain, 'VaultDomain') domain_id_list.append(domain_id) # Delete System and account before discovery delete_discovered_system(profile_data['discovered_system'], domain_id_list) profile_list, profile_name, profile_id, account_list, account_id = ad_discovery_profile( domain_name, profile_data['account_in_domain']) # Run Discovery to discover window system result_run, success, response = Discovery.run_discovery_profile( core_session, profile_id, wait_for_run=True) assert success, f"Failed to run discovery profile: {response}" logger.info(f"Discovery ran successfully, API response: {result_run} ") # Check Last Verify and Last Verify Result for Account last_verify = None last_verify_result = None account_list = RedrockController.get_accounts(core_session) discovered_account = [] for account in account_list: if account['AccountDiscoveredTime'] is not None: discovered_account.append(account['ID']) last_verify = account['Status'] last_verify_result = account['LastHealthCheck'] assert len( discovered_account ) != 0, f"Failed to discover system, account and services {discovered_account}" logger.info(f"Discovered Account is: {discovered_account}") assert last_verify_result is not None, "Failed to test account" assert last_verify == "Missing Password", "Failed to test account" logger.info( f"Last Test:{last_verify} and Last Test Result: {last_verify_result}") # Check Last Test Result and Last Test for Domain result = ServerManager.get_all_domains(core_session) for domain in result: if domain['Name'] in domain_name: last_test = domain['LastHealthCheck'] last_test_result = domain['HealthCheckInterval'] assert last_test is not None, "Failed to test Domain" assert last_test_result is None, "Failed to test Domain" logger.info( f"Domain Name: {domain['Name']}, Last Test:{last_test} and Last Test Result: {last_test_result}" ) # Check Last Test Result and Last Test for Discovered System result = RedrockController.get_computers(core_session) last_test = None last_test_result = None discovered_system = [] for system in result: if system['DiscoveredTime'] is not None: discovered_system.append(system['ID']) last_test = system['LastHealthCheck'] last_test_result = system['HealthCheckInterval'] assert last_test is not None, "Failed to test system" assert last_test_result is None, "Failed to test system" logger.info( f"Last Test:{last_test} and Last Test Result: {last_test_result}") # Cleanup after discovery delete_discovered_system(profile_data['discovered_system'], domain_id_list)