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)
