def test_download_audit_log_record_write_file(self, mck_write):
"""Test download_audit_log_record write to file."""
ref_response = pf.FakeResponse(200,
dict(),
content=b'test_binary_data')
with mock.patch.object(common.CommonFunctions,
'download_file',
return_value=ref_response) as mck_dl:
ref_req_body = {AUDIT_LOG_FILENAME: 'test'}
response = self.system.download_audit_log_record(file_name='test',
dir_path='test')
mck_dl.assert_called_once_with(
category=SYSTEM,
resource_level=SYMMETRIX,
resource_level_id=self.system.array_id,
resource_type=AUDIT_LOG_RECORD,
resource=EXPORT_FILE,
payload=ref_req_body)
mck_write.assert_called_once_with(
data=ref_response,
file_extension=constants.PDF_SUFFIX,
file_name='test',
dir_path='test')
self.assertTrue(response[SUCCESS])
self.assertIn('/test/test.pdf', str(response[AUDIT_RECORD_PATH]))
def test_rest_request_value_error_no_status_code(self):
"""Test REST request value error no response or status code."""
with mock.patch.object(self.rest.session,
'request',
return_value=pf.FakeResponse(None, None)):
response, sc = self.rest.rest_request('/fake_uri', 'GET')
self.assertIsNone(sc)
self.assertIsNone(response)
def test_rest_request_value_error(self):
"""Test REST request value error no response."""
with mock.patch.object(self.rest.session,
'request',
return_value=pf.FakeResponse(500, None)):
response, sc = self.rest.rest_request('/fake_uri', 'GET')
self.assertEqual(500, sc)
self.assertIsNone(response)
def test_download_audit_log_record_write_file_no_name(self, mck_write):
"""Test download_audit_log_record no file name provided."""
ref_response = pf.FakeResponse(200, dict(),
content=b'test_binary_data')
with mock.patch.object(
common.CommonFunctions, 'download_file',
return_value=ref_response) as mck_dl:
response = self.system.download_audit_log_record()
mck_dl.assert_called_once()
mck_write.assert_called_once()
self.assertTrue(response[SUCCESS])
self.assertIn('/test/test.pdf', str(response[AUDIT_RECORD_PATH]))
def test_rest_request(self):
"""Test REST request success."""
with mock.patch.object(self.rest.session,
'request',
return_value=pf.FakeResponse(
200,
self.data.server_version)) as mock_request:
response, sc = self.rest.rest_request('/fake_uri', 'GET')
mock_request.assert_called_once_with(
method='GET',
timeout=120,
url='http://10.10.10.10:8443/univmax/restapi/fake_uri')
self.assertEqual(200, sc)
self.assertEqual(self.data.server_version, response)
def test_rest_request_object(self):
"""Test REST request with object."""
with mock.patch.object(self.rest.session,
'request',
return_value=pf.FakeResponse(
200,
self.data.server_version)) as mock_request:
request_object = {'param': 'test'}
response, sc = self.rest.rest_request(
'/fake_uri', 'GET', request_object=request_object)
mock_request.assert_called_once_with(
method='GET',
timeout=120,
data=json.dumps(request_object, sort_keys=True, indent=4),
url='http://10.10.10.10:8443/univmax/restapi/fake_uri')
self.assertEqual(200, sc)
self.assertEqual(self.data.server_version, response)
def test_upload_file_fail_backend_exception(self):
"""Test upload_file fail with volume backend API exception."""
with mock.patch.object(self.conn.rest_client,
'establish_rest_session',
return_value=pf.FakeRequestsSession()):
with mock.patch.object(
self.conn.rest_client,
'file_transfer_request',
return_value=(pf.FakeResponse(
200,
return_object=dict(),
text=self.data.response_string_dict_fail), 200)):
self.assertRaises(exception.VolumeBackendAPIException,
self.common.upload_file,
category=constants.SYSTEM,
resource_level=constants.SETTINGS,
resource_type=constants.IMPORT_FILE,
form_data={'test_req': True})
def test_write_binary_data_to_file_with_dir(self, mck_open):
"""Test write_binary_data_to_file with directory input param."""
test_data = pf.FakeResponse(200, dict(), content=b'test_binary_data')
test_dir_path = Path.home()
test_file_name = 'test_file'
test_file_extension = constants.PDF_SUFFIX
ref_name = Path(test_file_name)
ref_path = Path(test_dir_path)
pdf_name = ref_name.with_suffix(test_file_extension)
ref_write_path = Path.joinpath(ref_path, pdf_name)
response = self.file.write_binary_data_to_file(
data=test_data, file_extension=test_file_extension,
file_name=test_file_name, dir_path=test_dir_path)
mck_open.assert_called_once_with(
ref_write_path, constants.FILE_WRITE_MODE)
self.assertEqual(ref_write_path, response)
class PyU4VSystemTest(testtools.TestCase):
"""Test System."""
def setUp(self):
"""Setup."""
super(PyU4VSystemTest, self).setUp()
self.data = pcd.CommonData()
self.conf_file, self.conf_dir = (
pf.FakeConfigFile.create_fake_config_file())
univmax_conn.file_path = self.conf_file
with mock.patch.object(rest_requests.RestRequests,
'establish_rest_session',
return_value=pf.FakeRequestsSession()):
self.conn = univmax_conn.U4VConn(array_id=self.data.array)
self.common = self.conn.common
self.system = self.conn.system
def test_get_system_health(self):
"""Test get_system_health."""
health_check_result = self.system.get_system_health()
self.assertEqual(self.data.array_health, health_check_result)
def test_list_system_health_check(self):
"""Test list_system_health_checks."""
health_check_list = self.system.list_system_health_check()
self.assertEqual(self.data.array_health_check_list, health_check_list)
def test_get_health_check_details(self):
"""Test get_health_check_details."""
health_check = self.system.get_health_check_details(health_check_id=1)
self.assertEqual(self.data.health_check_response, health_check)
def test_perform_health_check(self):
"""Test perform_health_check."""
run_test = self.system.perform_health_check()
self.assertEqual(run_test, self.data.perform_health_check_response)
def test_delete_health_check(self):
"""Test delete_health_check."""
common.CommonFunctions.delete_resource = MagicMock(
side_effect=self.common.delete_resource)
self.system.delete_health_check(health_check_id=1)
common.CommonFunctions.delete_resource.assert_called_once_with(
category=SYSTEM,
resource_level=SYMMETRIX,
resource_level_id=self.conn.array_id,
resource_type=HEALTH,
resource_type_id=HEALTH_CHECK,
object_type=1)
def test_get_disk_id_list(self):
"""Test get_disk_id_list."""
disk_list = self.system.get_disk_id_list(failed=True)
self.assertEqual(self.data.disk_list, disk_list)
def test_get_disk_details(self):
"""Test get_disk_details."""
disk_info = self.system.get_disk_details(disk_id='1')
self.assertEqual(self.data.disk_info, disk_info)
def test_get_tags(self):
"""Test get_tags."""
common.CommonFunctions.get_resource = MagicMock(
side_effect=self.common.get_resource)
tag_list = self.system.get_tags(array_id=self.conn.array_id,
tag_name='UNIT-TEST',
storage_group_id='TEST-SG',
num_of_storage_groups=1,
num_of_arrays=3)
common.CommonFunctions.get_resource.assert_called_once_with(
category=SYSTEM,
resource_level=TAG,
params={
ARRAY_ID: self.conn.array_id,
TAG_NAME: 'UNIT-TEST',
SG_ID: 'TEST-SG',
SG_NUM: '1',
ARRAY_NUM: '3'
})
self.assertEqual(self.data.tag_list, tag_list)
def test_get_tagged_objects(self):
"""Test get_tagged_objects."""
tagged_objects = self.system.get_tagged_objects(tag_name='UNIT-TEST')
self.assertEqual(self.data.tagged_objects, tagged_objects)
def test_get_alert_summary(self):
"""Test get_alert_summary."""
alert_summary = self.system.get_alert_summary()
self.assertEqual(self.data.alert_summary, alert_summary)
def test_get_alert_ids(self):
"""Test get_alert_ids."""
alert_ids = self.system.get_alert_ids(array='123456789',
_type='Server',
severity='Warning',
state='New',
created_date='1234455',
_object='BE',
object_type='Director',
acknowledged=True,
description='Alert')
self.assertEqual(self.data.alert_list['alertId'], alert_ids)
def test_get_alert_details(self):
"""Test get_alert_details."""
alert_details = self.system.get_alert_details(alert_id=ALERT_ID)
self.assertEqual(self.data.alert_details, alert_details)
@mock.patch.object(common.CommonFunctions, 'modify_resource')
def test_acknowledge_alert(self, mck_modify):
"""Test acknowledge_alert."""
ref_payload = {'editAlertActionParam': 'ACKNOWLEDGE'}
self.system.acknowledge_alert(alert_id=ALERT_ID)
mck_modify.assert_called_once_with(category=SYSTEM,
resource_level=ALERT,
resource_level_id=ALERT_ID,
payload=ref_payload)
@mock.patch.object(common.CommonFunctions, 'delete_resource')
def test_delete_alert(self, mck_delete):
"""Test delete_alert."""
self.system.delete_alert(alert_id=ALERT_ID)
mck_delete.assert_called_once_with(category=SYSTEM,
resource_level=ALERT,
resource_level_id=ALERT_ID)
@mock.patch.object(common.CommonFunctions,
'download_file',
return_value=pf.FakeResponse(
200, dict(), content=b'test_binary_data'))
def test_download_settings_success_return_binary(self, mck_dl):
"""Test _download_settings success binary data returned."""
response = self.system._download_settings(request_body=dict(),
return_binary=True)
mck_dl.assert_called_once_with(category=constants.SYSTEM,
resource_level=constants.SETTINGS,
resource_type=constants.EXPORT_FILE,
payload=dict())
self.assertTrue(response['success'])
self.assertIn('binary_data', response.keys())
self.assertEqual(b'test_binary_data', response['binary_data'])
@mock.patch('builtins.open', new_callable=mock.mock_open)
@mock.patch.object(common.CommonFunctions,
'download_file',
return_value=pf.FakeResponse(
200, dict(), content=b'test_binary_data'))
def test_download_settings_success_write_file(self, mck_dl, mck_open):
"""Test _download_settings success"""
response = self.system._download_settings(request_body=dict())
mck_dl.assert_called_once_with(category=constants.SYSTEM,
resource_level=constants.SETTINGS,
resource_type=constants.EXPORT_FILE,
payload=dict())
mck_open.assert_called_once()
self.assertTrue(response['success'])
self.assertIn(str(Path.cwd()), str(response['settings_path']))
self.assertIn(constants.SETTINGS_FILENAME_TEMPLATE,
str(response['settings_path']))
@mock.patch('builtins.open', new_callable=mock.mock_open)
@mock.patch.object(common.CommonFunctions,
'download_file',
return_value=pf.FakeResponse(
200, dict(), content=b'test_binary_data'))
def test_download_settings_success_write_file_custom_path(
self, mck_dl, mck_open):
"""Test _download_settings success"""
response = self.system._download_settings(request_body=dict(),
file_name='test',
dir_path=Path.home())
mck_dl.assert_called_once_with(category=constants.SYSTEM,
resource_level=constants.SETTINGS,
resource_type=constants.EXPORT_FILE,
payload=dict())
mck_open.assert_called_once()
self.assertTrue(response['success'])
self.assertIn(str(Path.home()), str(response['settings_path']))
self.assertIn('test.zip', str(response['settings_path']))
@mock.patch.object(common.CommonFunctions,
'download_file',
return_value=None)
def test_download_settings_fail_no_response(self, mck_dl):
"""Test _download_settings fail no response from API."""
response = self.system._download_settings(request_body=dict())
mck_dl.assert_called_once_with(category=constants.SYSTEM,
resource_level=constants.SETTINGS,
resource_type=constants.EXPORT_FILE,
payload=dict())
self.assertEqual({'success': False}, response)
@mock.patch.object(common.CommonFunctions,
'download_file',
return_value=pf.FakeResponse(
200, dict(), content=b'test_binary_data'))
def test_download_settings_dir_path_exception(self, mck_dl):
"""Test _download_settings directory doesn't exist exception."""
self.assertRaises(exception.InvalidInputException,
self.system._download_settings,
request_body=dict(),
dir_path='fake')
mck_dl.assert_called_once_with(category=constants.SYSTEM,
resource_level=constants.SETTINGS,
resource_type=constants.EXPORT_FILE,
payload=dict())
def test_download_all_settings(self):
"""Test download_all_settings."""
ref_request_body = {
constants.FILE_PASSWORD: '******',
constants.SRC_ARRAY: self.data.remote_array
}
with mock.patch.object(self.system, '_download_settings') as mck_dl:
self.system.download_all_settings(file_password='******',
dir_path='/test/file/path',
file_name='test_filename',
array_id=self.data.remote_array,
return_binary=True)
mck_dl.assert_called_once_with(request_body=ref_request_body,
dir_path='/test/file/path',
file_name='test_filename',
return_binary=True)
def test_download_unisphere_settings_1_2_params(self):
"""Test download_unisphere_settings success 1 & 2 output params."""
ref_request_body = {
constants.FILE_PASSWORD:
'******',
constants.SRC_ARRAY:
self.conn.array_id,
constants.EXCLUDE_SYS_SETTINGS: [constants.ALL_SETTINGS],
constants.EXCLUDE_UNI_SETTINGS:
[constants.UNI_ALERT_SETTINGS, constants.UNI_PERF_PREF_SETTINGS]
}
with mock.patch.object(self.system, '_download_settings') as mck_dl:
self.system.download_unisphere_settings(
file_password='******',
dir_path='/test/file/path',
file_name='test_filename',
return_binary=True,
exclude_alert_notification_settings=True,
exclude_performance_preference_settings=True)
mck_dl.assert_called_once_with(request_body=ref_request_body,
dir_path='/test/file/path',
file_name='test_filename',
return_binary=True)
def test_download_unisphere_settings_3_4_params(self):
"""Test download_unisphere_settings success 3 & 4 output params."""
ref_request_body = {
constants.FILE_PASSWORD:
'******',
constants.SRC_ARRAY:
self.conn.array_id,
constants.EXCLUDE_SYS_SETTINGS: [constants.ALL_SETTINGS],
constants.EXCLUDE_UNI_SETTINGS: [
constants.UNI_PERF_USER_SETTINGS,
constants.UNI_PERF_METRIC_SETTINGS
]
}
with mock.patch.object(self.system, '_download_settings') as mck_dl:
self.system.download_unisphere_settings(
file_password='******',
dir_path='/test/file/path',
file_name='test_filename',
return_binary=True,
exclude_performance_user_templates=True,
exclude_performance_metric_settings=True)
mck_dl.assert_called_once_with(request_body=ref_request_body,
dir_path='/test/file/path',
file_name='test_filename',
return_binary=True)
def test_download_unisphere_settings_all_excluded_exception(self):
"""Test download_unisphere_settings all settings excluded exception."""
self.assertRaises(exception.InvalidInputException,
self.system.download_unisphere_settings,
file_password='******',
exclude_alert_notification_settings=True,
exclude_performance_preference_settings=True,
exclude_performance_user_templates=True,
exclude_performance_metric_settings=True)
def test_download_system_settings_1_2_params(self):
"""Test download_system_settings success 1 & 2 output params."""
ref_request_body = {
constants.FILE_PASSWORD:
'******',
constants.SRC_ARRAY:
self.data.remote_array,
constants.EXCLUDE_SYS_SETTINGS: [
constants.SYS_ALERT_SETTINGS,
constants.SYS_ALERT_NOTIFI_SETTINGS
],
constants.EXCLUDE_UNI_SETTINGS: [constants.ALL_SETTINGS]
}
with mock.patch.object(self.system, '_download_settings') as mck_dl:
self.system.download_system_settings(
file_password='******',
dir_path='/test/file/path',
file_name='test_filename',
array_id=self.data.remote_array,
return_binary=True,
exclude_alert_policy_settings=True,
alert_level_notification_settings=True)
mck_dl.assert_called_once_with(request_body=ref_request_body,
dir_path='/test/file/path',
file_name='test_filename',
return_binary=True)
def test_download_system_settings_3_4_params(self):
"""Test download_system_settings success 3 & 4 output params."""
ref_request_body = {
constants.FILE_PASSWORD:
'******',
constants.SRC_ARRAY:
self.data.remote_array,
constants.EXCLUDE_SYS_SETTINGS: [
constants.SYS_THRESH_SETTINGS,
constants.SYS_PERF_THRESH_SETTINGS
],
constants.EXCLUDE_UNI_SETTINGS: [constants.ALL_SETTINGS]
}
with mock.patch.object(self.system, '_download_settings') as mck_dl:
self.system.download_system_settings(
file_password='******',
dir_path='/test/file/path',
file_name='test_filename',
array_id=self.data.remote_array,
return_binary=True,
exclude_system_threshold_settings=True,
exclude_performance_threshold_settings=True)
mck_dl.assert_called_once_with(request_body=ref_request_body,
dir_path='/test/file/path',
file_name='test_filename',
return_binary=True)
def test_download_system_settings_all_excluded_exception(self):
"""Test download_system_settings all settings excluded exception."""
self.assertRaises(exception.InvalidInputException,
self.system.download_system_settings,
file_password='******',
exclude_alert_policy_settings=True,
alert_level_notification_settings=True,
exclude_system_threshold_settings=True,
exclude_performance_threshold_settings=True)
@mock.patch.object(common.CommonFunctions, 'upload_file')
@mock.patch('builtins.open', return_value=__file__)
def test_upload_settings(self, mck_open, mck_up):
"""Test upload_settings success."""
ref_form_data = {
constants.ZIP_FILE: __file__,
constants.TGT_ARRAYS: self.data.remote_array,
constants.FILE_PASSWORD: '******'
}
self.system.upload_settings(file_password='******',
file_path=__file__,
array_id=self.data.remote_array)
mck_up.assert_called_once_with(category=constants.SYSTEM,
resource_level=constants.SETTINGS,
resource_type=constants.IMPORT_FILE,
form_data=ref_form_data)
@mock.patch.object(common.CommonFunctions, 'upload_file')
def test_upload_settings_binary_data(self, mck_up):
"""Test upload_settings binary data success."""
ref_form_data = {
constants.ZIP_FILE: b'test_binary_data',
constants.TGT_ARRAYS: self.conn.array_id,
constants.FILE_PASSWORD: '******'
}
self.system.upload_settings(file_password='******',
binary_data=b'test_binary_data')
mck_up.assert_called_once_with(category=constants.SYSTEM,
resource_level=constants.SETTINGS,
resource_type=constants.IMPORT_FILE,
form_data=ref_form_data)
def test_upload_settings_path_exception(self):
"""Test upload_settings path doesn't exist exception."""
self.assertRaises(exception.InvalidInputException,
self.system.upload_settings,
file_password='******',
file_path='/fake')
def test_upload_settings_invalid_data_type(self):
"""Test upload_settings invalid data type"""
self.assertRaises(exception.InvalidInputException,
self.system.upload_settings,
file_password='******',
binary_data='/fake')
def test_get_audit_log_list(self):
"""Test get_audit_log_list success."""
end = int(time.time())
# Set start time 24hrs + 1 second to trigger LOG warning
start = end - (60 * 60 * 24) - 1
response = self.system.get_audit_log_list(start_time=start,
end_time=end,
array_id='test',
user_name='test',
host_name='test',
client_host='test',
message='test',
record_id='test',
activity_id='test',
application_id='test',
application_version='test',
task_id='test',
process_id='test',
vendor_id='test',
os_type='test',
os_revision='test',
api_library='test',
api_version='test',
audit_class='test',
action_code='test',
function_class='test')
self.assertTrue(response)
self.assertIsInstance(response, list)
@mock.patch.object(common.CommonFunctions,
'get_request',
return_value={'count': 0})
def test_get_audit_log_list_no_content(self, mck_get):
"""Test upload_settings binary data success."""
end = int(time.time())
start = end
response = self.system.get_audit_log_list(start_time=start,
end_time=end)
self.assertFalse(response)
self.assertIsInstance(response, list)
def test_get_audit_log_record(self):
"""Test get_audit_log_record."""
response = self.system.get_audit_log_record(record_id='test')
self.assertTrue(response)
self.assertIsInstance(response, dict)
@mock.patch.object(common.CommonFunctions,
'download_file',
return_value=pf.FakeResponse(
200, dict(), content=b'test_binary_data'))
def test_download_audit_log_record_return_binary(self, mck_dl):
"""Test download_audit_log_record return binary."""
ref_req_body = {AUDIT_LOG_FILENAME: 'test'}
response = self.system.download_audit_log_record(file_name='test',
return_binary=True)
mck_dl.assert_called_once_with(category=SYSTEM,
resource_level=SYMMETRIX,
resource_level_id=self.system.array_id,
resource_type=AUDIT_LOG_RECORD,
resource=EXPORT_FILE,
payload=ref_req_body)
self.assertTrue(response[SUCCESS])
self.assertIn(BINARY_DATA, response.keys())
self.assertEqual(b'test_binary_data', response[BINARY_DATA])
@mock.patch.object(file_handler,
'write_binary_data_to_file',
return_value='/test/test.pdf')
def test_download_audit_log_record_write_file(self, mck_write):
"""Test download_audit_log_record write to file."""
ref_response = pf.FakeResponse(200,
dict(),
content=b'test_binary_data')
with mock.patch.object(common.CommonFunctions,
'download_file',
return_value=ref_response) as mck_dl:
ref_req_body = {AUDIT_LOG_FILENAME: 'test'}
response = self.system.download_audit_log_record(file_name='test',
dir_path='test')
mck_dl.assert_called_once_with(
category=SYSTEM,
resource_level=SYMMETRIX,
resource_level_id=self.system.array_id,
resource_type=AUDIT_LOG_RECORD,
resource=EXPORT_FILE,
payload=ref_req_body)
mck_write.assert_called_once_with(
data=ref_response,
file_extension=constants.PDF_SUFFIX,
file_name='test',
dir_path='test')
self.assertTrue(response[SUCCESS])
self.assertIn('/test/test.pdf', str(response[AUDIT_RECORD_PATH]))
@mock.patch.object(file_handler,
'write_binary_data_to_file',
return_value='/test/test.pdf')
def test_download_audit_log_record_write_file_no_name(self, mck_write):
"""Test download_audit_log_record no file name provided."""
ref_response = pf.FakeResponse(200,
dict(),
content=b'test_binary_data')
with mock.patch.object(common.CommonFunctions,
'download_file',
return_value=ref_response) as mck_dl:
response = self.system.download_audit_log_record()
mck_dl.assert_called_once()
mck_write.assert_called_once()
self.assertTrue(response[SUCCESS])
self.assertIn('/test/test.pdf', str(response[AUDIT_RECORD_PATH]))
def test_get_director_list(self):
"""Test get_director_list."""
array_id = self.data.array
dir_list = self.system.get_director_list(array_id=array_id)
self.assertTrue(dir_list)
self.assertIsInstance(dir_list, list)
self.assertEqual([self.data.director_id1, self.data.director_id2],
dir_list)
def test_get_iscsi_director_list(self):
"""Test get_director_list iscsi_only set to True."""
array_id = self.data.array
iscsi_dir_list = self.system.get_director_list(array_id=array_id,
iscsi_only=True)
self.assertTrue(iscsi_dir_list)
self.assertIsInstance(iscsi_dir_list, list)
self.assertEqual([self.data.director_id2], iscsi_dir_list)
def test_get_director_port_list(self):
"""Test get_director_port_list."""
director_id = self.data.director_id1
dir_port_list = self.system.get_director_port_list(
director_id=director_id, iscsi_target=False)
self.assertTrue(dir_port_list)
self.assertIsInstance(dir_port_list, list)
self.assertEqual(self.data.port_key_list.get('symmetrixPortKey'),
dir_port_list)
def test_get_ip_interface_list(self):
"""Test get_ip_interface_list"""
director_id = self.data.director_id2
port_id = 0
ip_int_list = self.system.get_ip_interface_list(
director_id=director_id, port_id=port_id)
self.assertTrue(ip_int_list)
self.assertIsInstance(ip_int_list, list)
self.assertEqual(self.data.ip_interface_list.get('ipInterfaceId'),
ip_int_list)
def test_get_ip_interface(self):
"""Test get_ip_interface."""
director_id = self.data.director_id2
port_id = 0
interface_id = self.data.ip_interface_address_network
ip_int_info = self.system.get_ip_interface(director_id=director_id,
port_id=port_id,
interface_id=interface_id)
self.assertTrue(ip_int_info)
self.assertIsInstance(ip_int_info, dict)
self.assertEqual(self.data.ip_interface_details, ip_int_info)
