def test_update_device_details_with_filtering_failure_case_01(self, ome_connection_mock, ome_response_mock):
error_msg = '400: Bad Request'
service_tag_dict = {}
non_available_tags = [Constants.service_tag2]
ome_connection_mock.invoke_request.side_effect = HTTPError('http://testhost.com', 400, error_msg, {}, None)
with pytest.raises(HTTPError, match=error_msg) as ex:
self.module.update_device_details_with_filtering(non_available_tags, service_tag_dict, ome_connection_mock)
def test_modules_provisioned_raises(self):
self.connection.send.side_effect = HTTPError(
'https://bigip.local/mgmt/tm/sys/provision', 400, '', {}, StringIO('{"errorMessage": "ERROR"}')
)
with self.assertRaises(F5ModuleError) as res:
modules_provisioned(self.client)
assert "{'errorMessage': 'ERROR'}" in str(res.exception)
def test_main_detailed_inventory_http_error_case(
self, ome_default_args, module_mock, validate_device_inputs_mock,
ome_connection_mock, get_device_resource_parameters_mock,
ome_response_mock):
ome_default_args.update({
"fact_subset": "detailed_inventory",
"system_query_options": {
"device_id": [Constants.device_id1],
"device_service_tag": [Constants.service_tag1]
}
})
detailed_inventory = {
"detailed_inventory:": {
"device_id": {
Constants.device_id1:
"DeviceService/Devices(Constants.device_id1)/InventoryDetails"
},
"device_service_tag": {
Constants.service_tag1:
"DeviceService/Devices(4321)/InventoryDetails"
}
}
}
get_device_resource_parameters_mock.return_value = detailed_inventory
ome_connection_mock.invoke_request.side_effect = HTTPError(
'http://testhost.com', 400, '', {}, None)
result = self._run_module_with_fail_json(ome_default_args)
assert 'device_info' not in result
def test_get_device_id_from_service_tags_error_case(
self, ome_connection_mock, ome_response_mock):
ome_connection_mock.get_all_report_details.side_effect = HTTPError(
'http://testhost.com', 400, '', {}, None)
with pytest.raises(HTTPError) as ex:
self.module._get_device_id_from_service_tags(["INVALID"],
ome_connection_mock)
def test_bigiq_version_raises_on_http_error(self):
self.connection.send.side_effect = HTTPError(
'https://bigiq.local/mgmt/shared/resolver/device-groups/cm-shared-all-big-iqs/devices',
400, '', {}, StringIO('{"errorMessage": "ERROR"}'))
with self.assertRaises(F5ModuleError) as res:
bigiq_version(self.client)
assert '{\'errorMessage\': \'ERROR\'}' in str(res.exception)
def test_main_HTTPError_case(self, idrac_connection_firmware_mock,
idrac_default_args,
idrac_connection_firmware_redfish_mock,
mocker):
idrac_default_args.update({
"share_name": "sharename",
"catalog_file_name": "Catalog.xml",
"share_user": "******",
"share_password": "******",
"share_mnt": "sharmnt",
"reboot": True,
"job_wait": True
})
json_str = to_text(json.dumps({"data": "out"}))
idrac_connection_firmware_redfish_mock.success = True
idrac_connection_firmware_redfish_mock.json_data = {
"FirmwareVersion": "2.70"
}
mocker.patch(MODULE_PATH + 'idrac_firmware.update_firmware_omsdk',
side_effect=HTTPError('http://testhost.com', 400,
'http error message',
{"accept-type": "application/json"},
StringIO(json_str)))
result = self._run_module_with_fail_json(idrac_default_args)
assert 'msg' in result
assert result['failed'] is True
def test_send_request_should_return_error_info_when_http_error_raises(self):
self.connection_mock.send.side_effect = HTTPError('http://testhost.com', 500, '', {},
StringIO('{"errorMessage": "ERROR"}'))
resp = self.checkpoint_plugin.send_request('/test', None)
assert resp == (500, {'errorMessage': 'ERROR'})
def test_perform_storage_volume_action_exception_case(self, redfish_response_mock,
redfish_connection_mock_for_storage_volume):
redfish_response_mock.headers.update({"Location": "JobService/Jobs/JID_123"})
redfish_connection_mock_for_storage_volume.invoke_request.side_effect = HTTPError('http://testhost.com', 400,
'', {}, None)
with pytest.raises(HTTPError) as ex:
self.module.perform_storage_volume_action("POST", "uri", redfish_connection_mock_for_storage_volume,
"create", payload={"payload": "value"})
def test_auth_error(self, mocker):
request_mock = mocker.patch.object(client, "Request").return_value
request_mock.open.side_effect = HTTPError("", 401, "Unauthorized", {},
None)
c = client.Client("https://instance.com", "user", "pass")
with pytest.raises(errors.AuthError):
c.request("GET", "api/now/some/path")
def test_login_raises_exception_when_http_error(self):
self.connection_mock.send.side_effect = HTTPError('http://testhost.com', 400, '', {},
StringIO('{"message": "Failed to authenticate user"}'))
with self.assertRaises(ConnectionError) as res:
self.ftd_plugin.login('foo', 'bar')
assert 'Failed to authenticate user' in str(res.exception)
def test_send_request_should_return_error_info_when_http_error_raises(self):
self.connection_mock.send.side_effect = HTTPError('http://testhost.com', 500, '', {},
StringIO('{"errorMessage": "ERROR"}'))
resp = self.ftd_plugin.send_request('/test', HTTPMethod.GET)
assert {ResponseParams.SUCCESS: False, ResponseParams.STATUS_CODE: 500,
ResponseParams.RESPONSE: {'errorMessage': 'ERROR'}} == resp
def test_fetch_storage_resource_error_case_04(self, redfish_connection_mock_for_storage_volume,
redfish_response_mock):
f_module = self.get_module_mock()
msg = "http error"
redfish_connection_mock_for_storage_volume.root_uri = "/redfish/v1/"
redfish_connection_mock_for_storage_volume.invoke_request.side_effect = HTTPError('http://testhost.com', 400,
msg, {}, None)
with pytest.raises(Exception, match=msg) as exc:
self.module.fetch_storage_resource(f_module, redfish_connection_mock_for_storage_volume)
def test_fetch_storage_resource_error_case_03(self, redfish_connection_mock_for_storage_volume,
redfish_response_mock):
f_module = self.get_module_mock()
msg = "Target out-of-band controller does not support storage feature using Redfish API."
redfish_connection_mock_for_storage_volume.root_uri = "/redfish/v1/"
redfish_connection_mock_for_storage_volume.invoke_request.side_effect = HTTPError('http://testhost.com', 404,
json.dumps(msg), {}, None)
with pytest.raises(Exception) as exc:
self.module.fetch_storage_resource(f_module, redfish_connection_mock_for_storage_volume)
def test_download_file_http_error(self):
self.connection.send.side_effect = [
HTTPError('http://bigip.local', 400, '', {}, StringIO('{"errorMessage": "ERROR"}'))
]
with self.assertRaises(HTTPError) as res:
self.connection.download_file('/fake/path/to/download/fakefile', '/tmp/fakefile')
assert res.exception.code == 400
def test_request_raises_on_status_500(self, open_url_mock):
open_url_mock.side_effect = HTTPError('https://api.test.manifold.co/v1/endpoint',
500, 'Server error', {}, six.StringIO('ERROR'))
client = ManifoldApiClient('token-123')
with self.assertRaises(ApiError) as context:
client.request('test', 'endpoint')
self.assertEqual('Server returned: HTTP Error 500: Server error while requesting '
'https://api.test.manifold.co/v1/endpoint:\nERROR',
str(context.exception))
def test_get_device_id_from_service_tags_error_case(self, connection_mock, response_mock):
connection_mock.__enter__.return_value = connection_mock
connection_mock.invoke_request.side_effect = HTTPError('http://testhost.com',
400, '', {}, None)
response_mock.json_data = {"value": [{"DeviceServiceTag": "MX1234", "Id": 1234}]}
response_mock.status_code = 200
response_mock.success = True
with pytest.raises(HTTPError) as ex:
self.module._get_device_id_from_service_tags(["INVALID"], connection_mock)
def test_main_HTTPError_error_case(self, module_mock, validate_inputs_mock, connection_mock, get_resource_parameters_mock, response_mock):
get_resource_parameters_mock.return_value = resource_basic_inventory
connection_mock.__enter__.return_value = connection_mock
connection_mock.invoke_request.side_effect = HTTPError('http://testhost.com', 400, '', {}, None)
response_mock.json_data = {"value": [{"device_id1": "details", "device_id2": "details"}]}
response_mock.status_code = 400
result = self._run_module_with_fail_json(default_args)
assert 'device_info' not in result
assert result['failed'] is True
def test_send_request_should_return_error_info_when_http_error_raises(self):
self.connection.send.side_effect = HTTPError(
'http://bigip.local', 400, '', {}, StringIO('{"errorMessage": "ERROR"}')
)
with self.assertRaises(AnsibleConnectionFailure) as res:
self.connection.httpapi.login('foo', 'bar')
assert "Authentication process failed, server returned: {'errorMessage': 'ERROR'}" in str(res.exception)
def test_send_request_should_return_error_info_when_http_error_raises(
self):
self.connection_mock.send.side_effect = HTTPError(
'http://f5cs.com', 500, '', {},
StringIO('{"errorMessage": "ERROR"}'))
resp = self.f5cs_plugin.send_request('/login', None)
assert resp == dict(code=500, contents={'errorMessage': 'ERROR'})
def test_http_error_handling(self, mocker):
request = mocker.patch.object(client, "Request").return_value
request.open.side_effect = HTTPError("url", 404, "missing", {}, None)
c = client.Client("https://host", "u", "p", True, "ca")
r = c.request("PUT", ("config", "a/b"))
assert r.status == 404
assert r.data == "missing"
def test_idrac_redfish_main_HTTPError_case(self, param, idrac_connection_mock_for_redfish_storage_controller,
redfish_default_args, mocker):
redfish_default_args.update(param)
json_str = to_text(json.dumps({"data": "out"}))
mocker.patch('ansible.modules.remote_management.dellemc.idrac_redfish_storage_controller.check_raid_service',
side_effect=HTTPError('http://testhost.com', 400, 'http error message',
{"accept-type": "application/json"}, StringIO(json_str)))
result = self._run_module_with_fail_json(redfish_default_args)
assert 'msg' in result
assert result['failed'] is True
def test_get_list_of_supported_api_versions_with_failed_http_request(self):
error_msg = "Invalid Credentials"
fp = mock.MagicMock()
fp.read.return_value = '{{"error-msg": "{0}"}}'.format(error_msg)
send_mock = mock.MagicMock(side_effect=HTTPError('url', 400, 'msg', 'hdrs', fp))
with mock.patch.object(self.ftd_plugin.connection, 'send', send_mock):
with self.assertRaises(ConnectionError) as res:
self.ftd_plugin._get_supported_api_versions()
assert error_msg in str(res.exception)
def test_check_specified_identifier_exists_in_the_system_exception_case_02(
self, redfish_connection_mock_for_storage_volume,
redfish_response_mock):
f_module = self.get_module_mock(params={"controller_id": "1234"})
msg = "http error"
redfish_connection_mock_for_storage_volume.invoke_request.side_effect = HTTPError(
'http://testhost.com', 400, msg, {}, None)
with pytest.raises(Exception, match=msg) as exc:
self.module.check_specified_identifier_exists_in_the_system(
f_module, redfish_connection_mock_for_storage_volume, "uri",
"Specified Controller 123 does not exist in the System.")
def test_handle_httperror_should_update_tokens_and_retry_on_auth_errors(self):
self.ftd_plugin.refresh_token = 'REFRESH_TOKEN'
self.connection_mock.send.return_value = self._connection_response(
{'access_token': 'NEW_ACCESS_TOKEN', 'refresh_token': 'NEW_REFRESH_TOKEN'}
)
retry = self.ftd_plugin.handle_httperror(HTTPError('http://testhost.com', 401, '', {}, None))
assert retry
assert 'NEW_ACCESS_TOKEN' == self.ftd_plugin.access_token
assert 'NEW_REFRESH_TOKEN' == self.ftd_plugin.refresh_token
def test_check_domain_service_http(self, ome_conn_mock_network, ome_default_args, mocker):
f_module = self.get_module_mock()
err_message = {'error': {'@Message.ExtendedInfo': [{'MessageId': 'CGEN1006'}]}}
ome_conn_mock_network.invoke_request.side_effect = HTTPError('http://testhost.com', 400,
json.dumps(err_message),
{"accept-type": "application/json"}, None)
mocker.patch(MODULE_PATH + 'json.loads', return_value=err_message)
with pytest.raises(Exception) as err:
self.module.check_domain_service(f_module, ome_conn_mock_network)
assert err.value.args[0] == "The device location settings operation is supported only on " \
"OpenManage Enterprise Modular."
def test_invoke_request_http_error_handling(self, mock_response, mocker):
open_url_mock = mocker.patch('ansible.module_utils.remote_management.dellemc.ome.open_url',
return_value=mock_response)
open_url_mock.side_effect = HTTPError('http://testhost.com/', 400,
'Bad Request Error', {}, None)
module_params = {'hostname': '192.168.0.1', 'username': '******',
'password': '******', "port": 443}
req_session = False
with pytest.raises(HTTPError) as e:
with RestOME(module_params, req_session) as obj:
obj.invoke_request("/testpath", "GET")
def test_http_error(self, mocker):
request_mock = mocker.patch.object(client, "Request").return_value
request_mock.open.side_effect = HTTPError(
"", 404, "Not Found", {}, io.StringIO(to_text("My Error")))
c = client.Client("https://instance.com", "user", "pass")
resp = c.request("GET", "api/now/some/path")
assert resp.status == 404
assert resp.data == "My Error"
assert resp.headers == {}
def test_upload_file_total_failure(self):
self.connection.send.side_effect = HTTPError(
'http://bigip.local', 400, '', {}, StringIO('{"errorMessage": "ERROR"}')
)
binary_file = os.path.join(fixture_path, 'test_binary_file.mock')
with self.assertRaises(AnsibleConnectionFailure) as res:
self.connection.httpapi.upload_file('/fake/path/to/upload', binary_file)
assert 'Failed to upload file too many times.' in str(res.exception)
assert self.connection.send.call_count == 3
def test_non_200(self, mocker):
auth_resp = mocker.Mock()
auth_resp.read.return_value = '{"access_token": "token"}'
data_resp = HTTPError("url", 404, '{"msg": "missing item"}', {}, None)
open_url = mocker.patch.object(client, "open_url")
open_url.side_effect = auth_resp, data_resp
resp = client.Client("http://ex.com/", "user", "pass").get("/path")
assert 404 == resp.status
assert '{"msg": "missing item"}' == resp.data
assert {"msg": "missing item"} == resp.json
def test_oauth_failure(self, mocker):
request_mock = mocker.patch.object(client, "Request").return_value
request_mock.open.side_effect = HTTPError(
"", 403, "Forbidden", {}, io.StringIO(to_text("Error message")))
c = client.Client("instance.com",
"user",
"pass",
client_id="id",
client_secret="secret")
with pytest.raises(errors.UnexpectedAPIResponse,
match="Error message"):
c.auth_header
